Refactor Source and SourceRegistry.

lib/src/solver/backtracking_solver.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.
 
 /// A back-tracking depth-first solver.
 ///
 /// Attempts to find the best solution for a root package's transitive
 /// dependency graph, where a "solution" is a set of concrete package versions.
 /// A valid solution will select concrete versions for every package reached
 /// from the root package's dependency graph, and each of those packages will
@@ skipping 26 matching lines @@
 
 import 'package:pub_semver/pub_semver.dart';
 
 import '../barback.dart' as barback;
 import '../exceptions.dart';
 import '../lock_file.dart';
 import '../log.dart' as log;
 import '../package.dart';
 import '../pubspec.dart';
 import '../sdk.dart' as sdk;
-import '../source_registry.dart';
-import '../source/hosted.dart';
 import '../source/unknown.dart';
+import '../system_cache.dart';
 import '../utils.dart';
 import 'version_queue.dart';
 import 'version_selection.dart';
 import 'version_solver.dart';
 
 /// The top-level solver.
 ///
 /// Keeps track of the current potential solution, and the other possible
 /// versions for speculative package selections. Backtracks and advances to the
 /// next potential solution in the case of a failure.
 class BacktrackingSolver {
   final SolveType type;
-  final SourceRegistry sources;
+  final SystemCache systemCache;
   final Package root;
 
   /// The lockfile that was present before solving.
   final LockFile lockFile;
 
   /// A cache of data requested during solving.
   final SolverCache cache;
 
   /// The set of packages that are being explicitly upgraded.
   ///
@@ skipping 38 matching lines @@
   /// package, since it has only one valid version, but [_selection] does, since
   /// its dependencies are relevant. Second, when backtracking, [_versions]
   /// contains the version that's being backtracked, while [_selection] does
   /// not.
   VersionSelection _selection;
 
   /// The number of solutions the solver has tried so far.
   var _attemptedSolutions = 1;
 
   /// A pubspec for pub's implicit dependencies on barback and related packages.
-  final Pubspec _implicitPubspec = () {
-    var dependencies = [];
-    barback.pubConstraints.forEach((name, constraint) {
-      dependencies.add(HostedSource.refFor(name).withConstraint(constraint));
-    });
+  final Pubspec _implicitPubspec;
 
-    return new Pubspec("pub itself", dependencies: dependencies);
-  }();
-
-  BacktrackingSolver(SolveType type, SourceRegistry sources, this.root,
+  BacktrackingSolver(SolveType type, SystemCache systemCache, this.root,
           this.lockFile, List<String> useLatest)
       : type = type,
-        sources = sources,
-        cache = new SolverCache(type, sources) {
+        systemCache = systemCache,
+        cache = new SolverCache(type, systemCache),
+        _implicitPubspec = _makeImplicitPubspec(systemCache) {
     _selection = new VersionSelection(this);
 
     for (var package in useLatest) {
       _forceLatest.add(package);
     }
 
     for (var override in root.dependencyOverrides) {
       _overrides[override.name] = override;
     }
   }
 
+  /// Creates [_implicitPubspec].
+  static Pubspec _makeImplicitPubspec(SystemCache systemCache) {
+    var dependencies = [];
+    barback.pubConstraints.forEach((name, constraint) {
+      dependencies.add(
+          systemCache.sources.hosted.refFor(name)
+              .withConstraint(constraint));
+    });
+
+    return new Pubspec("pub itself", dependencies: dependencies);
+  }
+
   /// Run the solver.
   ///
   /// Completes with a list of specific package versions if successful or an
   /// error if it failed to find a solution.
   Future<SolveResult> solve() async {
     var stopwatch = new Stopwatch();
 
     _logParameters();
 
     // Sort the overrides by package name to make sure they're deterministic.
@@ skipping 10 matching lines @@
       _validateSdkConstraint(root.pubspec);
 
       logSolve();
       var packages = await _solve();
 
       var pubspecs = {};
       for (var id in packages) {
         pubspecs[id.name] = await _getPubspec(id);
       }
 
-      return new SolveResult.success(sources, root, lockFile, packages,
-          overrides, pubspecs, _getAvailableVersions(packages),
+      return new SolveResult.success(systemCache.sources, root, lockFile,
+          packages, overrides, pubspecs, _getAvailableVersions(packages),
           _attemptedSolutions);
     } on SolveFailure catch (error) {
       // Wrap a failure in a result so we can attach some other data.
-      return new SolveResult.failure(sources, root, lockFile, overrides,
-          error, _attemptedSolutions);
+      return new SolveResult.failure(systemCache.sources, root, lockFile,
+          overrides, error, _attemptedSolutions);
     } finally {
       // Gather some solving metrics.
       var buffer = new StringBuffer();
       buffer.writeln('${runtimeType} took ${stopwatch.elapsed} seconds.');
       buffer.writeln(cache.describeResults());
       log.solver(buffer);
     }
   }
 
   /// Generates a map containing all of the known available versions for each
@@ skipping 26 matching lines @@
   ///
   /// Returns `null` if it isn't in the lockfile (or has been unlocked).
   PackageId getLocked(String package) {
     if (type == SolveType.GET) return lockFile.packages[package];
 
     // When downgrading, we don't want to force the latest versions of
     // non-hosted packages, since they don't support multiple versions and thus
     // can't be downgraded.
     if (type == SolveType.DOWNGRADE) {
       var locked = lockFile.packages[package];
-      if (locked != null && !sources[locked.source].hasMultipleVersions) {
+      if (locked != null &&
+          !systemCache.sources[locked.source].hasMultipleVersions) {
         return locked;
       }
     }
 
     if (_forceLatest.isEmpty || _forceLatest.contains(package)) return null;
     return lockFile.packages[package];
   }
 
   /// Gets the package [name] that's currently contained in the lockfile if it
   /// matches the current constraint and has the same source and description as
   /// other references to that package.
   ///
   /// Returns `null` otherwise.
   PackageId _getValidLocked(String name) {
     var package = getLocked(name);
     if (package == null) return null;
 
     var constraint = _selection.getConstraint(name);
     if (!constraint.allows(package.version)) {
       logSolve('$package is locked but does not match $constraint');
       return null;
     } else {
       logSolve('$package is locked');
     }
 
     var required = _selection.getRequiredDependency(name);
     if (required != null) {
       if (package.source != required.dep.source) return null;
 
-      var source = sources[package.source];
+      var source = systemCache.sources[package.source];
       if (!source.descriptionsEqual(
           package.description, required.dep.description)) return null;
     }
 
     return package;
   }
 
   /// Tries to find the best set of versions that meet the constraints.
   ///
   /// Selects matching versions of unselected packages, or backtracks if there
@@ skipping 253 matching lines @@
           _fail(otherDep.depender.name);
         }
 
         logSolve(
             'inconsistent source "${dep.source}" for ${dep.name}:\n'
             '  $dependency\n' +
                 _selection.describeDependencies(dep.name));
         throw new SourceMismatchException(dep.name, allDeps);
       }
 
-      var source = sources[dep.source];
+      var source = systemCache.sources[dep.source];
       if (!source.descriptionsEqual(
           dep.description, required.dep.description)) {
         // Mark the dependers as failing rather than the package itself, because
         // no version with this description will be compatible.
         for (var otherDep in _selection.getDependenciesOn(dep.name)) {
           _fail(otherDep.depender.name);
         }
 
         logSolve(
             'inconsistent description "${dep.description}" for ${dep.name}:\n'
@@ skipping 38 matching lines @@
         // Not overridden.
         return dep;
       }).toSet();
     } else {
       // Ignore any overridden dependencies.
       deps.removeWhere((dep) => _overrides.containsKey(dep.name));
     }
 
     // Make sure the package doesn't have any bad dependencies.
     for (var dep in deps.toSet()) {
-      if (!dep.isRoot && sources[dep.source] is UnknownSource) {
+      if (!dep.isRoot && systemCache.sources[dep.source] is UnknownSource) {
         throw new UnknownSourceException(id.name, [new Dependency(id, dep)]);
       }
 
       if (dep.name == 'barback') {
         deps.add(new PackageDep.magic('pub itself'));
       }
     }
 
     return deps;
   }
 
   /// Loads and returns the pubspec for [id].
   Future<Pubspec> _getPubspec(PackageId id) async {
     if (id.isRoot) return root.pubspec;
     if (id.isMagic && id.name == 'pub itself') return _implicitPubspec;
-
-    var source = sources[id.source];
-    return await source.describe(id);
+    return await systemCache.source(id.source).describe(id);
   }
 
   /// Logs the initial parameters to the solver.
   void _logParameters() {
     var buffer = new StringBuffer();
     buffer.writeln("Solving dependencies:");
     for (var package in root.dependencies) {
       buffer.write("- $package");
       var locked = getLocked(package.name);
       if (_forceLatest.contains(package.name)) {
@@ skipping 33 matching lines @@
   void _validateSdkConstraint(Pubspec pubspec) {
     if (_overrides.containsKey(pubspec.name)) return;
     if (pubspec.environment.sdkVersion.allows(sdk.version)) return;
 
     throw new BadSdkVersionException(pubspec.name,
         'Package ${pubspec.name} requires SDK version '
         '${pubspec.environment.sdkVersion} but the current SDK is '
         '${sdk.version}.');
   }
 }