Make a bunch of stuff in pub synchronous.

utils/pub/io.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.
 
 /// Helper functionality to make working with IO easier.
 library io;
 
 import 'dart:async';
 import 'dart:io';
 import 'dart:isolate';
@@ skipping 31 matching lines @@
 /// Returns whether or not [entry] is nested somewhere within [dir]. This just
 /// performs a path comparison; it doesn't look at the actual filesystem.
 bool isBeneath(entry, dir) {
   var relative = relativeTo(entry, dir);
   return !path.isAbsolute(relative) && splitPath(relative)[0] != '..';
 }
 
 /// Returns the path to [target] from [base].
 String relativeTo(target, base) => path.relative(target, from: base);
 
-/// Asynchronously determines if [path], which can be a [String] file path, a
-/// [File], or a [Directory] exists on the file system. Returns a [Future] that
-/// completes with the result.
-Future<bool> exists(path) {
-  path = _getPath(path);
-  return Future.wait([fileExists(path), dirExists(path)]).then((results) {
-    return results[0] || results[1];
-  });
-}
+/// Determines if [path], which can be a [String] file path, a [File], or a
+/// [Directory] exists on the file system.
+bool entryExists(path) => fileExists(path) || dirExists(path);
 
-/// Asynchronously determines if [file], which can be a [String] file path or a
-/// [File], exists on the file system. Returns a [Future] that completes with
-/// the result.
-Future<bool> fileExists(file) {
-  var path = _getPath(file);
-  return log.ioAsync("Seeing if file $path exists.",
-      new File(path).exists(),
-      (exists) => "File $path ${exists ? 'exists' : 'does not exist'}.");
-}
+/// Determines if [file], which can be a [String] file path or a [File], exists
+/// on the file system.
+bool fileExists(file) => _getFile(file).existsSync();
 
 /// Reads the contents of the text file [file], which can either be a [String]
 /// or a [File].
-Future<String> readTextFile(file) {
-  var path = _getPath(file);
-  return log.ioAsync("Reading text file $path.",
-      new File(path).readAsString(Encoding.UTF_8),
-      (contents) {
-        // Sanity check: don't spew a huge file.
-        if (contents.length < 1024 * 1024) {
-          return "Read $path. Contents:\n$contents";
-        } else {
-          return "Read ${contents.length} characters from $path.";
-        }
-      });
-}
+String readTextFile(file) => _getFile(file).readAsStringSync(Encoding.UTF_8);
 
 /// Creates [file] (which can either be a [String] or a [File]), and writes
-/// [contents] to it. Completes when the file is written and closed.
+/// [contents] to it.
 ///
 /// If [dontLogContents] is true, the contents of the file will never be logged.
-Future<File> writeTextFile(file, String contents, {dontLogContents: false}) {
+File writeTextFile(file, String contents, {dontLogContents: false}) {
   var path = _getPath(file);
   file = new File(path);
 
   // Sanity check: don't spew a huge file.
   log.io("Writing ${contents.length} characters to text file $path.");
   if (!dontLogContents && contents.length < 1024 * 1024) {
     log.fine("Contents:\n$contents");
   }
 
-  return file.open(FileMode.WRITE).then((opened) {
-    return opened.writeString(contents).then((ignore) {
-        return opened.close().then((_) {
-          log.fine("Wrote text file $path.");
-          return file;
-        });
-    });
-  });
+  file.writeAsStringSync(contents);
+  return file;

[nweiz, 2013/02/01 02:05:55]

"return file..writeAsStringSync(contents)"? Is that too cute?

[Bob Nystrom, 2013/02/01 23:17:21]

Eh, I'll try it. Let's see if it grows on us.

 }
 
-/// Asynchronously deletes [file], which can be a [String] or a [File]. Returns
-/// a [Future] that completes when the deletion is done.
-Future<File> deleteFile(file) {
-  var path = _getPath(file);
-  return log.ioAsync("delete file $path",
-      new File(path).delete());
-}
+/// Deletes [file], which can be a [String] or a [File]. Returns a [Future]
+/// that completes when the deletion is done.
+File deleteFile(file) => _getFile(file)..delete();
 
 /// Writes [stream] to a new file at [path], which may be a [String] or a
 /// [File]. Will replace any file already at that path. Completes when the file
 /// is done being written.
 Future<File> createFileFromStream(InputStream stream, path) {
   path = _getPath(path);
 
   log.io("Creating $path from stream.");
 
   var completer = new Completer<File>();
@@ skipping 24 matching lines @@
       log.fine("Got error after stream was closed: $error");
     }
   }
 
   stream.onError = completeError;
   outputStream.onError = completeError;
 
   return completer.future;
 }
 
-/// Creates a directory [dir]. Returns a [Future] that completes when the
-/// directory is created.
-Future<Directory> createDir(dir) {
-  dir = _getDirectory(dir);
-  return log.ioAsync("create directory ${dir.path}",
-      dir.create());
-}
+/// Creates a directory [dir].
+Directory createDir(dir) => _getDirectory(dir)..createSync();
 
 /// Ensures that [path] and all its parent directories exist. If they don't
