Get rid of old redundant methods in io.dart.

utils/pub/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 entrypoint;
 
 import 'dart:async';
+
+import '../../pkg/path/lib/path.dart' as path;
+
 import 'io.dart';
 import 'lock_file.dart';
 import 'log.dart' as log;
 import 'package.dart';
 import 'pubspec.dart';
 import 'sdk.dart' as sdk;
 import 'system_cache.dart';
 import 'utils.dart';
 import 'version.dart';
 import 'version_solver.dart';
@@ skipping 24 matching lines @@
   /// Packages which are either currently being asynchronously installed to the
   /// directory, or have already been installed.
   final _installs = 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 this "packages" directory.
-  String get path => join(root.dir, 'packages');
+  /// The path to the entrypoint's "packages" directory.
+  String get packagesDir => join(root.dir, 'packages');
 
   /// Ensures that the package identified by [id] is installed to the directory.
   /// Returns the resolved [PackageId].
   ///
   /// If this completes successfully, the package is guaranteed to be importable
   /// using the `package:` scheme.
   ///
   /// This will automatically install the package to the system-wide cache as
   /// well if it requires network access to retrieve (specifically, if
   /// `id.source.shouldCache` is true).
   ///
   /// See also [installDependencies].
   Future<PackageId> install(PackageId id) {
     var pendingOrCompleted = _installs[id];
     if (pendingOrCompleted != null) return pendingOrCompleted;
 
-    var packageDir = join(path, id.name);
+    var packageDir = join(packagesDir, id.name);
     var future = defer(() {
-      ensureDir(dirname(packageDir));
+      ensureDir(path.dirname(packageDir));
       if (!dirExists(packageDir)) return;
 
       // 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.");
       return deleteDir(packageDir);
     }).then((_) {
       if (id.source.shouldCache) {
         return cache.install(id).then(
             (pkg) => createPackageSymlink(id.name, pkg.dir, packageDir));
@@ skipping 37 matching lines @@
       for (var dependency in dependencies) {
         solver.useLatestVersion(dependency);
       }
       return solver.solve();
     }).then(_installDependencies);
   }
 
   /// Removes the old packages directory, installs all dependencies listed in
   /// [packageVersions], and writes a [LockFile].
   Future _installDependencies(List<PackageId> packageVersions) {
-    return cleanDir(path).then((_) {
+    return cleanDir(packagesDir).then((_) {
       return Future.wait(packageVersions.map((id) {
         if (id.isRoot) return new Future.immediate(id);
         return install(id);
       }));
     }).then(_saveLockFile)
       .then(_installSelfReference)
       .then(_linkSecondaryPackageDirs);
   }
 
   /// Traverses the root's package dependency graph and loads each of the
@@ skipping 76 matching lines @@
     }
 
     var lockFilePath = 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:`.
   Future _installSelfReference(_) {
     return defer(() {
-      var linkPath = join(path, root.name);
+      var linkPath = join(packagesDir, root.name);
       // Create the symlink if it doesn't exist.
       if (entryExists(linkPath)) return;
-      ensureDir(path);
+      ensureDir(packagesDir);
       return createPackageSymlink(root.name, root.dir, linkPath,
           isSelfLink: true);
     });
   }
 
   /// If `bin/`, `test/`, or `example/` directories exist, symlink `packages/`
   /// into them so that their entrypoints can be run. Do the same for any
   /// subdirectories of `test/` and `example/`.
   Future _linkSecondaryPackageDirs(_) {
     var binDir = join(root.dir, 'bin');
@@ skipping 27 matching lines @@
       });
     });
   }
 
   // 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.
   Future<List<String>> _listDirWithoutPackages(dir) {
     return listDir(dir).then((files) {
       return Future.wait(files.map((file) {
-        if (basename(file) == 'packages') return new Future.immediate([]);
+        if (path.basename(file) == 'packages') return new Future.immediate([]);
         return defer(() {
           if (!dirExists(file)) return [];
           return _listDirWithoutPackages(file);
         }).then((subfiles) {
           var fileAndSubfiles = [file];
           fileAndSubfiles.addAll(subfiles);
           return fileAndSubfiles;
         });
       }));
     }).then(flatten);
   }
 
   /// Creates a symlink to the `packages` directory in [dir] if none exists.
   Future _linkSecondaryPackageDir(String dir) {
     return defer(() {
       var to = join(dir, 'packages');
       if (entryExists(to)) return;
-      return createSymlink(path, to);
+      return createSymlink(packagesDir, to);
     });
   }
 }