Get rid of old redundant methods 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]) {

[nweiz, 2013/02/14 00:10:37]

Can we get rid of this?

[Bob Nystrom, 2013/02/14 01:14:19]

That will be a bit more invasive, so I figured I'd do that in another patch. I
like doing things incrementally.

   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]);
 }
 
-/// 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
-/// [String], [File], or [Directory].
-String dirname(file) => path.dirname(_getPath(file));
-
 /// Splits [entry] into its individual components.
 List<String> splitPath(entry) => path.split(_getPath(entry));

[nweiz, 2013/02/14 00:10:37]

Can we get rid of this?

[Bob Nystrom, 2013/02/14 01:14:19]

Done.

 
 /// 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(entry, dir) {

[nweiz, 2013/02/14 00:10:37]

Since this just calls path methods now, we should mark these as Strings.

[Bob Nystrom, 2013/02/14 01:14:19]

Done.

-  var relative = relativeTo(entry, dir);
+  var relative = path.relative(entry, from: dir);
   return !path.isAbsolute(relative) && splitPath(relative)[0] != '..';
 }
 
-/// Returns the path to [target] from [base].
-String relativeTo(target, base) => path.relative(target, from: base);
-
 /// 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 [file], which can be a [String] file path or a [File], exists
 /// on the file system.
 bool fileExists(file) => _getFile(file).existsSync();
 
 /// Reads the contents of the text file [file], which can either be a [String]
 /// or a [File].
@@ skipping 19 matching lines @@
 
   // 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..writeAsStringSync(contents);
 }
 
-/// Deletes [file], which can be a [String] or a [File]. Returns a [Future]
-/// that completes when the deletion is done.
+/// 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)
@@ skipping 13 matching lines @@
 
   var file = new File(path);
   return stream.pipe(wrapOutputStream(file.openOutputStream())).then((_) {
     log.fine("Created $path from stream.");
   });
 }
 
 /// Creates a directory [dir].
 Directory createDir(dir) => _getDirectory(dir)..createSync();
 
-/// Ensures that [path] and all its parent directories exist. If they don't
+/// Ensures that [dirPath] and all its parent directories exist. If they don't
 /// exist, creates them.
-Directory ensureDir(path) {
-  path = _getPath(path);
+Directory ensureDir(dirPath) {
+  dirPath = _getPath(dirPath);
 
-  log.fine("Ensuring directory $path exists.");
-  var dir = new Directory(path);
-  if (path == '.' || dirExists(path)) return dir;
+  log.fine("Ensuring directory $dirPath exists.");
+  var dir = new Directory(dirPath);
+  if (dirPath == '.' || dirExists(dirPath)) return dir;
 
-  ensureDir(dirname(path));
+  ensureDir(path.dirname(dirPath));
 
   try {
     createDir(dir);
   } 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;
 }
 
 /// 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.
-Directory createTempDir([dir = '']) {
+/// created in a platform-dependent temporary location. Returns the path of the
+/// created directory.
+String createTempDir([dir = '']) {
   var tempDir = _getDirectory(dir).createTempSync();
   log.io("Created temp directory ${tempDir.path}");
-  return tempDir;
+  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)));
 }
@@ skipping 37 matching lines @@
     var stackTrace;
     try {
       throw "";
     } catch (_, localStackTrace) {
       stackTrace = localStackTrace;
     }
 
     var children = [];
     lister.onError = (error) => completer.completeError(error, stackTrace);
     lister.onDir = (file) {
-      if (!includeHiddenFiles && basename(file).startsWith('.')) return;
-      file = join(dir, basename(file));
+      if (!includeHiddenFiles && path.basename(file).startsWith('.')) return;
+      file = 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));
       }
     };
 
     lister.onFile = (file) {
-      if (!includeHiddenFiles && basename(file).startsWith('.')) return;
-      contents.add(join(dir, basename(file)));
+      if (!includeHiddenFiles && path.basename(file).startsWith('.')) return;
+      contents.add(join(dir, path.basename(file)));
     };
 
     return completer.future.then((contents) {
       return Future.wait(children).then((childContents) {
         contents.addAll(flatten(childContents));
         return contents;
       });
     });
   }
 
@@ skipping 109 matching lines @@
     // 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);
   });
 }
 
-/// Given [entry] which may be a [String], [File], or [Directory] relative to
-/// the current working directory, returns its full canonicalized path.
-String getFullPath(entry) => path.absolute(_getPath(entry));
-
-/// Returns whether or not [entry] is an absolute path.
-bool isAbsolute(entry) => path.isAbsolute(_getPath(entry));
-
 /// 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 = dirname(scriptPath);
-  while (basename(utilDir) != 'utils' && basename(utilDir) != 'util') {
-    if (basename(utilDir) == '') throw 'Could not find path to pub.';
-    utilDir = dirname(utilDir);
+  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));
 }
 
 // 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.
@@ skipping 329 matching lines @@
 
 /// 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.
 ///
 /// Returns a future that completes to the value that the future returned from
 /// [fn] completes to.
 Future withTempDir(Future fn(String path)) {
   return defer(() {
     var tempDir = createTempDir();
-    return fn(tempDir.path).whenComplete(() {
+    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);
 
@@ skipping 86 matching lines @@
   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 controller = new StreamController<List<int>>();
 
   if (baseDir == null) baseDir = path.current;
-  baseDir = getFullPath(baseDir);
+  baseDir = path.absolute(baseDir);
   contents = contents.map((entry) {
-    entry = getFullPath(entry);
+    entry = path.absolute(_getPath(entry));
     if (!isBeneath(entry, baseDir)) {
       throw 'Entry $entry is not inside $baseDir.';
     }
-    return relativeTo(entry, baseDir);
+    return path.relative(entry, from: baseDir);
   }).toList();
 
   if (Platform.operatingSystem != "windows") {
     var args = ["--create", "--gzip", "--directory", baseDir];
     args.addAll(contents.map(_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) {
       store(process.stdout, controller);
@@ skipping 86 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 Uri.parse(uri);
 }