Don't implicitly run "pub get".

lib/src/global_packages.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.global_packages;
 
 import 'dart:async';
 import 'dart:io';
 
 import 'package:path/path.dart' as p;
@@ skipping 108 matching lines @@
   /// binstubs will be created.
   ///
   /// if [overwriteBinStubs] is `true`, any binstubs that collide with
   /// existing binstubs in other packages will be overwritten by this one's.
   /// Otherwise, the previous ones will be preserved.
   Future activatePath(String path, List<String> executables,
       {bool overwriteBinStubs}) async {
     var entrypoint = new Entrypoint(path, cache);
 
     // Get the package's dependencies.
-    await entrypoint.ensureLockFileIsUpToDate();
+    await entrypoint.acquireDependencies(SolveType.GET);
     var name = entrypoint.root.name;
 
     // Call this just to log what the current active package is, if any.
     _describeActive(name);
 
     // Write a lockfile that points to the local package.
     var fullPath = canonicalize(entrypoint.root.dir);
     var id = new PackageId(name, "path", entrypoint.root.version,
         PathSource.describePath(fullPath));
 
@@ skipping 25 matching lines @@
       throw result.error;
     }
     result.showReport(SolveType.GET);
 
     // Make sure all of the dependencies are locally installed.
     var ids = await Future.wait(result.packages.map(_cacheDependency));
     var lockFile = new LockFile(ids, cache.sources);
 
     // Load the package graph from [result] so we don't need to re-parse all
     // the pubspecs.
-    var graph = await new Entrypoint.inMemory(root, lockFile, cache)
-        .loadPackageGraph(result);
-    var snapshots = await _precompileExecutables(graph.entrypoint, dep.name);
+    var entrypoint = new Entrypoint.fromSolveResult(root, cache, result);
+    var snapshots = await _precompileExecutables(entrypoint, dep.name);
     _writeLockFile(dep.name, lockFile);
     writeTextFile(_getPackagesFilePath(dep.name), lockFile.packagesFile());
 
-    _updateBinStubs(graph.packages[dep.name], executables,
+    _updateBinStubs(entrypoint.packageGraph.packages[dep.name], executables,
         overwriteBinStubs: overwriteBinStubs, snapshots: snapshots);
   }
 
   /// Precompiles the executables for [package] and saves them in the global
   /// cache.
   ///
   /// Returns a map from executable name to path for the snapshots that were
   /// successfully precompiled.
   Future<Map<String, String>> _precompileExecutables(Entrypoint entrypoint,
       String package) {
     return log.progress("Precompiling executables", () async {
       var binDir = p.join(_directory, package, 'bin');
       cleanDir(binDir);
 
-      var graph = await entrypoint.loadPackageGraph();
       var environment = await AssetEnvironment.create(
           entrypoint, BarbackMode.RELEASE,
-          entrypoints: graph.packages[package].executableIds,
+          entrypoints: entrypoint.packageGraph.packages[package].executableIds,
           useDart2JS: false);
       environment.barback.errors.listen((error) {
         log.error(log.red("Build error:\n$error"));
       });
 
       return environment.precompileExecutables(package, binDir);
     });
   }
 
   /// Downloads [id] into the system cache if it's a cached package.
@@ skipping 142 matching lines @@
       log.verbosity = log.Verbosity.WARNING;
     }
 
     var snapshotPath = p.join(binDir, '$executable.dart.snapshot');
     return exe.runSnapshot(snapshotPath, args,
         checked: checked,
         packagesFile: _getPackagesFilePath(package),
         recompile: () async {
       log.fine("$package:$executable is out of date and needs to be "
           "recompiled.");
-      var graph = await find(package).loadPackageGraph();
-      await _precompileExecutables(graph.entrypoint, package);
+      await _precompileExecutables(
+          find(package).packageGraph.entrypoint, package);
     });
   }
 
   /// Gets the path to the lock file for an activated cached package with
   /// [name].
   String _getLockFilePath(String name) =>
       p.join(_directory, name, "pubspec.lock");
 
   /// Gets the path to the .packages file for an activated cached package with
   /// [name].
@@ skipping 78 matching lines @@
     var successes = [];
     var failures = [];
     if (dirExists(_directory)) {
       for (var entry in listDir(_directory)) {
         var id;
         try {
           id = _loadPackageId(entry);
           log.message("Reactivating ${log.bold(id.name)} ${id.version}...");
 
           var entrypoint = find(id.name);
-          var graph = await entrypoint.loadPackageGraph();
           var snapshots = await _precompileExecutables(entrypoint, id.name);
           var packageExecutables = executables.remove(id.name);
           if (packageExecutables == null) packageExecutables = [];
-          _updateBinStubs(graph.packages[id.name], packageExecutables,
-              overwriteBinStubs: true, snapshots: snapshots,
+          _updateBinStubs(
+              entrypoint.packageGraph.packages[id.name],
+              packageExecutables,
+              overwriteBinStubs: true,
+              snapshots: snapshots,
               suggestIfNotOnPath: false);
           successes.add(id.name);
         } catch (error, stackTrace) {
           var message = "Failed to reactivate "
               "${log.bold(p.basenameWithoutExtension(entry))}";
           if (id != null) {
             message += " ${id.version}";
             if (id.source != "hosted") message += " from ${id.source}";
           }
 
@@ skipping 306 matching lines @@
   }
 
   /// Returns the value of the property named [name] in the bin stub script
   /// [source].
   String _binStubProperty(String source, String name) {
     var pattern = new RegExp(quoteRegExp(name) + r": ([a-zA-Z0-9_-]+)");
     var match = pattern.firstMatch(source);
     return match == null ? null : match[1];
   }
 }