Use precompiled dependencies in pub.

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

 // Copyright (c) 2014, 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.barback.asset_environment;
 
 import 'dart:async';
 import 'dart:io';
 
 import 'package:barback/barback.dart';
 import 'package:path/path.dart' as path;
 import 'package:watcher/watcher.dart';
 
+import '../cached_package.dart';
 import '../entrypoint.dart';
 import '../exceptions.dart';
 import '../io.dart';
 import '../log.dart' as log;
 import '../package.dart';
 import '../package_graph.dart';
 import '../sdk.dart' as sdk;
 import '../source/cached.dart';
 import '../utils.dart';
 import 'admin_server.dart';
@@ skipping 35 matching lines @@
   /// transformers, and server are loaded and ready.
   static Future<AssetEnvironment> create(Entrypoint entrypoint,
       BarbackMode mode, {WatcherType watcherType, String hostname, int basePort,
       Iterable<String> packages, bool useDart2JS: true}) {
     if (watcherType == null) watcherType = WatcherType.NONE;
     if (hostname == null) hostname = "localhost";
     if (basePort == null) basePort = 0;
 
     return entrypoint.loadPackageGraph().then((graph) {
       log.fine("Loaded package graph.");
-      var barback = new Barback(new PubPackageProvider(graph, packages));
+      graph = _adjustPackageGraph(graph, mode, packages);
+      var barback = new Barback(new PubPackageProvider(graph));
       barback.log.listen(_log);
 
       var environment = new AssetEnvironment._(graph, barback, mode,
-          watcherType, hostname, basePort, packages);
+          watcherType, hostname, basePort);
 
       return environment._load(useDart2JS: useDart2JS)
           .then((_) => environment);
     });
   }
 
+  /// Return a version of [graph] that's restricted to [packages] (if passed)
+  /// and loads cached packages (if [mode] is [BarbackMode.DEBUG]).
+  static PackageGraph _adjustPackageGraph(PackageGraph graph,
+      BarbackMode mode, Iterable<String> packages) {
+    if (mode != BarbackMode.DEBUG && packages == null) return graph;
+    packages = (packages == null ? graph.packages.keys : packages).toSet();
+
+    return new PackageGraph(graph.entrypoint, graph.lockFile,
+        new Map.fromIterable(packages, value: (packageName) {
+      var package = graph.packages[packageName];
+      if (mode != BarbackMode.DEBUG) return package;
+      var cache = path.join('.pub/deps/debug', packageName);
+      if (!dirExists(cache)) return package;
+      return new CachedPackage(package, cache);
+    }));
+  }
+
   /// The server for the Web Socket API and admin interface.
   AdminServer _adminServer;
 
   /// The public directories in the root package that are included in the asset
   /// environment, keyed by their root directory.
   final _directories = new Map<String, SourceDirectory>();
 
   /// The [Barback] instance used to process assets in this environment.
   final Barback barback;
 
   /// The root package being built.
   Package get rootPackage => graph.entrypoint.root;
 
-  /// The underlying [PackageGraph] being built.
+  /// The graph of packages whose assets and transformers are loaded in this
+  /// environment.
+  ///
+  /// This isn't necessarily identical to the graph that's passed in to the
+  /// environment. It may expose fewer packages if some packages' assets don't
+  /// need to be loaded, and it may expose some [CachedPackage]s.
   final PackageGraph graph;
 
   /// The mode to run the transformers in.
   final BarbackMode mode;
 
   /// The [Transformer]s that should be appended by default to the root
   /// package's transformer cascade. Will be empty if there are none.
   final _builtInTransformers = <Transformer>[];
 
   /// How source files should be watched.
   final WatcherType _watcherType;
 
   /// The hostname that servers are bound to.
   final String _hostname;
 
   /// The starting number for ports that servers will be bound to.
   ///
   /// Servers will be bound to ports starting at this number and then
   /// incrementing from there. However, if this is zero, then ephemeral port
   /// numbers will be selected for each server.
   final int _basePort;
 
