Track Source objects in PackageNames.

lib/src/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.
 
 import 'dart:async';
 import 'dart:io';
 
 import 'package:barback/barback.dart';
 import 'package:package_config/packages_file.dart' as packages_file;
 import 'package:path/path.dart' as p;
@@ skipping 52 matching lines @@
   /// Whether this is an entrypoint for a globally-activated package.
   final bool isGlobal;
 
   /// The lockfile for the entrypoint.
   ///
   /// If not provided to the entrypoint, it will be loaded lazily from disk.
   LockFile get lockFile {
     if (_lockFile != null) return _lockFile;
 
     if (!fileExists(lockFilePath)) {
-      _lockFile = new LockFile.empty(cache.sources);
+      _lockFile = new LockFile.empty();
     } else {
       _lockFile = new LockFile.load(lockFilePath, cache.sources);
     }
 
     return _lockFile;
   }
   LockFile _lockFile;
 
   /// The package graph for the application and all of its transitive
   /// dependencies.
@@ skipping 448 matching lines @@
           'changed since the pubspec.lock file was generated, please run "pub '
           'get" again.');
     }
   }
 
   /// Returns whether the locked version of [dep] matches the dependency.
   bool _isDependencyUpToDate(PackageDep dep) {
     if (dep.name == root.name) return true;
 
     var locked = lockFile.packages[dep.name];
-    if (locked == null) return false;
-
-    if (dep.source != locked.source) return false;
-
-    if (!dep.constraint.allows(locked.version)) return false;
-
-    var source = cache.sources[dep.source];
-    if (source == null) return false;
-
-    return source.descriptionsEqual(dep.description, locked.description);
+    return locked != null && dep.allows(locked);
   }
 
   /// Determines whether all of the packages in the lockfile are already
   /// installed and available.
   bool _arePackagesAvailable() {
     return lockFile.packages.values.every((package) {
-      var source = cache.sources[package.source];
-      if (source is UnknownSource) return false;
+      if (package.source is UnknownSource) return false;
 
       // We only care about cached sources. Uncached sources aren't "installed".
       // If one of those is missing, we want to show the user the file not
       // found error later since installing won't accomplish anything.
-      var boundSource = cache.source(package.source);
-      if (boundSource is! CachedSource) return true;
+      var source = cache.source(package.source);
+      if (source is! CachedSource) return true;
 
       // Get the directory.
-      var dir = boundSource.getDirectory(package);
+      var dir = source.getDirectory(package);
       // See if the directory is there and looks like a package.
       return dirExists(dir) && fileExists(p.join(dir, "pubspec.yaml"));
     });
   }
 
   /// Determines whether or not the `.packages` file is out of date with respect
   /// to the lockfile.
   ///
   /// This will be `false` if the packages file contains dependencies that are
   /// not in the lockfile or that don't match what's in there.
   bool _isPackagesFileUpToDate() {
     var packages = packages_file.parse(
         new File(packagesFile).readAsBytesSync(),
         p.toUri(packagesFile));
 
     return lockFile.packages.values.every((lockFileId) {
-      var source = cache.source(lockFileId.source);
-
       // It's very unlikely that the lockfile is invalid here, but it's not
       // impossible—for example, the user may have a very old application
       // package with a checked-in lockfile that's newer than the pubspec, but
       // that contains sdk dependencies.
-      if (source.source is UnknownSource) return false;
+      if (lockFileId.source is UnknownSource) return false;
 
       var packagesFileUri = packages[lockFileId.name];
       if (packagesFileUri == null) return false;
 
       // Pub only generates "file:" and relative URIs.
       if (packagesFileUri.scheme != 'file' &&
           packagesFileUri.scheme.isNotEmpty) {
         return false;
       }
 
+      var source = cache.source(lockFileId.source);
+
       // Get the dirname of the .packages path, since it's pointing to lib/.
       var packagesFilePath = p.dirname(
           p.join(root.dir, p.fromUri(packagesFileUri)));
       var lockFilePath = p.join(root.dir, source.getDirectory(lockFileId));
 
       // For cached sources, make sure the directory exists and looks like a
       // package. This is also done by [_arePackagesAvailable] but that may not
       // be run if the lockfile is newer than the pubspec.
       if (source is CachedSource &&
           !dirExists(packagesFilePath) ||
@@ skipping 71 matching lines @@
   /// If [packageSymlinks] is true, creates a symlink to the "packages"
   /// directory in [dir].
   ///
   /// Otherwise, deletes a "packages" directories in [dir] if one exists.
   void _linkOrDeleteSecondaryPackageDir(String dir) {
     var symlink = p.join(dir, 'packages');
     if (entryExists(symlink)) deleteEntry(symlink);
     if (_packageSymlinks) createSymlink(packagesDir, symlink, relative: true);
   }
 }