Refactor Source and SourceRegistry.

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.
 
 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.
 ///
 /// Only one version of a given package name can be globally activated at a
@@ skipping 36 matching lines @@
   ///
   /// [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 activateGit(String repo, List<String> executables,
       {bool overwriteBinStubs}) async {
-    var source = cache.sources["git"] as GitSource;
-    var name = await source.getPackageNameFromRepo(repo);
+    var name = await cache.git.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(
-        GitSource.refFor(name, repo).withConstraint(VersionConstraint.any),
+        cache.git.source.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(HostedSource.refFor(name).withConstraint(constraint),
-        executables, overwriteBinStubs: overwriteBinStubs);
+    await _installInCache(
+        cache.hosted.source.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 = PathSource.idFor(name, entrypoint.root.version, fullPath);
+    var id = cache.path.source.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);
   }
 
   /// Installs the package [dep] and its dependencies into the system cache.
   Future _installInCache(PackageDep dep, List<String> executables,
       {bool overwriteBinStubs}) async {
     // Create a dummy package with just [dep] so we can do resolution on it.
     var root = new Package.inMemory(new Pubspec("pub global activate",
         dependencies: [dep], sources: cache.sources));
 
     // Resolve it and download its dependencies.
-    var result = await resolveVersions(SolveType.GET, cache.sources, root);
+    var result = await resolveVersions(SolveType.GET, cache, root);
     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.
     await Future.wait(result.packages.map(_cacheDependency));
 
     // 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);
 
     var lockFile = result.lockFile;
     _writeLockFile(dep.name, lockFile);
-    writeTextFile(_getPackagesFilePath(dep.name), lockFile.packagesFile());
+    writeTextFile(_getPackagesFilePath(dep.name), lockFile.packagesFile(cache));
 
     _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.
@@ skipping 12 matching lines @@
       });
 
       return environment.precompileExecutables(package, binDir);
     });
   }
 
   /// Downloads [id] into the system cache if it's a cached package.
   Future _cacheDependency(PackageId id) async {
     if (id.isRoot) return;
 
-    var source = cache.sources[id.source];
+    var source = cache.source(id.source);
     if (source is! CachedSource) return;
 
     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");
     if (fileExists(oldPath)) deleteEntry(oldPath);
 
     writeTextFile(_getLockFilePath(package), lockFile.serialize(cache.rootDir));
 
     var id = lockFile.packages[package];
     log.message('Activated ${_formatPackage(id)}.');
   }
 
   /// Shows the user the currently active package with [name], if any.
   void _describeActive(String name) {
     try {
       var lockFile = new LockFile.load(_getLockFilePath(name), cache.sources);
       var id = lockFile.packages[name];
 
       if (id.source == 'git') {
-        var url = GitSource.urlFromDescription(id.description);
+        var url = cache.git.source.urlFromDescription(id.description);
         log.message('Package ${log.bold(name)} is currently active from Git '
             'repository "${url}".');
       } else if (id.source == 'path') {
-        var path = PathSource.pathFromDescription(id.description);
+        var path = cache.path.source.pathFromDescription(id.description);
         log.message('Package ${log.bold(name)} is currently active at path '
             '"$path".');
       } else {
         log.message('Package ${log.bold(name)} is currently active at version '
             '${log.bold(id.version)}.');
       }
     } on IOException {
       // If we couldn't read the lock file, it's not activated.
       return null;
     }
@@ skipping 41 matching lines @@
       ensureDir(p.dirname(lockFilePath));
       new File(oldLockFilePath).renameSync(lockFilePath);
     }
 
     // Remove the package itself from the lockfile. We put it in there so we
     // could find and load the [Package] object, but normally an entrypoint
     // doesn't expect to be in its own lockfile.
     var id = lockFile.packages[name];
     lockFile = lockFile.removePackage(name);
 
-    var source = cache.sources[id.source];
+    var source = cache.source(id.source);
     var entrypoint;
     if (source is CachedSource) {
       // For cached sources, the package itself is in the cache and the
       // lockfile is the one we just loaded.
       entrypoint = new Entrypoint.inMemory(
-          cache.sources.load(id), lockFile, cache, isGlobal: true);
+          cache.load(id), lockFile, cache, isGlobal: true);
     } else {
       // For uncached sources (i.e. path), the ID just points to the real
       // directory for the package.
       assert(id.source == "path");
       entrypoint = new Entrypoint(
-          PathSource.pathFromDescription(id.description), cache,
+          cache.path.source.pathFromDescription(id.description), cache,
           isGlobal: true);
     }
 
     if (entrypoint.root.pubspec.environment.sdkVersion.allows(sdk.version)) {
       return entrypoint;
     }
 
     dataError("${log.bold(name)} ${entrypoint.root.version} doesn't support "
         "Dart ${sdk.version}.");
   }
@@ skipping 72 matching lines @@
       throw new FormatException("Pubspec for activated package $name didn't "
           "contain an entry for itself.");
     }
 
     return id;
   }
 
   /// Returns formatted string representing the package [id].
   String _formatPackage(PackageId id) {
     if (id.source == 'git') {
-      var url = GitSource.urlFromDescription(id.description);
+      var url = cache.sources.git.urlFromDescription(id.description);
       return '${log.bold(id.name)} ${id.version} from Git repository "$url"';
     } else if (id.source == 'path') {
-      var path = PathSource.pathFromDescription(id.description);
+      var path = cache.sources.path.pathFromDescription(id.description);
       return '${log.bold(id.name)} ${id.version} at path "$path"';
     } else {
       return '${log.bold(id.name)} ${id.version}';
     }
   }
 
   /// Repairs any corrupted globally-activated packages and their binstubs.
   ///
   /// Returns a pair of two lists of strings. The first indicates which packages
   /// were successfully re-activated; the second indicates which failed.
@@ skipping 363 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];
   }
 }