dart:io | Handle drive letters in Path.relativeTo on Windows.

sdk/lib/io/path_impl.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.
 
 part of dart.io;
 
 class _Path implements Path {
   final String _path;
   final bool isWindowsShare;
 
@@ skipping 28 matching lines @@
 
   int get hashCode => _path.hashCode;
   bool get isEmpty => _path.isEmpty;
   bool get isAbsolute => _path.startsWith('/');
   bool get hasTrailingSeparator => _path.endsWith('/');
 
   String toString() => _path;
 
   Path relativeTo(Path base) {
     // Returns a path "relative" such that
-    //    base.join(relative) == this.canonicalize.
+    // base.join(relative) == this.canonicalize.
     // Throws exception if an impossible case is reached.
     if (base.isAbsolute != isAbsolute ||
         base.isWindowsShare != isWindowsShare) {
-      throw new ArgumentError(
-          "Invalid case of Path.relativeTo(base):\n"
-          "  Path and base must both be relative, or both absolute.\n"
-          "  Arguments: $_path.relativeTo($base)");
+      throw new ArgumentError("""

[Søren Gjesse, 2013/03/14 13:53:32]

Please keep using concatenation of adjacent strings in this file.

+Invalid case of Path.relativeTo(base):
+  Path and base must both be relative, or both absolute.
+  Arguments: $_path.relativeTo($base)""");
     }
 
     var basePath = base.toString();
+    // Handle drive letters specially on Windows.
+    if (base.isAbsolute && Platform.operatingSystem == 'windows') {
+      bool baseHasDrive =
+          basePath.length >= 4 && basePath[2] == ':' && basePath[3] == '/';
+      bool pathHasDrive =
+          _path.length >= 4 && _path[2] == ':' && _path[3] == '/';
+      if (baseHasDrive && pathHasDrive) {
+        int baseDrive = basePath.codeUnitAt(1) | 32;  // Convert to uppercase.
+        if (baseDrive >= 'a'.codeUnitAt(0) &&
+            baseDrive <= 'z'.codeUnitAt(0) &&
+            baseDrive == (_path.codeUnitAt(1) | 32)) {
+          if(basePath[1] != _path[1]) {
+            // Replace the drive letter in basePath with that from _path.
+            basePath = '/${_path[1]}:/${basePath.substring(4)}';
+            base = new Path(basePath);
+          }
+        } else {
+          throw new ArgumentError("""
+Invalid case of Path.relativeTo(base):
+  Base path and target path are on different Windows drives.
+  Arguments: $_path.relativeTo($base)""");
+        }
+      } else if (baseHasDrive != pathHasDrive) {
+        throw new ArgumentError("""
+Invalid case of Path.relativeTo(base):
+  Base path must start with a drive letter if and only if target path does.
+  Arguments: $_path.relativeTo($base)""");
+      }
+
+    }
     if (_path.startsWith(basePath)) {
       if (_path == basePath) return new Path('.');
       // There must be a '/' at the end of the match, or immediately after.
       int matchEnd = basePath.length;
       if (_path[matchEnd - 1] == '/' || _path[matchEnd] == '/') {
         // Drop any extra '/' characters at matchEnd
         while (matchEnd < _path.length && _path[matchEnd] == '/') {
           matchEnd++;
         }
         return new Path(_path.substring(matchEnd)).canonicalize();
       }
     }
 
     List<String> baseSegments = base.canonicalize().segments();
     List<String> pathSegments = canonicalize().segments();
     if (baseSegments.length == 1 && baseSegments[0] == '.') {
       baseSegments = [];
     }
     if (pathSegments.length == 1 && pathSegments[0] == '.') {
       pathSegments = [];
     }
     int common = 0;
     int length = min(pathSegments.length, baseSegments.length);
     while (common < length && pathSegments[common] == baseSegments[common]) {
       common++;
     }
     final segments = new List<String>();
 
     if (common < baseSegments.length && baseSegments[common] == '..') {
-      throw new ArgumentError(
-          "Invalid case of Path.relativeTo(base):\n"
-          "  Base path has more '..'s than path does."
-          "  Arguments: $_path.relativeTo($base)");
+      throw new ArgumentError("""
+Invalid case of Path.relativeTo(base):
+  Base path has more '..'s than path does.
+  Arguments: $_path.relativeTo($base)""");
     }
     for (int i = common; i < baseSegments.length; i++) {
       segments.add('..');
     }
     for (int i = common; i < pathSegments.length; i++) {
       segments.add('${pathSegments[i]}');
     }
     if (segments.isEmpty) {
       segments.add('.');
     }
@@ skipping 164 matching lines @@
     while (pos > 0 && _path[pos - 1] == '/') --pos;
     var dirPath = (pos > 0) ? _path.substring(0, pos) : '/';
     return new _Path._internal(dirPath, isWindowsShare);
   }
 
   String get filename {
     int pos = _path.lastIndexOf('/');
     return _path.substring(pos + 1);
   }
 }