Big merge from experimental to bleeding edge.

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 'io.dart';
 import 'package.dart';
 import 'pubspec.dart';
 import 'system_cache.dart';
 import 'version.dart';
 
 /// A source from which to install packages.
 ///
 /// Each source has many packages that it looks up using [PackageId]s. The
 /// source is responsible for installing these packages to the package cache.
@@ skipping 40 matching lines @@
   /// [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(String name, description) {
     return describe(new PackageId(name, this, Version.none, description))
-      .transform((pubspec) => [pubspec.version]);
+      .then((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
   /// must implement it manually.
   Future<Pubspec> describe(PackageId id) {
     if (!shouldCache) throw "Source $name must implement describe(id).";
-    return installToSystemCache(id).transform((package) => package.pubspec);
+    return installToSystemCache(id).then((package) => package.pubspec);
   }
 
   /// Installs the package identified by [id] to [path]. Returns a [Future] that
   /// completes when the installation was finished. The [Future] should resolve
   /// to true if the package was found in the source and false if it wasn't. For
   /// all other error conditions, it should complete with an exception.
   ///
   /// [path] is guaranteed not to exist, and its parent directory is guaranteed
   /// to exist.
   ///
   /// Note that [path] may be deleted. If re-installing a package that has
   /// already been installed would be costly or impossible,
   /// [installToSystemCache] should be implemented instead of [install].
   ///
   /// This doesn't need to be implemented if [installToSystemCache] is
   /// implemented.
   Future<bool> install(PackageId id, String path) {
     throw "Either install or installToSystemCache must be implemented for "
         "source $name.";
   }
 
   /// Installs the package identified by [id] to the system cache. This is only
   /// called for sources with [shouldCache] set to true.
   ///
   /// By default, this uses [systemCacheDirectory] and [install].
   Future<Package> installToSystemCache(PackageId id) {
     var path = systemCacheDirectory(id);
-    return exists(path).chain((exists) {
+    return exists(path).then((exists) {
       if (exists) return new Future<bool>.immediate(true);
-      return ensureDir(dirname(path)).chain((_) => install(id, path));
-    }).chain((found) {
+      return ensureDir(dirname(path)).then((_) => install(id, path));
+    }).then((found) {
       if (!found) throw 'Package $id not found.';
       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
@@ skipping 39 matching lines @@
   /// 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);
 
   /// Returns the source's name.
   String toString() => name;
 }