Add Bob's path library to pub.

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:io';
 import 'dart:isolate';
 import 'dart:uri';
 
 // TODO(nweiz): Make this import better.
 import '../../pkg/http/lib/http.dart' as http;
+import 'curl_client.dart';
 import 'utils.dart';
-import 'curl_client.dart';
+import 'path.dart' as path;
 
 bool _isGitInstalledCache;
 
 /// The cached Git command.
 String _gitCommandCache;
 
-/** Gets the current working directory. */
-String get currentWorkingDir => new File('.').fullPathSync();
-
 final NEWLINE_PATTERN = new RegExp("\r\n?|\n\r?");
 
 /**
  * Prints the given string to `stderr` on its own line.
  */
 void printError(value) {
   stderr.writeString(value.toString());
   stderr.writeString('\n');
 }
 
 
 /**
  * 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]) {
-  final parts = sanitizePath(part1).split('/');
+  part1 = _getPath(part1);
+  if (part2 != null) part2 = _getPath(part2);
+  if (part3 != null) part3 = _getPath(part3);
+  if (part4 != null) part4 = _getPath(part4);
 
-  for (final part in [part2, part3, part4]) {
-    if (part == null) continue;
-
-    for (final piece in _getPath(part).split('/')) {
-      if (piece == '..' && parts.length > 0 &&
-          parts.last != '.' && parts.last != '..') {
-        parts.removeLast();
-      } else if (piece != '') {
-        if (parts.length > 0 && parts.last == '.') {
-          parts.removeLast();
-        }
-        parts.add(piece);
-      }
-    }
+  // TODO(nweiz): Don't use "?part" in path.dart.
+  if (part4 != null) {
+    return path.join(part1, part2, part3, part4);
+  } else if (part3 != null) {
+    return path.join(part1, part2, part3);
+  } else if (part2 != null) {
+    return path.join(part1, part2);
+  } else {
+    return path.join(part1);
   }
-
-  return Strings.join(parts, Platform.pathSeparator);
 }
 
-/// Splits [path] into its individual components.
-List<String> splitPath(path) => sanitizePath(path).split('/');
+/// 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.filename(_getPath(file));
 
-/**
- * Gets the basename, the file name without any leading directory path, for
- * [file], which can either be a [String], [File], or [Directory].
- */
-// TODO(rnystrom): Copied from file_system (so that we don't have to add
-// file_system to the SDK). Should unify.
-String basename(file) {
-  file = sanitizePath(file);
+// TODO(nweiz): move this into path.dart.
+/// Gets the the leading directory path for [file], which can either be a
+/// [String], [File], or [Directory].
+String dirname(file) {
+  file = _sanitizePath(file);
 
   int lastSlash = file.lastIndexOf('/', file.length);
   if (lastSlash == -1) {
-    return file;
-  } else {
-    return file.substring(lastSlash + 1);
-  }
-}
-
-/**
- * Gets the the leading directory path for [file], which can either be a
- * [String], [File], or [Directory].
- */
-// TODO(nweiz): Copied from file_system (so that we don't have to add
-// file_system to the SDK). Should unify.
-String dirname(file) {
-  file = sanitizePath(file);
-
-  int lastSlash = file.lastIndexOf('/', file.length);
-  if (lastSlash == -1) {
     return '.';
   } else {
     return file.substring(0, lastSlash);
   }
 }
 
+// TODO(nweiz): move this into path.dart.
+/// Splits [path] into its individual components.
+List<String> splitPath(path) => _sanitizePath(path).split('/');
+
 /// 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) =>
-  sanitizePath(entry).startsWith('${sanitizePath(dir)}/');
+bool isBeneath(entry, dir) {
+  var relative = relativeTo(entry, dir);
+  return !path.isAbsolute(relative) && !relative.startsWith('..');
+}
+
+// TODO(nweiz): move this into path.dart.
+/// Returns the path to [target] from [base].
+String relativeTo(target, base) =>
+  new path.Builder(root: base).relative(target);
 
 /**
  * Asynchronously determines if [path], which can be a [String] file path, a
  * [File], or a [Directory] exists on the file system. Returns a [Future] that
  * completes with the result.
  */
 Future<bool> exists(path) {
   path = _getPath(path);
   return Futures.wait([fileExists(path), dirExists(path)]).transform((results) {
     return results[0] || results[1];
@@ skipping 276 matching lines @@
           'Warning: Package "$name" does not have a "lib" directory so you '
           'will not be able to import any libraries from it.');
     }
 
     return new Future.immediate(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) {
-  var path = _getPath(entry);
-
-  // Don't do anything if it's already absolute.
-  if (isAbsolute(path)) return path;
-
-  // Using Path.join here instead of File().fullPathSync() because the former
-  // does not require an actual file to exist at that path.
-  return new Path.fromNative(currentWorkingDir).join(new Path(path))
-      .toNativePath();
-}
+String getFullPath(entry) => path.absolute(_getPath(entry));
 
 /// Returns whether or not [entry] is an absolute path.
-bool isAbsolute(entry) => _splitAbsolute(entry).first != null;
+bool isAbsolute(entry) => path.isAbsolute(_getPath(entry));
 
-/// Splits [entry] into two components: the absolute path prefix and the
-/// remaining path. Takes into account Windows' quirky absolute paths syntaxes.
-Pair<String, String> _splitAbsolute(entry) {
-  var path = _getPath(entry);
-
-  if (Platform.operatingSystem != 'windows') {
-    return !path.startsWith('/') ? new Pair(null, path)
-        : new Pair('/', path.substring(1));
-  }
-
-  // An absolute path on Windows is either UNC (two leading backslashes),
-  // or a drive letter followed by a colon and a slash.
-  var match = new RegExp(r'^(\\\\|[a-zA-Z]:[/\\])').firstMatch(path);
-  return match == null ? new Pair(null, path)
-      : new Pair(match.group(0), path.substring(match.end));
-}
-
-/// Resolves [path] relative to the location of pub.dart.
-String relativeToPub(String path) {
+/// 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 = new Path.fromNative(scriptPath).directoryPath;
-  while (utilDir.filename != 'utils' && utilDir.filename != 'util') {
-    if (utilDir.filename == '') throw 'Could not find path to pub.';
-    utilDir = utilDir.directoryPath;
+  var utilDir = dirname(scriptPath);
+  while (basename(utilDir) != 'utils' && basename(utilDir) != 'util') {
+    if (basename(utilDir) == '') throw 'Could not find path to pub.';
+    utilDir = dirname(utilDir);
   }
 
-  return utilDir.append('pub').append(path).canonicalize().toNativePath();
+  return path.normalize(join(utilDir, 'pub', target));
 }
 
 /// A StringInputStream reading from stdin.
 final _stringStdin = new StringInputStream(stdin);
 
 /// Returns a single line read from a [StringInputStream]. By default, reads
 /// from stdin.
 ///
 /// A [StringInputStream] passed to this should have no callbacks registered.
 Future<String> readLine([StringInputStream stream]) {
@@ skipping 397 matching lines @@
     if (result.exitCode != 0) {
       throw 'Could not un-gzip (exit code ${result.exitCode}). Error:\n'
           '${Strings.join(result.stdout, "\n")}\n'
           '${Strings.join(result.stderr, "\n")}';
     }
     // Find the tar file we just created since we don't know its name.
     return listDir(tempDir);
   }).chain((files) {
     var tarFile;
     for (var file in files) {
-      if (new Path(file).extension == 'tar') {
+      if (path.extension(file) == '.tar') {
         tarFile = file;
         break;
       }
     }
 
     if (tarFile == null) throw 'The gzip file did not contain a tar file.';
 
     // Untar the archive into the destination directory.
     return runProcess(command, ['x', tarFile], workingDir: destination);
   }).chain((result) {
@@ skipping 11 matching lines @@
 
 /// Create a .tar.gz archive from a list of entries. Each entry can be a
 /// [String], [Directory], or [File] object. The root of the archive is
 /// considered to be [baseDir], which defaults to the current working directory.
 /// Returns an [InputStream] that will emit the contents of the archive.
 InputStream createTarGz(List contents, {baseDir}) {
   // TODO(nweiz): Propagate errors to the returned stream (including non-zero
   // exit codes). See issue 3657.
   var stream = new ListInputStream();
 
-  if (baseDir == null) baseDir = currentWorkingDir;
+  if (baseDir == null) baseDir = path.current;
   baseDir = getFullPath(baseDir);
   contents = contents.map((entry) {
     entry = getFullPath(entry);
     if (!isBeneath(entry, baseDir)) {
       throw 'Entry $entry is not inside $baseDir.';
     }
-    return new Path.fromNative(entry).relativeTo(new Path.fromNative(baseDir))
-        .toNativePath();
+    return relativeTo(entry, baseDir);
   });
 
   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) {
       pipeInputToInput(process.stdout, stream);
@@ skipping 73 matching lines @@
  */
 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 the path string for [entry], normalizing backslashes to forward slashes
 /// on Windows.
-String sanitizePath(entry) {
+String _sanitizePath(entry) {
   entry = _getPath(entry);
   if (Platform.operatingSystem != 'windows') return entry;
 
   var split = _splitAbsolute(entry);
   if (split.first == null) return split.last.replaceAll('\\', '/');
 
   // For absolute Windows paths, we don't want the prefix (either "\\" or e.g.
   // "C:\") to look like a normal path component, so we ensure that it only
   // contains backslashes.
   return '${split.first.replaceAll('/', '\\')}'
          '${split.last.replaceAll('\\', '/')}';
 }
 
+/// Splits [entry] into two components: the absolute path prefix and the
+/// remaining path. Takes into account Windows' quirky absolute paths syntaxes.

[Bob Nystrom, 2012/12/08 03:36:53]

Add a TODO to move this (or something similar) into path.

[nweiz, 2012/12/08 03:43:45]

Done.

+Pair<String, String> _splitAbsolute(entry) {
+  var path = _getPath(entry);
+
+  if (Platform.operatingSystem != 'windows') {
+    return !path.startsWith('/') ? new Pair(null, path)
+        : new Pair('/', path.substring(1));
+  }
+
+  // An absolute path on Windows is either UNC (two leading backslashes),
+  // or a drive letter followed by a colon and a slash.
+  var match = new RegExp(r'^(\\\\|[a-zA-Z]:[/\\])').firstMatch(path);
+  return match == null ? new Pair(null, path)
+      : new Pair(match.group(0), path.substring(match.end));
+}
+
 /**
  * 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 new Uri.fromString(uri);
 }