Add offline support to pub install and update.

sdk/lib/_internal/pub/lib/src/hosted_source.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 hosted_source;
 
 import 'dart:async';
 import 'dart:io' as io;
 import 'dart:json' as json;
 import 'dart:uri';
@@ skipping 80 matching lines @@
       });
     });
   }
 
   /// The system cache directory for the hosted source contains subdirectories
   /// for each separate repository URL that's used on the system. Each of these
   /// subdirectories then contains a subdirectory for each package installed
   /// from that site.
   Future<String> systemCacheDirectory(PackageId id) {
     var parsed = _parseDescription(id.description);
-    var url = _getSourceDirectory(parsed.last);
-    var urlDir = replace(url, new RegExp(r'[<>:"\\/|?*%]'), (match) {
-      return '%${match[0].codeUnitAt(0)}';
-    });
+    var dir = _getSourceDirectory(parsed.last);
 
     return new Future.value(
-        path.join(systemCacheRoot, urlDir, "${parsed.first}-${id.version}"));
+        path.join(systemCacheRoot, dir, "${parsed.first}-${id.version}"));
   }
 
   String packageName(description) => _parseDescription(description).first;
 
   bool descriptionsEqual(description1, description2) =>
       _parseDescription(description1) == _parseDescription(description2);
 
   /// Ensures that [description] is a valid hosted package description.
   ///
   /// There are two valid formats. A plain string refers to a package with the
   /// given name from the default host, while a map with keys "name" and "url"
   /// refers to a package with the given name from the host at the given URL.
   dynamic parseDescription(String containingPath, description,
                            {bool fromLockFile: false}) {
     _parseDescription(description);
     return description;
   }
 
-  List<Package> getCachedPackages() {
+  List<Package> getCachedPackages([String url]) {
+    if (url == null) url = _defaultUrl;
+
     var cacheDir = path.join(systemCacheRoot,
-                             _getSourceDirectory(_defaultUrl));
+                             _getSourceDirectory(url));
     if (!dirExists(cacheDir)) return [];
 
     return listDir(path.join(cacheDir)).map((entry) {
       // TODO(keertip): instead of catching exception in pubspec parse with
-      // sdk dependency, fix to parse and report usage of sdk dependency. 
+      // sdk dependency, fix to parse and report usage of sdk dependency.
       // dartbug.com/10190
       try {
         return new Package.load(null, entry, systemCache.sources);
       }  on ArgumentError catch (e) {
-        log.error(e);         
+        log.error(e);
       }
     }).where((package) => package != null).toList();
   }
 
   /// When an error occurs trying to read something about [package] from [url],
   /// this tries to translate into a more user friendly error message. Always
   /// throws an error, either the original one or a better one.
   void _throwFriendlyError(error, package, url) {
     if (error is PubHttpException &&
         error.response.statusCode == 404) {
       fail('Could not find package "$package" at $url.');
     }
 
     if (error is TimeoutException) {
       fail('Timed out trying to find package "$package" at $url.');
     }
 
     if (error is io.SocketIOException) {
       fail('Got socket error trying to find package "$package" at $url.\n'
           '${error.osError}');
     }
 
     // Otherwise re-throw the original exception.
     throw error;
   }
+}
 
+/// This is the modified hosted source used when pub install or update 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<Version>> getVersions(String name, description) {
+    return new Future(() {
+      var parsed = _parseDescription(description);
+      var server = parsed.last;
+      log.io("Finding versions of $name in "
+             "${systemCache.rootDir}/${_getSourceDirectory(server)}");
+      return getCachedPackages(server)
+          .where((package) => package.name == name)
+          .map((package) => package.version)
+          .toList();
+    }).then((versions) {
+      // If there are no versions in the cache, report a clearer error.
+      if (versions.isEmpty) fail('Could not find package "$name" in cache.');
+
+      return versions;
+    });
+  }
+
+  Future<bool> install(PackageId id, String destPath) {
+    // Since HostedSource returns `true` for [shouldCache], install will only
+    // be called for uncached packages.
+    throw new UnsupportedError("Cannot install packages when offline.");
+  }
+
+  Future<Pubspec> describe(PackageId id) {
+    // [getVersions()] will only return packages that are already cached.
+    // SystemCache should only call [describe()] on a package after it has
+    // failed to find it in the cache, so this code should not be reached.
+    throw new UnsupportedError("Cannot describe packages when offline.");
+  }
 }
 
 /// The URL of the default package repository.
 final _defaultUrl = "https://pub.dartlang.org";
 
 String _getSourceDirectory(String url) {
-  return url.replaceAll(new RegExp(r"^https?://"), "");
+  url = url.replaceAll(new RegExp(r"^https?://"), "");
+  return replace(url, new RegExp(r'[<>:"\\/|?*%]'),
+      (match) => '%${match[0].codeUnitAt(0)}');
 }
 
 /// Parses [description] into its server and package name components, then
 /// converts that to a Uri given [pattern]. Ensures the package name is
 /// properly URL encoded.
 Uri _makeUrl(description, String pattern(String server, String package)) {
   var parsed = _parseDescription(description);
   var server = parsed.last;
   var package = encodeUriComponent(parsed.first);
   return new Uri(pattern(server, package));
@@ skipping 31 matching lines @@
   }
 
   var name = description["name"];
   if (name is! String) {
     throw new FormatException("The 'name' key must have a string value.");
   }
 
   var url = description.containsKey("url") ? description["url"] : _defaultUrl;
   return new Pair<String, String>(name, url);
 }