-/// exist, creates them. Returns a [Future] that completes once all the
-/// directories are created.
-Future<Directory> ensureDir(path) {
+/// exist, creates them.
+Directory ensureDir(path) {
   path = _getPath(path);
+
   log.fine("Ensuring directory $path exists.");
-  if (path == '.') return new Future.immediate(new Directory('.'));
+  var dir = new Directory(path);
+  if (path == '.' || dirExists(path)) return dir;
 
-  return dirExists(path).then((exists) {
-    if (exists) {
-      log.fine("Directory $path already exists.");
-      return new Directory(path);
+  ensureDir(dirname(path));
+
+  try {
+    createDir(dir);
+  } on DirectoryIOException catch (ex) {
+    // Error 17 means the directory already exists (or 183 on Windows).
+    if (ex.osError.errorCode == 17 || ex.osError.errorCode == 183) {
+      log.fine("Got 'already exists' error when creating directory.");
+    } else {
+      throw ex;
     }
+  }
 
-    return ensureDir(dirname(path)).then((_) {
-      return createDir(path).catchError((asyncError) {
-        if (asyncError.error is! DirectoryIOException) throw asyncError;
-        // Error 17 means the directory already exists (or 183 on Windows).
-        if (asyncError.error.osError.errorCode == 17 ||
-            asyncError.error.osError.errorCode == 183) {
-          log.fine("Got 'already exists' error when creating directory.");
-          return _getDirectory(path);
-        }
-
-        throw asyncError;
-      });
-    });
-  });
+  return dir;
 }
 
 /// Creates a temp directory whose name will be based on [dir] with a unique
 /// suffix appended to it. If [dir] is not provided, a temp directory will be
 /// created in a platform-dependent temporary location. Returns a [Future] that
 /// completes when the directory is created.
 Future<Directory> createTempDir([dir = '']) {
   dir = _getDirectory(dir);
   return log.ioAsync("create temp directory ${dir.path}",
       dir.createTemp());
@@ skipping 73 matching lines @@
       return Future.wait(children).then((childContents) {
         contents.addAll(flatten(childContents));
         return contents;
       });
     });
   }
 
   return doList(_getDirectory(dir), new Set<String>());
 }
 
-/// Asynchronously determines if [dir], which can be a [String] directory path
-/// or a [Directory], exists on the file system. Returns a [Future] that
-/// completes with the result.
-Future<bool> dirExists(dir) {
-  dir = _getDirectory(dir);
-  return log.ioAsync("Seeing if directory ${dir.path} exists.",
-      dir.exists(),
-      (exists) => "Directory ${dir.path} "
-                  "${exists ? 'exists' : 'does not exist'}.");
-}
+/// Determines if [dir], which can be a [String] directory path or a
+/// [Directory], exists on the file system.
+bool dirExists(dir) => _getDirectory(dir).existsSync();
 
 /// "Cleans" [dir]. If that directory already exists, it will be deleted. Then a
 /// new empty directory will be created. Returns a [Future] that completes when
 /// the new clean directory is created.
 Future<Directory> cleanDir(dir) {
-  return dirExists(dir).then((exists) {
-    if (exists) {
+  // Make sure all errors propagate through future.
+  return defer(() {
+    if (dirExists(dir)) {
       // Delete it first.
       return deleteDir(dir).then((_) => createDir(dir));
     } else {
       // Just create it.
       return createDir(dir);
     }
   });
 }
 
 /// Renames (i.e. moves) the directory [from] to [to]. Returns a [Future] with
@@ skipping 66 matching lines @@
   });
 }
 
 /// Creates a new symlink that creates an alias from the `lib` directory of
 /// package [from] to [to], both of which can be a [String], [File], or
 /// [Directory]. Returns a [Future] which completes to the symlink file (i.e.
 /// [to]). If [from] does not have a `lib` directory, this shows a warning if
 /// appropriate and then does nothing.
 Future<File> createPackageSymlink(String name, from, to,
     {bool isSelfLink: false}) {
-  // See if the package has a "lib" directory.
-  from = join(from, 'lib');
-  return dirExists(from).then((exists) {
+  // Make sure all errors propagate through future.
+  return defer(() {
+    // See if the package has a "lib" directory.
+    from = join(from, 'lib');
     log.fine("Creating ${isSelfLink ? "self" : ""}link for package '$name'.");
-    if (exists) return createSymlink(from, to);
+    if (dirExists(from)) return createSymlink(from, to);
 
     // It's OK for the self link (i.e. the root package) to not have a lib
     // directory since it may just be a leaf application that only has
     // code in bin or web.
     if (!isSelfLink) {
       log.warning('Warning: Package "$name" does not have a "lib" directory so '
                   'you will not be able to import any libraries from it.');
     }
 
-    return to;
+    return _getFile(to);
   });
 }
 
 /// Given [entry] which may be a [String], [File], or [Directory] relative to
 /// the current working directory, returns its full canonicalized path.
 String getFullPath(entry) => path.absolute(_getPath(entry));
 
 /// Returns whether or not [entry] is an absolute path.
 bool isAbsolute(entry) => path.isAbsolute(_getPath(entry));
 
@@ skipping 524 matching lines @@
 class PubProcessResult {
   final List<String> stdout;
   final List<String> stderr;
   final int exitCode;
 
   const PubProcessResult(this.stdout, this.stderr, this.exitCode);
 
   bool get success => exitCode == 0;
 }
 
+/// Gets a dart:io [File] for [entry], which can either already be a File or be
+/// a path string.
+File _getFile(entry) {
+  if (entry is File) return entry;
+  if (entry is String) return new File(entry);
+  throw 'Entry $entry is not a supported type.';
+}
+
 /// Gets the path string for [entry], which can either already be a path string,
 /// or be a [File] or [Directory]. Allows working generically with "file-like"
 /// objects.
 String _getPath(entry) {
   if (entry is String) return entry;
   if (entry is File) return entry.name;
   if (entry is Directory) return entry.path;
   throw 'Entry $entry is not a supported type.';
 }
 
 /// Gets a [Directory] for [entry], which can either already be one, or be a
 /// [String].
 Directory _getDirectory(entry) {
   if (entry is Directory) return entry;
   return new Directory(entry);
 }
 
 /// Gets a [Uri] for [uri], which can either already be one, or be a [String].
 Uri _getUri(uri) {
   if (uri is Uri) return uri;
   return Uri.parse(uri);
 }