Big merge from experimental to bleeding edge.

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';
 import 'dart:json';
 import 'dart:uri';
 
 import '../../pkg/path/lib/path.dart' as path;
 import 'log.dart' as log;
 import 'utils.dart';
 
 bool _isGitInstalledCache;
 
 /// The cached Git command.
 String _gitCommandCache;
 
 final NEWLINE_PATTERN = new RegExp("\r\n?|\n\r?");
 
 /// Joins a number of path string parts into a single path. Handles
 /// platform-specific path separators. Parts can be [String], [Directory], or
 /// [File] objects.
 String join(part1, [part2, part3, part4, part5, part6, part7, part8]) {
   var parts = [part1, part2, part3, part4, part5, part6, part7, part8]
-      .map((part) => part == null ? null : _getPath(part));
+      .mappedBy((part) => part == null ? null : _getPath(part)).toList();
 
   return path.join(parts[0], parts[1], parts[2], parts[3], parts[4], parts[5],
       parts[6], parts[7]);
 }
 
 /// Gets the basename, the file name without any leading directory path, for
 /// [file], which can either be a [String], [File], or [Directory].
 String basename(file) => path.basename(_getPath(file));
 
 /// Gets the the leading directory path for [file], which can either be a
@@ skipping 11 matching lines @@
 }
 
 /// 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 Futures.wait([fileExists(path), dirExists(path)]).transform((results) {
+  return Futures.wait([fileExists(path), dirExists(path)]).then((results) {
     return results[0] || results[1];
   });
 }
 
 /// 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.",
@@ skipping 24 matching lines @@
 Future<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).chain((opened) {
-    return opened.writeString(contents).chain((ignore) {
-        return opened.close().transform((_) {
+  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;
         });
     });
   });
 }
 
 /// 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) {
@@ skipping 51 matching lines @@
 }
 
 /// 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) {
   path = _getPath(path);
   log.fine("Ensuring directory $path exists.");
   if (path == '.') return new Future.immediate(new Directory('.'));
 
