Add leading slash to URI path when required.

sdk/lib/core/uri.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.core;
 
 /**
  * A parsed URI, as specified by RFC-3986, http://tools.ietf.org/html/rfc3986.
  */
 class Uri {
   int _port;
+  String _path;
 
   /**
    * Returns the scheme component.
    *
    * Returns the empty string if there is no scheme component.
    */
   final String scheme;
 
   /**
    * Returns the authority component.
@@ skipping 34 matching lines @@
   int get port => _port;
 
   /**
    * Returns the path component.
    *
    * The returned path is encoded. To get direct access to the decoded
    * path use [pathSegments].
    *
    * Returns the empty string if there is no path component.
    */
-  final String path;
+  String get path => _path;
 
   /**
    * Returns the query component. The returned query is encoded. To get
    * direct access to the decoded query use [queryParameters].
    *
    * Returns the empty string if there is no query component.
    */
   final String query;
 
   /**
@@ skipping 53 matching lines @@
    * [port]. The port is normalized for scheme http and https where
    * port 80 and port 443 respectively is set.
    *
    * The path component is set through either [path] or
    * [pathSegments]. When [path] is used, the provided string is
    * expected to be fully percent-encoded, and is used in its literal
    * form. When [pathSegments] is used, each of the provided segments
    * is percent-encoded and joined using the forward slash
    * separator. The percent-encoding of the path segments encodes all
    * characters except for the unreserved characters and the following
-   * list of characters: `!$&'()*+,;=:@`.
+   * list of characters: `!$&'()*+,;=:@`. If the other components
+   * calls for an absolute path a leading slash `/` is prepended if
+   * not already there.
    *
    * The query component is set through either [query] or
    * [queryParameters]. When [query] is used the provided string is
    * expected to be fully percent-encoded and is used in its literal
    * form. When [queryParameters] is used the query is built from the
    * provided map. Each key and value in the map is percent-encoded
    * and joined using equal and ampersand characters. The
    * percent-encoding of the keys and values encodes all characters
    * except for the unreserved characters.
    *
    * The fragment component is set through [fragment].
    */
   Uri({scheme,
        this.userInfo: "",
        this.host: "",
        port: 0,
        String path,
        List<String> pathSegments,
        String query,
        Map<String, String> queryParameters,
        fragment: ""}) :
       scheme = _makeScheme(scheme),
-      path = _makePath(path, pathSegments),
       query = _makeQuery(query, queryParameters),
       fragment = _makeFragment(fragment) {
     // Perform scheme specific normalization.
     if (scheme == "http" && port == 80) {
       _port = 0;
     } else if (scheme == "https" && port == 443) {
       _port = 0;
     } else {
       _port = port;
     }
+    // Fill the path.
+    _path = _makePath(path, pathSegments);

[Lasse Reichstein Nielsen, 2013/06/06 11:50:32]

But _makePath was changed to return void?

[Søren Gjesse, 2013/06/06 14:06:54]

And that was wrong.

   }
 
   /*
    * Returns the URI path split into its segments. Each of the
    * segments in the returned list have been decoded. If the path is
-   * empty the empty list will be returned.
+   * empty the empty list will be returned. A leading slash `/` does
+   * not affect the segments returned.
    *
-   * The returned list is immutable and will throw [StateError] on any
+   * The returned list is unmodifiable and will throw [UnsupportedError] on any
    * calls that would mutate it.
    */
   List<String> get pathSegments {
     if (_pathSegments == null) {
+      var pathToSplit = !path.isEmpty && path.codeUnitAt(0) == _SLASH
+                        ? path.substring(1)
+                        : path;
       _pathSegments = new UnmodifiableListView(
-        path == "" ? const<String>[]
-                   : path.split("/")
-                         .map(Uri.decodeComponent)
-                         .toList(growable: false));
+        pathToSplit == "" ? const<String>[]
+                          : pathToSplit.split("/")
+                                       .map(Uri.decodeComponent)
+                                       .toList(growable: false));
     }
     return _pathSegments;
   }
 
   /*
    * Returns the URI query split into a map according to the rules
    * specified for FORM post in the HTML 4.01 specification. Each key
    * and value in the returned map have been decoded. If there is no
    * query the empty map will be returned.
    *
-   * The returned map is immutable and will throw [StateError] on any
+   * The returned map is unmodifiable and will throw [UnsupportedError] on any
    * calls that would mutate it.
    */
   Map<String, String> get queryParameters {
     if (_queryParameters == null) {
       var map;
       map = query.split("&").fold({}, (map, element) {
         int index = element.indexOf("=");
         if (index == -1) {
           if (!element.isEmpty) map[decodeQueryComponent(element)] = "";
         } else if (index != 0) {
@@ skipping 28 matching lines @@
           allLowercase = false;
         } else {
           throw new ArgumentError('Illegal scheme: $scheme');
         }
       }
     }
 
     return allLowercase ? scheme : scheme.toLowerCase();
   }
 
-  static String _makePath(String path, List<String> pathSegments) {
+  void _makePath(String path, List<String> pathSegments) {
     if (path == null && pathSegments == null) return "";
     if (path != null && pathSegments != null) {
       throw new ArgumentError('Both path and pathSegments specified');
     }
-    if (path != null) return _normalize(path);
-
-    return pathSegments.map((s) => _uriEncode(_pathCharTable, s)).join("/");
+    var result;
+    if (path != null) {
+      result = _normalize(path);
+    } else {
+      result = pathSegments.map((s) => _uriEncode(_pathCharTable, s)).join("/");
+    }
+    if ((hasAuthority || (scheme == "file")) &&
+        !result.isEmpty && result.codeUnitAt(0) != _SLASH) {

[Lasse Reichstein Nielsen, 2013/06/06 11:50:32]

result.startsWith("/") ?

(and remember isNotEmpty :)

[Søren Gjesse, 2013/06/06 14:06:54]

Done.

+      return "/${result}";

[Lasse Reichstein Nielsen, 2013/06/06 11:50:32]

No need for { and } around "result".

[Søren Gjesse, 2013/06/06 14:06:54]

Done.

+    }
+    return result;
   }
 
   static String _makeQuery(String query, Map<String, String> queryParameters) {
     if (query == null && queryParameters == null) return "";
     if (query != null && queryParameters != null) {
       throw new ArgumentError('Both query and queryParameters specified');
     }
     if (query != null) return _normalize(query);
 
     var result = new StringBuffer();
@@ skipping 430 matching lines @@
    * cases an encoded URI should be parsed into components using
    * [Uri.parse] before decoding the separate components.
    */
   static String decodeFull(String uri) {
     return _uriDecode(uri);
   }
 
   // Frequently used character codes.
   static const int _PERCENT = 0x25;
   static const int _PLUS = 0x2B;
+  static const int _SLASH = 0x2F;
   static const int _ZERO = 0x30;
   static const int _NINE = 0x39;
   static const int _COLON = 0x3A;
   static const int _UPPER_CASE_A = 0x41;
   static const int _UPPER_CASE_F = 0x46;
   static const int _LOWER_CASE_A = 0x61;
   static const int _LOWER_CASE_F = 0x66;
 
   /**
    * This is the internal implementation of JavaScript's encodeURI function.
@@ skipping 275 matching lines @@
   void clear() {
     throw new UnsupportedError("Cannot modify an unmodifiable map");
   }
   void forEach(void f(K key, V value)) => _map.forEach(f);
   Iterable<K> get keys => _map.keys;
   Iterable<V> get values => _map.values;
   int get length => _map.length;
   bool get isEmpty => _map.isEmpty;
   bool get isNotEmpty => _map.isNotEmpty;
 }