Support relative paths in path dependencies.

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 'dart:async';
 
 import '../../pkg/path/lib/path.dart' as path;
 
@@ skipping 151 matching lines @@
   ///
   /// This doesn't need to be implemented if [shouldCache] is false.
   Future<String> systemCacheDirectory(PackageId id) {
     return new Future.immediateError(
         "systemCacheDirectory() must be implemented if shouldCache is true.");
   }
 
   /// 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.
+  /// that the given [description] is well-formed according to this source, and
+  /// to give the source a chance to canonicalize the description.
+  ///
+  /// [containingPath] is the path to the local file (pubspec or lockfile)
+  /// where this description appears. It may be `null` if the description is
+  /// coming from some in-memory source (such as pulling down a pubspec from
+  /// pub.dartlang.org).
+  ///
+  /// It should return if a (possibly modified) valid description, or throw a
+  /// [FormatException] if not valid.
   ///
   /// [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}) {}
+  dynamic parseDescription(String containingPath, description,
+                           {bool fromLockFile: false}) {
+    return 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, just uses regular equality.
   bool descriptionsEqual(description1, description2) =>
     description1 == description2;
 
   /// For some sources, [PackageId]s can point to different chunks of code at
   /// different times. This takes such an [id] and returns a future that
   /// completes to a [PackageId] that will uniquely specify a single chunk of
   /// code forever.
   ///
   /// For example, [GitSource] might take an [id] with description
   /// `http://github.com/dart-lang/some-lib.git` and return an id with a
   /// description that includes the current commit of the Git repository.
   ///
   /// This will be called after the package identified by [id] is installed, so
   /// the source can use the installed package to determine information about
   /// the resolved id.
   ///
   /// The returned [PackageId] may have a description field that's invalid
-  /// according to [validateDescription], although it must still be serializable
+  /// according to [parseDescription], 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);
 
   /// Returns the source's name.
   String toString() => name;
 }