Get rid of join() and encapsulate File and Directory in io.dart.

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 535 matching lines @@
   var dir = new Options().script;
   while (path.basename(dir) != 'pub') dir = path.dirname(dir);
 
   return path.absolute(dir);
 }
 
 /// Schedules renaming (moving) the directory at [from] to [to], both of which
 /// are assumed to be relative to [sandboxDir].
 void scheduleRename(String from, String to) {
   _schedule((sandboxDir) {
-    return renameDir(join(sandboxDir, from), join(sandboxDir, to));
+    return renameDir(path.join(sandboxDir, from), path.join(sandboxDir, to));
   });
 }
 
 /// Schedules a call to the Pub command-line utility. Runs Pub with [args] and
 /// validates that its results match [output], [error], and [exitCode].
 void schedulePub({List args, Pattern output, Pattern error,
     Future<Uri> tokenEndpoint, int exitCode: 0}) {
   _schedule((sandboxDir) {
     return _doPub(runProcess, sandboxDir, args, tokenEndpoint).then((result) {
       var failures = [];
@@ skipping 58 matching lines @@
   expectLater(pub.nextLine(), equals(""));
 
   pub.writeLine("y");
 }
 
 /// Calls [fn] with appropriately modified arguments to run a pub process. [fn]
 /// should have the same signature as [startProcess], except that the returned
 /// [Future] may have a type other than [Process].
 Future _doPub(Function fn, sandboxDir, List args, Future<Uri> tokenEndpoint) {
   String pathInSandbox(String relPath) {
-    return join(path.absolute(sandboxDir), relPath);
+    return path.join(path.absolute(sandboxDir), relPath);
   }
 
   return defer(() {
     ensureDir(pathInSandbox(appPath));
     return Future.wait([
       _awaitObject(args),
       tokenEndpoint == null ? new Future.immediate(null) : tokenEndpoint
     ]);
   }).then((results) {
     var args = results[0];
@@ skipping 200 matching lines @@
 
   /// Asserts that the name of the descriptor is a [String] and returns it.
   String get _stringName {
     if (name is String) return name;
     throw 'Pattern $name must be a string.';
   }
 
   /// Validates that at least one file in [dir] matching [name] is valid
   /// according to [validate]. [validate] should throw or complete to an
   /// exception if the input path is invalid.
-  Future _validateOneMatch(String dir, Future validate(String path)) {
+  Future _validateOneMatch(String dir, Future validate(String entry)) {
     // Special-case strings to support multi-level names like "myapp/packages".
     if (name is String) {
-      var path = join(dir, name);
+      var entry = path.join(dir, name);
       return defer(() {
-        if (!entryExists(path)) {
-          throw new ExpectException('Entry $path not found.');
+        if (!entryExists(entry)) {
+          throw new ExpectException('Entry $entry not found.');
         }
-        return validate(path);
+        return validate(entry);
       });
     }
 
     // TODO(nweiz): remove this when issue 4061 is fixed.
     var stackTrace;
     try {
       throw "";
     } catch (_, localStackTrace) {
       stackTrace = localStackTrace;
     }
@@ skipping 47 matching lines @@
 
   String get textContents => new String.fromCharCodes(contents);
 
   FileDescriptor.bytes(Pattern name, this.contents) : super(name);
 
   FileDescriptor(Pattern name, String contents) :
       this.bytes(name, encodeUtf8(contents));
 
   /// Creates the file within [dir]. Returns a [Future] that is completed after
   /// the creation is done.
-  Future<File> create(dir) =>
-      defer(() => writeBinaryFile(join(dir, _stringName), contents));
+  Future<String> create(dir) =>
+      defer(() => writeBinaryFile(path.join(dir, _stringName), contents));
 
   /// Deletes the file within [dir]. Returns a [Future] that is completed after
   /// the deletion is done.
   Future delete(dir) =>
-      defer(() => deleteFile(join(dir, _stringName)));
+      defer(() => deleteFile(path.join(dir, _stringName)));
 
   /// Validates that this file correctly matches the actual file at [path].
   Future validate(String path) {
     return _validateOneMatch(path, (file) {
       var text = readTextFile(file);
       if (text == textContents) return null;
 
       throw new ExpectException(
           'File $file should contain:\n\n$textContents\n\n'
           'but contained:\n\n$text');
@@ skipping 16 matching lines @@
 class DirectoryDescriptor extends Descriptor {
   /// The files and directories contained in this directory.
   final List<Descriptor> contents;
 
   DirectoryDescriptor(Pattern name, List<Descriptor> contents)
     : this.contents = contents == null ? <Descriptor>[] : contents,
       super(name);
 
   /// Creates the file within [dir]. Returns a [Future] that is completed after
   /// the creation is done.
-  Future<Directory> create(parentDir) {
+  Future<String> create(parentDir) {
     return defer(() {
       // Create the directory.
-      var dir = ensureDir(join(parentDir, _stringName));
+      var dir = ensureDir(path.join(parentDir, _stringName));
       if (contents == null) return dir;
 
       // Recursively create all of its children.
       var childFutures = 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));
+    return deleteDir(path.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 =
@@ skipping 41 matching lines @@
     return new ByteStream(controller.stream);
   }
 }
 
 /// Describes a Git repository and its contents.
 class GitRepoDescriptor extends DirectoryDescriptor {
   GitRepoDescriptor(Pattern name, List<Descriptor> contents)
   : super(name, contents);
 
   /// Creates the Git repository and commits the contents.
-  Future<Directory> create(parentDir) {
+  Future create(parentDir) {
     return _runGitCommands(parentDir, [
       ['init'],
       ['add', '.'],
       ['commit', '-m', 'initial commit']
     ]);
   }
 
   /// Commits any changes to the Git repository.
   Future commit(parentDir) {
     return _runGitCommands(parentDir, [
@@ skipping 10 matching lines @@
   Future<String> revParse(String ref) {
     return _scheduleValue((parentDir) {
       return super.create(parentDir).then((rootDir) {
         return _runGit(['rev-parse', ref], rootDir);
       }).then((output) => output[0]);
     });
   }
 
   /// Schedule a Git command to run in this repository.
   void scheduleGit(List<String> args) {
-    _schedule((parentDir) {
-      var gitDir = new Directory(join(parentDir, name));
-      return _runGit(args, gitDir);
-    });
+    _schedule((parentDir) => _runGit(args, path.join(parentDir, name)));
   }
 
   Future _runGitCommands(parentDir, List<List<String>> commands) {
     var workingDir;
 
     Future runGitStep(_) {
       if (commands.isEmpty) return new Future.immediate(workingDir);
       var command = commands.removeAt(0);
       return _runGit(command, workingDir).then(runGitStep);
     }
 
     return super.create(parentDir).then((rootDir) {
       workingDir = rootDir;
       return runGitStep(null);
     });
   }
 
-  Future<List<String>> _runGit(List<String> args, Directory workingDir) {
+  Future<List<String>> _runGit(List<String> args, String workingDir) {
     // Explicitly specify the committer information. Git needs this to commit
     // and we don't want to rely on the buildbots having this already set up.
     var environment = {
       'GIT_AUTHOR_NAME': 'Pub Test',
       'GIT_AUTHOR_EMAIL': 'pub@dartlang.org',
       'GIT_COMMITTER_NAME': 'Pub Test',
       'GIT_COMMITTER_EMAIL': 'pub@dartlang.org'
     };
 
-    return gitlib.run(args, workingDir: workingDir.path,
-        environment: environment);
+    return gitlib.run(args, workingDir: workingDir, environment: environment);
   }
 }
 
 /// Describes a gzipped tar file and its contents.
 class TarFileDescriptor extends Descriptor {
   final List<Descriptor> contents;
 
   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) {
+  Future<String> create(parentDir) {
     return withTempDir((tempDir) {
       return Future.wait(contents.map((child) => child.create(tempDir)))
           .then((createdContents) {
         return createTarGz(createdContents, baseDir: tempDir).toBytes();
       }).then((bytes) {
-        return new File(join(parentDir, _stringName)).writeAsBytes(bytes);
+        var file = path.join(parentDir, _stringName);
+        writeBinaryFile(file, bytes);
+        return file;
       });
     });
   }
 
   /// Validates that the `.tar.gz` file at [path] contains the expected
   /// contents.
   Future validate(String path) {
     throw "TODO(nweiz): implement this";
   }
 
   Future delete(dir) {
     throw new UnsupportedError('');
   }
 
   /// Loads the contents of this tar file.
   ByteStream load(List<String> path) {
     if (!path.isEmpty) {
       throw "Can't load ${path.join('/')} from within $name: not a directory.";
     }
 
     var controller = new StreamController<List<int>>();
     // TODO(nweiz): propagate any errors to the return value. See issue 3657.
     withTempDir((tempDir) {
       return create(tempDir).then((tar) {
-        var sourceStream = tar.openInputStream();
+        var sourceStream = new File(tar).openInputStream();
         return store(wrapInputStream(sourceStream), controller);
       });
     });
     return new ByteStream(controller.stream);
   }
 }
 
 /// A descriptor that validates that no file exists with the given name.
 class NothingDescriptor extends Descriptor {
   NothingDescriptor(String name) : super(name);
 
   Future create(dir) => new Future.immediate(null);
   Future delete(dir) => new Future.immediate(null);
 
   Future validate(String dir) {
     return defer(() {
-      if (entryExists(join(dir, name))) {
+      if (entryExists(path.join(dir, name))) {
         throw new ExpectException('File $name in $dir should not exist.');
       }
     });
   }
 
   ByteStream load(List<String> path) {
     if (path.isEmpty) {
       throw "Can't load the contents of $name: it doesn't exist.";
     } else {
       throw "Can't load ${path.join('/')} from within $name: $name doesn't "
         "exist.";
     }
   }
 }
 
 /// A function that creates a [Validator] subclass.
 typedef Validator ValidatorCreator(Entrypoint entrypoint);
 
 /// Schedules a single [Validator] to run on the [appPath]. Returns a scheduled
 /// Future that contains the errors and warnings produced by that validator.
 Future<Pair<List<String>, List<String>>> schedulePackageValidation(
     ValidatorCreator fn) {
   return _scheduleValue((sandboxDir) {
-    var cache = new SystemCache.withSources(join(sandboxDir, cachePath));
+    var cache = new SystemCache.withSources(path.join(sandboxDir, cachePath));
 
     return defer(() {
-      var validator = fn(new Entrypoint(join(sandboxDir, appPath), cache));
+      var validator = fn(new Entrypoint(path.join(sandboxDir, appPath), cache));
       return validator.validate().then((_) {
         return new Pair(validator.errors, validator.warnings);
       });
     });
   });
 }
 
 /// A matcher that matches a Pair.
 Matcher pairOf(Matcher firstMatcher, Matcher lastMatcher) =>
    new _PairMatcher(firstMatcher, lastMatcher);
@@ skipping 411 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);
     });
   });
 }