Rename "install" -> "get" and "update" -> "upgrade".

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 23 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;
 
-  /// Packages which are either currently being asynchronously installed to the
-  /// directory, or have already been installed.
-  final _installs = new Map<PackageId, Future<PackageId>>();
+  /// Packages which are either currently being asynchronously downloaded to the
+  /// directory, or have already been downloaded.

[nweiz, 2013/10/07 21:25:15]

It seems weird that the docstring says "download" but the variable name says
"get".

[Bob Nystrom, 2013/10/07 22:32:25]

Yeah. Reworded.

+  final _pendingGets = new Map<PackageId, Future<PackageId>>();
 
   /// Loads the entrypoint from a package at [rootDir].
   Entrypoint(String rootDir, SystemCache cache)
       : root = new Package.load(null, rootDir, cache.sources),
         cache = cache;
 
   // TODO(rnystrom): Make this path configurable.
   /// 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 => entryExists(lockFilePath);
 
   /// The path to the entrypoint package's lockfile.
   String get lockFilePath => path.join(root.dir, 'pubspec.lock');
 
-  /// Ensures that the package identified by [id] is installed to the directory.
-  /// Returns the resolved [PackageId].
+  /// Gets package [id] and makes it available for use by this entrypoint.
   ///
   /// If this completes successfully, the package is guaranteed to be importable
-  /// using the `package:` scheme.
+  /// using the `package:` scheme. Returns the resolved [PackageId].
   ///
-  /// This will automatically install the package to the system-wide cache as
-  /// well if it requires network access to retrieve (specifically, if the
-  /// package's source has [shouldCache] as `true`).
+  /// 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 has [shouldCache] as `true`).
   ///
