Properly handle HTTP hosted URLs.

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.
 
 import 'dart:async';
 import 'dart:io' as io;
 import "dart:convert";
 
 import 'package:http/http.dart' as http;
-import 'package:path/path.dart' as path;
+import 'package:path/path.dart' as p;
 import 'package:pub_semver/pub_semver.dart';
 
 import '../exceptions.dart';
 import '../http.dart';
 import '../io.dart';
 import '../log.dart' as log;
 import '../package.dart';
 import '../pubspec.dart';
 import '../utils.dart';
 import 'cached.dart';
@@ skipping 86 matching lines @@
 
     return new Pubspec.fromMap(
         version['pubspec'], systemCache.sources,
         expectedName: id.name, location: url);
   }
 
   /// Downloads the package identified by [id] to the system cache.
   Future<Package> downloadToSystemCache(PackageId id) async {
     if (!isInSystemCache(id)) {
       var packageDir = getDirectory(id);
-      ensureDir(path.dirname(packageDir));
+      ensureDir(p.dirname(packageDir));
       var parsed = _parseDescription(id.description);
       await _download(parsed.last, parsed.first, id.version, packageDir);
     }
 
     return new Package.load(id.name, getDirectory(id), systemCache.sources);
   }
 
   /// 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 downloaded from that site.
   String getDirectory(PackageId id) {
     var parsed = _parseDescription(id.description);
     var dir = _urlToDirectory(parsed.last);
-    return path.join(systemCacheRoot, dir, "${parsed.first}-${id.version}");
+    return p.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
@@ skipping 11 matching lines @@
 
   /// Re-downloads all packages that have been previously downloaded into the
   /// system cache from any server.
   Future<Pair<List<PackageId>, List<PackageId>>> repairCachedPackages() async {
     if (!dirExists(systemCacheRoot)) return new Pair([], []);
 
     var successes = [];
     var failures = [];
 
     for (var serverDir in listDir(systemCacheRoot)) {
-      var url = _directoryToUrl(path.basename(serverDir));
-      var packages = _getCachedPackagesInDirectory(path.basename(serverDir));
+      var url = _directoryToUrl(p.basename(serverDir));
+      var packages = _getCachedPackagesInDirectory(p.basename(serverDir));
       packages.sort(Package.orderByNameAndVersion);
 
       for (var package in packages) {
         var id = idFor(package.name, package.version, url: url);
 
         try {
           await _download(url, package.name, package.version, package.dir);
           successes.add(id);
         } catch (error, stackTrace) {
           failures.add(id);
@@ skipping 13 matching lines @@
 
   /// Gets all of the packages that have been downloaded into the system cache
   /// from the default server.
   List<Package> getCachedPackages() {
     return _getCachedPackagesInDirectory(_urlToDirectory(defaultUrl));
   }
 
   /// Gets all of the packages that have been downloaded into the system cache
   /// into [dir].
   List<Package> _getCachedPackagesInDirectory(String dir) {
-    var cacheDir = path.join(systemCacheRoot, dir);
+    var cacheDir = p.join(systemCacheRoot, dir);
     if (!dirExists(cacheDir)) return [];
 
     return listDir(cacheDir)
         .map((entry) => new Package.load(null, entry, systemCache.sources))
         .toList();
   }
 
   /// Downloads package [package] at [version] from [server], and unpacks it
   /// into [destPath].
   Future _download(String server, String package, Version version,
@@ skipping 45 matching lines @@
 /// 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 [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 ${ref.name} in "
         "$systemCacheRoot/${_urlToDirectory(server)}");
 
-    var dir = path.join(systemCacheRoot, _urlToDirectory(server));
+    var dir = p.join(systemCacheRoot, _urlToDirectory(server));
 
     var versions;
     if (dirExists(dir)) {
       versions = await listDir(dir).map((entry) {
-        var components = path.basename(entry).split("-");
+        var components = p.basename(entry).split("-");
         if (components.first != ref.name) return null;
         return HostedSource.idFor(
             ref.name, new Version.parse(components.skip(1).join("-")),
             url: _serverFor(ref.description));
       }).where((id) => id != null).toList();
     } else {
       versions = [];
     }
 
     // If there are no versions in the cache, report a clearer error.
@@ skipping 26 matching lines @@
 /// incorrectly: it uses the character's *decimal* ASCII value instead of hex.
 ///
 /// This could cause an ambiguity since some characters get encoded as three
 /// digits and others two. It's possible for one to be a prefix of the other.
 /// In practice, the set of characters that are encoded don't happen to have
 /// any collisions, so the encoding is reversible.
 ///
 /// This behavior is a bug, but is being preserved for compatibility.
 String _urlToDirectory(String url) {
   // Normalize all loopback URLs to "localhost".
-  url = url.replaceAllMapped(new RegExp(r"^https?://(127\.0\.0\.1|\[::1\])?"),
-      (match) => match[1] == null ? '' : 'localhost');
+  url = url.replaceAllMapped(
+      new RegExp(r"^(https?://)(127\.0\.0\.1|\[::1\]|localhost)?"),
+      (match) {
+    // Don't include the scheme for HTTPS URLs. This makes the directory names
+    // nice for the default and most recommended scheme. We also don't include
+    // it for localhost URLs, since they're always known to be HTTP.
+    var localhost = match[2] == null ? '' : 'localhost';
+    var scheme = match[1] == 'https://' || localhost.isNotEmpty ? '' : match[1];
+    return "$scheme$localhost";
+  });
   return replace(url, new RegExp(r'[<>:"\\/|?*%]'),
       (match) => '%${match[0].codeUnitAt(0)}');
 }
 
 /// Given a directory name in the system cache, returns the URL of the server
 /// whose packages it contains.
 ///
 /// See [_urlToDirectory] for details on the mapping. Note that because the
 /// directory name does not preserve the scheme, this has to guess at it. It
 /// chooses "http" for loopback URLs (mainly to support the pub tests) and
 /// "https" for all others.
 String _directoryToUrl(String url) {
   // Decode the pseudo-URL-encoded characters.
   var chars = '<>:"\\/|?*%';
   for (var i = 0; i < chars.length; i++) {
     var c = chars.substring(i, i + 1);
     url = url.replaceAll("%${c.codeUnitAt(0)}", c);
   }
 
-  // Figure out the scheme.
-  var scheme = "https";
+  // If the URL has an explicit scheme, use that.
+  if (url.contains("://")) return url;
 
-  // See if it's a loopback IP address.
-  if (isLoopback(url.replaceAll(new RegExp(":.*"), ""))) scheme = "http";
+  // Otherwise, default to http for localhost and https for everything else.
+  var scheme =
+      isLoopback(url.replaceAll(new RegExp(":.*"), "")) ? "http" : "https";
   return "$scheme://$url";
 }
 
 /// 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;
@@ skipping 39 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);
 }