Refactor Source and SourceRegistry.

test/version_solver_test.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 'package:pub/src/lock_file.dart';
 import 'package:pub/src/log.dart' as log;
 import 'package:pub/src/package.dart';
 import 'package:pub/src/pubspec.dart';
 import 'package:pub/src/sdk.dart' as sdk;
 import 'package:pub/src/solver/version_solver.dart';
+import 'package:pub/src/source.dart';
 import 'package:pub/src/source/cached.dart';
 import 'package:pub/src/system_cache.dart';
 import 'package:pub/src/utils.dart';
 import 'package:pub_semver/pub_semver.dart';
 import 'package:test/test.dart';
 
 MockSource source1;
 MockSource source2;
 
 main() {
@@ skipping 1079 matching lines @@
     'a': '2.0.0-dev.1'
   }, downgrade: true);
 }
 
 testResolve(String description, Map packages, {
     Map lockfile, Map overrides, Map result, FailMatcherBuilder error,
     int maxTries, bool downgrade: false}) {
   if (maxTries == null) maxTries = 1;
 
   test(description, () {
-    var cache = new SystemCache('.');
     source1 = new MockSource('mock1');
     source2 = new MockSource('mock2');
-    cache.register(source1);
-    cache.register(source2);
+
+    var cache = new SystemCache(rootDir: '.');
+    cache.sources.register(source1);
+    cache.sources.register(source2);
     cache.sources.setDefault(source1.name);
 
     // Build the test package graph.
     var root;
     packages.forEach((description, dependencies) {
       var id = parseSpec(description);
       var package = mockPackage(id, dependencies,
           id.name == 'myapp' ? overrides : null);
       if (id.name == 'myapp') {
         // Don't add the root package to the server, so we can verify that Pub
         // doesn't try to look up information about the local package on the
         // remote server.
         root = package;
       } else {
-        (cache.sources[id.source] as MockSource).addPackage(
-            id.description, package);
+        (cache.source(id.source) as BoundMockSource)
+            .addPackage(id.description, package);
       }
     });
 
     // Clean up the expectation.
     if (result != null) {
       var newResult = {};
       result.forEach((description, version) {
         var id = parseSpec(description, version);
         newResult[id.name] = id;
       });
       result = newResult;
     }
 
     // Parse the lockfile.
     var realLockFile;
     if (lockfile == null) {
       realLockFile = new LockFile.empty(cache.sources);
     } else {
       realLockFile = new LockFile(lockfile.keys.map((name) {
         var version = new Version.parse(lockfile[name]);
         return new PackageId(name, source1.name, version, name);
       }), cache.sources);
     }
 
     // Resolve the versions.
     log.verbosity = log.Verbosity.NONE;
     var future = resolveVersions(
         downgrade ? SolveType.DOWNGRADE : SolveType.GET,
-        cache.sources, root, lockFile: realLockFile);
+        cache, root, lockFile: realLockFile);
 
     var matcher;
     if (result != null) {
       matcher = new SolveSuccessMatcher(result, maxTries);
     } else if (error != null) {
       matcher = error(maxTries);
     }
 
     expect(future, completion(matcher));
   });
@@ skipping 168 matching lines @@
   }
 }
 
 /// A source used for testing. This both creates mock package objects and acts
 /// as a source for them.
 ///
 /// In order to support testing packages that have the same name but different
 /// descriptions, a package's name is calculated by taking the description
 /// string and stripping off any trailing hyphen followed by non-hyphen
 /// characters.
-class MockSource extends CachedSource {
-  final _packages = <String, Map<Version, Package>>{};
-
-  /// Keeps track of which package version lists have been requested. Ensures
-  /// that a source is only hit once for a given package and that pub
-  /// internally caches the results.
-  final _requestedVersions = new Set<String>();
-
-  /// Keeps track of which package pubspecs have been requested. Ensures that a
-  /// source is only hit once for a given package and that pub internally
-  /// caches the results.
-  final _requestedPubspecs = new Map<String, Set<Version>>();
-
+class MockSource extends Source {
   final String name;
   final hasMultipleVersions = true;
 
   MockSource(this.name);
 
+  BoundSource bind(SystemCache cache) => new BoundMockSource(this, cache);
+
   PackageRef parseRef(String name, description, {String containingPath}) =>
       new PackageRef(name, this.name, description);
 
   PackageId parseId(String name, Version version, description) =>
       new PackageId(name, this.name, version, description);
 
   bool descriptionsEqual(description1, description2) =>
       description1 == description2;
+}
+
+class BoundMockSource extends CachedSource {
+  final SystemCache systemCache;
+
+  final MockSource source;
+
+  final _packages = <String, Map<Version, Package>>{};
+
+  /// Keeps track of which package version lists have been requested. Ensures
+  /// that a source is only hit once for a given package and that pub
+  /// internally caches the results.
+  final _requestedVersions = new Set<String>();
+
+  /// Keeps track of which package pubspecs have been requested. Ensures that a
+  /// source is only hit once for a given package and that pub internally
+  /// caches the results.
+  final _requestedPubspecs = new Map<String, Set<Version>>();
+
+  BoundMockSource(this.source, this.systemCache);
 
   String getDirectory(PackageId id) => '${id.name}-${id.version}';
 
   Future<List<PackageId>> doGetVersions(PackageRef ref) async {
     // Make sure the solver doesn't request the same thing twice.
     if (_requestedVersions.contains(ref.description)) {
       throw new Exception('Version list for ${ref.description} was already '
           'requested.');
     }
 
     _requestedVersions.add(ref.description);
 
     if (!_packages.containsKey(ref.description)){
       throw new Exception('MockSource does not have a package matching '
           '"${ref.description}".');
     }
 
     return _packages[ref.description].values.map((package) {
       return new PackageId(
-          ref.name, this.name, package.version, ref.description);
+          ref.name, source.name, package.version, ref.description);
     }).toList();
   }
 
   Future<Pubspec> describeUncached(PackageId id) {
     return new Future.sync(() {
       // Make sure the solver doesn't request the same thing twice.
       if (_requestedPubspecs.containsKey(id.description) &&
           _requestedPubspecs[id.description].contains(id.version)) {
         throw new Exception('Pubspec for $id was already requested.');
       }
@@ skipping 106 matching lines @@
   }
 
   var source = "mock1";
   if (match[7] != null) {
     source = match[7];
     if (source == "root") source = null;
   }
 
   return new PackageId(name, source, parsedVersion, description);
 }