Support browser caching using hashes in serverMode (fixes #93, fixes #92)

lib/src/dependency_graph.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /// Tracks the shape of the import/export graph and dependencies between files.
 library dev_compiler.src.dependency_graph;
 
 import 'dart:collection' show HashSet;
 
 import 'package:analyzer/analyzer.dart' show parseDirectives;
 import 'package:analyzer/src/generated/ast.dart'
     show
         LibraryDirective,
         ImportDirective,
         ExportDirective,
         PartDirective,
         PartOfDirective,
         CompilationUnit,
         Identifier;
 import 'package:analyzer/src/generated/engine.dart'
     show ParseDartTask, AnalysisContext;
 import 'package:analyzer/src/generated/source.dart' show Source, SourceKind;
 import 'package:html5lib/dom.dart' show Document;
 import 'package:html5lib/parser.dart' as html;
 import 'package:logging/logging.dart' show Level;
 import 'package:path/path.dart' as path;
 import 'package:source_span/source_span.dart' show SourceSpan;
 
 import 'info.dart';
+import 'options.dart';
 import 'report.dart';
 import 'utils.dart';
 
 /// Holds references to all source nodes in the import graph. This is mainly
 /// used as a level of indirection to ensure that each source has a canonical
 /// representation.
 class SourceGraph {
   /// All nodes in the source graph. Used to get a canonical representation for
   /// any node.
   final Map<Uri, SourceNode> nodes = {};
 
   /// Analyzer used to resolve source files.
   final AnalysisContext _context;
   final CheckerReporter _reporter;
+  final CompilerOptions _options;
 
-  SourceGraph(this._context, this._reporter);
+  SourceGraph(this._context, this._reporter, this._options);
 
   /// Node associated with a resolved [uri].
   SourceNode nodeFromUri(Uri uri) {
     var uriString = Uri.encodeFull('$uri');
     return nodes.putIfAbsent(uri, () {
       var source = _context.sourceFactory.forUri(uriString);
       var extension = path.extension(uriString);
       if (extension == '.html') {
         return new HtmlSourceNode(uri, source, this);
       } else if (extension == '.dart' || uriString.startsWith('dart:')) {
@@ skipping 12 matching lines @@
   /// Resolved URI for this node.
   final Uri uri;
 
   /// Resolved source from the analyzer. We let the analyzer internally track
   /// for modifications to the source files.
   final Source source;
 
   /// Last stamp read from `source.modificationStamp`.
   int _lastStamp = 0;
 
+  /// A hash used to help browsers cache the output that would be produced from
+  /// building this node.
+  String cachingHash;
+
   /// Whether we need to rebuild this source file.
   bool needsRebuild = false;
 
   /// Whether the structure of dependencies from this node (scripts, imports,
   /// exports, or parts) changed after we reparsed its contents.
   bool structureChanged = false;
 
   /// Direct dependencies in the [SourceGraph]. These include script tags for
   /// [HtmlSourceNode]s; and imports, exports and parts for [DartSourceNode]s.
   Iterable<SourceNode> get allDeps => const [];
@@ skipping 33 matching lines @@
   Iterable<SourceNode> get allDeps => [scripts, runtimeDeps].expand((e) => e);
 
   @override
   Iterable<SourceNode> get depsWithoutParts => allDeps;
 
   /// Parsed document, updated whenever [update] is invoked.
   Document document;
 
   HtmlSourceNode(uri, source, graph) : super(uri, source) {
     var prefix = 'package:dev_compiler/runtime';
-    runtimeDeps
-      ..add(graph.nodeFromUri(Uri.parse('$prefix/dart_runtime.js')))
-      ..add(graph.nodeFromUri(Uri.parse('$prefix/harmony_feature_check.js')))
-      ..add(graph.nodeFromUri(Uri.parse('$prefix/messages_widget.js')))
-      ..add(graph.nodeFromUri(Uri.parse('$prefix/messages.css')));
+    var files = ['harmony_feature_check.js', 'dart_runtime.js'];
+    if (graph._options.serverMode) {
+      files.addAll(const ['messages_widget.js', 'messages.css']);
+    }
+    files.forEach((file) {
+      runtimeDeps.add(graph.nodeFromUri(Uri.parse('$prefix/$file')));
+    });
   }
 
   void update(SourceGraph graph) {
     super.update(graph);
     if (needsRebuild) {
       graph._reporter.clearHtml(uri);
       document = html.parse(source.contents.data, generateSpans: true);
       var newScripts = new Set<DartSourceNode>();
       var tags = document.querySelectorAll('script[type="application/dart"]');
       for (var script in tags) {
@@ skipping 187 matching lines @@
 rebuild(SourceNode start, SourceGraph graph, bool build(SourceNode node)) {
   refreshStructureAndMarks(start, graph);
   // Hold which source nodes may have changed their public API, this includes
   // libraries that were modified or libraries that export other modified APIs.
   // TODO(sigmund): consider removing this special support for exports? Many
   // cases anways require using summaries to understand what parts of the public
   // API may be affected by transitive changes. The re-export case is just one
   // of those transitive cases, but is not sufficient. See
   // https://github.com/dart-lang/dev_compiler/issues/76
   var apiChangeDetected = new HashSet<SourceNode>();
-  bool structureHasChanged = false;
+  bool htmlNeedsRebuild = false;
 
   bool shouldBuildNode(SourceNode n) {
     if (n.needsRebuild) return true;
-    if (n is HtmlSourceNode) return structureHasChanged;
+    if (n is HtmlSourceNode) return htmlNeedsRebuild;
     if (n is ResourceSourceNode) return false;
     return (n as DartSourceNode).imports
         .any((i) => apiChangeDetected.contains(i));
   }
 
   visitInPostOrder(start, (n) {
-    if (n.structureChanged) structureHasChanged = true;
+    if (n.structureChanged) htmlNeedsRebuild = true;
     if (shouldBuildNode(n)) {
+      var oldHash = n.cachingHash;
       if (build(n)) apiChangeDetected.add(n);
+      if (oldHash != n.cachingHash) htmlNeedsRebuild = true;
     } else if (n is DartSourceNode &&
         n.exports.any((e) => apiChangeDetected.contains(e))) {
       apiChangeDetected.add(n);
     }
     n.needsRebuild = false;
     n.structureChanged = false;
     if (n is DartSourceNode) {
       // Note: clearing out flags in the parts could be a problem if someone
       // tries to use a file both as a part and a library at the same time.
       // In that case, we might not correctly propagate changes in the places
@@ skipping 31 matching lines @@
   helper(start);
 }
 
 bool _same(Set a, Set b) => a.length == b.length && a.containsAll(b);
 
 /// An error message discovered while parsing the dependencies between files.
 class DependencyGraphError extends MessageWithSpan {
   const DependencyGraphError(String message, SourceSpan span)
       : super(message, Level.SEVERE, span);
 }