Add a --[no]-packages-dir flag.

lib/src/entrypoint.dart

 // Copyright (c) 2012, 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.
 
 import 'dart:async';
 import 'dart:io';
 
 import 'package:barback/barback.dart';
 import 'package:package_config/packages_file.dart' as packages_file;
 import 'package:path/path.dart' as p;
@@ skipping 53 matching lines @@
 /// contains a reusable library may not be the entrypoint when used by an app,
 /// but may be the entrypoint when you're running its tests.
 class Entrypoint {
   /// The root package this entrypoint is associated with.
   final Package root;
 
   /// The system-wide cache which caches packages that need to be fetched over
   /// the network.
   final SystemCache cache;
 
-  /// Whether to create and symlink a "packages" directory containing links to
-  /// the installed packages.
-  final bool _packageSymlinks;
-
   /// Whether this entrypoint is in memory only, as opposed to representing a
   /// real directory on disk.
   final bool _inMemory;
 
   /// Whether this is an entrypoint for a globally-activated package.
   final bool isGlobal;
 
   /// The lockfile for the entrypoint.
   ///
   /// If not provided to the entrypoint, it will be loaded lazily from disk.
@@ skipping 24 matching lines @@
         key: (id) => id.name,
         value: (id) => cache.load(id));
     packages[root.name] = root;
 
     _packageGraph = new PackageGraph(this, lockFile, packages);
     return _packageGraph;
   }
   PackageGraph _packageGraph;
 
   /// The path to the entrypoint's "packages" directory.
-  String get packagesDir => root.path('packages');
+  String get packagesPath => root.path('packages');
 
   /// The path to the entrypoint's ".packages" file.
   String get packagesFile => root.path('.packages');
 
   /// The path to the entrypoint package's pubspec.
   String get pubspecPath => root.path('pubspec.yaml');
 
   /// The path to the entrypoint package's lockfile.
   String get lockFilePath => root.path('pubspec.lock');
 
   /// The path to the directory containing precompiled dependencies.
   ///
   /// We just precompile the debug version of a package. We're mostly interested
   /// in improving speed for development iteration loops, which usually use
   /// debug mode.
   String get _precompiledDepsPath => root.path('.pub', 'deps', 'debug');
 
   /// The path to the directory containing dependency executable snapshots.
   String get _snapshotPath => root.path('.pub', 'bin');
 
   /// Loads the entrypoint from a package at [rootDir].
-  ///
-  /// If [packageSymlinks] is `true`, this will create a "packages" directory
-  /// with symlinks to the installed packages. This directory will be symlinked
-  /// into any directory that might contain an entrypoint.
-  Entrypoint(String rootDir, SystemCache cache, {bool packageSymlinks: true,
-          this.isGlobal: false})
+  Entrypoint(String rootDir, SystemCache cache, {this.isGlobal: false})
       : root = new Package.load(null, rootDir, cache.sources),
         cache = cache,
-        _packageSymlinks = packageSymlinks,
         _inMemory = false;
 
   /// Creates an entrypoint given package and lockfile objects.
   Entrypoint.inMemory(this.root, this._lockFile, this.cache,
           {this.isGlobal: false})
-      : _packageSymlinks = false,
-        _inMemory = true;
+      : _inMemory = true;
 
   /// Creates an entrypoint given a package and a [solveResult], from which the
   /// package graph and lockfile will be computed.
   Entrypoint.fromSolveResult(this.root, this.cache, SolveResult solveResult,
           {this.isGlobal: false})
-      : _packageSymlinks = false,
-        _inMemory = true {
+      : _inMemory = true {
     _packageGraph = new PackageGraph.fromSolveResult(this, solveResult);
     _lockFile = _packageGraph.lockFile;
   }
 
   /// Gets all dependencies of the [root] package.
   ///
   /// Performs version resolution according to [SolveType].
   ///
   /// [useLatest], if provided, defines a list of packages that will be
   /// unlocked and forced to their latest versions. If [upgradeAll] is
   /// true, the previous lockfile is ignored and all packages are re-resolved
   /// from scratch. Otherwise, it will attempt to preserve the versions of all
   /// previously locked packages.
   ///
   /// Shows a report of the changes made relative to the previous lockfile. If
   /// this is an upgrade or downgrade, all transitive dependencies are shown in
   /// the report. Otherwise, only dependencies that were changed are shown. If
   /// [dryRun] is `true`, no physical changes are made.
   ///
   /// If [precompile] is `true` (the default), this snapshots dependencies'
   /// executables and runs transformers on transformed dependencies.
   ///
+  /// If [packagesDir] is `true`, this will create "packages" directory with
+  /// symlinks to the installed packages. This directory will be symlinked into
+  /// any directory that might contain an entrypoint.
+  ///
   /// Updates [lockFile] and [packageRoot] accordingly.
   Future acquireDependencies(SolveType type, {List<String> useLatest,
-      bool dryRun: false, bool precompile: true}) async {
+      bool dryRun: false, bool precompile: true, bool packagesDir: false})

