Move pubspec caching into each source.

lib/src/source/hosted.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.hosted;
 
 import 'dart:async';
 import 'dart:io' as io;
 import "dart:convert";
 
@@ skipping 19 matching lines @@
   /// Gets the default URL for the package server for hosted dependencies.
   static String get defaultUrl {
     var url = io.Platform.environment["PUB_HOSTED_URL"];
     if (url != null) return url;
 
     return "https://pub.dartlang.org";
   }
 
   /// Downloads a list of all versions of a package that are available from the
   /// site.
-  Future<List<Pubspec>> getVersions(String name, description) async {
-    var url = _makeUrl(description,
+  Future<List<PackageId>> doGetVersions(PackageRef ref) async {
+    var url = _makeUrl(ref.description,
         (server, package) => "$server/api/packages/$package");
 
     log.io("Get versions from $url.");
 
     var body;
     try {
       body = await httpClient.read(url, headers: PUB_API_HEADERS);
     } catch (error, stackTrace) {
-      var parsed = _parseDescription(description);
+      var parsed = _parseDescription(ref.description);
       _throwFriendlyError(error, stackTrace, parsed.first, parsed.last);
     }
 
     var doc = JSON.decode(body);
     return doc['versions'].map((map) {
-      return new Pubspec.fromMap(
+      var pubspec = new Pubspec.fromMap(
           map['pubspec'], systemCache.sources,
-          expectedName: name, location: url);
+          expectedName: ref.name, location: url);
+      var id = ref.atVersion(pubspec.version);
+      memoizePubspec(id, pubspec);
+
+      return id;
     }).toList();
   }
 
   /// Downloads and parses the pubspec for a specific version of a package that
   /// is available from the site.
   Future<Pubspec> describeUncached(PackageId id) async {
     // Request it from the server.
     var url = _makeVersionUrl(id, (server, package, version) =>
         "$server/api/packages/$package/versions/$version");
 
@@ skipping 147 matching lines @@
     throw error;
   }
 }
 
 /// This is the modified hosted source used when pub get or upgrade are run
 /// with "--offline".
 ///
 /// This uses the system cache to get the list of available packages and does
 /// no network access.
 class OfflineHostedSource extends HostedSource {
-  /// Gets the list of all versions of [name] that are in the system cache.
-  Future<List<Pubspec>> getVersions(String name, description) async {
-    var parsed = _parseDescription(description);
+  /// Gets the list of all versions of [ref] that are in the system cache.
+  Future<List<PackageId>> doGetVersions(PackageRef ref) async {
+    var parsed = _parseDescription(ref.description);
     var server = parsed.last;
-    log.io("Finding versions of $name in "
+    log.io("Finding versions of ${ref.name} in "
         "$systemCacheRoot/${_urlToDirectory(server)}");
-    var versions = await _getCachedPackagesInDirectory(_urlToDirectory(server))
-        .where((package) => package.name == name)
-        .map((package) => package.pubspec)
-        .toList();
+
+    var dir = path.join(systemCacheRoot, _urlToDirectory(server));
+
+    var versions;
+    if (dirExists(dir)) {
+      versions = await listDir(dir).map((entry) {
+        var components = path.basename(entry).split("-");
+        if (components.first != ref.name) return null;
+        return ref.atVersion(new Version.parse(components.last));
+      }).where((id) => id != null).toList();
+    } else {
+      versions = [];
+    }
 
     // If there are no versions in the cache, report a clearer error.
     if (versions.isEmpty) {
       throw new PackageNotFoundException(
-          "Could not find package $name in cache.");
+          "Could not find package ${ref.name} in cache.");
     }
 
     return versions;
   }
 
   Future _download(String server, String package, Version version,
       String destPath) {
     // Since HostedSource is cached, this will only be called for uncached
     // packages.
     throw new UnsupportedError("Cannot download packages when offline.");
@@ skipping 95 matching lines @@
   var name = description["name"];
   if (name is! String) {
     throw new FormatException("The 'name' key must have a string value.");
   }
 
   var url = description["url"];
   if (url == null) url = HostedSource.defaultUrl;
 
   return new Pair<String, String>(name, url);
 }