Rename mappedBy to map.

utils/tests/pub/test_pub.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.
 
 /// Test infrastructure for testing pub. Unlike typical unit tests, most pub
 /// tests are integration tests that stage some stuff on the file system, run
 /// pub, and then validate the results. This library provides an API to build
 /// tests like that.
 library test_pub;
 
@@ skipping 172 matching lines @@
         versions[version] = yaml(spec);
       }
 
       _servedPackageDir.contents.clear();
       for (var name in _servedPackages.keys) {
         var versions = _servedPackages[name].keys.toList();
         _servedPackageDir.contents.addAll([
           file('$name.json',
               json.stringify({'versions': versions})),
           dir(name, [
-            dir('versions', flatten(versions.mappedBy((version) {
+            dir('versions', flatten(versions.map((version) {
               return [
                 file('$version.yaml', _servedPackages[name][version]),
                 tar('$version.tar.gz', [
                   file('pubspec.yaml', _servedPackages[name][version]),
                   libDir(name, '$name $version')
                 ])
               ];
             })))
           ])
         ]);
@@ skipping 318 matching lines @@
 
       if (result.exitCode != exitCode) {
         failures.add(
             'Pub returned exit code ${result.exitCode}, expected $exitCode.');
       }
 
       if (failures.length > 0) {
         if (error == null) {
           // If we aren't validating the error, still show it on failure.
           failures.add('Pub stderr:');
-          failures.addAll(result.stderr.mappedBy((line) => '| $line'));
+          failures.addAll(result.stderr.map((line) => '| $line'));
         }
 
         throw new ExpectException(Strings.join(failures, '\n'));
       }
 
       return null;
     });
   });
 }
 
@@ skipping 151 matching lines @@
 
 void _validateOutputRegex(List<String> failures, String pipe,
                           RegExp expected, List<String> actual) {
   var actualText = Strings.join(actual, '\n');
   if (actualText.contains(expected)) return;
 
   if (actual.length == 0) {
     failures.add('Expected $pipe to match "${expected.pattern}" but got none.');
   } else {
     failures.add('Expected $pipe to match "${expected.pattern}" but got:');
-    failures.addAll(actual.mappedBy((line) => '| $line'));
+    failures.addAll(actual.map((line) => '| $line'));
   }
 }
 
 void _validateOutputString(List<String> failures, String pipe,
                            String expectedText, List<String> actual) {
   final expected = expectedText.split('\n');
 
   // Strip off the last line. This lets us have expected multiline strings
   // where the closing ''' is on its own line. It also fixes '' expected output
   // to expect zero lines of output, not a single empty line.
@@ skipping 24 matching lines @@
       } else {
         // Output is OK, but include it in case other lines are wrong.
         results.add('| ${actual[i]}');
       }
     }
   }
 
   // If any lines mismatched, show the expected and actual.
   if (failed) {
     failures.add('Expected $pipe:');
-    failures.addAll(expected.mappedBy((line) => '| $line'));
+    failures.addAll(expected.map((line) => '| $line'));
     failures.add('Got:');
     failures.addAll(results);
   }
 }
 
 /// Base class for [FileDescriptor] and [DirectoryDescriptor] so that a
 /// directory can contain a heterogeneous collection of files and
 /// subdirectories.
 abstract class Descriptor {
   /// The name of this file or directory. This must be a [String] if the file
@@ skipping 163 matching lines @@
 
   /// Creates the file within [dir]. Returns a [Future] that is completed after
   /// the creation is done.
   Future<Directory> create(parentDir) {
     // Create the directory.
     return ensureDir(join(parentDir, _stringName)).then((dir) {
       if (contents == null) return new Future<Directory>.immediate(dir);
 
       // Recursively create all of its children.
       final childFutures =
-          contents.mappedBy((child) => child.create(dir)).toList();
+          contents.map((child) => child.create(dir)).toList();
       // Only complete once all of the children have been created too.
       return Future.wait(childFutures).then((_) => dir);
     });
   }
 
   /// Deletes the directory within [dir]. Returns a [Future] that is completed
   /// after the deletion is done.
   Future delete(dir) {
     return deleteDir(join(dir, _stringName));
   }
 
   /// Validates that the directory at [path] contains all of the expected
   /// contents in this descriptor. Note that this does *not* check that the
   /// directory doesn't contain other unexpected stuff, just that it *does*
   /// contain the stuff we do expect.
   Future validate(String path) {
     return _validateOneMatch(path, (dir) {
       // Validate each of the items in this directory.
       final entryFutures =
-          contents.mappedBy((entry) => entry.validate(dir)).toList();
+          contents.map((entry) => entry.validate(dir)).toList();
 
       // If they are all valid, the directory is valid.
       return Future.wait(entryFutures).then((entries) => null);
     });
   }
 
   /// Loads [path] from within this directory.
   InputStream load(List<String> path) {
     if (path.isEmpty) {
       throw "Can't load the contents of $name: is a directory.";
@@ skipping 111 matching lines @@
   TarFileDescriptor(Pattern name, this.contents)
   : super(name);
 
   /// Creates the files and directories within this tar file, then archives
   /// them, compresses them, and saves the result to [parentDir].
   Future<File> create(parentDir) {
     // TODO(rnystrom): Use withTempDir().
     var tempDir;
     return createTempDir().then((_tempDir) {
       tempDir = _tempDir;
-      return Future.wait(contents.mappedBy((child) => child.create(tempDir)));
+      return Future.wait(contents.map((child) => child.create(tempDir)));
     }).then((createdContents) {
       return consumeInputStream(createTarGz(createdContents, baseDir: tempDir));
     }).then((bytes) {
       return new File(join(parentDir, _stringName)).writeAsBytes(bytes);
     }).then((file) {
       return deleteDir(tempDir).then((_) => file);
     });
   }
 
   /// Validates that the `.tar.gz` file at [path] contains the expected
@@ skipping 390 matching lines @@
   }
 }
 
 /// Takes a simple data structure (composed of [Map]s, [List]s, scalar objects,
 /// and [Future]s) and recursively resolves all the [Future]s contained within.
 /// Completes with the fully resolved structure.
 Future _awaitObject(object) {
   // Unroll nested futures.
   if (object is Future) return object.then(_awaitObject);
   if (object is Collection) {
-    return Future.wait(object.mappedBy(_awaitObject).toList());
+    return Future.wait(object.map(_awaitObject).toList());
   }
   if (object is! Map) return new Future.immediate(object);
 
   var pairs = <Future<Pair>>[];
   object.forEach((key, value) {
     pairs.add(_awaitObject(value)
         .then((resolved) => new Pair(key, resolved)));
   });
   return Future.wait(pairs).then((resolvedPairs) {
     var map = {};
@@ skipping 43 matching lines @@
 /// calling [completion] is unnecessary.
 void expectLater(Future actual, matcher, {String reason,
     FailureHandler failureHandler, bool verbose: false}) {
   _schedule((_) {
     return actual.then((value) {
       expect(value, matcher, reason: reason, failureHandler: failureHandler,
           verbose: false);
     });
   });
 }