Support relative paths in path dependencies.

utils/pub/entrypoint.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 entrypoint;
 
 import 'dart:async';
 
 import '../../pkg/path/lib/path.dart' as path;
 
@@ skipping 64 matching lines @@
       ensureDir(path.dirname(packageDir));
       if (!dirExists(packageDir)) return;
 
       // TODO(nweiz): figure out when to actually delete the directory, and when
       // we can just re-use the existing symlink.
       log.fine("Deleting package directory for ${id.name} before install.");
       return deleteDir(packageDir);
     }).then((_) {
       if (id.source.shouldCache) {
         return cache.install(id).then(
-            (pkg) => createPackageSymlink(id.name, pkg.dir, packageDir));
+            (pkg) => createPackageSymlink(id.name, packageDir, pkg.dir));
       } else {
         return id.source.install(id, packageDir).then((found) {
           if (found) return null;
           // TODO(nweiz): More robust error-handling.
           throw 'Package ${id.name} not found in source "${id.source.name}".';
         });
       }
     }).then((_) => id.resolved);
 
     _installs[id] = future;
@@ skipping 106 matching lines @@
                 "package.");
       }
     });
   }
 
   /// Loads the list of concrete package versions from the `pubspec.lock`, if it
   /// exists. If it doesn't, this completes to an empty [LockFile].
   LockFile loadLockFile() {
     var lockFilePath = path.join(root.dir, 'pubspec.lock');
     if (!fileExists(lockFilePath)) return new LockFile.empty();
-    return new LockFile.parse(readTextFile(lockFilePath), cache.sources);
+    return new LockFile.parse(lockFilePath, readTextFile(lockFilePath),
+        cache.sources);

[nweiz, 2013/02/15 23:09:24]

Should this be LockFile.load, which just takes a path and reads it itself? Then
you could keep LockFile.parse with its old signature.

[Bob Nystrom, 2013/02/16 00:09:57]

Done.

   }
 
   /// Saves a list of concrete package versions to the `pubspec.lock` file.
   void _saveLockFile(List<PackageId> packageIds) {
     var lockFile = new LockFile.empty();
     for (var id in packageIds) {
       if (!id.isRoot) lockFile.packages[id.name] = id;
     }
 
     var lockFilePath = path.join(root.dir, 'pubspec.lock');
     writeTextFile(lockFilePath, lockFile.serialize());
   }
 
   /// Installs a self-referential symlink in the `packages` directory that will
   /// allow a package to import its own files using `package:`.
   Future _installSelfReference(_) {
     return defer(() {
       var linkPath = path.join(packagesDir, root.name);
       // Create the symlink if it doesn't exist.
       if (entryExists(linkPath)) return;
       ensureDir(packagesDir);
-      return createPackageSymlink(root.name, root.dir, linkPath,
+      return createPackageSymlink(root.name, linkPath, root.dir,
           isSelfLink: true);
     });
   }
 
   /// If `bin/`, `test/`, or `example/` directories exist, symlink `packages/`
   /// into them so that their entrypoints can be run. Do the same for any
   /// subdirectories of `test/` and `example/`.
   Future _linkSecondaryPackageDirs(_) {
     var binDir = path.join(root.dir, 'bin');
     var exampleDir = path.join(root.dir, 'example');
@@ skipping 42 matching lines @@
           fileAndSubfiles.addAll(subfiles);
           return fileAndSubfiles;
         });
       }));
     }).then(flatten);
   }
 
   /// Creates a symlink to the `packages` directory in [dir] if none exists.
   Future _linkSecondaryPackageDir(String dir) {
     return defer(() {
-      var to = path.join(dir, 'packages');
-      if (entryExists(to)) return;
-      return createSymlink(packagesDir, to);
+      var symlink = path.join(dir, 'packages');
+      if (entryExists(symlink)) return;
+      return createSymlink(symlink, packagesDir);
     });
   }
 }