Add Uri.http and Uri.https constructors

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 {
@@ skipping 90 matching lines @@
     this(scheme: _emptyIfNull(m[_COMPONENT_SCHEME]),
          userInfo: _emptyIfNull(m[_COMPONENT_USER_INFO]),
          host: _eitherOf(
          m[_COMPONENT_HOST], m[_COMPONENT_HOST_IPV6]),
          port: _parseIntOrZero(m[_COMPONENT_PORT]),
          path: _emptyIfNull(m[_COMPONENT_PATH]),
          query: _emptyIfNull(m[_COMPONENT_QUERY_DATA]),
          fragment: _emptyIfNull(m[_COMPONENT_FRAGMENT]));
 
   /**
-   * Create a new URI from its components.
+   * Creates a new URI from its components.
    *
    * Each component is set through a named argument. Any number of
    * components can be provided. The default value for the components
    * not provided is the empry string, except for [port] which has a
    * default value of 0. The [path] and [query] components can be set
    * using two different named arguments.
    *
    * The scheme component is set through [scheme]. The scheme is
    * normalized to all lowercase letters.
    *
@@ skipping 49 matching lines @@
     } else if (scheme == "https" && port == 443) {
       _port = 0;
     } else {
       _port = port;
     }
     // Fill the path.
     _path = _makePath(path, pathSegments);
   }
 
   /**
+   * Creates a new `http` URI from authority, path and query.
+   *
+   * Examples:
+   *
+   *     // Create the URI http://example.org/path?q=abc.
+   *     new Uri.http("google.com", "/search", { "q" : "dart" });http://example.org/path?q=abc.
+   *     new Uri.http("user:pass@localhost:8080, "");  // http://user:pass@localhost:8080/
+   *     new Uri.http("example.org, "a b");  // http://example.org/a%20b
+   *     new Uri.http("example.org, "/a%2F");  // http://example.org/a%25%2F
+   *
+   * The `scheme` is always set to `http`.
+   *
+   * The `userInfo`, `host` and `port` components are set from the
+   * [authority] argument.
+   *
+   * The `path` component is set from the [unencodedPath]
+   * argument. The path passed must not be encoded as this constructor
+   * encodes the path.
+   *
+   * The `query` component is set from the optional [queryParameters]
+   * argument.
+   */
+  factory Uri.http(String authority,
+                   String unencodedPath,
+                   [Map<String, String> queryParameters]) {
+    return _makeHttpUri("http", authority, unencodedPath, queryParameters);
+  }
+
+  /**
+   * Creates a new `https` URI from authority, path and query.
+   *
+   * This constructor is the same as [Uri.http] except for the scheme
+   * which is set to `https`.
+   */
+  factory Uri.https(String authority,
+                    String unencodedPath,
+                    [Map<String, String> queryParameters]) {
+    return _makeHttpUri("https", authority, unencodedPath, queryParameters);
+  }
+
+  static Uri _makeHttpUri(String scheme,
+                          String authority,
+                          String unencodedPath,
+                          Map<String, String> queryParameters) {
+    var userInfo = "";
+    var host = "";
+    var port = 0;
+
+    var hostStart = 0;
+    // Split off the user info.
+    bool hasUserInfo = false;
+    for (int i = 0; i < authority.length; i++) {
+      if (authority.codeUnitAt(i) == _AT_SIGN) {
+        hasUserInfo = true;
+        userInfo = authority.substring(0, i);
+        hostStart = i + 1;
+        break;
+      }
+    }
+    // Split host and port.
+    bool hasPort = false;
+    for (int i = hostStart; i < authority.length; i++) {
+      if (authority.codeUnitAt(i) == _COLON) {
+        hasPort = true;
+        host = authority.substring(hostStart, i);
+        if (!host.isEmpty) {
+          var portString = authority.substring(i + 1);
+          if (portString.isNotEmpty) port = int.parse(portString);
+        }
+        break;
+      }
+    }
+    if (!hasPort) {
+      host = hasUserInfo ? authority.substring(hostStart) : authority;
+    }
+
+    return new Uri(scheme: scheme,
+                   userInfo: userInfo,
+                   host: host,
+                   port: port,
+                   pathSegments: unencodedPath.split("/"),
+                   queryParameters: queryParameters);
+  }
+
+  /**
    * 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. A leading slash `/` does
    * not affect the segments returned.
    *
    * The returned list is unmodifiable and will throw [UnsupportedError] on any
    * calls that would mutate it.
    */
   List<String> get pathSegments {
     if (_pathSegments == null) {
@@ skipping 548 matching lines @@
     });
   }
 
   // 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 _AT_SIGN = 0x40;
   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.
    * It encodes all characters in the string [text] except for those
    * that appear in [canonicalTable], and returns the escaped string.
    */
@@ 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;
 }