Track Source objects in PackageNames.

lib/src/source/git.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:path/path.dart' as path;
 import 'package:pub_semver/pub_semver.dart';
 
 import '../git.dart' as git;
@@ skipping 10 matching lines @@
 class GitSource extends Source {
   final name = "git";
 
   BoundGitSource bind(SystemCache systemCache) =>
       new BoundGitSource(this, systemCache);
 
   /// Returns a reference to a git package with the given [name] and [url].
   ///
   /// If passed, [reference] is the Git reference. It defaults to `"HEAD"`.
   PackageRef refFor(String name, String url, {String reference}) =>
-      new PackageRef(name, "git", {'url': url, 'ref': reference ?? 'HEAD'});
+      new PackageRef(name, this, {'url': url, 'ref': reference ?? 'HEAD'});
 
   /// Given a valid git package description, returns the URL of the repository
   /// it pulls from.
   String urlFromDescription(description) => description["url"];
 
   PackageRef parseRef(String name, description, {String containingPath}) {
     // TODO(rnystrom): Handle git URLs that are relative file paths (#8570).
     if (description is String) description = {'url': description};
 
     if (description is! Map) {
       throw new FormatException("The description must be a Git URL or a map "
           "with a 'url' key.");
     }
 
     if (description["url"] is! String) {
       throw new FormatException("The 'url' field of the description must be a "
           "string.");
     }
 
     _validateUrl(description["url"]);
 
     var ref = description["ref"];
     if (ref != null && ref is! String) {
       throw new FormatException("The 'ref' field of the description must be a "
           "string.");
     }
 
-    return new PackageRef(name, this.name, {
+    return new PackageRef(name, this, {
       "url": description["url"],
       "ref": description["ref"] ?? "HEAD"
     });
   }
 
   PackageId parseId(String name, Version version, description) {
     if (description is! Map) {
       throw new FormatException("The description must be a map with a 'url' "
           "key.");
     }
 
     if (description["url"] is! String) {
       throw new FormatException("The 'url' field of the description must be a "
           "string.");
     }
 
     _validateUrl(description["url"]);
 
     var ref = description["ref"];
     if (ref != null && ref is! String) {
       throw new FormatException("The 'ref' field of the description must be a "
           "string.");
     }
 
     if (description["resolved-ref"] is! String) {
       throw new FormatException("The 'resolved-ref' field of the description "
           "must be a string.");
     }
 
-    return new PackageId(name, this.name, version, {
+    return new PackageId(name, this, version, {
       "url": description["url"],
       "ref": description["ref"] ?? "HEAD",
       "resolved-ref": description["resolved-ref"]
     });
   }
 
   /// Throws a [FormatException] if [url] isn't a valid Git URL.
   void _validateUrl(String url) {
     // If the URL contains an @, it's probably an SSH hostname, which we don't
     // know how to validate.
@@ skipping 25 matching lines @@
     if (description1['url'] != description2['url']) return false;
     if (description1['ref'] != description2['ref']) return false;
 
     if (description1.containsKey('resolved-ref') &&
         description2.containsKey('resolved-ref')) {
       return description1['resolved-ref'] == description2['resolved-ref'];
     }
 
     return true;
   }
+
+  int hashDescription(description) {
+    // Don't include the resolved ref in the hash code because we ignore it in
+    // [descriptionsEqual] if only one description defines it.
+    return description['url'].hashCode ^ description['ref'].hashCode;
+  }
 }
 
 /// The [BoundSource] for [GitSource].
 class BoundGitSource extends CachedSource {
   final GitSource source;
 
   final SystemCache systemCache;
 
   BoundGitSource(this.source, this.systemCache);
 
@@ skipping 13 matching lines @@
     });
   }
 
   Future<List<PackageId>> doGetVersions(PackageRef ref) async {
     await _ensureRepoCache(ref);
     var path = _repoCachePath(ref);
     var revision = await _firstRevision(path, ref.description['ref']);
     var pubspec = await _describeUncached(ref, revision);
 
     return [
-      new PackageId(ref.name, source.name, pubspec.version, {
+      new PackageId(ref.name, source, pubspec.version, {
         'url': ref.description['url'],
         'ref': ref.description['ref'],
         'resolved-ref': revision
       })
     ];
   }
 
   /// Since we don't have an easy way to read from a remote Git repo, this
   /// just installs [id] into the system cache, then describes it from there.
   Future<Pubspec> describeUncached(PackageId id) =>
@@ skipping 71 matching lines @@
         .where((entry) => dirExists(path.join(entry, ".git")))
         .map((packageDir) => new Package.load(
             null, packageDir, systemCache.sources))
         .toList();
 
     // Note that there may be multiple packages with the same name and version
     // (pinned to different commits). The sort order of those is unspecified.
     packages.sort(Package.orderByNameAndVersion);
 
     for (var package in packages) {
-      var id = new PackageId(package.name, source.name, package.version, null);
+      var id = new PackageId(package.name, source, package.version, null);
 
       log.message("Resetting Git repository for "
           "${log.bold(package.name)} ${package.version}...");
 
       try {
         // Remove all untracked files.
         await git.run(["clean", "-d", "--force", "-x"],
             workingDir: package.dir);
 
         // Discard all changes to tracked files.
@@ skipping 105 matching lines @@
         (result) => null);
   }
 
   /// Returns the path to the canonical clone of the repository referred to by
   /// [id] (the one in `<system cache>/git/cache`).
   String _repoCachePath(PackageRef ref) {
     var repoCacheName = '${ref.name}-${sha1(ref.description['url'])}';
     return path.join(systemCacheRoot, 'cache', repoCacheName);
   }
 }