Add github version range support

lib/src/source/git.dart

@@ -7,6 +7,7 @@ library pub.source.git;
 import 'dart:async';
 
 import 'package:path/path.dart' as path;
+import 'package:pub_semver/pub_semver.dart';
 
 import '../git.dart' as git;
 import '../io.dart';
@@ -40,6 +41,49 @@ class GitSource extends CachedSource {
     });
   }
 
+  /// Gets the list of all versions from git tags.
+  /// Anything that Version.parse understands is considered a version,
+  /// it will also attempt to strip off a preceding 'v' e.g. v1.0.0
+  Future<List<Pubspec>> getVersions(String name, description) async {
+    if (!_useVersionTags(description)) {
+      // No need to get versions if the useVersionTags option is false
+      return super.getVersions(name, description);
+    }
+
+    PackageId id =
+        new PackageId(name, this.name, null, _getDescription(description));
+    String cachePath = _repoCachePath(id);
+    if (!entryExists(cachePath)) {
+      // Must have the repo cloned in order to list its tags
+      await _clone(_getUrl(id), cachePath);
+    }
+
+    List results = await git.run(["tag", "-l"], workingDir: cachePath);
+    List<Pubspec> validVersions = [];
+    for (String version in results) {
+      // Strip preceding 'v' character so 'v1.0.0' can be parsed into a Version
+      if (version.startsWith('v')) {
+        version = version.substring(1);
+      }
+      try {
+        // Use Version.parse to determine valid version tags
+        Version validVersion = new Version.parse(version);
+        // Fetch the pubspec for this version
+        Pubspec pubspec = await _getPubspec(cachePath, validVersion.toString());
+        if (pubspec != null) {
+          validVersions.add(pubspec);
+        }
+      } on FormatException {}
+    }
+
+    if (validVersions.isNotEmpty) {
+      return validVersions;
+    }
+
+    // No valid version tags were found, defer to super
+    return super.getVersions(name, description);
+  }
+
   /// 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) {
@@ -104,6 +148,7 @@ class GitSource extends CachedSource {
     var parsed = new Map.from(description);
     parsed.remove('url');
     parsed.remove('ref');
+    parsed.remove('use_version_tags');
     if (fromLockFile) parsed.remove('resolved-ref');
 
     if (!parsed.isEmpty) {
@@ -149,6 +194,10 @@ class GitSource extends CachedSource {
   Future<PackageId> resolveId(PackageId id) {
     return _ensureRevision(id).then((revision) {
       var description = {'url': _getUrl(id), 'ref': _getRef(id)};
+      bool useVersionTags = _useVersionTags(id);
+      if (useVersionTags) {
+        description['use_version_tags'] = useVersionTags;
+      }
       description['resolved-ref'] = revision;
       return new PackageId(id.name, name, id.version, description);
     });
@@ -253,9 +302,22 @@ class GitSource extends CachedSource {
   /// by [id] on the effective ref of [id].
   ///
   /// This assumes that the canonical clone already exists.
-  Future<String> _getRev(PackageId id) {
-    return git.run(["rev-list", "--max-count=1", _getEffectiveRef(id)],
-        workingDir: _repoCachePath(id)).then((result) => result.first);
+  Future<String> _getRev(PackageId id) async {
+    var ref = _getEffectiveRef(id);
+    try {
+      var result = await git.run(["rev-list", "--max-count=1", ref],
+          workingDir: _repoCachePath(id));
+      return result.first;
+    } on git.GitException {
+      if (ref == id.version.toString()) {
+        // Try again with a "v" before the ref in case this was a version tag
+        ref = 'v$ref';
+        var result = await git.run(["rev-list", "--max-count=1", ref],
+            workingDir: _repoCachePath(id));
+        return result.first;
+      }
+      rethrow;
+    }
   }
 
   /// Clones the repo at the URI [from] to the path [to] on the local
@@ -284,9 +346,28 @@ class GitSource extends CachedSource {
   }
 
   /// Checks out the reference [ref] in [repoPath].
-  Future _checkOut(String repoPath, String ref) {
-    return git.run(["checkout", ref], workingDir: repoPath).then(
-        (result) => null);
+  Future _checkOut(String repoPath, String ref) async {
+    try {
+      await git.run(["checkout", ref], workingDir: repoPath);
+    } on git.GitException {
+      // Try again with a "v" before the ref in case this was a version tag
+      await git.run(["checkout", 'v$ref'], workingDir: repoPath);
+    }
+  }
+
+  /// Use `git show` to get the pubspec.yaml at a particular ref,
+  /// then parse it into a Pubspec object
+  ///
+  /// It is possible that a pubspec didn't always exist, return null if
+  /// that is the case.
+  Future<Pubspec> _getPubspec(String repoPath, String ref) async {
+    try {
+      var result = await git.run(['show', '$ref:pubspec.yaml'],
+          workingDir: repoPath);
+      return new Pubspec.parse(result.join('\n'), systemCache.sources);
+    } on git.GitException {
+      return null;
+    }
   }
 
   /// Returns the path to the canonical clone of the repository referred to by
@@ -313,13 +394,17 @@ class GitSource extends CachedSource {
   /// [resolveId].
   ///
   /// [description] may be a description or a [PackageId].
-  String _getEffectiveRef(description) {
-    description = _getDescription(description);
+  String _getEffectiveRef(PackageId id) {
+    Map description = _getDescription(id);
     if (description is Map && description.containsKey('resolved-ref')) {
       return description['resolved-ref'];
     }
 
     var ref = _getRef(description);
+    if (_useVersionTags(description) && id.version != null &&
+        id.version != Version.none) {
+      return id.version.toString();
+    }
     return ref == null ? 'HEAD' : ref;
   }
 
@@ -338,4 +423,14 @@ class GitSource extends CachedSource {
     if (description is PackageId) return description.description;
     return description;
   }
+
+  /// Returns value of "use_version_tags" in the description
+  ///
+  /// [description] may be a description or a [PackageId].
+  bool _useVersionTags(description) {
+    description = _getDescription(description);
+    if (description is String) return false;
+    return description.containsKey('use_version_tags')
+        ? description['use_version_tags'] : false;
+  }
 }