Support directories other than "web" in pub build.

sdk/lib/_internal/pub/lib/src/barback/dart2js_transformer.dart

 // Copyright (c) 2013, 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.
 
 library pub.dart2js_transformer;
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
 
 import 'package:analyzer/analyzer.dart';
 import 'package:barback/barback.dart';
 import 'package:path/path.dart' as path;
 import 'package:stack_trace/stack_trace.dart';
 
 import '../../../../compiler/compiler.dart' as compiler;
 import '../../../../compiler/implementation/dart2js.dart'
     show AbortLeg;
 import '../../../../compiler/implementation/source_file.dart';
 import '../barback.dart';
 import '../dart.dart' as dart;
 import '../io.dart';
 import '../package.dart';
 import '../package_graph.dart';
 import '../utils.dart';
+import 'build_environment.dart';
 
 /// The set of all valid configuration options for this transformer.
 final _validOptions = new Set<String>.from([
   'commandLineOptions', 'checked', 'minify', 'verbose', 'environment',
   'analyzeAll', 'suppressWarnings', 'suppressHints', 'terse'
 ]);
 
 /// A [Transformer] that uses dart2js's library API to transform Dart
 /// entrypoints in "web" to JavaScript.
 class Dart2JSTransformer extends Transformer {
-  final PackageGraph _graph;
+  final BuildEnvironment _environment;
   final BarbackSettings _settings;
 
-  /// The [AssetId]s the transformer has discovered so far. Used by pub build
-  /// to determine where to copy the JS bootstrap files.
-  // TODO(rnystrom): Do something cleaner for this, or eliminate those files.
-  final entrypoints = new Set<AssetId>();
-
   /// If this is non-null, then the transformer is currently being applied, so
   /// subsequent calls to [apply] will wait for this to finish before
   /// proceeding.
   ///
   /// Dart2js uses lots of memory, so if we try to actually run compiles in
   /// parallel, it takes down the VM. Instead, the transformer will force
   /// all applies to be sequential. The tracking bug to do something better
   /// is here: https://code.google.com/p/dart/issues/detail?id=14730.
   Future _running;
 
-  Dart2JSTransformer.withSettings(this._graph, this._settings) {
+  Dart2JSTransformer.withSettings(this._environment, this._settings) {
     var invalidOptions = _settings.configuration.keys.toSet()
         .difference(_validOptions);
     if (invalidOptions.isEmpty) return;
 
     throw new FormatException("Unrecognized dart2js "
         "${pluralize('option', invalidOptions.length)} "
         "${toSentence(invalidOptions.map((option) => '"$option"'))}.");
   }
 
-  Dart2JSTransformer(PackageGraph graph, BarbackMode mode)
-      : this.withSettings(graph, new BarbackSettings({}, mode));
+  Dart2JSTransformer(BuildEnvironment environment, BarbackMode mode)
+      : this.withSettings(environment, new BarbackSettings({}, mode));
 
-  /// Only ".dart" files within "web/" are processed.
+  /// Only ".dart" files within a buildable directory are processed.
   Future<bool> isPrimary(Asset asset) {
-    return new Future.value(
-        asset.id.extension == ".dart" &&
-        asset.id.path.startsWith("web/"));
+    if (asset.id.extension != ".dart") return new Future.value(false);
+
+    for (var dir in ["benchmark", "example", "test", "web"]) {
+      if (asset.id.path.startsWith("$dir/")) return new Future.value(true);
+    }
+
+    return new Future.value(false);
   }
 
   Future apply(Transform transform) {
     // Wait for any ongoing apply to finish first.
     // TODO(rnystrom): If there are multiple simultaneous compiles, this will
     // resume and pause them repeatedly. It still serializes them correctly,
     // but it might be cleaner to use a real queue.
     // TODO(rnystrom): Add a test that this is functionality is helpful.
     if (_running != null) {
       return _running.then((_) => apply(transform));
     }
 
     var completer = new Completer();
     _running = completer.future;
 
     var stopwatch = new Stopwatch();
     stopwatch.start();
 
     return transform.primaryInput.readAsString().then((code) {
       try {
         var id = transform.primaryInput.id;
         var name = id.path;
-        if (id.package != _graph.entrypoint.root.name) {
+        if (id.package != _environment.rootPackage.name) {
           name += " in ${id.package}";
         }
 
         var parsed = parseCompilationUnit(code, name: name);
         if (!dart.isEntrypoint(parsed)) return null;
       } on AnalyzerErrorGroup catch (e) {
         transform.logger.error(e.message);
         return null;
       }
 
-      var provider = new _BarbackCompilerProvider(_graph, transform);
+      var provider = new _BarbackCompilerProvider(_environment, transform);
 
       // Create a "path" to the entrypoint script. The entrypoint may not
       // actually be on disk, but this gives dart2js a root to resolve
       // relative paths against.
       var id = transform.primaryInput.id;
 
-      entrypoints.add(id);
-
-      var entrypoint = path.join(_graph.packages[id.package].dir, id.path);
+      var entrypoint = path.join(_environment.graph.packages[id.package].dir,
+          id.path);
 
       // TODO(rnystrom): Should have more sophisticated error-handling here.
       // Need to report compile errors to the user in an easily visible way.
       // Need to make sure paths in errors are mapped to the original source
       // path so they can understand them.
       return Chain.track(dart.compile(
           entrypoint, provider,
           commandLineOptions: _configCommandLineOptions,
           checked: _configBool('checked'),
           minify: _configBool(
               'minify', defaultsTo: _settings.mode == BarbackMode.RELEASE),
           verbose: _configBool('verbose'),
           environment: _configEnvironment,
-          packageRoot: path.join(_graph.entrypoint.root.dir, "packages"),
+          packageRoot: path.join(_environment.rootPackage.dir,
+                                 "packages"),
           analyzeAll: _configBool('analyzeAll'),
           suppressWarnings: _configBool('suppressWarnings'),
           suppressHints: _configBool('suppressHints'),
           terse: _configBool('terse'))).then((_) {
         stopwatch.stop();
         transform.logger.info("Took ${stopwatch.elapsed} to compile $id.");
       });
     }).whenComplete(() {
       completer.complete();
       _running = null;
@@ skipping 41 matching lines @@
   }
 }
 
 /// Defines an interface for dart2js to communicate with barback and pub.
 ///
 /// Note that most of the implementation of diagnostic handling here was
 /// copied from [FormattingDiagnosticHandler] in dart2js. The primary
 /// difference is that it uses barback's logging code and, more importantly, it
 /// handles missing source files more gracefully.
 class _BarbackCompilerProvider implements dart.CompilerProvider {
-  final PackageGraph _graph;
+  final BuildEnvironment _environment;
   final Transform _transform;
 
   /// The map of previously loaded files.
   ///
   /// Used to show where an error occurred in a source file.
   final _sourceFiles = new Map<String, SourceFile>();
 
   // TODO(rnystrom): Make these configurable.
   /// Whether or not warnings should be logged.
   var _showWarnings = true;
@@ skipping 13 matching lines @@
 
   compiler.Diagnostic _lastKind = null;
 
   static final int _FATAL =
       compiler.Diagnostic.CRASH.ordinal |
       compiler.Diagnostic.ERROR.ordinal;
   static final int _INFO =
       compiler.Diagnostic.INFO.ordinal |
       compiler.Diagnostic.VERBOSE_INFO.ordinal;
 
-  _BarbackCompilerProvider(this._graph, this._transform);
+  _BarbackCompilerProvider(this._environment, this._transform);
 
   /// A [CompilerInputProvider] for dart2js.
   Future<String> provideInput(Uri resourceUri) {
     // We only expect to get absolute "file:" URLs from dart2js.
     assert(resourceUri.isAbsolute);
     assert(resourceUri.scheme == "file");
 
     var sourcePath = path.fromUri(resourceUri);
     return _readResource(resourceUri).then((source) {
       _sourceFiles[resourceUri.toString()] =
@@ skipping 102 matching lines @@
   }
 
   AssetId _sourceUrlToId(Uri url) {
     // See if it's a special path with "packages" or "assets" in it.
     var id = specialUrlToId(url);
     if (id != null) return id;
 
     // See if it's a path to a "public" asset within the root package. All
     // other files in the root package are not visible to transformers, so
     // should be loaded directly from disk.
-    var rootDir = _graph.entrypoint.root.dir;
+    var rootDir = _environment.rootPackage.dir;
     var sourcePath = path.fromUri(url);
     if (isBeneath(sourcePath, path.join(rootDir, "lib")) ||
         isBeneath(sourcePath, path.join(rootDir, "asset")) ||
         isBeneath(sourcePath, path.join(rootDir, "web"))) {
       var relative = path.relative(sourcePath, from: rootDir);
 
-      return new AssetId(_graph.entrypoint.root.name, relative);
+      return new AssetId(_environment.rootPackage.name, relative);
     }
 
     return null;
   }
 }