Add encodimg argument to Uri.encodeQueryString

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, such as a URL.
  *
  * **See also:**
@@ skipping 663 matching lines @@
       if (result == null) {
         assert(prevIndex == 0);
         result = new StringBuffer(component.substring(prevIndex, index));
       } else {
         result.write(component.substring(prevIndex, index));
       }
     }
 
     while (index < length) {
 
-      // Normalize percent encoding to uppercase and don't encode
+      // Normalize percent-encoding to uppercase and don't encode
       // unreserved characters.
       if (component.codeUnitAt(index) == _PERCENT) {
         if (length < index + 2) {
             throw new ArgumentError(
                 "Invalid percent-encoding in URI component: $component");
         }
 
         var codeUnit1 = component.codeUnitAt(index + 1);
         var codeUnit2 = component.codeUnitAt(index + 2);
         var decodedCodeUnit = decodeHexDigitPair(index + 1);
@@ skipping 412 matching lines @@
    */
   static String encodeComponent(String component) {
     return _uriEncode(_unreserved2396Table, component);
   }
 
   /**
    * Encode the string [component] according to the HTML 4.01 rules
    * for encoding the posting of a HTML form as a query string
    * component.
    *
-   * Spaces will be replaced with plus and all characters except for
-   * uppercase and lowercase letters, decimal digits and the
-   * characters `-._~`. Note that the set of characters encoded is a
-   * superset of what HTML 4.01 says as it refers to RFC 1738 for
-   * reserved characters.
+   * Encode the string [component] according to the HTML 4.01 rules
+   * for encoding the posting of a HTML form as a query string
+   * component.
+
+   * The component is first encoded to bytes using [encoding].
+   * The default is to use [UTF8] encoding, which preserves all
+   * the characters that don't need encoding.
+
+   * Then the resulting bytes are "percent-encoded". This transforms
+   * spaces (U+0020) to a plus sign ('+') and all bytes that are not
+   * the ASCII decimal digits, letters or one of '-._~' are written as
+   * a percent sign '%' followed by the two-digit hexadecimal
+   * representation of the byte.
+
+   * Note that the set of characters which are percent-encoded is a
+   * superset of what HTML 4.01 requires, since it refers to RFC 1738
+   * for reserved characters.
    *
    * When manually encoding query components remember to encode each
    * part separately before building the query string.
    *
    * To avoid the need for explicitly encoding the query use the
    * [queryParameters] optional named arguments when constructing a
    * [Uri].
    *
    * See http://www.w3.org/TR/html401/interact/forms.html#h-17.13.4.2 for more
    * details.
    */
-  static String encodeQueryComponent(String component) {
-    return _uriEncode(_unreservedTable, component, spaceToPlus: true);
+  static String encodeQueryComponent(String component,
+                                     {Encoding encoding: UTF8}) {
+    return _uriEncode(
+        _unreservedTable, component, encoding: encoding, spaceToPlus: true);
   }
 
   /**
    * Decodes the percent-encoding in [encodedComponent].
    *
    * Note that decoding a URI component might change its meaning as
    * some of the decoded characters could be characters with are
    * delimiters for a given URI componene type. Always split a URI
    * component using the delimiters for the component before decoding
    * the individual parts.
@@ skipping 201 matching lines @@
           if (value == -1) {
             return new List.filled((9 - parts.length) * 2, 0);
           } else {
             return [(value >> 8) & 0xFF, value & 0xFF];
           }
         })
         .toList();
   }
 
   // Frequently used character codes.
+  static const int _SPACE = 0x20;
   static const int _DOUBLE_QUOTE = 0x22;
   static const int _PERCENT = 0x25;
   static const int _ASTERISK = 0x2A;
   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 _LESS = 0x3C;
   static const int _GREATER = 0x3E;
   static const int _QUESTION = 0x3F;
   static const int _AT_SIGN = 0x40;
   static const int _UPPER_CASE_A = 0x41;
   static const int _UPPER_CASE_F = 0x46;
   static const int _UPPER_CASE_Z = 0x5A;
   static const int _LEFT_BRACKET = 0x5B;
   static const int _BACKSLASH = 0x5C;
   static const int _RIGHT_BRACKET = 0x5D;
   static const int _LOWER_CASE_A = 0x61;
   static const int _LOWER_CASE_F = 0x66;
   static const int _LOWER_CASE_Z = 0x7A;
   static const int _BAR = 0x7C;
 
   /**
    * 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.
    */
   static String _uriEncode(List<int> canonicalTable,
-                    String text,
-                    {bool spaceToPlus: false}) {
-    byteToHex(int v) {
-      final String hex = '0123456789ABCDEF';
-      return '%${hex[v >> 4]}${hex[v & 0x0f]}';
+                           String text,
+                           {Encoding encoding: UTF8,
+                            bool spaceToPlus: false}) {
+    byteToHex(byte, buffer) {
+      const String hex = '0123456789ABCDEF';
+      buffer.writeCharCode(hex.codeUnitAt(byte >> 4));
+      buffer.writeCharCode(hex.codeUnitAt(byte & 0x0f));
     }
 
+    // Encode the string into bytes then generate an ASCII only string
+    // by percent encoding selected bytes.
     StringBuffer result = new StringBuffer();
-    for (int i = 0; i < text.length; i++) {
-      int ch = text.codeUnitAt(i);
-      if (ch < 128 && ((canonicalTable[ch >> 4] & (1 << (ch & 0x0f))) != 0)) {
-        result.write(text[i]);
-      } else if (spaceToPlus && text[i] == " ") {
-        result.write("+");
+    var bytes = encoding.encode(text);
+    for (int i = 0; i < bytes.length; i++) {
+      int byte = bytes[i];
+      if (byte < 128 &&
+          ((canonicalTable[byte >> 4] & (1 << (byte & 0x0f))) != 0)) {
+        result.writeCharCode(byte);
+      } else if (spaceToPlus && byte == _SPACE) {
+        result.writeCharCode(_PLUS);
       } else {
-        if (ch >= 0xD800 && ch < 0xDC00) {
-          // Low surrogate. We expect a next char high surrogate.
-          ++i;
-          int nextCh = text.length == i ? 0 : text.codeUnitAt(i);
-          if (nextCh >= 0xDC00 && nextCh < 0xE000) {
-            // convert the pair to a U+10000 codepoint
-            ch = 0x10000 + ((ch - 0xD800) << 10) + (nextCh - 0xDC00);
-          } else {
-            throw new ArgumentError('Malformed URI');
-          }
-        }
-        // TODO(floitsch): don't allocate a new string.
-        for (int codepoint in UTF8.encode(new String.fromCharCode(ch))) {
-          result.write(byteToHex(codepoint));
-        }
+        result.writeCharCode(_PERCENT);
+        byteToHex(byte, result);
       }
     }
     return result.toString();
   }
 
   /**
    * Convert a byte (2 character hex sequence) in string [s] starting
    * at position [pos] to its ordinal value
    */
   static int _hexCharPairToByte(String s, int pos) {
@@ skipping 23 matching lines @@
    * This function is similar to the JavaScript-function `decodeURI`.
    *
    * If [plusToSpace] is `true`, plus characters will be converted to spaces.
    *
    * The decoder will create a byte-list of the percent-encoded parts, and then
    * decode the byte-list using [encoding]. The default encodingis UTF-8.
    */
   static String _uriDecode(String text,
                            {bool plusToSpace: false,
                             Encoding encoding: UTF8}) {
-    StringBuffer result = new StringBuffer();
-    List<int> codepoints = new List<int>();
-    for (int i = 0; i < text.length;) {
-      int ch = text.codeUnitAt(i);
-      if (ch != _PERCENT) {
-        if (plusToSpace && ch == _PLUS) {
-          result.write(" ");
-        } else {
-          result.writeCharCode(ch);
+    // First check whether there is any characters which need special handling.
+    bool simple = true;
+    for (int i = 0; i < text.length && simple; i++) {
+      var codeUnit = text.codeUnitAt(i);
+      simple = codeUnit != _PERCENT && codeUnit != _PLUS;
+    }
+    List<int> bytes;
+    if (simple) {
+      if (encoding == UTF8 || encoding == LATIN1) {
+        return text;
+      } else {
+        bytes = text.codeUnits;
+      }
+    } else {
+      bytes = new List();
+      for (int i = 0; i < text.length; i++) {
+        var codeUnit = text.codeUnitAt(i);
+        if (codeUnit > 127) {
+          throw new ArgumentError("Illegal percent encoding in URI");
         }
-        i++;
-      } else {
-        codepoints.clear();
-        while (ch == _PERCENT) {
-          if (++i > text.length - 2) {
+        if (codeUnit == _PERCENT) {
+          if (i + 3 > text.length) {
             throw new ArgumentError('Truncated URI');
           }
-          codepoints.add(_hexCharPairToByte(text, i));
+          bytes.add(_hexCharPairToByte(text, i + 1));
           i += 2;
-          if (i == text.length) break;
-          ch = text.codeUnitAt(i);
+        } else if (plusToSpace && codeUnit == _PLUS) {
+          bytes.add(_SPACE);
+        } else {
+          bytes.add(codeUnit);
         }
-        result.write(encoding.decode(codepoints));
       }
     }
-    return result.toString();
+    return encoding.decode(bytes);
   }
 
   static bool _isAlphabeticCharacter(int codeUnit)
     => (codeUnit >= _LOWER_CASE_A && codeUnit <= _LOWER_CASE_Z) ||
        (codeUnit >= _UPPER_CASE_A && codeUnit <= _UPPER_CASE_Z);
 
   // Tables of char-codes organized as a bit vector of 128 bits where
   // each bit indicate whether a character code on the 0-127 needs to
   // be escaped or not.
 
@@ skipping 180 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;
 }