Add logging system to pub and sprinkle some logging in.

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 22 matching lines @@
  * 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 'dart:math';
 import 'lock_file.dart';
+import 'log.dart' as log;
 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 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,
     LockFile lockFile) {
-  print('Resolving dependencies...');
+  log.message('Resolving dependencies...');
   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;
@@ skipping 187 matching lines @@
   /**
    * The new selected version.
    */
   final Version version;
 
   ChangeVersion(this.package, this.source, this.description, this.version) {
     if (source == null) throw "null source";
   }
 
   Future process(VersionSolver solver) {
+    log.fine("Changing $package to version $version.");
+
     var dependency = solver.getDependency(package);
     var oldVersion = dependency.version;
     solver.setVersion(package, version);
 
     // The dependencies between the old and new version may be different. Walk
     // them both and update any constraints that differ between the two.
     return Futures.wait([
         getDependencyRefs(solver, oldVersion),
         getDependencyRefs(solver, version)]).transform((list) {
       var oldDependencyRefs = list[0];
@@ skipping 131 matching lines @@
   /**
    * The package being depended on and the constraints being placed on it. The
    * source, version, and description in this ref are all considered constraints
    * on the dependent package.
    */
   final PackageRef ref;
 
   AddConstraint(this.depender, this.ref);
 
   Future process(VersionSolver solver) {
+    log.fine("Adding $depender's constraint $ref.");
+
     var dependency = solver.getDependency(ref.name);
     var oldDependency = dependency.clone();
     dependency.placeConstraint(depender, ref);
     return _processChange(solver, oldDependency, dependency);
   }
 
   void undo(VersionSolver solver) {
     solver.getDependency(ref.name).removeConstraint(depender);
   }
 }
@@ skipping 11 matching lines @@
    * The package that was being depended on.
    */
   String dependent;
 
   /** The constraint that was removed. */
   PackageRef _removed;
 
   RemoveConstraint(this.depender, this.dependent);
 
   Future process(VersionSolver solver) {
+    log.fine("Removing $depender's constraint ($_removed) on $dependent.");
+
     var dependency = solver.getDependency(dependent);
     var oldDependency = dependency.clone();
     _removed = dependency.removeConstraint(depender);
     return _processChange(solver, oldDependency, dependency);
   }
 
   void undo(VersionSolver solver) {
     solver.getDependency(dependent).placeConstraint(depender, _removed);
   }
 }
 
 /** [package]'s version is no longer constrained by the lockfile. */
 class UnlockPackage implements WorkItem {
   /** The package being unlocked. */
   Dependency package;
 
   UnlockPackage(this.package);
 
   Future process(VersionSolver solver) {
+    log.fine("Unlocking ${package.name}.");
+
     solver.lockFile.packages.remove(package.name);
     return solver.getBestVersion(package).transform((best) {
       if (best == null) return null;
       solver.enqueue(new ChangeVersion(
           package.name, package.source, package.description, best));
     });
   }
 }
 
 // TODO(rnystrom): Instead of always pulling from the source (which will mean
@@ skipping 284 matching lines @@
 
   String toString() {
     // TODO(nweiz): Dump descriptions to YAML when that's supported.
     return "Incompatible dependencies on '$package':\n"
         "- '$depender1' depends on it with description "
         "${JSON.stringify(description1)}\n"
         "- '$depender2' depends on it with description "
         "${JSON.stringify(description2)}";
   }
 }