-  /// The set of all packages that are visible for this environment.
-  ///
-  /// By default, this is all transitive dependencies of the entrypoint, but it
-  /// may be a narrower set if fewer packages are needed.
-  final Set<String> packages;
-
   /// The modified source assets that have not been sent to barback yet.
   ///
   /// The build environment can be paused (by calling [pauseUpdates]) and
   /// resumed ([resumeUpdates]). While paused, all source asset updates that
   /// come from watching or adding new directories are not sent to barback.
   /// When resumed, all pending source updates are sent to barback.
   ///
   /// This lets pub serve and pub build create an environment and bind several
   /// servers before barback starts building and producing results
   /// asynchronously.
   ///
   /// If this is `null`, then the environment is "live" and all updates will
   /// go to barback immediately.
   Set<AssetId> _modifiedSources;
 
-  AssetEnvironment._(PackageGraph graph, this.barback, this.mode,
-        this._watcherType, this._hostname, this._basePort,
-        Iterable<String> packages)
-      : graph = graph,
-        packages = packages == null ? graph.packages.keys.toSet() :
-            packages.toSet();
+  AssetEnvironment._(this.graph, this.barback, this.mode,
+        this._watcherType, this._hostname, this._basePort);
 
   /// Gets the built-in [Transformer]s that should be added to [package].
   ///
   /// Returns `null` if there are none.
   Iterable<Transformer> getBuiltInTransformers(Package package) {
     // Built-in transformers only apply to the root package.
     if (package.name != rootPackage.name) return null;
 
     // The built-in transformers are for dart2js and forwarding assets around
     // dart2js.
@@ skipping 177 matching lines @@
       var relativePath = path.relative(assetPath, from: dir.directory);
       return dir.server.then((server) =>
           server.url.resolveUri(path.toUri(relativePath)));
     }));
   }
 
   /// Look up [assetPath] in the "packages" directory in the entrypoint package.
   Future<List<Uri>> _lookUpPathInPackagesDirectory(String assetPath) {
     var components = path.split(path.relative(assetPath));
     if (components.first != "packages") return new Future.value([]);
-    if (!packages.contains(components[1])) return new Future.value([]);
+    if (!graph.packages.containsKey(components[1])) return new Future.value([]);

[Bob Nystrom, 2014/09/23 19:47:45]

async?

[nweiz, 2014/09/23 21:34:50]

I didn't want to make a bunch of async transformations in methods that just had
mechanical method-reference changes. Too much churn at once.

     return Future.wait(_directories.values.map((dir) {
       return dir.server.then((server) =>
           server.url.resolveUri(path.toUri(assetPath)));
     }));
   }
 
   /// Look up [assetPath] in the "lib" or "asset" directory of a dependency
   /// package.
   Future<List<Uri>> _lookUpPathInDependency(String assetPath) {
-    for (var packageName in packages) {
+    for (var packageName in graph.packages.keys) {
       var package = graph.packages[packageName];
-      var libDir = path.join(package.dir, 'lib');
-      var assetDir = path.join(package.dir, 'asset');
+      var libDir = package.path('lib');
+      var assetDir = package.path('asset');
 
       var uri;
       if (path.isWithin(libDir, assetPath)) {
         uri = path.toUri(path.join('packages', package.name,
             path.relative(assetPath, from: libDir)));
       } else if (path.isWithin(assetDir, assetPath)) {
         uri = path.toUri(path.join('assets', package.name,
             path.relative(assetPath, from: assetDir)));
       } else {
         continue;
@@ skipping 155 matching lines @@
     }, fine: true);
   }
 
   /// Provides the public source assets in the environment to barback.
   ///
   /// If [watcherType] is not [WatcherType.NONE], enables watching on them.
   Future _provideSources() {
     // Just include the "lib" directory from each package. We'll add the
     // other build directories in the root package by calling
     // [serveDirectory].
-    return Future.wait(packages.map((package) {
-      return _provideDirectorySources(graph.packages[package], "lib");
+    return Future.wait(graph.packages.values.map((package) {
+      return _provideDirectorySources(package, "lib");
     }));
   }
 
   /// Provides all of the source assets within [dir] in [package] to barback.
   ///
   /// If [watcherType] is not [WatcherType.NONE], enables watching on them.
   /// Returns the subscription to the watcher, or `null` if none was created.
   Future<StreamSubscription<WatchEvent>> _provideDirectorySources(
       Package package, String dir) {
     log.fine("Providing sources for ${package.name}|$dir.");
@@ skipping 43 matching lines @@
   /// but slower [listDir].
   Iterable<AssetId> _listDirectorySources(Package package, String dir) {
     // This is used in some performance-sensitive paths and can list many, many
     // files. As such, it leans more havily towards optimization as opposed to
     // readability than most code in pub. In particular, it avoids using the
     // path package, since re-parsing a path is very expensive relative to
     // string operations.
     return package.listFiles(beneath: dir).map((file) {
       // From profiling, path.relative here is just as fast as a raw substring
       // and is correct in the case where package.dir has a trailing slash.
-      var relative = path.relative(file, from: package.dir);
+      var relative = package.relative(file);
 
       if (Platform.operatingSystem == 'windows') {
         relative = relative.replaceAll("\\", "/");
       }
 
       var uri = new Uri(pathSegments: relative.split("/"));
       return new AssetId(package.name, uri.toString());
     });
   }
 
   /// Adds a file watcher for [dir] within [package], if the directory exists
   /// and the package needs watching.
   Future<StreamSubscription<WatchEvent>> _watchDirectorySources(
       Package package, String dir) {
     // If this package comes from a cached source, its contents won't change so
     // we don't need to monitor it. `packageId` will be null for the
     // application package, since that's not locked.
     var packageId = graph.lockFile.packages[package.name];
     if (packageId != null &&
         graph.entrypoint.cache.sources[packageId.source] is CachedSource) {
       return new Future.value();
     }
 
-    var subdirectory = path.join(package.dir, dir);
+    var subdirectory = package.path(dir);
     if (!dirExists(subdirectory)) return new Future.value();
 
     // TODO(nweiz): close this watcher when [barback] is closed.
     var watcher = _watcherType.create(subdirectory);
     var subscription = watcher.events.listen((event) {
       // Don't watch files symlinked into these directories.
       // TODO(rnystrom): If pub gets rid of symlinks, remove this.
       var parts = path.split(event.path);
       if (parts.contains("packages")) return;
 
       // Skip files that were (most likely) compiled from nearby ".dart"
       // files. These are created by the Editor's "Run as JavaScript"
       // command and are written directly into the package's directory.
       // When pub's dart2js transformer then tries to create the same file
       // name, we get a build error. To avoid that, just don't consider
       // that file to be a source.
       // TODO(rnystrom): Remove these when the Editor no longer generates
       // .js files and users have had enough time that they no longer have
       // these files laying around. See #15859.
       if (event.path.endsWith(".dart.js")) return;
       if (event.path.endsWith(".dart.js.map")) return;
       if (event.path.endsWith(".dart.precompiled.js")) return;
 
-      var idPath = path.relative(event.path, from: package.dir);
+      var idPath = package.relative(event.path);
       var id = new AssetId(package.name, path.toUri(idPath).toString());
       if (event.type == ChangeType.REMOVE) {
         if (_modifiedSources != null) {
           _modifiedSources.remove(id);
         } else {
           barback.removeSources([id]);
         }
       } else if (_modifiedSources != null) {
         _modifiedSources.add(id);
       } else {
@@ skipping 136 matching lines @@
   String toString() => "polling";
 }
 
 class _NoneWatcherType implements WatcherType {
   const _NoneWatcherType();
 
   DirectoryWatcher create(String directory) => null;
 
   String toString() => "none";
 }