Don't extract the name of a package from its description.

utils/pub/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('source');
 
 #import('io.dart');
 #import('package.dart');
 #import('pubspec.dart');
 #import('system_cache.dart');
@@ skipping 48 matching lines @@
    * This should only be called once for each source, by [SystemCache.register].
    * It should not be overridden by base classes.
    */
   void bind(SystemCache systemCache) {
     assert(_systemCache == null);
     this._systemCache = systemCache;
   }
 
   /**
    * Get the list of all versions that exist for the package described by
-   * [description].
+   * [description]. [name] is the expected name of the package.
    *
    * Note that this does *not* require the packages to be installed, which is
    * the point. This is used during version resolution to determine which
    * package versions are available to be installed (or already installed).
    *
    * By default, this assumes that each description has a single version and
    * uses [describe] to get that version.
    */
-  Future<List<Version>> getVersions(description) {
-    return describe(new PackageId(this, Version.none, description))
+  Future<List<Version>> getVersions(String name, description) {
+    return describe(new PackageId(name, this, Version.none, description))
       .transform((pubspec) => [pubspec.version]);
   }
 
   /**
    * Loads the (possibly remote) pubspec for the package version identified by
    * [id]. This may be called for packages that have not yet been installed
    * during the version resolution process.
    *
    * For cached sources, by default this uses [installToSystemCache] to get the
    * pubspec. There is no default implementation for non-cached sources; they
@@ skipping 31 matching lines @@
    *
    * By default, this uses [systemCacheDirectory] and [install].
    */
   Future<Package> installToSystemCache(PackageId id) {
     var path = systemCacheDirectory(id);
     return exists(path).chain((exists) {
       if (exists) return new Future<bool>.immediate(true);
       return ensureDir(dirname(path)).chain((_) => install(id, path));
     }).chain((found) {
       if (!found) throw 'Package $id not found.';
-      return Package.load(path, systemCache.sources);
+      return Package.load(id.name, path, systemCache.sources);
     });
   }
 
   /**
    * Returns the directory in the system cache that the package identified by
    * [id] should be installed to. This should return a path to a subdirectory of
    * [systemCacheRoot].
    *
    * This doesn't need to be implemented if [shouldCache] is false, or if
    * [installToSystemCache] is implemented.
    */
   String systemCacheDirectory(PackageId id) =>
     join(systemCacheRoot, packageName(id.description));
 
   /**
    * When a [Pubspec] or [LockFile] is parsed, it reads in the description for
    * each dependency. It is up to the dependency's [Source] to determine how
    * that should be interpreted. This will be called during parsing to validate
    * that the given [description] is well-formed according to this source. It
    * should return if the description is valid, or throw a [FormatException] if
    * not.
    *
    * [fromLockFile] is true when the description comes from a [LockFile], to
    * allow the source to use lockfile-specific descriptions via [resolveId].
    */
   void validateDescription(description, [bool fromLockFile=false]) {}
 
   /**
-   * Returns a human-friendly name for the package described by [description].
-   * This method should be light-weight. It doesn't need to validate that the
-   * given package exists.
-   *
-   * The package name should be lower-case and suitable for use in a filename.
-   * It may contain forward slashes.
-   */
-  String packageName(description) => description;
-
-  /**
    * Returns whether or not [description1] describes the same package as
    * [description2] for this source. This method should be light-weight. It
    * doesn't need to validate that either package exists.
    *
    * By default, this assumes both descriptions are strings and compares them
    * for equality.
    */
   bool descriptionsEqual(description1, description2) =>
     description1 == description2;
 
@@ skipping 13 matching lines @@
    *
    * The returned [PackageId] may have a description field that's invalid
    * according to [validateDescription], although it must still be serializable
    * to JSON and YAML. It must also be equal to [id] according to
    * [descriptionsEqual].
    *
    * By default, this just returns [id].
    */
   Future<PackageId> resolveId(PackageId id) => new Future.immediate(id);
 }