Emit assets in serial, use Stream.pipe to write to output files

pkg/polymer/lib/src/build/runner.dart

 // Copyright (c) 2013, 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.
 
 /**
  * Definitions used to run the polymer linter and deploy tools without using
  * pub serve or pub deploy.
  */
 library polymer.src.build.runner;
 
@@ skipping 192 matching lines @@
       .then((_) => assets);
   });
 }
 
 Future _emitTransformedFiles(AssetSet assets, BarbackOptions options) {
   // Copy all the assets we transformed
   var futures = [];
   var currentPackage = options.currentPackage;
   var transformTests = options.transformTests;
   var outPackages = path.join(options.outDir, 'packages');
-  for (var asset in assets) {
+
+  return Future.forEach(assets, (asset) {
     var id = asset.id;
     var dir = _firstDir(id.path);
-    if (dir == null) continue;
+    if (dir == null) return null;
 
     var filepath;
     if (dir == 'lib') {
       // Put lib files directly under the packages folder (e.g. 'lib/foo.dart'
       // will be emitted at out/packages/package_name/foo.dart).
       filepath = path.join(outPackages, id.package,
           _toSystemPath(id.path.substring(4)));
     } else if (id.package == currentPackage &&
         (dir == 'web' || (transformTests && dir == 'test'))) {
       filepath = path.join(options.outDir, _toSystemPath(id.path));
     } else {
       // TODO(sigmund): do something about other assets?
-      continue;
+      return null;
     }
 
-    futures.add(_writeAsset(filepath, asset));
-  }
-  return Future.wait(futures);
+    return _writeAsset(filepath, asset);
+  });
 }
 
 /**
  * Adds a package symlink from each directory under `out/web/foo/` to
  * `out/packages`.
  */
 Future _addPackagesSymlinks(AssetSet assets, BarbackOptions options) {
   var outPackages = path.join(options.outDir, 'packages');
   var currentPackage = options.currentPackage;
   for (var asset in assets) {
@@ skipping 19 matching lines @@
 /**
  * Emits a 'packages' directory directly under `out/packages` with the contents
  * of every file that was not transformed by barback.
  */
 Future _emitPackagesDir(BarbackOptions options) {
   if (options.transformPolymerDependencies) return new Future.value(null);
   var outPackages = path.join(options.outDir, 'packages');
   _ensureDir(outPackages);
 
   // Copy all the files we didn't process
-  var futures = [];
   var dirs = options.packageDirs;
-  for (var package in _polymerPackageDependencies) {
-    for (var relpath in _listPackageDir(package, 'lib', options)) {
+
+  return Future.forEach(_polymerPackageDependencies, (package) {
+    return Future.forEach(_listPackageDir(package, 'lib', options), (relpath) {
       var inpath = path.join(dirs[package], relpath);
       var outpath = path.join(outPackages, package, relpath.substring(4));
-      futures.add(_copyFile(inpath, outpath));
-    }
-  }
-  return Future.wait(futures);
+      return _copyFile(inpath, outpath);
+    });
+  });
 }
 
 /** Ensure [dirpath] exists. */
 void _ensureDir(String dirpath) {
   new Directory(dirpath).createSync(recursive: true);
 }
 
 /**
  * Returns the first directory name on a url-style path, or null if there are no
  * slashes.
  */
 String _firstDir(String url) {
   var firstSlash = url.indexOf('/');
   if (firstSlash == -1) return null;
   return url.substring(0, firstSlash);
 }
 
 /** Copy a file from [inpath] to [outpath]. */
 Future _copyFile(String inpath, String outpath) {
   _ensureDir(path.dirname(outpath));
-  var writer = new File(outpath).openWrite();
-  return writer.addStream(new File(inpath).openRead())
-      .then((_) => writer.close());
+  return new File(inpath).openRead().pipe(new File(outpath).openWrite());
 }
 
 /** Write contents of an [asset] into a file at [filepath]. */
 Future _writeAsset(String filepath, Asset asset) {
   _ensureDir(path.dirname(filepath));
-  var writer = new File(filepath).openWrite();
-  return writer.addStream(asset.read()).then((_) => writer.close());
+  return asset.read().pipe(new File(filepath).openWrite());
 }