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

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 '../../pkg/http/lib/http.dart' show ByteStream;
 import 'error_group.dart';
 import 'exit_codes.dart' as exit_codes;
 import 'log.dart' as log;
 import 'utils.dart';
 
 export '../../pkg/http/lib/http.dart' show ByteStream;
 
 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)).toList();
-
-  return path.join(parts[0], parts[1], parts[2], parts[3], parts[4], parts[5],
-      parts[6], parts[7]);
-}
-
 /// 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(String entry, String dir) {
   var relative = path.relative(entry, from: dir);
   return !path.isAbsolute(relative) && path.split(relative)[0] != '..';
 }
 
-/// 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);
+/// Determines if a file or directory at [path] exists.
+bool entryExists(String path) => fileExists(path) || dirExists(path);
 
-/// Determines if [file], which can be a [String] file path or a [File], exists
-/// on the file system.
-bool fileExists(file) => _getFile(file).existsSync();
+/// Determines if [file] exists on the file system.
+bool fileExists(String file) => new File(file).existsSync();
 
-/// Reads the contents of the text file [file], which can either be a [String]
-/// or a [File].
-String readTextFile(file) => _getFile(file).readAsStringSync(Encoding.UTF_8);
+/// Reads the contents of the text file [file].
+String readTextFile(String file) =>
+    new File(file).readAsStringSync(Encoding.UTF_8);
 
