Port dart:io Path tests to package:path.

pkg/path/lib/path.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.
 
 /// A comprehensive, cross-platform path manipulation library.
 ///
 /// ## Installing ##
 ///
 /// Use [pub][] to install this package. Add the following to your
 /// `pubspec.yaml` file.
@@ skipping 96 matching lines @@
     _builder.basenameWithoutExtension(path);
 
 /// Gets the part of [path] before the last separator.
 ///
 ///     path.dirname('path/to/foo.dart'); // -> 'path/to'
 ///     path.dirname('path/to');          // -> 'to'
 ///
 /// Trailing separators are ignored.
 ///
 ///     builder.dirname('path/to/'); // -> 'path'
+///
+/// If an absolute path contains no directories, only a root, then the root
+/// is returned.
+///
+///     path.dirname('/');  // -> '/' (posix)
+///     path.dirname('c:\');  // -> 'c:\' (windows)
+///
+/// If a relative path has no directories, then '.' is returned.

[Bob Nystrom, 2013/07/15 17:49:29]

Blank line here.

[Bill Hesse, 2013/07/16 12:42:26]

Done.

+///     path.dirname('foo');  // -> '.'
+///     path.dirname('');  // -> '.'
 String dirname(String path) => _builder.dirname(path);
 
 /// Gets the file extension of [path]: the portion of [basename] from the last
 /// `.` to the end (including the `.` itself).
 ///
 ///     path.extension('path/to/foo.dart');    // -> '.dart'
 ///     path.extension('path/to/foo');         // -> ''
 ///     path.extension('path.to/foo');         // -> ''
 ///     path.extension('path/to/foo.dart.js'); // -> '.js'
 ///
@@ skipping 454 matching lines @@
                                .toList();
     if (parsed.root != null) parsed.parts.insert(0, parsed.root);
     return parsed.parts;
   }
 
   /// Normalizes [path], simplifying it by handling `..`, and `.`, and
   /// removing redundant path separators whenever possible.
   ///
   ///     builder.normalize('path/./to/..//file.text'); // -> 'path/file.txt'
   String normalize(String path) {
-    if (path == '') return path;
-
     var parsed = _parse(path);
     parsed.normalize();
     return parsed.toString();
   }
 
   /// Creates a new path by appending the given path parts to the [root].
   /// Equivalent to [join()] with [root] as the first argument. Example:
   ///
   ///     var builder = new Builder(root: 'root');
   ///     builder.resolve('path', 'to', 'foo'); // -> 'root/path/to/foo'