-  /// See also [installDependencies].
-  Future<PackageId> install(PackageId id) {
-    var pending = _installs[id];
+  /// See also [getDependencies].
+  Future<PackageId> get(PackageId id) {
+    var pending = _pendingGets[id];
     if (pending != null) return pending;
 
     var packageDir = path.join(packagesDir, id.name);
     var source;
 
     var future = new Future.sync(() {
       ensureDir(path.dirname(packageDir));
 
       if (entryExists(packageDir)) {
         // TODO(nweiz): figure out when to actually delete the directory, and
         // when we can just re-use the existing symlink.
-        log.fine("Deleting package directory for ${id.name} before install.");
+        log.fine("Deleting package directory for ${id.name} before get.");
         deleteEntry(packageDir);
       }
 
       source = cache.sources[id.source];
 
       if (source.shouldCache) {
-        return cache.install(id).then(
+        return cache.download(id).then(
             (pkg) => createPackageSymlink(id.name, pkg.dir, packageDir));
       } else {
-        return source.install(id, packageDir).then((found) {
+        return source.get(id, packageDir).then((found) {
           if (found) return null;
           fail('Package ${id.name} not found in source "${id.source}".');
         });
       }
     }).then((_) => source.resolveId(id));
 
-    _installs[id] = future;
+    _pendingGets[id] = future;
 
     return future;
   }
 
-  /// Installs all dependencies of the [root] package to its "packages"
-  /// directory, respecting the [LockFile] if present. Returns a [Future] that
-  /// completes when all dependencies are installed.
-  Future installDependencies() {
+  /// Gets all dependencies of the [root] package and places them in its

[nweiz, 2013/10/07 21:25:15]

"Gets" -> "Downloads", since placing them in the "packages" directory is defined
as the difference between the two. Same for [upgradeDependencies] and
[upgradeAllDependencies].

[Bob Nystrom, 2013/10/07 22:32:25]

I've tried to have "download" consistently mean "put in system cache" and "get"
mean "make available for use by a package" (which may sometimes require
downloading first).

In the case where all of your dependencies are path, none of these functions
will hit the system cache, so I think "get" is right here.

[nweiz, 2013/10/07 23:23:08]

I feel like if you're going to use "get" here you shouldn't also explicitly call
out that it "places them in its 'packages' directory", since that's part of what
"get" means. Saying it explicitly makes the distinction less clear.

[Bob Nystrom, 2013/10/08 21:15:03]

Done. See: https://codereview.chromium.org/26284002

+  /// "packages" directory, respecting the [LockFile] if present. Returns a
+  /// [Future] that completes when all dependencies are available.
+  Future getDependencies() {
     return new Future.sync(() {
       return resolveVersions(cache.sources, root, lockFile: loadLockFile());
-    }).then(_installDependencies);
+    }).then(_getDependencies);
   }
 
-  /// Installs the latest available versions of all dependencies of the [root]
-  /// package to its "package" directory, writing a new [LockFile]. Returns a
-  /// [Future] that completes when all dependencies are installed.
-  Future updateAllDependencies() {
-    return resolveVersions(cache.sources, root).then(_installDependencies);
+  /// Gets the latest available versions of all dependencies of the [root]
+  /// package and places them in its "package" directory, writing a new
+  /// [LockFile]. Returns a [Future] that completes when all dependencies are
+  /// available.
+  Future upgradeAllDependencies() {
+    return resolveVersions(cache.sources, root).then(_getDependencies);
   }
 
-  /// Installs the latest available versions of [dependencies], while leaving
+  /// Gets the latest available versions of [dependencies], while leaving
   /// other dependencies as specified by the [LockFile] if possible. Returns a
-  /// [Future] that completes when all dependencies are installed.
-  Future updateDependencies(List<String> dependencies) {
+  /// [Future] that completes when all dependencies are available.
+  Future upgradeDependencies(List<String> dependencies) {
     return new Future.sync(() {
       return resolveVersions(cache.sources, root,
           lockFile: loadLockFile(), useLatest: dependencies);
-    }).then(_installDependencies);
+    }).then(_getDependencies);
   }
 
-  /// Removes the old packages directory, installs all dependencies listed in
+  /// Removes the old packages directory, gets all dependencies listed in
   /// [result], and writes a [LockFile].
-  Future _installDependencies(SolveResult result) {
+  Future _getDependencies(SolveResult result) {
     return new Future.sync(() {
       if (!result.succeeded) throw result.error;
 
       cleanDir(packagesDir);
       return Future.wait(result.packages.map((id) {
         if (id.isRoot) return new Future.value(id);
-        return install(id);
+        return get(id);
       }).toList());
     }).then((ids) {
       _saveLockFile(ids);
-      _installSelfReference();
+      _linkSelf();
       _linkSecondaryPackageDirs();
     });
   }
 
   /// Loads the list of concrete package versions from the `pubspec.lock`, if it
   /// exists. If it doesn't, this completes to an empty [LockFile].
   LockFile loadLockFile() {
     if (!lockFileExists) return new LockFile.empty();
     return new LockFile.load(lockFilePath, cache.sources);
   }
@@ skipping 49 matching lines @@
   void _saveLockFile(List<PackageId> packageIds) {
     var lockFile = new LockFile.empty();
     for (var id in packageIds) {
       if (!id.isRoot) lockFile.packages[id.name] = id;
     }
 
     var lockFilePath = path.join(root.dir, 'pubspec.lock');
     writeTextFile(lockFilePath, lockFile.serialize());
   }
 
-  /// Installs a self-referential symlink in the `packages` directory that will
-  /// allow a package to import its own files using `package:`.
-  void _installSelfReference() {
+  /// Creates a self-referential symlink in the `packages` directory that allows
+  /// 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.
@@ skipping 82 matching lines @@
         // Skip directories and broken symlinks.
         if (!fileExists(file)) return false;
 
         var relative = path.relative(file, from: beneath);
         if (_BLACKLISTED_FILES.contains(path.basename(relative))) return false;
         return !path.split(relative).any(_BLACKLISTED_DIRS.contains);
       }).toList();
     });
   }
 }