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 88 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');          // -> 'path'
 ///
 /// 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.
+///
+///     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 122 matching lines @@
 ///     path.relative('/root/path/a/b.dart'); // -> 'a/b.dart'
 ///     path.relative('/root/other.dart'); // -> '../other.dart'
 ///
 /// If the [from] argument is passed, [path] is made relative to that instead.
 ///
 ///     path.relative('/root/path/a/b.dart',
 ///         from: '/root/path'); // -> 'a/b.dart'
 ///     path.relative('/root/other.dart',
 ///         from: '/root/path'); // -> '../other.dart'
 ///
+/// If [path] and/or [from] are relative paths, they are assumed to be relative
+/// to the current directory.
+///
 /// Since there is no relative path from one drive letter to another on Windows,
 /// or from one hostname to another for URLs, this will return an absolute path
 /// in those cases.
 ///
 ///     // Windows
 ///     path.relative(r'D:\other', from: r'C:\home'); // -> 'D:\other'
 ///
 ///     // URL
 ///     path.relative('http://dartlang.org', from: 'http://pub.dartlang.org');
 ///       // -> 'http://dartlang.org'
@@ skipping 314 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'
   String resolve(String part1, [String part2, String part3, String part4,
               String part5, String part6, String part7]) {
     return join(root, part1, part2, part3, part4, part5, part6, part7);
   }
 
   /// Attempts to convert [path] to an equivalent relative path relative to
   /// [root].
   ///
   ///     var builder = new Builder(root: '/root/path');
   ///     builder.relative('/root/path/a/b.dart'); // -> 'a/b.dart'
   ///     builder.relative('/root/other.dart'); // -> '../other.dart'
   ///
   /// If the [from] argument is passed, [path] is made relative to that instead.
   ///
   ///     builder.relative('/root/path/a/b.dart',
   ///         from: '/root/path'); // -> 'a/b.dart'
   ///     builder.relative('/root/other.dart',
   ///         from: '/root/path'); // -> '../other.dart'
   ///
+  /// If [path] and/or [from] are relative paths, they are assumed to be
+  /// relative to [root].
+  ///
   /// Since there is no relative path from one drive letter to another on
   /// 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 '.';
-
     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".');
+    }
     _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('');
+    }
+
     // 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 340 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 71 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));
 }