Make Source.getDirectory synchronous.

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.
 
 library pub.entrypoint;
 
 import 'dart:async';
 
 import 'package:path/path.dart' as path;
 import 'package:barback/barback.dart';
@@ skipping 384 matching lines @@
 
       return source.descriptionsEqual(package.description, locked.description);
     });
   }
 
   /// Determines whether all of the packages in the lockfile are already
   /// installed and available.
   ///
   /// Note: this assumes [isLockFileUpToDate] has already been called and
   /// returned `true`.
-  Future<bool> _arePackagesAvailable(LockFile lockFile) {
-    return Future.wait(lockFile.packages.values.map((package) {
+  bool _arePackagesAvailable(LockFile lockFile) {
+    return lockFile.packages.values.every((package) {
       var source = cache.sources[package.source];
 
       // This should only be called after [_isLockFileUpToDate] has returned
       // `true`, which ensures all of the sources in the lock file are valid.
       assert(source != null);
 
       // 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.
-      if (source is! CachedSource) return new Future.value(true);
+      if (source is! CachedSource) return true;
 
       // Get the directory.
-      return source.getDirectory(package).then((dir) {
-        // See if the directory is there and looks like a package.
-        return dirExists(dir) || fileExists(path.join(dir, "pubspec.yaml"));
-      });
-    })).then((results) {
-      // Make sure they are all true.
-      return results.every((result) => result);
+      var dir = source.getDirectory(package);
+      // See if the directory is there and looks like a package.
+      return dirExists(dir) || fileExists(path.join(dir, "pubspec.yaml"));
     });
   }
 
   /// Gets dependencies if the lockfile is out of date with respect to the
   /// pubspec.
   Future ensureLockFileIsUpToDate() async {
     if (!lockFileExists) {
       log.message(
           "You don't have a lockfile, so we need to generate that:");
     } else if (_isLockFileUpToDate(lockFile)) {
       // If we do have a lock file, we still need to make sure the packages are
       // actually installed. The user may have just gotten a package that
       // includes a lockfile.
-      if (await _arePackagesAvailable(lockFile)) return;
+      if (_arePackagesAvailable(lockFile)) return;
 
       // If we don't have a current lock file, we definitely need to install.
       log.message(
           "You are missing some dependencies, so we need to install them "
           "first:");
     } else {
       log.message(
           "Your pubspec has changed, so we need to update your lockfile:");
     }
 
     await acquireDependencies(SolveType.GET);
   }
 
   /// Loads the package graph for the application and all of its transitive
   /// dependencies.
   ///
   /// If [result] is passed, this loads the graph from it without re-parsing the
   /// lockfile or any pubspecs. Otherwise, before loading, this makes sure the
   /// lockfile and dependencies are installed and up to date.
   Future<PackageGraph> loadPackageGraph([SolveResult result]) async {
     if (_packageGraph != null) return _packageGraph;
 
     var graph = await log.progress("Loading package graph", () async {
       if (result != null) {
-        var packages = await Future.wait(result.packages.map((id) async {
+        var packages = new Map.fromIterable(result.packages,
+            key: (id) => id.name,
+            value: (id) {
           if (id.name == root.name) return root;
 
-          var dir = await cache.sources[id.source].getDirectory(id);
-          return new Package(result.pubspecs[id.name], dir);
-        }));
+          return new Package(result.pubspecs[id.name],
+              cache.sources[id.source].getDirectory(id));
+        });
 
-        return new PackageGraph(this, new LockFile(result.packages),
-            new Map.fromIterable(packages, key: (package) => package.name));
+        return new PackageGraph(this, new LockFile(result.packages), packages);
       }
 
       await ensureLockFileIsUpToDate();
-      var packages = await Future.wait(lockFile.packages.values.map((id) async {
-        var source = cache.sources[id.source];
-        var dir = await source.getDirectory(id);
+      var packages = new Map.fromIterable(lockFile.packages.values,
+          key: (id) => id.name,
+          value: (id) {
+        var dir = cache.sources[id.source].getDirectory(id);
         return new Package.load(id.name, dir, cache.sources);
-      }));
-
-      var packageMap = new Map.fromIterable(packages, key: (p) => p.name);
-      packageMap[root.name] = root;
-      return new PackageGraph(this, lockFile, packageMap);
+      });
+      packages[root.name] = root;
+      return new PackageGraph(this, lockFile, packages);
     }, fine: true);
 
     _packageGraph = graph;
     return graph;
   }
 
   /// Saves a list of concrete package versions to the `pubspec.lock` file.
   void _saveLockFile(List<PackageId> packageIds) {
     _lockFile = new LockFile(packageIds);
     var lockFilePath = root.path('pubspec.lock');
@@ skipping 57 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 = path.join(dir, 'packages');
     if (entryExists(symlink)) deleteEntry(symlink);
     if (_packageSymlinks) createSymlink(packagesDir, symlink, relative: true);
   }
 }