Use a lockfile to persist Pub's installed version constellation.

utils/pub/version_solver.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.
 
 /**
  * Attempts to resolve a set of version constraints for a package dependency
  * graph and select an appropriate set of best specific versions for all
  * dependent packages. It works iteratively and tries to reach a stable
  * solution where the constraints of all dependencies are met. If it fails to
  * reach a solution after a certain number of iterations, it assumes the
@@ skipping 20 matching lines @@
  * of the constraints that its depending packages place on it. If that overall
  * constraint changes (say from "<3.0.0" to "<2.5.0"), then the currently
  * picked version for that package may fall outside of the new constraint. If
  * that happens, we find the new best version that meets the updated constraint
  * and then the change the package to use that version. That cycles back up to
  * the beginning again.
  */
 #library('version_solver');
 
 #import('dart:json');
+#import('lock_file.dart');
 #import('package.dart');
 #import('pubspec.dart');
 #import('root_source.dart');
 #import('source.dart');
 #import('source_registry.dart');
 #import('utils.dart');
 #import('version.dart');
 
 /**
  * Attempts to select the best concrete versions for all of the transitive
  * dependencies of [root] taking into account all of the [VersionConstraint]s
- * that those dependencies place on each other. If successful, completes to a
- * [Map] that maps package names to the selected version for that package. If
- * it fails, the future will complete with a [NoVersionException],
- * [DisjointConstraintException], or [CouldNotSolveException].
+ * that those dependencies place on each other and the requirements imposed by
+ * [lockFile]. If successful, completes to a [Map] that maps package names to
+ * the selected version for that package. If it fails, the future will complete
+ * with a [NoVersionException], [DisjointConstraintException], or
+ * [CouldNotSolveException].
  */
-Future<List<PackageId>> resolveVersions(SourceRegistry sources, Package root) {
-  return new VersionSolver(sources, root).solve();
+Future<List<PackageId>> resolveVersions(SourceRegistry sources, Package root,
+    LockFile lockFile) {
+  return new VersionSolver(sources, root, lockFile).solve();
 }
 
 class VersionSolver {
   final SourceRegistry _sources;
   final Package _root;
+  final LockFile lockFile;
   final PubspecCache _pubspecs;
   final Map<String, Dependency> _packages;
   final Queue<WorkItem> _work;
   int _numIterations = 0;
 
-  VersionSolver(SourceRegistry sources, Package root)
+  VersionSolver(SourceRegistry sources, this._root, this.lockFile)
       : _sources = sources,
-        _root = root,
         _pubspecs = new PubspecCache(sources),
         _packages = <Dependency>{},
         _work = new Queue<WorkItem>();
 
   Future<List<PackageId>> solve() {
     // Kick off the work by adding the root package at its concrete version to
     // the dependency graph.
     var ref = new PackageRef(new RootSource(_root), _root.version, _root.name);
     enqueue(new AddConstraint('(entrypoint)', ref));
     _pubspecs.cache(ref.atVersion(_root.version), _root.pubspec);
@@ skipping 40 matching lines @@
   }
 
   /**
    * Sets the best selected version of [package] to [version].
    */
   void setVersion(String package, Version version) {
     _packages[package].version = version;
   }
 
   List<PackageId> buildResults() {
-    return _packages.getValues()
-      .filter((dep) => dep.isDependedOn)
-      .map((dep) => new PackageId(dep.source, dep.version, dep.description));
+    return _packages.getValues().filter((dep) => dep.isDependedOn).map((dep) {
+      var description = dep.description;
+
+      // If the lockfile contains a fully-resolved description for the package,
+      // use that. This allows e.g. Git to ensure that the same commit is used.
+      var lockedPackage = lockFile.packages[dep.name];
+      if (lockedPackage != null && lockedPackage.version == dep.version &&
+          lockedPackage.source.name == dep.source.name &&
+          dep.source.descriptionsEqual(description, lockedPackage.description)) {

[Jennifer Messerly, 2012/07/19 18:45:34]

long line

[nweiz, 2012/07/19 18:56:54]

Done.

+        description = lockedPackage.description;
+      }
+
+      return new PackageId(dep.source, dep.version, description);
+    });
   }
 }
 
 /**
  * The constraint solver works by iteratively processing a queue of work items.
  * Each item is a single atomic change to the dependency graph. Handling them
  * in a queue lets us handle asynchrony (resolving versions requires information
  * from servers) as well as avoid deeply nested recursion.
 */
 interface WorkItem {
@@ skipping 123 matching lines @@
     }
 
     // If the dependency is on the root package, then we don't need to do
     // anything since it's already at the best version.
     if (name == solver._root.name) {
       solver.enqueue(new ChangeVersion(
           source, description, solver._root.version));
       return null;
     }
 
+    // If the dependency is on a package in the lockfile, use the lockfile's
+    // version for that package if it's valid given the other constraints.
+    if (solver.lockFile.packages.containsKey(name)) {

[Jennifer Messerly, 2012/07/19 18:45:34]

nit: I probably would write this as

  var lockedPackage = solver.lockFile.packages[name]
  if (lockedPackage != null) {
    var lockedVersion = lockedPackage.version;

saves a map lookup & slightly less characters :)

[nweiz, 2012/07/19 18:56:54]

Done.

+      var lockedVersion = solver.lockFile.packages[name].version;
+      if (newConstraint.allows(lockedVersion)) {
+        solver.enqueue(new ChangeVersion(source, description, lockedVersion));
+        return null;
+      }
+    }
+
     // The constraint has changed, so see what the best version of the package
     // that meets the new constraint is.
     return source.getVersions(description).transform((versions) {
       var best = null;
       for (var version in versions) {
         if (newConstraint.allows(version)) {
           if (best == null || version > best) best = version;
         }
       }
 
@@ skipping 258 matching lines @@
   final description1;
   final description2;
 
   DescriptionMismatchException(this.package, this.description1,
       this.description2);
 
   // TODO(nweiz): Dump to YAML when that's supported
   String toString() => "Package '$package' has conflicting descriptions "
     "'${JSON.stringify(description1)}' and '${JSON.stringify(description2)}'";
 }