Support Windows share paths in the Path class.

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.
 
 class _Path implements Path {
   final String _path;
+  final bool isWindowsShare;
 
-  _Path(String source) : _path = source;
-  _Path.fromNative(String source) : _path = _clean(source);
+  _Path(String source) : _path = source, isWindowsShare = false;
 
-  int get hashCode => _path.hashCode;
+  _Path.fromNative(String source)
+      : _path = _clean(source), isWindowsShare = _isWindowsShare(source);
+
+  _Path._internal(String this._path, bool this.isWindowsShare);
 
   static String _clean(String source) {
-    switch (Platform.operatingSystem) {
-      case 'windows':
-        return _cleanWindows(source);
-      default:
-        return source;
-    }
+    if (Platform.operatingSystem == 'windows') return _cleanWindows(source);
+    return source;
   }
 
-  static String _cleanWindows(source) {
+  static String _cleanWindows(String source) {
     // Change \ to /.
     var clean = source.replaceAll('\\', '/');
     // Add / before intial [Drive letter]:
     if (clean.length >= 2 && clean[1] == ':') {
       clean = '/$clean';
     }
+    if (_isWindowsShare(source)) {
+      return clean.substring(1, clean.length);
+    }
     return clean;
   }
 
+  static bool _isWindowsShare(String source) {
+    return Platform.operatingSystem == 'windows' && source.startsWith('\\\\');
+  }
+
+  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) {
     // Throws exception if an unimplemented or impossible case is reached.
     // Returns a path "relative" such that
     //    base.join(relative) == this.canonicalize.
     // Throws an exception if no such path exists, or the case is not
     // implemented yet.
     var basePath = base.toString();
-    if (base.isAbsolute && _path.startsWith(basePath)) {
+    if (base.isAbsolute && _path.startsWith(basePath) &&
+        base.isWindowsShare == isWindowsShare) {
       if (_path == basePath) return new Path('.');
       if (base.hasTrailingSeparator) {
         return new Path(_path.substring(basePath.length));
       }
       if (_path[basePath.length] == '/') {
         return new Path(_path.substring(basePath.length + 1));
       }
-    } else if (base.isAbsolute && isAbsolute) {
+    } else if (base.isAbsolute && isAbsolute &&
+               base.isWindowsShare == isWindowsShare) {
       List<String> baseSegments = base.canonicalize().segments();
       List<String> pathSegments = canonicalize().segments();
       int common = 0;
       int length = min(pathSegments.length, baseSegments.length);
       while (common < length && pathSegments[common] == baseSegments[common]) {
         common++;
       }
       final sb = new StringBuffer();
 
       for (int i = common + 1; i < baseSegments.length; i++) {
@@ skipping 19 matching lines @@
 
   Path join(Path further) {
     if (further.isAbsolute) {
       throw new ArgumentError(
           "Path.join called with absolute Path as argument.");
     }
     if (isEmpty) {
       return further.canonicalize();
     }
     if (hasTrailingSeparator) {
-      return new Path('$_path${further}').canonicalize();
+      var joined = new _Path._internal('$_path${further}', isWindowsShare);
+      return joined.canonicalize();
     }
-    return new Path('$_path/${further}').canonicalize();
+    var joined = new _Path._internal('$_path/${further}', isWindowsShare);
+    return joined.canonicalize();
   }
 
   // Note: The URI RFC names for these operations are normalize, resolve, and
   // relativize.
   Path canonicalize() {
     if (isCanonical) return this;
     return makeCanonical();
   }
 
   bool get isCanonical {
@@ skipping 69 matching lines @@
         segmentsToJoin.add('');
       } else {
         segmentsToJoin.add('.');
       }
     } else {
       segmentsToJoin.addAll(newSegs);
       if (hasTrailingSeparator) {
         segmentsToJoin.add('');
       }
     }
-    return new Path(Strings.join(segmentsToJoin, '/'));
+    return new _Path._internal(Strings.join(segmentsToJoin, '/'),
+                               isWindowsShare);
   }
 
   String toNativePath() {
     if (Platform.operatingSystem == 'windows') {
       String nativePath = _path;
       // Drop '/' before a drive letter.
       if (nativePath.length >= 3 &&
           nativePath.startsWith('/') &&
           nativePath[2] == ':') {
         nativePath = nativePath.substring(1);
       }
       nativePath = nativePath.replaceAll('/', '\\');
+      if (isWindowsShare) {
+        return '\\$nativePath';
+      }
       return nativePath;
     }
     return _path;
   }
 
   List<String> segments() {
     List result = _path.split('/');
     if (isAbsolute) result.removeRange(0, 1);
     if (hasTrailingSeparator) result.removeLast();
     return result;
   }
 
   Path append(String finalSegment) {
     if (isEmpty) {
-      return new Path(finalSegment);
+      return new _Path._internal(finalSegment, isWindowsShare);
     } else if (hasTrailingSeparator) {
-      return new Path('$_path$finalSegment');
+      return new _Path._internal('$_path$finalSegment', isWindowsShare);
     } else {
-      return new Path('$_path/$finalSegment');
+      return new _Path._internal('$_path/$finalSegment', isWindowsShare);
     }
   }
 
   String get filenameWithoutExtension {
     var name = filename;
     if (name == '.' || name == '..') return name;
     int pos = name.lastIndexOf('.');
     return (pos < 0) ? name : name.substring(0, pos);
   }
 
   String get extension {
     var name = filename;
     int pos = name.lastIndexOf('.');
     return (pos < 0) ? '' : name.substring(pos + 1);
   }
 
   Path get directoryPath {
     int pos = _path.lastIndexOf('/');
     if (pos < 0) return new Path('');
     while (pos > 0 && _path[pos - 1] == '/') --pos;
-    return new Path((pos > 0) ? _path.substring(0, 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);
   }
 }