-/// Reads the contents of the binary file [file], which can either be a [String]
-/// or a [File].
-List<int> readBinaryFile(file) {
-  var path = _getPath(file);
-  log.io("Reading binary file $path.");
-  var contents = new File(path).readAsBytesSync();
-  log.io("Read ${contents.length} bytes from $path.");
+/// Reads the contents of the binary file [file].
+List<int> readBinaryFile(String file) {
+  log.io("Reading binary file $file.");
+  var contents = new File(file).readAsBytesSync();
+  log.io("Read ${contents.length} bytes from $file.");
   return contents;
 }
 
-/// Creates [file] (which can either be a [String] or a [File]), and writes
-/// [contents] to it.
+/// Creates [file] and writes [contents] to it.
 ///
 /// If [dontLogContents] is true, the contents of the file will never be logged.
-File writeTextFile(file, String contents, {dontLogContents: false}) {
-  var path = _getPath(file);
-  file = new File(path);
-
+String writeTextFile(String file, String contents, {dontLogContents: false}) {
   // Sanity check: don't spew a huge file.
-  log.io("Writing ${contents.length} characters to text file $path.");
+  log.io("Writing ${contents.length} characters to text file $file.");
   if (!dontLogContents && contents.length < 1024 * 1024) {
     log.fine("Contents:\n$contents");
   }
 
-  return file..writeAsStringSync(contents);
-}
-
-/// Deletes [file], which can be a [String] or a [File].
-File deleteFile(file) => _getFile(file)..delete();
-
-/// Creates [file] (which can either be a [String] or a [File]), and writes
-/// [contents] to it.
-File writeBinaryFile(file, List<int> contents) {
-  var path = _getPath(file);
-  file = new File(path);
-
-  log.io("Writing ${contents.length} bytes to binary file $path.");
-  file.openSync(FileMode.WRITE)
-      ..writeListSync(contents, 0, contents.length)
-      ..closeSync();
-  log.fine("Wrote text file $path.");
+  new File(file).writeAsStringSync(contents);
   return file;
 }
 
-/// 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(Stream<List<int>> stream, path) {
-  path = _getPath(path);
+/// Deletes [file].
+void deleteFile(String file) {
+  new File(file).delete();
+}
 
-  log.io("Creating $path from stream.");
+/// Creates [file] and writes [contents] to it.
+String writeBinaryFile(String file, List<int> contents) {
+  log.io("Writing ${contents.length} bytes to binary file $file.");
+  new File(file).openSync(FileMode.WRITE)
+      ..writeListSync(contents, 0, contents.length)
+      ..closeSync();
+  log.fine("Wrote text file $file.");
+  return file;
+}
 
-  var file = new File(path);
-  return stream.pipe(wrapOutputStream(file.openOutputStream())).then((_) {
-    log.fine("Created $path from stream.");
+/// Writes [stream] to a new file at path [file]. Will replace any file already
+/// at that path. Completes when the file is done being written.
+Future<String> createFileFromStream(Stream<List<int>> stream, String file) {
+  log.io("Creating $file from stream.");
+
+  var stream = new File(file).openOutputStream();
+  return stream.pipe(wrapOutputStream(stream)).then((_) {
+    log.fine("Created $file from stream.");
+    return file;
   });
 }
 
 /// Creates a directory [dir].
-Directory createDir(dir) => _getDirectory(dir)..createSync();
+String createDir(String dir) {
+  new Directory(dir).createSync();
+  return dir;
+}
 
 /// Ensures that [dirPath] and all its parent directories exist. If they don't
 /// exist, creates them.
-Directory ensureDir(dirPath) {
-  dirPath = _getPath(dirPath);
-
+String ensureDir(String dirPath) {
   log.fine("Ensuring directory $dirPath exists.");
   var dir = new Directory(dirPath);
-  if (dirPath == '.' || dirExists(dirPath)) return dir;
+  if (dirPath == '.' || dirExists(dirPath)) return dirPath;
 
   ensureDir(path.dirname(dirPath));
 
   try {
-    createDir(dir);
+    createDir(dirPath);
   } 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 dir;
+  return dirPath;
 }
 
 /// 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 the path of the
 /// created directory.
 String createTempDir([dir = '']) {
-  var tempDir = _getDirectory(dir).createTempSync();
+  var tempDir = new Directory(dir).createTempSync();
   log.io("Created temp directory ${tempDir.path}");
   return tempDir.path;
 }
 
-/// Asynchronously recursively deletes [dir], which can be a [String] or a
-/// [Directory]. Returns a [Future] that completes when the deletion is done.
-Future<Directory> deleteDir(dir) {
-  dir = _getDirectory(dir);
-
-  return _attemptRetryable(() => log.ioAsync("delete directory ${dir.path}",
-      dir.delete(recursive: true)));
+/// Asynchronously recursively deletes [dir]. Returns a [Future] that completes
+/// when the deletion is done.
+Future<String> deleteDir(String dir) {
+  return _attemptRetryable(() => log.ioAsync("delete directory $dir",
+      new Directory(dir).delete(recursive: true).then((_) => dir)));
 }
 
-/// Asynchronously lists the contents of [dir], which can be a [String]
-/// directory path or a [Directory]. If [recursive] is `true`, lists
+/// Asynchronously lists the contents of [dir]. If [recursive] is `true`, lists
 /// subdirectory contents (defaults to `false`). If [includeHiddenFiles] is
 /// `true`, includes files and directories beginning with `.` (defaults to
 /// `false`).
 ///
 /// If [dir] is a string, the returned paths are guaranteed to begin with it.
-Future<List<String>> listDir(dir,
+Future<List<String>> listDir(String dir,
     {bool recursive: false, bool includeHiddenFiles: false}) {
-  Future<List<String>> doList(Directory dir, Set<String> listedDirectories) {
+  Future<List<String>> doList(String dir, Set<String> listedDirectories) {
     var contents = <String>[];
     var completer = new Completer<List<String>>();
 
     // Avoid recursive symlinks.
-    var resolvedPath = new File(dir.path).fullPathSync();
+    var resolvedPath = new File(dir).fullPathSync();
     if (listedDirectories.contains(resolvedPath)) {
       return new Future.immediate([]);
     }
 
     listedDirectories = new Set<String>.from(listedDirectories);
     listedDirectories.add(resolvedPath);
 
-    log.io("Listing directory ${dir.path}.");
-    var lister = dir.list();
+    log.io("Listing directory $dir.");
+    var lister = new Directory(dir).list();
 
     lister.onDone = (done) {
       // TODO(rnystrom): May need to sort here if it turns out onDir and onFile
       // aren't guaranteed to be called in a certain order. So far, they seem to.
       if (done) {
-        log.fine("Listed directory ${dir.path}:\n"
-                  "${contents.join('\n')}");
+        log.fine("Listed directory $dir:\n${contents.join('\n')}");
         completer.complete(contents);
       }
     };
 
     // TODO(nweiz): remove this when issue 4061 is fixed.
     var stackTrace;
     try {
       throw "";
     } catch (_, localStackTrace) {
       stackTrace = localStackTrace;
     }
 
     var children = [];
     lister.onError = (error) => completer.completeError(error, stackTrace);
     lister.onDir = (file) {
       if (!includeHiddenFiles && path.basename(file).startsWith('.')) return;
-      file = join(dir, path.basename(file));
+      file = path.join(dir, path.basename(file));
       contents.add(file);
       // TODO(nweiz): don't manually recurse once issue 7358 is fixed. Note that
       // once we remove the manual recursion, we'll need to explicitly filter
       // out files in hidden directories.
       if (recursive) {
-        children.add(doList(new Directory(file), listedDirectories));
+        children.add(doList(file, listedDirectories));
       }
     };
 
     lister.onFile = (file) {
       if (!includeHiddenFiles && path.basename(file).startsWith('.')) return;
-      contents.add(join(dir, path.basename(file)));
+      contents.add(path.join(dir, path.basename(file)));
     };
 
     return completer.future.then((contents) {
       return Future.wait(children).then((childContents) {
         contents.addAll(flatten(childContents));
         return contents;
       });
     });
   }
 
-  return doList(_getDirectory(dir), new Set<String>());
+  return doList(dir, new Set<String>());
 }
 
-/// Determines if [dir], which can be a [String] directory path or a
-/// [Directory], exists on the file system.
-bool dirExists(dir) => _getDirectory(dir).existsSync();
+/// Determines if [dir] exists on the file system.
+bool dirExists(String dir) => new Directory(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) {
+Future<String> cleanDir(String dir) {
   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
 /// the destination directory.
-Future<Directory> renameDir(from, String to) {
-  from = _getDirectory(from);
-  log.io("Renaming directory ${from.path} to $to.");
+Future<String> renameDir(String from, String to) {
+  log.io("Renaming directory $from to $to.");
 
-  return _attemptRetryable(() => from.rename(to)).then((dir) {
-    log.fine("Renamed directory ${from.path} to $to.");
-    return dir;
+  return _attemptRetryable(() => new Directory(from).rename(to)).then((dir) {
+    log.fine("Renamed directory $from to $to.");
+    return to;
   });
 }
 
 /// 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.
 ///
 /// Takes a [callback] which returns a future for the operation being attempted.
 /// If that future completes with an error, it will slepp and then [callback]
@@ skipping 13 matching lines @@
 
       // Wait a bit and try again.
       log.fine("Operation failed, retrying (attempt $attempts).");
       return sleep(500).then(makeAttempt);
     });
   }
 
   return makeAttempt(null);
 }
 
-/// Creates a new symlink that creates an alias from [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]).
+/// Creates a new symlink that creates an alias from [from] to [to]. Returns a
+/// [Future] which completes to the symlink file (i.e. [to]).
 ///
 /// Note that on Windows, only directories may be symlinked to.
-Future<File> createSymlink(from, to) {
-  from = _getPath(from);
-  to = _getPath(to);
-
+Future<String> createSymlink(String from, String to) {
   log.fine("Creating symlink ($to is a symlink to $from)");
 
   var command = 'ln';
   var args = ['-s', from, to];
 
   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).then((result) {
-    // TODO(rnystrom): Check exit code and output?
-    return new File(to);
-  });
+  // TODO(rnystrom): Check exit code and output?
+  return runProcess(command, args).then((result) => 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,
+/// package [from] to [to]. 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<String> createPackageSymlink(String name, String from, String to,
     {bool isSelfLink: false}) {
   return defer(() {
     // See if the package has a "lib" directory.
-    from = join(from, 'lib');
+    from = path.join(from, 'lib');
     log.fine("Creating ${isSelfLink ? "self" : ""}link for package '$name'.");
     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 _getFile(to);
+    return to;
   });
 }
 
 /// Resolves [target] relative to the location of pub.dart.
 String relativeToPub(String target) {
   var scriptPath = new File(new Options().script).fullPathSync();
 
   // Walk up until we hit the "util(s)" directory. This lets us figure out where
   // we are if this function is called from pub.dart, or one of the tests,
   // which also live under "utils", or from the SDK where pub is in "util".
   var utilDir = path.dirname(scriptPath);
   while (path.basename(utilDir) != 'utils' &&
          path.basename(utilDir) != 'util') {
     if (path.basename(utilDir) == '') throw 'Could not find path to pub.';
     utilDir = path.dirname(utilDir);
   }
 
-  return path.normalize(join(utilDir, 'pub', target));
+  return path.normalize(path.join(utilDir, 'pub', target));
 }
 
 // TODO(nweiz): add a ByteSink wrapper to make writing strings to stdout/stderr
 // nicer.
 
 /// A sink that writes to standard output. Errors piped to this stream will be
 /// surfaced to the top-level error handler.
 final StreamSink<List<int>> stdoutSink = _wrapStdio(stdout, "stdout");
 
 /// A sink that writes to standard error. Errors piped to this stream will be
@@ skipping 262 matching lines @@
   }
 
   /// Sends [signal] to the underlying process.
   bool kill([ProcessSignal signal = ProcessSignal.SIGTERM]) =>
     _process.kill(signal);
 }
 
 /// Calls [fn] with appropriately modified arguments. [fn] should have the same
 /// signature as [Process.start], except that the returned [Future] may have a
 /// type other than [Process].
-Future _doProcess(Function fn, String executable, List<String> args, workingDir,
-    Map<String, String> environment) {
+Future _doProcess(Function fn, String executable, List<String> args,
+    String workingDir, Map<String, String> environment) {
   // TODO(rnystrom): Should dart:io just handle this?
   // Spawning a process on Windows will not look for the executable in the
   // system path. So, if executable looks like it needs that (i.e. it doesn't
   // have any path separators in it), then spawn it through a shell.
   if ((Platform.operatingSystem == "windows") &&
       (executable.indexOf('\\') == -1)) {
     args = flatten(["/c", executable, args]);
     executable = "cmd";
   }
 
   final options = new ProcessOptions();
   if (workingDir != null) {
-    options.workingDirectory = _getDirectory(workingDir).path;
+    options.workingDirectory = workingDir;
   }
 
   if (environment != null) {
     options.environment = new Map.from(Platform.environment);
     environment.forEach((key, value) => options.environment[key] = value);
   }
 
   log.process(executable, args);
 
   return fn(executable, args, options);
@@ skipping 35 matching lines @@
 /// [fn] completes to.
 Future withTempDir(Future fn(String path)) {
   return defer(() {
     var tempDir = createTempDir();
     return fn(tempDir).whenComplete(() {
       return deleteDir(tempDir);
     });
   });
 }
 
-/// 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(Stream<List<int>> stream, destination) {
-  destination = _getPath(destination);
-
+/// Extracts a `.tar.gz` file from [stream] to [destination]. Returns whether
+/// or not the extraction was successful.
+Future<bool> extractTarGz(Stream<List<int>> stream, String destination) {
   log.fine("Extracting .tar.gz stream to $destination.");
 
   if (Platform.operatingSystem == "windows") {
     return _extractTarGzWindows(stream, destination);
   }
 
   return startProcess("tar",
       ["--extract", "--gunzip", "--directory", destination]).then((process) {
     // Ignore errors on process.std{out,err}. They'll be passed to
     // process.exitCode, and we don't want them being top-levelled by
@@ skipping 23 matching lines @@
   // 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);
 
   return withTempDir((tempDir) {
     // Write the archive to a temp file.
-    return createFileFromStream(stream, join(tempDir, 'data.tar.gz')).then((_) {
+    var dataFile = path.join(tempDir, 'data.tar.gz');
+    return createFileFromStream(stream, dataFile).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);
     }).then((result) {
       if (result.exitCode != 0) {
         throw 'Could not un-gzip (exit code ${result.exitCode}). Error:\n'
             '${result.stdout.join("\n")}\n'
             '${result.stderr.join("\n")}';
@@ skipping 34 matching lines @@
   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 controller = new StreamController<List<int>>();
 
   if (baseDir == null) baseDir = path.current;
   baseDir = path.absolute(baseDir);
   contents = contents.map((entry) {
-    entry = path.absolute(_getPath(entry));
+    entry = path.absolute(entry);
     if (!isBeneath(entry, baseDir)) {
       throw 'Entry $entry is not inside $baseDir.';
     }
     return path.relative(entry, from: baseDir);
   }).toList();
 
   if (Platform.operatingSystem != "windows") {
     var args = ["--create", "--gzip", "--directory", baseDir];
-    args.addAll(contents.map(_getPath));
+    args.addAll(contents);
     // 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) {
       store(process.stdout, controller);
     }).catchError((e) {
       // We don't have to worry about double-signaling here, since the store()
       // above will only be reached if startProcess succeeds.
       controller.signalError(e.error, e.stackTrace);
       controller.close();
     });
     return new ByteStream(controller.stream);
   }
 
   withTempDir((tempDir) {
     // Create the tar file.
-    var tarFile = join(tempDir, "intermediate.tar");
+    var tarFile = path.join(tempDir, "intermediate.tar");
     var args = ["a", "-w$baseDir", tarFile];
     args.addAll(contents.map((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
@@ skipping 34 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);
 }