@@ skipping 20 matching lines @@
   /// Windows, this will return an absolute path in that case.
   ///
   ///     builder.relative(r'D:\other', from: r'C:\other'); // -> 'D:\other'
   ///
   /// This will also return an absolute path if an absolute [path] is passed to
   /// a builder with a relative [root].
   ///
   ///     var builder = new Builder(r'some/relative/path');
   ///     builder.relative(r'/absolute/path'); // -> '/absolute/path'
   String relative(String path, {String from}) {
-    if (path == '') return '.';
-

[Bill Hesse, 2013/07/15 16:58:48]

This is wrong if [from] is not null.  It should work correctly with a null from
as well.

[Bob Nystrom, 2013/07/15 17:49:29]

Eek, you're right.

     from = from == null ? root : this.join(root, from);
 
     // We can't determine the path from a relative path to an absolute path.
     if (this.isRelative(from) && this.isAbsolute(path)) {
       return this.normalize(path);
     }
 
     // If the given path is relative, resolve it relative to the root of the
     // builder.
     if (this.isRelative(path) || this.isRootRelative(path)) {
@@ skipping 26 matching lines @@
 
     // Strip off their common prefix.
     while (fromParsed.parts.length > 0 && pathParsed.parts.length > 0 &&
            fromParsed.parts[0] == pathParsed.parts[0]) {
       fromParsed.parts.removeAt(0);
       fromParsed.separators.removeAt(1);
       pathParsed.parts.removeAt(0);
       pathParsed.separators.removeAt(1);
     }
 
-    // If there are any directories left in the root path, we need to walk up
-    // out of them.
+    // If there are any directories left in the from path, we need to walk up
+    // out of them.  If a directory left in the from path is '..', it cannot
+    // be cancelled by adding a '..'.
+    if (fromParsed.parts.length > 0 && fromParsed.parts[0] == '..') {
+      throw new ArgumentError('Unable to find a path to "$path" from "$from".');
+    }

[Bob Nystrom, 2013/07/15 17:49:29]

Can you give me an example where this will come into play? I'd expect that
fromParsed wouldn't have any ".." by the time you get here in most cases. We
should add a test that hits this code path.

If you can get to this case (maybe your builder's root is a relative path with a
leading ".."?), I'd like to see if there's a "right" thing we can do instead of
throwing an exception. People expect path manipulation operations to just work,
so we try very hard not to throw exceptions.

[Bill Hesse, 2013/07/16 12:42:26]

My tests include this case.  Any case with ".." in the from path that is not
matched with one in the to path, when builder.root is '.'.  I think the abstract
case, where you want one relative path relative to another, without regard to
where the paths are based, is important.  I wish it could be done easier than
making a new builder, but I can live with it.  This truly is an exception -
there is no good answer that makes sense for this request, and to rely on the
result for anything would be an error.

     _growListFront(pathParsed.parts, fromParsed.parts.length, '..');
     pathParsed.separators[0] = '';
     pathParsed.separators.insertAll(1,
         new List.filled(fromParsed.parts.length, style.separator));
 
     // Corner case: the paths completely collapsed.
     if (pathParsed.parts.length == 0) return '.';
 
+    // Corner case: path was '.' and some '..' directories were added in front.
+    // Don't add a final '/.' in that case.
+    if (pathParsed.parts.length > 1 && pathParsed.parts.last == '.') {
+      pathParsed.parts.removeLast();
+      pathParsed.separators..removeLast()..removeLast()..add('');
+    }

[Bob Nystrom, 2013/07/15 17:49:29]

Nice catch. Add a test for this?

[Bill Hesse, 2013/07/16 12:42:26]

There is a test for this, in my tests.

+
     // Make it relative.
     pathParsed.root = '';
     pathParsed.removeTrailingSeparators();
 
     return pathParsed.toString();
   }
 
   /// Removes a trailing extension from the last part of [path].
   ///
   ///     builder.withoutExtension('path/to/foo.dart'); // -> 'path/to/foo'
@@ skipping 338 matching lines @@
     return copy.parts.last;
   }
 
   String get basenameWithoutExtension {
     var copy = this.clone();
     copy.removeTrailingSeparators();
     if (copy.parts.isEmpty) return root == null ? '' : root;
     return copy._splitExtension()[0];
   }
 
-  bool get hasTrailingSeparator => !parts.isEmpty && (parts.last == '' || separators.last != '');
+  bool get hasTrailingSeparator =>
+      !parts.isEmpty && (parts.last == '' || separators.last != '');
 
   void removeTrailingSeparators() {
     while (!parts.isEmpty && parts.last == '') {
       parts.removeLast();
       separators.removeLast();
     }
     if (separators.length > 0) separators[separators.length - 1] = '';
   }
 
   void normalize() {
@@ skipping 30 matching lines @@
     var newSeparators = new List.generate(
         newParts.length, (_) => style.separator, growable: true);
     newSeparators.insert(0,
         isAbsolute && newParts.length > 0 &&
                 root.contains(style.needsSeparatorPattern) ?
             style.separator : '');
 
     parts = newParts;
     separators = newSeparators;
 
-    // Normalize the Windows root if needed.
+   // Normalize the Windows root if needed.

[Bill Hesse, 2013/07/15 16:58:48]

oops.

     if (root != null && style == Style.windows) {
       root = root.replaceAll('/', '\\');
     }
     removeTrailingSeparators();
   }
 
   String toString() {
     var builder = new StringBuffer();
     if (root != null) builder.write(root);
     for (var i = 0; i < parts.length; i++) {
@@ skipping 20 matching lines @@
     // doesn't count.
     if (lastDot <= 0) return [file, ''];
 
     return [file.substring(0, lastDot), file.substring(lastDot)];
   }
 
   _ParsedPath clone() => new _ParsedPath(
       style, root, isRootRelative,
       new List.from(parts), new List.from(separators));
 }