[Bob Nystrom, 2016/08/16 22:19:43]

The name "packagesDir" reads like it *is* the packages directory, not whether or
not there should be one. How about maybe "generatePackagesDir"? I know that's
kind of long, though.

[nweiz, 2016/08/16 22:27:57]

I generally prefer short names to totally unambiguous names, especially for
named parameters. I think the fact that this is the same as the command-line
argument is enough to make it pretty clear.

+      async {
     var result = await resolveVersions(type, cache, root,
         lockFile: lockFile, useLatest: useLatest);
     if (!result.succeeded) throw result.error;
 
     result.showReport(type);
 
     if (dryRun) {
       result.summarizeChanges(type, dryRun: dryRun);
       return;
     }
 
     // Install the packages and maybe link them into the entrypoint.
-    if (_packageSymlinks) {
-      cleanDir(packagesDir);
+    if (packagesDir) {
+      cleanDir(packagesPath);
     } else {
-      deleteEntry(packagesDir);
+      deleteEntry(packagesPath);
     }
 
-    await Future.wait(result.packages.map(_get));
+    await Future.wait(result.packages
+        .map((id) => _get(id, packagesDir: packagesDir)));
     _saveLockFile(result);
 
-    if (_packageSymlinks) _linkSelf();
-    _linkOrDeleteSecondaryPackageDirs();
+    if (packagesDir) _linkSelf();
+    _linkOrDeleteSecondaryPackageDirs(packagesDir: packagesDir);
 
     result.summarizeChanges(type, dryRun: dryRun);
 
     /// Build a package graph from the version solver results so we don't
     /// have to reload and reparse all the pubspecs.
     _packageGraph = new PackageGraph.fromSolveResult(this, result);
     packageGraph.loadTransformerCache().clearIfOutdated(result.changedPackages);
 
     try {
       if (precompile) {
@@ skipping 217 matching lines @@
 
     // Otherwise, we don't need to recompile.
     return [];
   }
 
   /// Makes sure the package at [id] is locally available.
   ///
   /// This automatically downloads the package to the system-wide cache as well
   /// if it requires network access to retrieve (specifically, if the package's
   /// source is a [CachedSource]).
-  Future _get(PackageId id) async {
+  Future _get(PackageId id, {bool packagesDir: false}) async {
     if (id.isRoot) return;
 
     var source = cache.source(id.source);
-    if (!_packageSymlinks) {
+    if (!packagesDir) {
       if (source is CachedSource) await source.downloadToSystemCache(id);
       return;
     }
 
-    var packageDir = p.join(packagesDir, id.name);
-    if (entryExists(packageDir)) deleteEntry(packageDir);
-    await source.get(id, packageDir);
+    var packagePath = p.join(packagesPath, id.name);
+    if (entryExists(packagePath)) deleteEntry(packagePath);
+    await source.get(id, packagePath);
   }
 
   /// Throws a [DataError] if the `.packages` file doesn't exist or if it's
   /// out-of-date relative to the lockfile or the pubspec.
   void assertUpToDate() {
     if (_inMemory) return;
 
     if (!entryExists(lockFilePath)) {
       dataError('No pubspec.lock file found, please run "pub get" first.');
     }
@@ skipping 173 matching lines @@
   /// Saves a list of concrete package versions to the `pubspec.lock` file.
   void _saveLockFile(SolveResult result) {
     _lockFile = result.lockFile;
     var lockFilePath = root.path('pubspec.lock');
     writeTextFile(lockFilePath, _lockFile.serialize(root.dir));
   }
 
   /// Creates a self-referential symlink in the `packages` directory that allows
   /// a package to import its own files using `package:`.
   void _linkSelf() {
-    var linkPath = p.join(packagesDir, root.name);
+    var linkPath = p.join(packagesPath, root.name);
     // Create the symlink if it doesn't exist.
     if (entryExists(linkPath)) return;
-    ensureDir(packagesDir);
+    ensureDir(packagesPath);
     createPackageSymlink(root.name, root.dir, linkPath,
         isSelfLink: true, relative: true);
   }
 
-  /// If [packageSymlinks] is true, add "packages" directories to the whitelist
-  /// of directories that may contain Dart entrypoints.
+  /// If [packagesDir] is true, add "packages" directories to the whitelist of
+  /// directories that may contain Dart entrypoints.
   ///
   /// Otherwise, delete any "packages" directories in the whitelist of
   /// directories that may contain Dart entrypoints.
-  void _linkOrDeleteSecondaryPackageDirs() {
+  void _linkOrDeleteSecondaryPackageDirs({bool packagesDir: false}) {
     // Only the main "bin" directory gets a "packages" directory, not its
     // subdirectories.
     var binDir = root.path('bin');
-    if (dirExists(binDir)) _linkOrDeleteSecondaryPackageDir(binDir);
+    if (dirExists(binDir)) {
+      _linkOrDeleteSecondaryPackageDir(binDir, packagesDir: packagesDir);
+    }
 
     // The others get "packages" directories in subdirectories too.
     for (var dir in ['benchmark', 'example', 'test', 'tool', 'web']) {
-      _linkOrDeleteSecondaryPackageDirsRecursively(root.path(dir));
+      _linkOrDeleteSecondaryPackageDirsRecursively(root.path(dir),
+          packagesDir: packagesDir);
     }
  }
 
-  /// If [packageSymlinks] is true, creates a symlink to the "packages"
-  /// directory in [dir] and all its subdirectories.
+  /// If [packagesDir] is true, creates a symlink to the "packages" directory in
+  /// [dir] and all its subdirectories.
   ///
   /// Otherwise, deletes any "packages" directories in [dir] and all its
   /// subdirectories.
-  void _linkOrDeleteSecondaryPackageDirsRecursively(String dir) {
+  void _linkOrDeleteSecondaryPackageDirsRecursively(String dir,
+      {bool packagesDir: false}) {
     if (!dirExists(dir)) return;
-    _linkOrDeleteSecondaryPackageDir(dir);
-    _listDirWithoutPackages(dir)
-        .where(dirExists)
-        .forEach(_linkOrDeleteSecondaryPackageDir);
+    _linkOrDeleteSecondaryPackageDir(dir, packagesDir: packagesDir);
+    for (var subdir in _listDirWithoutPackages(dir)) {
+      if (!dirExists(subdir)) continue;
+      _linkOrDeleteSecondaryPackageDir(subdir, packagesDir: packagesDir);
+    }
   }
 
   // TODO(nweiz): roll this into [listDir] in io.dart once issue 4775 is fixed.
   /// Recursively lists the contents of [dir], excluding hidden `.DS_Store`
   /// files and `package` files.
   List<String> _listDirWithoutPackages(dir) {
     return listDir(dir).expand/*<String>*/((file) {
       if (p.basename(file) == 'packages') return [];
       if (!dirExists(file)) return [];
       var fileAndSubfiles = [file];
       fileAndSubfiles.addAll(_listDirWithoutPackages(file));
       return fileAndSubfiles;
     });
   }
 
-  /// If [packageSymlinks] is true, creates a symlink to the "packages"
-  /// directory in [dir].
+  /// If [packagesDir] is true, creates a symlink to the "packages" directory in
+  /// [dir].
   ///
   /// Otherwise, deletes a "packages" directories in [dir] if one exists.
-  void _linkOrDeleteSecondaryPackageDir(String dir) {
+  void _linkOrDeleteSecondaryPackageDir(String dir, {bool packagesDir: false}) {
     var symlink = p.join(dir, 'packages');
     if (entryExists(symlink)) deleteEntry(symlink);
-    if (_packageSymlinks) createSymlink(packagesDir, symlink, relative: true);
+    if (packagesDir) createSymlink(packagesPath, symlink, relative: true);
   }
 }