Add InternalStyle:rootLength to implement isAbsolute and rootPrefix.

pkg/path/lib/src/context.dart

 // Copyright (c) 2013, 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.
 
 library path.context;
 
 import 'internal_style.dart';
 import 'style.dart';
 import 'parsed_path.dart';
 import 'path_exception.dart';
@@ skipping 130 matching lines @@
   ///     context.rootPrefix('/path/to/foo'); // -> '/'
   ///
   ///     // Windows
   ///     context.rootPrefix(r'path\to\foo'); // -> ''
   ///     context.rootPrefix(r'C:\path\to\foo'); // -> r'C:\'
   ///
   ///     // URL
   ///     context.rootPrefix('path/to/foo'); // -> ''
   ///     context.rootPrefix('http://dartlang.org/path/to/foo');
   ///       // -> 'http://dartlang.org'
-  String rootPrefix(String path) {
-    var root = _parse(path).root;
-    return root == null ? '' : root;
-  }
+  String rootPrefix(String path) => path.substring(0, style.rootLength(path));
 
   /// Returns `true` if [path] is an absolute path and `false` if it is a
   /// relative path.
   ///
   /// On POSIX systems, absolute paths start with a `/` (forward slash). On
   /// Windows, an absolute path starts with `\\`, or a drive letter followed by
   /// `:/` or `:\`. For URLs, absolute paths either start with a protocol and
   /// optional hostname (e.g. `http://dartlang.org`, `file://`) or with a `/`.
   ///
   /// URLs that start with `/` are known as "root-relative", since they're
   /// relative to the root of the current URL. Since root-relative paths are
   /// still absolute in every other sense, [isAbsolute] will return true for
   /// them. They can be detected using [isRootRelative].
-  bool isAbsolute(String path) => _parse(path).isAbsolute;
+  bool isAbsolute(String path) => style.rootLength(path) > 0;
 
   /// Returns `true` if [path] is a relative path and `false` if it is absolute.
   /// On POSIX systems, absolute paths start with a `/` (forward slash). On
   /// Windows, an absolute path starts with `\\`, or a drive letter followed by
   /// `:/` or `:\`.
   bool isRelative(String path) => !this.isAbsolute(path);
 
   /// Returns `true` if [path] is a root-relative path and `false` if it's not.
   ///
   /// URLs that start with `/` are known as "root-relative", since they're
   /// relative to the root of the current URL. Since root-relative paths are
   /// still absolute in every other sense, [isAbsolute] will return true for
   /// them. They can be detected using [isRootRelative].
   ///
   /// No POSIX and Windows paths are root-relative.
-  bool isRootRelative(String path) => _parse(path).isRootRelative;
+  bool isRootRelative(String path) => style.isRootRelative(path);
 
   /// Joins the given path parts into a single path. Example:
   ///
   ///     context.join('path', 'to', 'foo'); // -> 'path/to/foo'
   ///
   /// If any part ends in a path separator, then a redundant separator will not
   /// be added:
   ///
   ///     context.join('path/', 'to', 'foo'); // -> 'path/to/foo
   ///
@@ skipping 352 matching lines @@
     // Show the arguments.
     var message = new StringBuffer();
     message.write("$method(");
     message.write(args.take(numArgs)
         .map((arg) => arg == null ? "null" : '"$arg"')
         .join(", "));
     message.write("): part ${i - 1} was null, but part $i was not.");
     throw new ArgumentError(message.toString());
   }
 }