Rename BuildDirectory -> SourceDirectory.

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.build_environment;
+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:stack_trace/stack_trace.dart';
 import 'package:watcher/watcher.dart';
 
 import '../entrypoint.dart';
 import '../io.dart';
 import '../log.dart' as log;
 import '../package.dart';
 import '../package_graph.dart';
 import '../sdk.dart' as sdk;
 import 'admin_server.dart';
-import 'build_directory.dart';
+import 'barback_server.dart';
 import 'dart_forwarding_transformer.dart';
 import 'dart2js_transformer.dart';
 import 'load_all_transformers.dart';
 import 'pub_package_provider.dart';
-import 'barback_server.dart';
+import 'source_directory.dart';
 
 /// The entire "visible" state of the assets of a package and all of its
 /// dependencies, taking into account the user's configuration when running pub.
 ///
 /// Where [PackageGraph] just describes the entrypoint's dependencies as
 /// specified by pubspecs, this includes "transient" information like the mode
-/// that the user is running pub in, or which directories they want to build.
-class BuildEnvironment {
+/// that the user is running pub in, or which directories they want to
+/// transform.
+class AssetEnvironment {
   /// Creates a new build environment for working with the assets used by
   /// [entrypoint] and its dependencies.
   ///
   /// Spawns an HTTP server for each directory in [rootDirectories]. These
   /// servers will be on [hostname] and have ports based on [basePort].
   /// [basePort] itself is reserved for "web/" and `basePort + 1` is reserved
   /// for "test/"; further ports will be allocated for other root directories as
   /// necessary. If [basePort] is zero, each server will have an ephemeral port.
   ///
   /// Loads all used transformers using [mode] (including dart2js if
   /// [useDart2JS] is true).
   ///
   /// Includes [rootDirectories] in the root package, as well as "lib" and
   /// "asset".
   ///
   /// If [watcherType] is not [WatcherType.NONE], watches source assets for
   /// modification.
   ///
   /// Returns a [Future] that completes to the environment once the inputs,
   /// transformers, and server are loaded and ready.
-  static Future<BuildEnvironment> create(Entrypoint entrypoint,
+  static Future<AssetEnvironment> create(Entrypoint entrypoint,
       String hostname, int basePort, BarbackMode mode, WatcherType watcherType,
       {bool useDart2JS: true}) {
     return entrypoint.loadPackageGraph().then((graph) {
       log.fine("Loaded package graph.");
       var barback = new Barback(new PubPackageProvider(graph));
       barback.log.listen(_log);
 
-      var environment = new BuildEnvironment._(graph, barback, mode,
+      var environment = new AssetEnvironment._(graph, barback, mode,
           watcherType, hostname, basePort);
 
       return environment._load(useDart2JS: useDart2JS)
           .then((_) => environment);
     });
   }
 
   /// The server for the Web Socket API and admin interface.
   AdminServer _adminServer;
 
-  /// The public directories in the root package that are available for
-  /// building, keyed by their root directory.
-  final _directories = new Map<String, BuildDirectory>();
+  /// The public directories in the root package that are available part of the
+  /// build environment, keyed by their root directory.

[nweiz, 2014/04/15 01:22:47]

"available part of the build environment" -> "part of the asset environment"

[Bob Nystrom, 2014/04/16 17:24:10]

Done.

+  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.
   final PackageGraph graph;
 
@@ skipping 25 matching lines @@
   /// 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;
 
-  BuildEnvironment._(this.graph, this.barback, this.mode, this._watcherType,
+  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
@@ skipping 49 matching lines @@
 
     // If not using an ephemeral port, find the lowest-numbered available one.
     if (port != 0) {
       var boundPorts = _directories.values.map((directory) => directory.port)
           .toSet();
       while (boundPorts.contains(port)) {
         port++;
       }
     }
 
-    var buildDirectory = new BuildDirectory(
+    var sourceDirectory = new SourceDirectory(
         this, rootDirectory, _hostname, port);
-    _directories[rootDirectory] = buildDirectory;
+    _directories[rootDirectory] = sourceDirectory;
 
     return _provideDirectorySources(rootPackage, rootDirectory)
         .then((subscription) {
-      buildDirectory.watchSubscription = subscription;
-      return buildDirectory.serve();
+      sourceDirectory.watchSubscription = subscription;
+      return sourceDirectory.serve();
     });
   }
 
   /// Stops the server bound to [rootDirectory].
   ///
   /// Also removes any source files within that directory from barback. Returns
   /// the URL of the unbound server, of `null` if [rootDirectory] was not
   /// bound to a server.
   Future<Uri> unserveDirectory(String rootDirectory) {
     log.fine("Unserving $rootDirectory.");
     var directory = _directories.remove(rootDirectory);
     if (directory == null) return new Future.value();
 
     return directory.server.then((server) {
       var url = server.url;
-      return directory.close().then((_) {
-        // Remove the sources from barback, unless some other build directory
-        // includes them.
-        return _removeDirectorySources(rootDirectory);
-      }).then((_) => url);
+      return directory.close()
+          .then((_) => _removeDirectorySources(rootDirectory))
+          .then((_) => url);
     });
   }
 
-  /// Gets the build directory that contains [assetPath] within the entrypoint
+  /// Gets the source directory that contains [assetPath] within the entrypoint
   /// package.
   ///
-  /// If [assetPath] is not contained within a build directory, this will
-  /// throw an exception.
-  String getBuildDirectoryContaining(String assetPath) =>
+  /// If [assetPath] is not contained within a source directory, this throws
+  /// an exception.
+  String getSourceDirectoryContaining(String assetPath) =>
       _directories.values
           .firstWhere((dir) => path.isWithin(dir.directory, assetPath))
           .directory;
 
   /// Return all URLs serving [assetPath] in this environment.
   Future<List<Uri>> getUrlsForAssetPath(String assetPath) {
     // Check the three (mutually-exclusive) places the path could be pointing.
     return _lookUpPathInServerRoot(assetPath).then((urls) {
       if (urls.isNotEmpty) return urls;
       return _lookUpPathInPackagesDirectory(assetPath);
@@ skipping 249 matching lines @@
   Future _updateDirectorySources(Package package, String dir) {
     return _listDirectorySources(package, dir).then((ids) {
       if (_modifiedSources == null) {
         barback.updateSources(ids);
       } else {
         _modifiedSources.addAll(ids);
       }
     });
   }
 
-  /// Removes all of the files in [dir] in the root package from barback unless
-  /// some other build directory still contains them.
+  /// Removes all of the files in [dir] in the root package from barback.
   Future _removeDirectorySources(String dir) {
-    return _listDirectorySources(rootPackage, dir, where: (relative) {
-      // TODO(rnystrom): This is O(n*m) where n is the number of files and
-      // m is the number of served directories. Consider something more
-      // optimal if this becomes a bottleneck.
-      // Don't remove a source if some other directory still includes it.
-      return !_directories.keys.any((dir) => path.isWithin(dir, relative));
-    }).then((ids) {
+    return _listDirectorySources(rootPackage, dir).then((ids) {
       if (_modifiedSources == null) {
         barback.removeSources(ids);
       } else {
         _modifiedSources.removeAll(ids);
       }
     });
   }
 
   /// Lists all of the source assets in [dir] inside [package].
   ///
   /// For large packages, listing the contents is a performance bottleneck, so
   /// this is optimized for our needs in here instead of using the more general
   /// but slower [listDir].
-  ///
-  /// If [where] is given, then it is used to filter the resulting list of
-  /// packages. Only assets whose relative path within [package] matches that
-  /// will be included in the results.
-  Future<List<AssetId>> _listDirectorySources(Package package, String dir,
-      {bool where(String relativePath)}) {
+  Future<List<AssetId>> _listDirectorySources(Package package, String dir) {
     var subdirectory = path.join(package.dir, dir);
     if (!dirExists(subdirectory)) return new Future.value([]);
 
     return new Directory(subdirectory).list(recursive: true, followLinks: true)
         .expand((entry) {
       // Skip directories and (broken) symlinks.
       if (entry is Directory) return [];
       if (entry is Link) return [];
 
       var relative = path.normalize(
@@ skipping 11 matching lines @@
       // 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 (relative.endsWith(".dart.js")) return [];
       if (relative.endsWith(".dart.js.map")) return [];
       if (relative.endsWith(".dart.precompiled.js")) return [];
 
-      if (where != null && !where(relative)) return [];
-
       return [new AssetId(package.name, relative)];
     }).toList();
   }
 
   /// 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
@@ skipping 153 matching lines @@
   String toString() => "polling";
 }
 
 class _NoneWatcherType implements WatcherType {
   const _NoneWatcherType();
 
   DirectoryWatcher create(String directory) => null;
 
   String toString() => "none";
 }