-  return dirExists(path).chain((exists) {
+  return dirExists(path).then((exists) {
     if (exists) {
       log.fine("Directory $path already exists.");
       return new Future.immediate(new Directory(path));
     }
 
-    return ensureDir(dirname(path)).chain((_) {
-      var completer = new Completer<Directory>();
-      var future = createDir(path);
-      future.handleException((error) {
-        if (error is! DirectoryIOException) return false;
-        // Error 17 means the directory already exists (or 183 on Windows).
-        if (error.osError.errorCode != 17 &&
-            error.osError.errorCode != 183) {
+    return ensureDir(dirname(path)).then((_) {
+      return createDir(path)
+        .catchError((error) {
+          if (error is! DirectoryIOException) return false;
+          // Error 17 means the directory already exists (or 183 on Windows).
+          if (error.osError.errorCode != 17 &&
+              error.osError.errorCode != 183) {
           log.fine("Got 'already exists' error when creating directory.");
           return false;
         }
 
-        completer.complete(_getDirectory(path));
-        return true;
-      });
-      future.then(completer.complete);
-      return completer.future;
+          return _getDirectory(path);
+        });
     });
   });
 }
 
 /// 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);
@@ skipping 90 matching lines @@
   return log.ioAsync("Seeing if directory ${dir.path} exists.",
       dir.exists(),
       (exists) => "Directory ${dir.path} "
                   "${exists ? 'exists' : 'does not exist'}.");
 }
 
 /// "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).chain((exists) {
+  return dirExists(dir).then((exists) {
     if (exists) {
       // Delete it first.
-      return deleteDir(dir).chain((_) => createDir(dir));
+      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
 /// the destination directory.
 Future<Directory> renameDir(from, String to) {
   from = _getDirectory(from);
   log.io("Renaming directory ${from.path} to $to.");
 
-  return _attemptRetryable(() => from.rename(to)).transform((dir) {
+  return _attemptRetryable(() => from.rename(to)).then((dir) {
     log.fine("Renamed directory ${from.path} to $to.");
     return dir;
   });
 }
 
 /// On Windows, we sometimes get failures where the directory is still in use
 /// when we try to do something with it. This is usually because the OS hasn't
 /// noticed yet that a process using that directory has closed. To be a bit
 /// more resilient, we wait and retry a few times.
 ///
@@ skipping 37 matching lines @@
   if (Platform.operatingSystem == 'windows') {
     // Call mklink on Windows to create an NTFS junction point. Only works on
     // Vista or later. (Junction points are available earlier, but the "mklink"
     // command is not.) I'm using a junction point (/j) here instead of a soft
     // link (/d) because the latter requires some privilege shenanigans that
     // I'm not sure how to specify from the command line.
     command = 'mklink';
     args = ['/j', to, from];
   }
 
-  return runProcess(command, args).transform((result) {
+  return runProcess(command, args).then((result) {
     // TODO(rnystrom): Check exit code and output?
     return new File(to);
   });
 }
 
 /// 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).chain((exists) {
+  return dirExists(from).then((exists) {
     log.fine("Creating ${isSelfLink ? "self" : ""}link for package '$name'.");
     if (exists) 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.');
     }
@@ skipping 161 matching lines @@
 /// Spawns and runs the process located at [executable], passing in [args].
 /// Returns a [Future] that will complete with the results of the process after
 /// it has ended.
 ///
 /// The spawned process will inherit its parent's environment variables. If
 /// [environment] is provided, that will be used to augment (not replace) the
 /// the inherited variables.
 Future<PubProcessResult> runProcess(String executable, List<String> args,
     {workingDir, Map<String, String> environment}) {
   return _doProcess(Process.run, executable, args, workingDir, environment)
-      .transform((result) {
+      .then((result) {
     // TODO(rnystrom): Remove this and change to returning one string.
     List<String> toLines(String output) {
       var lines = output.split(NEWLINE_PATTERN);
       if (!lines.isEmpty && lines.last == "") lines.removeLast();
       return lines;
     }
 
     var pubResult = new PubProcessResult(toLines(result.stdout),
                                 toLines(result.stderr),
                                 result.exitCode);
 
     log.processResult(executable, pubResult);
     return pubResult;
   });
 }
 
 /// Spawns the process located at [executable], passing in [args]. Returns a
 /// [Future] that will complete with the [Process] once it's been started.
 ///
 /// The spawned process will inherit its parent's environment variables. If
 /// [environment] is provided, that will be used to augment (not replace) the
 /// the inherited variables.
 Future<Process> startProcess(String executable, List<String> args,
     {workingDir, Map<String, String> environment}) =>
   _doProcess(Process.start, executable, args, workingDir, environment)
-    .transform((process) => new _WrappedProcess(process));
+    .then((process) => new _WrappedProcess(process));
 
 /// A wrapper around [Process] that buffers the stdout and stderr to avoid
 /// running into issue 7218.
 class _WrappedProcess implements Process {
   final Process _process;
   final InputStream stderr;
   final InputStream stdout;
 
   OutputStream get stdin => _process.stdin;
 
@@ skipping 42 matching lines @@
 
 /// Wraps [input] to provide a timeout. If [input] completes before
 /// [milliseconds] have passed, then the return value completes in the same way.
 /// However, if [milliseconds] pass before [input] has completed, it completes
 /// with a [TimeoutException] with [description] (which should be a fragment
 /// describing the action that timed out).
 ///
 /// Note that timing out will not cancel the asynchronous operation behind
 /// [input].
 Future timeout(Future input, int milliseconds, String description) {
+  bool completed = false;
   var completer = new Completer();
   var timer = new Timer(milliseconds, (_) {
-    if (completer.future.isComplete) return;
-    completer.completeException(new TimeoutException(
+    completer = true;
+    completer.completeError(new TimeoutException(
         'Timed out while $description.'));
   });
-  input.handleException((e) {
-    if (completer.future.isComplete) return false;
-    timer.cancel();
-    completer.completeException(e, input.stackTrace);
-    return true;
-  });
-  input.then((value) {
-    if (completer.future.isComplete) return;
-    timer.cancel();
-    completer.complete(value);
-  });
+  input
+    .then((value) {
+      if (completed) return;
+      timer.cancel();
+      completer.complete(value);
+    })
+    .catchError((e) {
+      if (completed) return;
+      timer.cancel();
+      completer.completeError(e.error, e.stackTrace);
+    });
   return completer.future;
 }
 
 /// Creates a temporary directory and passes its path to [fn]. Once the [Future]
 /// returned by [fn] completes, the temporary directory and all its contents
 /// will be deleted.
 Future withTempDir(Future fn(String path)) {
   var tempDir;
-  var future = createTempDir().chain((dir) {
+  var future = createTempDir().then((dir) {
     tempDir = dir;
     return fn(tempDir.path);
   });
-  future.onComplete((_) {
+  future.catchError((_) {}).then(_) {
     log.fine('Cleaning up temp directory ${tempDir.path}.');
     deleteDir(tempDir);
   });
   return future;
 }
 
 /// Tests whether or not the git command-line app is available for use.
 Future<bool> get isGitInstalled {
   if (_isGitInstalledCache != null) {
     // TODO(rnystrom): The sleep is to pump the message queue. Can use
     // Future.immediate() when #3356 is fixed.
-    return sleep(0).transform((_) => _isGitInstalledCache);
+    return sleep(0).then((_) => _isGitInstalledCache);
   }
 
-  return _gitCommand.transform((git) => git != null);
+  return _gitCommand.then((git) => git != null);
 }
 
 /// Run a git process with [args] from [workingDir].
 Future<PubProcessResult> runGit(List<String> args,
     {String workingDir, Map<String, String> environment}) {
-  return _gitCommand.chain((git) => runProcess(git, args,
+  return _gitCommand.then((git) => runProcess(git, args,
         workingDir: workingDir, environment: environment));
 }
 
 /// Returns the name of the git command-line app, or null if Git could not be
 /// found on the user's PATH.
 Future<String> get _gitCommand {
   // TODO(nweiz): Just use Future.immediate once issue 3356 is fixed.
   if (_gitCommandCache != null) {
-    return sleep(0).transform((_) => _gitCommandCache);
+    return sleep(0).then((_) => _gitCommandCache);
   }
 
-  return _tryGitCommand("git").chain((success) {
+  return _tryGitCommand("git").then((success) {
     if (success) return new Future.immediate("git");
 
     // Git is sometimes installed on Windows as `git.cmd`
-    return _tryGitCommand("git.cmd").transform((success) {
+    return _tryGitCommand("git.cmd").then((success) {
       if (success) return "git.cmd";
       return null;
     });
-  }).transform((command) {
+  }).then((command) {
     _gitCommandCache = command;
     return command;
   });
 }
 
 /// Checks whether [command] is the Git command for this computer.
 Future<bool> _tryGitCommand(String command) {
   var completer = new Completer<bool>();
 
   // If "git --version" prints something familiar, git is working.
   var future = runProcess(command, ["--version"]);
 
   future.then((results) {
     var regex = new RegExp("^git version");
     completer.complete(results.stdout.length == 1 &&
                        regex.hasMatch(results.stdout[0]));
-  });
-
-  future.handleException((err) {
+  }).catchError((err) {
     // If the process failed, they probably don't have it.
     completer.complete(false);
-    return true;
   });
 
   return completer.future;
 }
 
 /// Extracts a `.tar.gz` file from [stream] to [destination], which can be a
 /// directory or a path. Returns whether or not the extraction was successful.
 Future<bool> extractTarGz(InputStream stream, destination) {
   destination = _getPath(destination);
 
   log.fine("Extracting .tar.gz stream to $destination.");
 
   if (Platform.operatingSystem == "windows") {
     return _extractTarGzWindows(stream, destination);
   }
 
   var completer = new Completer<int>();
   var processFuture = startProcess("tar",
       ["--extract", "--gunzip", "--directory", destination]);
   processFuture.then((process) {
     process.onExit = completer.complete;
     stream.pipe(process.stdin);
     process.stdout.pipe(stdout, close: false);
     process.stderr.pipe(stderr, close: false);
-  });
-  processFuture.handleException((error) {
-    completer.completeException(error, processFuture.stackTrace);
-    return true;
+  }).catchError((e) {
+    completer.completeError(e.error, e.stackTrace);
   });
 
-  return completer.future.transform((exitCode) {
+  return completer.future.then((exitCode) {
     log.fine("Extracted .tar.gz stream to $destination. Exit code $exitCode.");
     // TODO(rnystrom): Does anything check this result value? If not, it should
     // throw on a bad exit code.
     return exitCode == 0;
   });
 }
 
 Future<bool> _extractTarGzWindows(InputStream stream, String destination) {
   // TODO(rnystrom): In the repo's history, there is an older implementation of
   // this that does everything in memory by piping streams directly together
   // instead of writing out temp files. The code is simpler, but unfortunately,
   // 7zip seems to periodically fail when we invoke it from Dart and tell it to
   // read from stdin instead of a file. Consider resurrecting that version if
   // we can figure out why it fails.
 
   // Note: This line of code gets munged by create_sdk.py to be the correct
   // relative path to 7zip in the SDK.
   var pathTo7zip = '../../third_party/7zip/7za.exe';
   var command = relativeToPub(pathTo7zip);
 
   var tempDir;
 
   // TODO(rnystrom): Use withTempDir().
-  return createTempDir().chain((temp) {
+  return createTempDir().then((temp) {
     // Write the archive to a temp file.
     tempDir = temp;
     return createFileFromStream(stream, join(tempDir, 'data.tar.gz'));
-  }).chain((_) {
+  }).then((_) {
     // 7zip can't unarchive from gzip -> tar -> destination all in one step
     // first we un-gzip it to a tar file.
     // Note: Setting the working directory instead of passing in a full file
     // path because 7zip says "A full path is not allowed here."
     return runProcess(command, ['e', 'data.tar.gz'], workingDir: tempDir);
-  }).chain((result) {
+  }).then((result) {
     if (result.exitCode != 0) {
       throw 'Could not un-gzip (exit code ${result.exitCode}). Error:\n'
           '${Strings.join(result.stdout, "\n")}\n'
           '${Strings.join(result.stderr, "\n")}';
     }
     // Find the tar file we just created since we don't know its name.
     return listDir(tempDir);
-  }).chain((files) {
+  }).then((files) {
     var tarFile;
     for (var file in files) {
       if (path.extension(file) == '.tar') {
         tarFile = file;
         break;
       }
     }
 
     if (tarFile == null) throw 'The gzip file did not contain a tar file.';
 
     // Untar the archive into the destination directory.
     return runProcess(command, ['x', tarFile], workingDir: destination);
-  }).chain((result) {
+  }).then((result) {
     if (result.exitCode != 0) {
       throw 'Could not un-tar (exit code ${result.exitCode}). Error:\n'
           '${Strings.join(result.stdout, "\n")}\n'
           '${Strings.join(result.stderr, "\n")}';
     }
 
     log.fine('Clean up 7zip temp directory ${tempDir.path}.');
     // TODO(rnystrom): Should also delete this if anything fails.
     return deleteDir(tempDir);
-  }).transform((_) => true);
+  }).then((_) => true);
 }
 
 /// Create a .tar.gz archive from a list of entries. Each entry can be a
 /// [String], [Directory], or [File] object. The root of the archive is
 /// considered to be [baseDir], which defaults to the current working directory.
 /// Returns an [InputStream] that will emit the contents of the archive.
 InputStream createTarGz(List contents, {baseDir}) {
   var buffer = new StringBuffer();
   buffer.add('Creating .tag.gz stream containing:\n');
   contents.forEach((file) => buffer.add('$file\n'));
   log.fine(buffer.toString());
 
   // TODO(nweiz): Propagate errors to the returned stream (including non-zero
   // exit codes). See issue 3657.
   var stream = new ListInputStream();
 
   if (baseDir == null) baseDir = path.current;
   baseDir = getFullPath(baseDir);
-  contents = contents.map((entry) {
+  contents = contents.mappedBy((entry) {
     entry = getFullPath(entry);
     if (!isBeneath(entry, baseDir)) {
       throw 'Entry $entry is not inside $baseDir.';
     }
     return relativeTo(entry, baseDir);
-  });
+  }).toList();
 
   if (Platform.operatingSystem != "windows") {
     var args = ["--create", "--gzip", "--directory", baseDir];
-    args.addAll(contents.map(_getPath));
+    args.addAll(contents.mappedBy(_getPath));
     // TODO(nweiz): It's possible that enough command-line arguments will make
     // the process choke, so at some point we should save the arguments to a
     // file and pass them in via --files-from for tar and -i@filename for 7zip.
     startProcess("tar", args).then((process) {
       pipeInputToInput(process.stdout, stream);
 
       // Drain and discard 7zip's stderr. 7zip writes its normal output to
       // stderr. We don't want to show that since it's meaningless.
       // TODO(rnystrom): Should log this and display it if an actual error
       // occurs.
       consumeInputStream(process.stderr);
     });
     return stream;
   }
 
   withTempDir((tempDir) {
     // Create the tar file.
     var tarFile = join(tempDir, "intermediate.tar");
     var args = ["a", "-w$baseDir", tarFile];
-    args.addAll(contents.map((entry) => '-i!"$entry"'));
+    args.addAll(contents.mappedBy((entry) => '-i!"$entry"'));
 
     // Note: This line of code gets munged by create_sdk.py to be the correct
     // relative path to 7zip in the SDK.
     var pathTo7zip = '../../third_party/7zip/7za.exe';
     var command = relativeToPub(pathTo7zip);
 
     // We're passing 'baseDir' both as '-w' and setting it as the working
     // directory explicitly here intentionally. The former ensures that the
     // files added to the archive have the correct relative path in the archive.
     // The latter enables relative paths in the "-i" args to be resolved.
@@ skipping 49 matching lines @@
 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 new Uri.fromString(uri);
 }