Refactor Source.

sdk/lib/_internal/pub/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.
 
 library pub.source.git;
 
 import 'dart:async';
 
 import 'package:path/path.dart' as path;
 
 import '../git.dart' as git;
 import '../io.dart';
 import '../log.dart' as log;
 import '../package.dart';
-import '../source.dart';
+import '../pubspec.dart';
 import '../utils.dart';
+import 'cached.dart';
 
 /// A package source that gets packages from Git repos.
-class GitSource extends Source {
-  final String name = "git";
-
-  final bool shouldCache = true;
+class GitSource extends CachedSource {
+  final name = "git";
 
   /// The paths to the canonical clones of repositories for which "git fetch"
   /// has already been run during this run of pub.
   final _updatedRepos = new Set<String>();
 
   GitSource();
 
+  /// 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) {
+    return downloadToSystemCache(id).then((package) => package.pubspec);
+  }
+
   /// Clones a Git repo to the local filesystem.
   ///
   /// The Git cache directory is a little idiosyncratic. At the top level, it
   /// contains a directory for each commit of each repository, named `<package
   /// name>-<commit hash>`. These are the canonical package directories that are
   /// linked to from the `packages/` directory.
   ///
   /// In addition, the Git system cache contains a subdirectory named `cache/`
   /// which contains a directory for each separate repository URL, named
   /// `<package name>-<url hash>`. These are used to check out the repository
   /// itself; each of the commit-specific directories are clones of a directory
   /// in `cache/`.
   Future<Package> downloadToSystemCache(PackageId id, {bool force}) {
     // Force is not supported because the cache repair command doesn't need it.
     // Instead, it uses [resetCachedPackages].
     assert(force != true);
 
     var revisionCachePath;
 
     return git.isInstalled.then((installed) {
       if (!installed) {
         throw new Exception(
             "Cannot get ${id.name} from Git (${_getUrl(id)}).\n"
             "Please ensure Git is correctly installed.");
       }
 
       ensureDir(path.join(systemCacheRoot, 'cache'));
       return _ensureRevision(id);
-    }).then((_) => systemCacheDirectory(id)).then((path) {
+    }).then((_) => getDirectory(id)).then((path) {
       revisionCachePath = path;
       if (entryExists(revisionCachePath)) return null;
       return _clone(_repoCachePath(id), revisionCachePath, mirror: false);
     }).then((_) {
       var ref = _getEffectiveRef(id);
       if (ref == 'HEAD') return null;
       return _checkOut(revisionCachePath, ref);
     }).then((_) {
       return new Package.load(id.name, revisionCachePath, systemCache.sources);
     });
   }
 
   /// Returns the path to the revision-specific cache of [id].
-  Future<String> systemCacheDirectory(PackageId id) {
+  Future<String> getDirectory(PackageId id) {
     return _ensureRevision(id).then((rev) {
       var revisionCacheName = '${id.name}-$rev';
       return path.join(systemCacheRoot, revisionCacheName);
     });
   }
 
   /// Ensures [description] is a Git URL.
   dynamic parseDescription(String containingPath, description,
                            {bool fromLockFile: false}) {
     // TODO(rnystrom): Handle git URLs that are relative file paths (#8570).
@@ skipping 33 matching lines @@
 
   /// Attaches a specific commit to [id] to disambiguate it.
   Future<PackageId> resolveId(PackageId id) {
     return _ensureRevision(id).then((revision) {
       var description = {'url': _getUrl(id), 'ref': _getRef(id)};
       description['resolved-ref'] = revision;
       return new PackageId(id.name, name, id.version, description);
     });
   }
 
+  List<Package> getCachedPackages() {
+    // TODO(keertip): Implement getCachedPackages().
+    throw new UnimplementedError(
+        "The git source doesn't support listing its cached packages yet.");
+  }
+
   /// Resets all cached packages back to the pristine state of the Git
   /// repository at the revision they are pinned to.
   Future<Pair<int, int>> repairCachedPackages() {
     if (!dirExists(systemCacheRoot)) return new Future.value(new Pair(0, 0));
 
     var successes = 0;
     var failures = 0;
 
     var packages = listDir(systemCacheRoot)
       .where((entry) => dirExists(path.join(entry, ".git")))
@@ skipping 19 matching lines @@
       }).catchError((error, stackTrace) {
         failures++;
         log.error("Failed to reset ${log.bold(package.name)} "
             "${package.version}. Error:\n$error");
         log.fine(stackTrace);
         failures++;
       }, test: (error) => error is git.GitException);
     })).then((_) => new Pair(successes, failures));
   }
 
-  // TODO(keertip): Implement getCachedPackages().
-
   /// Ensure that the canonical clone of the repository referred to by [id] (the
   /// one in `<system cache>/git/cache`) exists and contains the revision
   /// referred to by [id].
   ///
   /// Returns a future that completes to the hash of the revision identified by
   /// [id].
   Future<String> _ensureRevision(PackageId id) {
     return syncFuture(() {
       var path = _repoCachePath(id);
       if (!entryExists(path)) {
@@ skipping 105 matching lines @@
     return description['ref'];
   }
 
   /// Returns [description] if it's a description, or [PackageId.description] if
   /// it's a [PackageId].
   _getDescription(description) {
     if (description is PackageId) return description.description;
     return description;
   }
 }