Refactor Source and SourceRegistry.

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.
 
 import 'dart:async';
 import 'dart:io';
 
 import 'package:barback/barback.dart';
 import 'package:package_config/packages_file.dart' as packages_file;
 import 'package:path/path.dart' as p;
@@ skipping 72 matching lines @@
   /// dependencies.
   ///
   /// Throws a [DataError] if the `.packages` file isn't up-to-date relative to
   /// the pubspec and the lockfile.
   PackageGraph get packageGraph {
     if (_packageGraph != null) return _packageGraph;
 
     assertUpToDate();
     var packages = new Map.fromIterable(lockFile.packages.values,
         key: (id) => id.name,
-        value: (id) => cache.sources.load(id));
+        value: (id) => cache.load(id));
     packages[root.name] = root;
 
     _packageGraph = new PackageGraph(this, lockFile, packages);
     return _packageGraph;
   }
   PackageGraph _packageGraph;
 
   /// The path to the entrypoint's "packages" directory.
   String get packagesDir => root.path('packages');
 
@@ skipping 58 matching lines @@
   /// this is an upgrade or downgrade, all transitive dependencies are shown in
   /// the report. Otherwise, only dependencies that were changed are shown. If
   /// [dryRun] is `true`, no physical changes are made.
   ///
   /// If [precompile] is `true` (the default), this snapshots dependencies'
   /// executables and runs transformers on transformed dependencies.
   ///
   /// Updates [lockFile] and [packageRoot] accordingly.
   Future acquireDependencies(SolveType type, {List<String> useLatest,
       bool dryRun: false, bool precompile: true}) async {
-    var result = await resolveVersions(type, cache.sources, root,
+    var result = await resolveVersions(type, cache, root,
         lockFile: lockFile, useLatest: useLatest);
     if (!result.succeeded) throw result.error;
 
     result.showReport(type);
 
     if (dryRun) {
       result.summarizeChanges(type, dryRun: dryRun);
       return;
     }
 
@@ skipping 27 matching lines @@
         _deletePrecompiledDependencies(
             _dependenciesToPrecompile(changed: result.changedPackages));
         _deleteExecutableSnapshots(changed: result.changedPackages);
       }
     } catch (error, stackTrace) {
       // Just log exceptions here. Since the method is just about acquiring
       // dependencies, it shouldn't fail unless that fails.
       log.exception(error, stackTrace);
     }
 
-    writeTextFile(packagesFile, lockFile.packagesFile(root.name));
+    writeTextFile(packagesFile, lockFile.packagesFile(cache, root.name));
   }
 
   /// Precompile any transformed dependencies of the entrypoint.
   ///
   /// If [changed] is passed, only dependencies whose contents might be changed
   /// if one of the given packages changes will be recompiled.
   Future _precompileDependencies({Iterable<String> changed}) async {
     if (changed != null) changed = changed.toSet();
 
     var dependenciesToPrecompile = _dependenciesToPrecompile(changed: changed);
@@ skipping 194 matching lines @@
   }
 
   /// Makes sure the package at [id] is locally available.
   ///
   /// 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 is a [CachedSource]).
   Future _get(PackageId id) async {
     if (id.isRoot) return;
 
-    var source = cache.sources[id.source];
+    var source = cache.source(id.source);
     if (!_packageSymlinks) {
       if (source is CachedSource) await source.downloadToSystemCache(id);
       return;
     }
 
     var packageDir = p.join(packagesDir, id.name);
     if (entryExists(packageDir)) deleteEntry(packageDir);
     await source.get(id, packageDir);
   }
 
@@ skipping 63 matching lines @@
     if (!root.immediateDependencies.every(_isDependencyUpToDate)) {
       dataError('The pubspec.yaml file has changed since the pubspec.lock '
           'file was generated, please run "pub get" again.');
     }
 
     var overrides = root.dependencyOverrides.map((dep) => dep.name).toSet();
 
     // Check that uncached dependencies' pubspecs are also still satisfied,
     // since they're mutable and may have changed since the last get.
     for (var id in lockFile.packages.values) {
-      var source = cache.sources[id.source];
+      var source = cache.source(id.source);
       if (source is CachedSource) continue;
 
       try {
-        if (cache.sources.load(id).dependencies.every((dep) =>
+        if (cache.load(id).dependencies.every((dep) =>
             overrides.contains(dep.name) || _isDependencyUpToDate(dep))) {
           continue;
         }
       } on FileException {
         // If we can't load the pubpsec, the user needs to re-run "pub get".
       }
 
       dataError('${p.join(source.getDirectory(id), 'pubspec.yaml')} has '
           'changed since the pubspec.lock file was generated, please run "pub '
           'get" again.');
@@ skipping 20 matching lines @@
   /// Determines whether all of the packages in the lockfile are already
   /// installed and available.
   bool _arePackagesAvailable() {
     return lockFile.packages.values.every((package) {
       var source = cache.sources[package.source];
       if (source is UnknownSource) return false;
 
       // We only care about cached sources. Uncached sources aren't "installed".
       // If one of those is missing, we want to show the user the file not
       // found error later since installing won't accomplish anything.
-      if (source is! CachedSource) return true;
+      var boundSource = cache.source(package.source);
+      if (boundSource is! CachedSource) return true;
 
       // Get the directory.
-      var dir = source.getDirectory(package);
+      var dir = boundSource.getDirectory(package);
       // See if the directory is there and looks like a package.
       return dirExists(dir) && fileExists(p.join(dir, "pubspec.yaml"));
     });
   }
 
   /// Determines whether or not the `.packages` file is out of date with respect
   /// to the lockfile.
   ///
   /// This will be `false` if the packages file contains dependencies that are
   /// not in the lockfile or that don't match what's in there.
   bool _isPackagesFileUpToDate() {
     var packages = packages_file.parse(
         new File(packagesFile).readAsBytesSync(),
         p.toUri(packagesFile));
 
     return lockFile.packages.values.every((lockFileId) {
-      var source = cache.sources[lockFileId.source];
+      var source = cache.source(lockFileId.source);
 
       // It's very unlikely that the lockfile is invalid here, but it's not
       // impossible—for example, the user may have a very old application
       // package with a checked-in lockfile that's newer than the pubspec, but
       // that contains sdk dependencies.
-      if (source == null) return false;
+      if (source.source is UnknownSource) return false;
 
       var packagesFileUri = packages[lockFileId.name];
       if (packagesFileUri == null) return false;
 
       // Pub only generates "file:" and relative URIs.
       if (packagesFileUri.scheme != 'file' &&
           packagesFileUri.scheme.isNotEmpty) {
         return false;
       }
 
@@ skipping 81 matching lines @@
   /// If [packageSymlinks] is true, creates a symlink to the "packages"
   /// directory in [dir].
   ///
   /// Otherwise, deletes a "packages" directories in [dir] if one exists.
   void _linkOrDeleteSecondaryPackageDir(String dir) {
     var symlink = p.join(dir, 'packages');
     if (entryExists(symlink)) deleteEntry(symlink);
     if (_packageSymlinks) createSymlink(packagesDir, symlink, relative: true);
   }
 }