Move pub into sdk/lib/_internal.

utils/pub/source.dart

Index: utils/pub/source.dart
diff --git a/utils/pub/source.dart b/utils/pub/source.dart
deleted file mode 100644
index ba2afa400c4b40ba4b2d28ad5d324b506f331624..0000000000000000000000000000000000000000
--- a/utils/pub/source.dart
+++ /dev/null
@@ -1,222 +0,0 @@
-// 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 'package:pathos/path.dart' as path;
-
-import 'io.dart';
-import 'package.dart';
-import 'pubspec.dart';
-import 'system_cache.dart';
-import 'utils.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.
-abstract class Source {
-  /// The name of the source. Should be lower-case, suitable for use in a
-  /// filename, and unique accross all sources.
-  String get name;
-
-  /// Whether or not this source is the default source.
-  bool get isDefault => systemCache.sources.defaultSource == this;
-
-  /// Whether this source's packages should be cached in Pub's global cache
-  /// directory.
-  ///
-  /// A source should be cached if it requires network access to retrieve
-  /// packages. It doesn't need to be cached if all packages are available
-  /// locally.
-  bool get shouldCache;
-
-  /// The system cache with which this source is registered.
-  SystemCache get systemCache {
-    assert(_systemCache != null);
-    return _systemCache;
-  }
-
-  /// The system cache variable. Set by [_bind].
-  SystemCache _systemCache;
-
-  /// The root directory of this source's cache within the system cache.
-  ///
-  /// This shouldn't be overridden by subclasses.
-  String get systemCacheRoot => path.join(systemCache.rootDir, name);
-
-  /// Records the system cache to which this source belongs.
-  ///
-  /// This should only be called once for each source, by
-  /// [SystemCache.register]. It should not be overridden by base classes.
-  void bind(SystemCache systemCache) {
-    assert(_systemCache == null);
-    this._systemCache = systemCache;
-  }
-
-  /// Get the list of all versions that exist for the package described by
-  /// [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))
-      .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 new UnimplementedError("Source $name must implement describe(id).");
-    }
-    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 new UnimplementedError("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 packageDir;
-    return systemCacheDirectory(id).then((p) {
-      packageDir = p;
-
-      // See if it's already cached.
-      if (dirExists(packageDir)) {
-        if (!_isCachedPackageCorrupted(packageDir)) return true;
-        // Busted, so wipe out the package and reinstall.
-        deleteEntry(packageDir);
-      }
-
-      ensureDir(path.dirname(packageDir));
-      return install(id, packageDir);
-    }).then((found) {
-      if (!found) fail('Package $id not found.');
-      return new Package.load(id.name, packageDir, systemCache.sources);
-    });
-  }
-
-  /// Since pub generates symlinks that point into the system cache (in
-  /// particular, targeting the "lib" directories of cached packages), it's
-  /// possible to accidentally break cached packages if something traverses
-  /// that symlink.
-  ///
-  /// This tries to determine if the cached package at [packageDir] has been
-  /// corrupted. The heuristics are it is corrupted if any of the following are
-  /// true:
-  ///
-  ///   * It has an empty "lib" directory.
-  ///   * It has no pubspec.
-  bool _isCachedPackageCorrupted(String packageDir) {
-    if (!fileExists(path.join(packageDir, "pubspec.yaml"))) return true;
-
-    var libDir = path.join(packageDir, "lib");
-    if (dirExists(libDir)) return listDir(libDir).length == 0;
-
-    // If we got here, it's OK.
-    return false;
-  }
-
-  /// 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.
-  Future<String> systemCacheDirectory(PackageId id) {
-    return new Future.error(
-        "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, 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].
-  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 [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.value(id);
-  
-  /// Returns the [Package]s that have been installed in the system cache.
-  List<Package> getCachedPackages() {
-    if (shouldCache) {
-      throw new UnimplementedError("Source $name must implement this.");
-    }
-  }
-
-  /// Returns the source's name.
-  String toString() => name;
-}