Fix Path.relativeTo and add support for relative paths as input.

tests/standalone/io/path_test.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.
 //
 // Test the Path class in dart:io.
 
 import "dart:io";
 
 void main() {
   testBaseFunctions();
@@ skipping 165 matching lines @@
   testAppend('a/b', '/c/d', 'a/b//c/d');
   testAppend('', 'foo/bar', 'foo/bar');
   testAppend('/foo', '', '/foo/');
 
   // .join can only join a relative path to a path.
   // It cannot join an absolute path to a path.
   Expect.throws(() => new Path('/a/b/').join(new Path('/c/d')));
 }
 
 void testRelativeTo() {
+  // Cases where the arguments are absolute paths.
   Expect.equals('c/d',
                 new Path('/a/b/c/d').relativeTo(new Path('/a/b')).toString());
   Expect.equals('c/d',
                 new Path('/a/b/c/d').relativeTo(new Path('/a/b/')).toString());
   Expect.equals('.',
                 new Path('/a').relativeTo(new Path('/a')).toString());
 
-  // Trailing / in base path represents directory
+  // Trailing slash in the base path has no effect.  This matches Path.join

[Mads Ager (google), 2013/01/16 13:20:10]

I'm wondering if this is actually the right thing to do. We are currently
internally operating on URI paths, so maybe we should stay with the URI
semantics here and just be better about documenting it (and have an easy way to
add the trailing slash if we know we are dealing with a directory).

[Bill Hesse, 2013/01/16 13:32:55]

I see your point.  But I would not like to leave it as-is without changing .join
to have URI semantics as well.  We should keep considering this.

With the new semantics, it turns out that the URI semantics can be easily
restored by calling
a.relativeTo(b.directoryPath)
instead of
a.relativeTo(b).

This is so straightforward that I will put it in the documentation of relativeTo
in the Path interface.

+  // semantics, but not URL join semantics.
   Expect.equals('../../z/x/y',
       new Path('/a/b/z/x/y').relativeTo(new Path('/a/b/c/d/')).toString());
-  Expect.equals('../z/x/y',
+  Expect.equals('../../z/x/y',
       new Path('/a/b/z/x/y').relativeTo(new Path('/a/b/c/d')).toString());
-  Expect.equals('../z/x/y/',
+  Expect.equals('../../z/x/y/',
       new Path('/a/b/z/x/y/').relativeTo(new Path('/a/b/c/d')).toString());
 
-  Expect.equals('../../z/x/y',
+  Expect.equals('../../../z/x/y',
       new Path('/z/x/y').relativeTo(new Path('/a/b/c')).toString());
   Expect.equals('../../../z/x/y',
       new Path('/z/x/y').relativeTo(new Path('/a/b/c/')).toString());
 
-  // Not implemented yet.  Should return new Path('../b/c/d/').
-  Expect.throws(() =>
-                new Path('b/c/d/').relativeTo(new Path('a/')));
+  // Cases where the arguments are relative paths.
+  Expect.equals('c/d',
+      new Path('a/b/c/d').relativeTo(new Path('a/b')).toString());
+  Expect.equals('c/d',
+      new Path('/a/b/c/d').relativeTo(new Path('/a/b/')).toString());
+  Expect.equals('.',
+      new Path('a/b/c').relativeTo(new Path('a/b/c')).toString());
+  Expect.equals('.',
+      new Path('').relativeTo(new Path('')).toString());
+  Expect.equals('.',
+      new Path('.').relativeTo(new Path('.')).toString());
+  Expect.equals('a',
+      new Path('a').relativeTo(new Path('.')).toString());
+  Expect.equals('..',
+      new Path('..').relativeTo(new Path('.')).toString());
+  Expect.equals('..',
+      new Path('.').relativeTo(new Path('a')).toString());
+  Expect.equals('.',
+      new Path('..').relativeTo(new Path('..')).toString());
+  Expect.equals('./',
+      new Path('a/b/f/../c/').relativeTo(new Path('a/e/../b/c')).toString());
+  Expect.equals('d',
+      new Path('a/b/f/../c/d').relativeTo(new Path('a/e/../b/c')).toString());
+  Expect.equals('..',
+      new Path('a/b/f/../c').relativeTo(new Path('a/e/../b/c/e/')).toString());
+  Expect.equals('../..',
+      new Path('').relativeTo(new Path('a/b/')).toString());
+  Expect.equals('../../..',
+      new Path('..').relativeTo(new Path('a/b')).toString());
+  Expect.equals('../b/c/d/',
+      new Path('b/c/d/').relativeTo(new Path('a/')).toString());
+
   // Should always throw - no relative path can be constructed.
   Expect.throws(() =>
                 new Path('a/b').relativeTo(new Path('../../d')));
+  // Should always throw - relative and absolute paths are compared.
+  Expect.throws(() =>
+                new Path('/a/b').relativeTo(new Path('c/d')));

[Mads Ager (google), 2013/01/16 13:20:10]

I think this will fit on one line?

+
+  Expect.throws(() =>
+                new Path('a/b').relativeTo(new Path('/a/b')));

[Mads Ager (google), 2013/01/16 13:20:10]

Ditto.

+
 }
 
-// Test that Windows share information is maintain through
+// Test that Windows share information is maintained through
 // Path operations.
 void testWindowsShare() {
   // Windows share information only makes sense on Windows.
   if (Platform.operatingSystem != 'windows') return;
   var path = new Path(r'\\share\a\b\..\c');
   Expect.isTrue(path.isAbsolute);
   Expect.isTrue(path.isWindowsShare);
   Expect.isFalse(path.hasTrailingSeparator);
   var canonical = path.canonicalize();
   Expect.isTrue(canonical.isAbsolute);
@@ skipping 11 matching lines @@
   Expect.isTrue(canonical.toString().startsWith('/share/a'));
   Expect.isTrue(canonical.toNativePath().startsWith(r'\\share\a'));
   Expect.listEquals(['share', 'a', 'c'], canonical.segments());
   var appended = canonical.append('d');
   Expect.isTrue(appended.isAbsolute);
   Expect.isTrue(appended.isWindowsShare);
   var directoryPath = canonical.directoryPath;
   Expect.isTrue(directoryPath.isAbsolute);
   Expect.isTrue(directoryPath.isWindowsShare);
 }