Add toUri and fromUri functions to pathos.

pkg/pathos/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 257 matching lines @@
 ///     path.relative('http://dartlang.org', from: 'http://pub.dartlang.org');
 ///       // -> 'http://dartlang.org'
 String relative(String path, {String from}) =>
     _builder.relative(path, from: from);
 
 /// Removes a trailing extension from the last part of [path].
 ///
 ///     withoutExtension('path/to/foo.dart'); // -> 'path/to/foo'
 String withoutExtension(String path) => _builder.withoutExtension(path);
 
+/// Returns the path represented by [uri].
+///
+/// For POSIX and Windows styles, [uri] must be a `file:` URI. For the URL
+/// style, this will just convert [uri] to a string.
+///
+///     // POSIX
+///     path.fromUri(Uri.parse('file:///path/to/foo'))
+///       // -> '/path/to/foo'
+///
+///     // Windows
+///     path.fromUri(Uri.parse('file:///C:/path/to/foo'))
+///       // -> r'C:\path\to\foo'
+///
+///     // URL
+///     path.fromUri(Uri.parse('http://dartlang.org/path/to/foo'))
+///       // -> 'http://dartlang.org/path/to/foo'
+String fromUri(Uri uri) => _builder.fromUri(uri);
+
+/// Returns the URI that represents [path].
+///
+/// For POSIX and Windows styles, this will return a `file:` URI. For the URL
+/// style, this will just convert [path] to a [Uri].
+///
+/// This will always convert relative paths to absolute ones before converting
+/// to a URI.
+///
+///     // POSIX
+///     path.toUri('/path/to/foo')
+///       // -> Uri.parse('file:///path/to/foo')
+///
+///     // Windows
+///     path.toUri(r'C:\path\to\foo')
+///       // -> Uri.parse('file:///C:/path/to/foo')
+///
+///     // URL
+///     path.toUri('http://dartlang.org/path/to/foo')
+///       // -> Uri.parse('http://dartlang.org/path/to/foo')
+Uri toUri(String path) => _builder.toUri(path);
+
 /// Validates that there are no non-null arguments following a null one and
 /// throws an appropriate [ArgumentError] on failure.
 _validateArgList(String method, List<String> args) {
   for (var i = 1; i < args.length; i++) {
     // Ignore nulls hanging off the end.
     if (args[i] == null || args[i - 1] != null) continue;
 
     var numArgs;
     for (numArgs = args.length; numArgs >= 1; numArgs--) {
       if (args[numArgs - 1] != null) break;
@@ skipping 378 matching lines @@
     for (var i = parsed.parts.length - 1; i >= 0; i--) {
       if (!parsed.parts[i].isEmpty) {
         parsed.parts[i] = parsed.basenameWithoutExtension;
         break;
       }
     }
 
     return parsed.toString();
   }
 
+  /// Returns the path represented by [uri].
+  ///
+  /// For POSIX and Windows styles, [uri] must be a `file:` URI. For the URL
+  /// style, this will just convert [uri] to a string.
+  ///
+  ///     // POSIX
+  ///     builder.fromUri(Uri.parse('file:///path/to/foo'))
+  ///       // -> '/path/to/foo'
+  ///
+  ///     // Windows
+  ///     builder.fromUri(Uri.parse('file:///C:/path/to/foo'))
+  ///       // -> r'C:\path\to\foo'
+  ///
+  ///     // URL
+  ///     builder.fromUri(Uri.parse('http://dartlang.org/path/to/foo'))
+  ///       // -> 'http://dartlang.org/path/to/foo'
+  String fromUri(Uri uri) => style.pathFromUri(uri);
+
+  /// Returns the URI that represents [path].
+  ///
+  /// For POSIX and Windows styles, this will return a `file:` URI. For the URL
+  /// style, this will just convert [path] to a [Uri].
+  ///
+  ///     // POSIX
+  ///     builder.toUri('/path/to/foo')
+  ///       // -> Uri.parse('file:///path/to/foo')
+  ///
+  ///     // Windows
+  ///     builder.toUri(r'C:\path\to\foo')
+  ///       // -> Uri.parse('file:///C:/path/to/foo')
+  ///
+  ///     // URL
+  ///     builder.toUri('http://dartlang.org/path/to/foo')
+  ///       // -> Uri.parse('http://dartlang.org/path/to/foo')
+  Uri toUri(String path) {
+    if (isRelative(path)) {
+      return Uri.parse(path.replaceAll(style.separatorPattern, '/'));
+    } else {
+      return style.pathToUri(join(root, path));
+    }
+  }
+
   _ParsedPath _parse(String path) {
     var before = path;
 
     // Remove the root prefix, if any.
     var root = style.getRoot(path);
     var isRootRelative = style.getRelativeRoot(path) != null;
     if (root != null) path = path.substring(root.length);
 
     // Split the parts on path separators.
     var parts = [];
@@ skipping 21 matching lines @@
     }
 
     return new _ParsedPath(style, root, isRootRelative, parts, separators);
   }
 }
 
 /// An enum type describing a "flavor" of path.
 class Style {
   /// POSIX-style paths use "/" (forward slash) as separators. Absolute paths
   /// start with "/". Used by UNIX, Linux, Mac OS X, and others.
-  static final posix = new Style._('posix', '/', '/', r'[^/]$', '/');
+  static final posix = new _PosixStyle();
 
   /// Windows paths use "\" (backslash) as separators. Absolute paths start with
   /// a drive letter followed by a colon (example, "C:") or two backslashes
   /// ("\\") for UNC paths.
   // TODO(rnystrom): The UNC root prefix should include the drive name too, not
   // just the "\\".
-  static final windows = new Style._('windows', '\\', r'[/\\]', r'[^/\\]$',
-      r'\\\\|[a-zA-Z]:[/\\]');
+  static final windows = new _WindowsStyle();
 
   /// URLs aren't filesystem paths, but they're supported by Pathos to make it
   /// easier to manipulate URL paths in the browser.
   ///
   /// URLs use "/" (forward slash) as separators. Absolute paths either start
   /// with a protocol and optional hostname (e.g. `http://dartlang.org`,
   /// `file://`) or with "/".
-  static final url = new Style._('url', '/', '/',
-      r"(^[a-zA-Z][-+.a-zA-Z\d]*://|[^/])$",
-      r"[a-zA-Z][-+.a-zA-Z\d]*://[^/]*", r"/");
+  static final url = new _UrlStyle();
 
   Style._(this.name, this.separator, String separatorPattern,
       String needsSeparatorPattern, String rootPattern,
       [String relativeRootPattern])
     : separatorPattern = new RegExp(separatorPattern),
       needsSeparatorPattern = new RegExp(needsSeparatorPattern),
       _rootPattern = new RegExp('^$rootPattern'),
       _relativeRootPattern = relativeRootPattern == null ? null :
           new RegExp('^$relativeRootPattern');
 
@@ skipping 42 matching lines @@
   /// Gets the root prefix of [path] if it's root-relative.
   ///
   /// If [path] is relative or absolute and not root-relative, returns `null`.
   String getRelativeRoot(String path) {
     if (_relativeRootPattern == null) return null;
     var match = _relativeRootPattern.firstMatch(path);
     if (match == null) return null;
     return match[0];
   }
 
+  /// Returns the path represented by [uri] in this style.
+  String pathFromUri(Uri uri);
+
+  /// Returns the URI that represents [path].
+  ///
+  /// [path] is guaranteed to be absolute. Relative paths are handled

[Bob Nystrom, 2013/06/13 00:21:18]

"guaranteed" is confusing here. Is it required to be, or does it mean
pathToUri() will handle it correctly if it isn't?

[nweiz, 2013/06/19 00:50:27]

This documentation is intended for implementors of [Style]. It's a guarantee
that pathos will only pass absolute paths to [pathToUri].

[Bob Nystrom, 2013/06/19 18:02:18]

Ah, that makes sense. It isn't strictly true that pathos is the only thing that
will ever call this, though, so can you reword the docs to make it clear that
this is a requirement for the argument?

+  /// automatically by [Builder].
+  Uri pathToUri(String path);
+
   String toString() => name;
 }
 
