Clean up the semantics of package descriptions.

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;
 import 'package:barback/barback.dart';
 import 'package:pub_semver/pub_semver.dart';
 
 import 'barback/asset_environment.dart';
 import 'entrypoint.dart';
 import 'exceptions.dart';
 import 'executable.dart' as exe;
 import 'io.dart';
 import 'lock_file.dart';
 import 'log.dart' as log;
 import 'package.dart';
 import 'pubspec.dart';
 import 'sdk.dart' as sdk;
 import 'solver/version_solver.dart';
 import 'source/cached.dart';
 import 'source/git.dart';
+import 'source/hosted.dart';
 import 'source/path.dart';
 import 'system_cache.dart';
 import 'utils.dart';
 
 /// Maintains the set of packages that have been globally activated.
 ///
 /// These have been hand-chosen by the user to make their executables in bin/
 /// available to the entire system. This lets them access them even when the
 /// current working directory is not inside another entrypoint package.
 ///
@@ skipping 47 matching lines @@
     var source = cache.sources["git"] as GitSource;
     var name = await source.getPackageNameFromRepo(repo);
     // Call this just to log what the current active package is, if any.
     _describeActive(name);
 
     // TODO(nweiz): Add some special handling for git repos that contain path
     // dependencies. Their executables shouldn't be cached, and there should
     // be a mechanism for redoing dependency resolution if a path pubspec has
     // changed (see also issue 20499).
     await _installInCache(
-        new PackageDep(name, "git", VersionConstraint.any, repo),
+        GitSource.refFor(name, repo).withConstraint(VersionConstraint.any),
         executables, overwriteBinStubs: overwriteBinStubs);
   }
 
   /// Finds the latest version of the hosted package with [name] that matches
   /// [constraint] and makes it the active global version.
   ///
   /// [executables] is the names of the executables that should have binstubs.
   /// If `null`, all executables in the package will get binstubs. If empty, no
   /// 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 activateHosted(String name, VersionConstraint constraint,
       List<String> executables, {bool overwriteBinStubs}) async {
     _describeActive(name);
-    await _installInCache(new PackageDep(name, "hosted", constraint, name),
+    await _installInCache(HostedSource.refFor(name).withConstraint(constraint),
         executables, overwriteBinStubs: overwriteBinStubs);
   }
 
   /// Makes the local package at [path] globally active.
   ///
   /// [executables] is the names of the executables that should have binstubs.
   /// If `null`, all executables in the package will get binstubs. If empty, no
   /// 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, isGlobal: true);
 
     // Get the package's dependencies.
     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));
+    var id = PathSource.idFor(name, entrypoint.root.version, fullPath);
 
     // TODO(rnystrom): Look in "bin" and display list of binaries that
     // user can run.
     _writeLockFile(name, new LockFile([id], cache.sources));
 
     var binDir = p.join(_directory, name, 'bin');
     if (dirExists(binDir)) deleteEntry(binDir);
 
     _updateBinStubs(entrypoint.root, executables,
         overwriteBinStubs: overwriteBinStubs);
@@ skipping 11 matching lines @@
     if (!result.succeeded) {
       // If the package specified by the user doesn't exist, we want to
       // surface that as a [DataError] with the associated exit code.
       if (result.error.package != dep.name) throw result.error;
       if (result.error is NoVersionException) dataError(result.error.message);
       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);
+    await Future.wait(result.packages.map(_cacheDependency));
+    var lockFile = new LockFile(result.packages, cache.sources);
 
     // Load the package graph from [result] so we don't need to re-parse all
     // the pubspecs.
     var entrypoint = new Entrypoint.fromSolveResult(root, cache, result,
         isGlobal: true);
     var snapshots = await _precompileExecutables(entrypoint, dep.name);
     _writeLockFile(dep.name, lockFile);
     writeTextFile(_getPackagesFilePath(dep.name), lockFile.packagesFile());
 
     _updateBinStubs(entrypoint.packageGraph.packages[dep.name], executables,
@@ skipping 17 matching lines @@
           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.
-  ///
-  /// Returns the resolved [PackageId] for [id].
-  Future<PackageId> _cacheDependency(PackageId id) async {
+  Future _cacheDependency(PackageId id) async {
+    if (id.isRoot) return;
+
     var source = cache.sources[id.source];
+    if (source is! CachedSource) return;
 
-    if (!id.isRoot && source is CachedSource) {
-      await source.downloadToSystemCache(id);
-    }
-
-    return source.resolveId(id);
+    await source.downloadToSystemCache(id);
   }
 
   /// Finishes activating package [package] by saving [lockFile] in the cache.
   void _writeLockFile(String package, LockFile lockFile) {
     ensureDir(p.join(_directory, package));
 
     // TODO(nweiz): This cleans up Dart 1.6's old lockfile location. Remove it
     // when Dart 1.6 is old enough that we don't think anyone will have these
     // lockfiles anymore (issue 20703).
     var oldPath = p.join(_directory, "$package.lock");
@@ skipping 565 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];
   }
 }