Add a hidden --no-package-symlinks flag.

sdk/lib/_internal/pub/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.
 
 library pub.entrypoint;
 
 import 'dart:async';
 
 import 'package:path/path.dart' as path;
 
@@ skipping 25 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;
+
   /// The lockfile for the entrypoint.
   ///
   /// If not provided to the entrypoint, it will be laoded lazily from disc.
   LockFile _lockFile;
 
   /// Loads the entrypoint from a package at [rootDir].
-  Entrypoint(String rootDir, SystemCache cache)
+  ///
+  /// 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})
       : root = new Package.load(null, rootDir, cache.sources),
-        cache = cache;
+        cache = cache,
+        _packageSymlinks = packageSymlinks;
 
   /// Creates an entrypoint given package and lockfile objects.
-  Entrypoint.inMemory(this.root, this._lockFile, this.cache);
+  Entrypoint.inMemory(this.root, this._lockFile, this.cache)
+      : _packageSymlinks = false;
 
   /// The path to the entrypoint's "packages" directory.
   String get packagesDir => path.join(root.dir, 'packages');
 
   /// `true` if the entrypoint package currently has a lock file.
   bool get lockFileExists => _lockFile != null || entryExists(lockFilePath);
 
   LockFile get lockFile {
     if (_lockFile != null) return _lockFile;
 
@@ skipping 34 matching lines @@
     }).then((result) {
       if (!result.succeeded) throw result.error;
 
       result.showReport(type);
 
       if (dryRun) {
         result.summarizeChanges(type, dryRun: dryRun);
         return null;
       }
 
-      // Install the packages.
-      cleanDir(packagesDir);
+      // Install the packages and maybe link them into the entrypoint.
+      if (_packageSymlinks) {
+        cleanDir(packagesDir);
+      } else {
+        deleteEntry(packagesDir);
+      }
+
       return Future.wait(result.packages.map(_get)).then((ids) {
         _saveLockFile(ids);
-        _linkSelf();
-        _linkSecondaryPackageDirs();
+
+        if (_packageSymlinks) _linkSelf();
+        _linkOrDeleteSecondaryPackageDirs();
+
         result.summarizeChanges(type, dryRun: dryRun);
       });
     });
   }
 
   /// 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<PackageId> _get(PackageId id) {
     if (id.isRoot) return new Future.value(id);
 
-    var packageDir = path.join(packagesDir, id.name);
-    if (entryExists(packageDir)) deleteEntry(packageDir);
+    var source = cache.sources[id.source];
+    return syncFuture(() {
+      if (!_packageSymlinks) {
+        if (source is! CachedSource) return null;
+        return source.downloadToSystemCache(id);
+      }
 
-    var source = cache.sources[id.source];
-    return source.get(id, packageDir).then((_) => source.resolveId(id));
+      var packageDir = path.join(packagesDir, id.name);
+      if (entryExists(packageDir)) deleteEntry(packageDir);
+      return source.get(id, packageDir);
+    }).then((_) => source.resolveId(id));
   }
 
   /// Determines whether or not the lockfile is out of date with respect to the
   /// pubspec.
   ///
   /// This will be `false` if there is no lockfile at all, or if the pubspec
   /// contains dependencies that are not in the lockfile or that don't match
   /// what's in there.
   bool _isLockFileUpToDate(LockFile lockFile) {
     return root.immediateDependencies.every((package) {
@@ skipping 104 matching lines @@
   /// a package to import its own files using `package:`.
   void _linkSelf() {
     var linkPath = path.join(packagesDir, root.name);
     // Create the symlink if it doesn't exist.
     if (entryExists(linkPath)) return;
     ensureDir(packagesDir);
     createPackageSymlink(root.name, root.dir, linkPath,
         isSelfLink: true, relative: true);
   }
 
-  /// Add "packages" directories to the whitelist of directories that may
-  /// contain Dart entrypoints.
-  void _linkSecondaryPackageDirs() {
+  /// If [packageSymlinks] 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() {
     // Only the main "bin" directory gets a "packages" directory, not its
     // subdirectories.
     var binDir = path.join(root.dir, 'bin');
-    if (dirExists(binDir)) _linkSecondaryPackageDir(binDir);
+    if (dirExists(binDir)) _linkOrDeleteSecondaryPackageDir(binDir);
 
     // The others get "packages" directories in subdirectories too.
     for (var dir in ['benchmark', 'example', 'test', 'tool', 'web']) {
-      _linkSecondaryPackageDirsRecursively(path.join(root.dir, dir));
+      _linkOrDeleteSecondaryPackageDirsRecursively(path.join(root.dir, dir));
     }
  }
 
-  /// Creates a symlink to the `packages` directory in [dir] and all its
+  /// If [packageSymlinks] 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 _linkSecondaryPackageDirsRecursively(String dir) {
+  void _linkOrDeleteSecondaryPackageDirsRecursively(String dir) {
     if (!dirExists(dir)) return;
-    _linkSecondaryPackageDir(dir);
+    _linkOrDeleteSecondaryPackageDir(dir);
     _listDirWithoutPackages(dir)
         .where(dirExists)
-        .forEach(_linkSecondaryPackageDir);
+        .forEach(_linkOrDeleteSecondaryPackageDir);
   }
 
   // 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 flatten(listDir(dir).map((file) {
       if (path.basename(file) == 'packages') return [];
       if (!dirExists(file)) return [];
       var fileAndSubfiles = [file];
       fileAndSubfiles.addAll(_listDirWithoutPackages(file));
       return fileAndSubfiles;
     }));
   }
 
-  /// Creates a symlink to the `packages` directory in [dir]. Will replace one
-  /// if already there.
-  void _linkSecondaryPackageDir(String dir) {
+  /// If [packageSymlinks] 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) {
     var symlink = path.join(dir, 'packages');
     if (entryExists(symlink)) deleteEntry(symlink);
-    createSymlink(packagesDir, symlink, relative: true);
+    if (_packageSymlinks) createSymlink(packagesDir, symlink, relative: true);
   }
 }