+/// The style for POSIX paths.
+class _PosixStyle extends Style {
+  _PosixStyle()
+      : super._('posix', '/', '/', r'[^/]$', '/');

[Bob Nystrom, 2013/06/13 00:21:18]

Since you are subclassing the styles now, let's make these abstract getters in
Style, instead of fields. Then override them instead of passing them to the
superclass constructor.

[nweiz, 2013/06/19 00:50:27]

Done.

+
+  String pathFromUri(Uri uri) {
+    if (uri.scheme == '' || uri.scheme == 'file') return uri.path;

[Bob Nystrom, 2013/06/13 00:21:18]

What about URL decoding?

[nweiz, 2013/06/19 00:50:27]

Done.

+    throw new ArgumentError("Uri $uri must have scheme 'file:'.");
+  }
+
+  Uri pathToUri(String path) => Uri.parse('file://$path');

[Bob Nystrom, 2013/06/13 00:21:18]

new Uri(scheme: "file", path: path);

[Søren Gjesse, 2013/06/13 07:13:32]

The path should also be encoded

new Uri(scheme: "file", path: Uri.encodeComponent(path))

[nweiz, 2013/06/19 00:50:27]

Done.

+}
+
+/// The style for Windows paths.
+class _WindowsStyle extends Style {
+  _WindowsStyle()
+      : super._('windows', '\\', r'[/\\]', r'[^/\\]$', r'\\\\|[a-zA-Z]:[/\\]');
+
+  String pathFromUri(Uri uri) {
+    if (uri.scheme != '' && uri.scheme != 'file') {
+      throw new ArgumentError("Uri $uri must have scheme 'file:'.");
+    }
+
+    if (uri.host == '') {
+      if (uri.path.startsWith('/')) {
+        // Drive-letter paths look like "file:///C:/path/to/file". The
+        // replaceFirst removes the extra initial slash.
+        return uri.path.replaceFirst("/", "").replaceAll("/", "\\");
+      } else {
+        return uri.path.replaceAll("/", "\\");

[Bob Nystrom, 2013/06/13 00:21:18]

Doing this replaceAll for both arms seems redundant. How about:

var path = uri.path;
if (path.startsWith('/')) {
  ...
  path = path.replaceFirst(...)
}
return path.replaceAll(...)

[nweiz, 2013/06/19 00:50:27]

Done.

+      }
+    } else {
+      // Network paths look like "file://hostname/path/to/file".
+      return "\\\\${uri.host}${uri.path.replaceAll("/", "\\")}";
+    }
+  }
+
+  Uri pathToUri(String path) {
+    if (path.startsWith('\\\\')) {
+      // Network paths become "file://hostname/path/to/file".
+      return Uri.parse('file:${path.replaceAll("\\", "/")}');

[Bob Nystrom, 2013/06/13 00:21:18]

Use the regular Uri constructor here instead of making a string just to the
parse it. Below too.

[nweiz, 2013/06/19 00:50:27]

Done.

+    } else {
+      // Drive-letter paths become "file:///C:/path/to/file".
+      return Uri.parse('file:///${path.replaceAll("\\", "/")}');
+    }
+  }
+}
+
+/// The style for URL paths.
+class _UrlStyle extends Style {
+  _UrlStyle()
+      : super._('url', '/', '/',
+          r"(^[a-zA-Z][-+.a-zA-Z\d]*://|[^/])$",
+          r"[a-zA-Z][-+.a-zA-Z\d]*://[^/]*", r"/");
+
+  String pathFromUri(Uri uri) => uri.toString();
+
+  Uri pathToUri(String path) => Uri.parse(path);
+}
+
 // TODO(rnystrom): Make this public?
 class _ParsedPath {
   /// The [Style] that was used to parse this path.
   Style style;
 
   /// The absolute root portion of the path, or `null` if the path is relative.
   /// On POSIX systems, this will be `null` or "/". On Windows, it can be
   /// `null`, "//" for a UNC path, or something like "C:\" for paths with drive
   /// letters.
   String root;
@@ skipping 120 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));
 }