Add a multipart HTTP request class.

pkg/http/lib/src/utils.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.
 
 library utils;
 
+import 'dart:crypto';
 import 'dart:io';
 import 'dart:isolate';
 import 'dart:scalarlist';
 import 'dart:uri';
+import 'dart:utf';
 
 /// Converts a URL query string (or `application/x-www-form-urlencoded` body)
 /// into a [Map] from parameter names to values.
 ///
 ///     queryToMap("foo=bar&baz=bang&qux");
 ///     //=> {"foo": "bar", "baz": "bang", "qux": ""}
 Map<String, String> queryToMap(String queryList) {
   var map = <String>{};
   for (var pair in queryList.split("&")) {
     var split = split1(pair, "=");
@@ skipping 40 matching lines @@
   if (toSplit.isEmpty) return <String>[];
 
   var index = toSplit.indexOf(pattern);
   if (index == -1) return [toSplit];
   return [
     toSplit.substring(0, index),
     toSplit.substring(index + pattern.length)
   ];
 }
 
-/// Returns the [Encoding] that corresponds to [charset]. Returns
-/// [Encoding.ISO_8859_1] if [charset] is null or if no [Encoding] was found
-/// that corresponds to [charset].
-Encoding encodingForCharset(String charset) {
-  if (charset == null) return Encoding.ISO_8859_1;
+/// Returns the [Encoding] that corresponds to [charset]. Returns [fallback] if
+/// [charset] is null or if no [Encoding] was found that corresponds to
+/// [charset].
+Encoding encodingForCharset(
+    String charset, [Encoding fallback = Encoding.ISO_8859_1]) {
+  if (charset == null) return fallback;
   var encoding = _encodingForCharset(charset);
-  return encoding == null ? Encoding.ISO_8859_1 : encoding;
+  return encoding == null ? fallback : encoding;
 }
 
-/// Returns the [Encoding] that corresponds to [charset]. Throws a [FormatException]
-/// if no [Encoding] was found that corresponds to [charset]. [charset] may not
-/// be null.
+/// Returns the [Encoding] that corresponds to [charset]. Throws a
+/// [FormatException] if no [Encoding] was found that corresponds to [charset].
+/// [charset] may not be null.
 Encoding requiredEncodingForCharset(String charset) {
   var encoding = _encodingForCharset(charset);
   if (encoding != null) return encoding;
   throw new FormatException('Unsupported encoding "$charset".');
 }
 
 /// Returns the [Encoding] that corresponds to [charset]. Returns null if no
 /// [Encoding] was found that corresponds to [charset]. [charset] may not be
 /// null.
 Encoding _encodingForCharset(String charset) {
   charset = charset.toLowerCase();
   if (charset == 'ascii' || charset == 'us-ascii') return Encoding.ASCII;
   if (charset == 'utf-8') return Encoding.UTF_8;
   if (charset == 'iso-8859-1') return Encoding.ISO_8859_1;
   return null;
 }
 
 /// Converts [bytes] into a [String] according to [encoding].
 String decodeString(List<int> bytes, Encoding encoding) {
   // TODO(nweiz): implement this once issue 6284 is fixed.
   return new String.fromCharCodes(bytes);
 }
 
 /// Converts [string] into a byte array according to [encoding].
 List<int> encodeString(String string, Encoding encoding) {
   // TODO(nweiz): implement this once issue 6284 is fixed.
   return string.charCodes;
 }
 
+/// A regular expression that matches strings that are composed entirely of
+/// ASCII-compatible characters.
+final RegExp _ASCII_ONLY = const RegExp(r"^[\x00-\x7F]+$");
+
+/// Returns whether [string] is composed entirely of ASCII-compatible
+/// characters.
+bool isPlainAscii(String string) => _ASCII_ONLY.hasMatch(string);
+
 /// Converts [input] into a [Uint8List]. If [input] is a [ByteArray] or
 /// [ByteArrayViewable], this just returns a view on [input].
 Uint8List toUint8List(List<int> input) {
   if (input is Uint8List) return input;
   if (input is ByteArrayViewable) input = input.asByteArray();
   if (input is ByteArray) return new Uint8List.view(input);
   var output = new Uint8List(input.length);
   output.setRange(0, input.length, input);
   return output;
 }
 
 /// Buffers all input from an InputStream and returns it as a future.
 Future<List<int>> consumeInputStream(InputStream stream) {
   var completer = new Completer<List<int>>();
   /// TODO(nweiz): use BufferList when issue 6409 is fixed
   var buffer = <int>[];
   stream.onClosed = () => completer.complete(buffer);
   stream.onData = () => buffer.addAll(stream.read());
   stream.onError = completer.completeException;
   return completer.future;
 }
 
-/// Takes all input from [source] and writes it to [sink].
+/// Takes all input from [source] and writes it to [sink], then closes [sink].
 void pipeInputToInput(InputStream source, ListInputStream sink) {
   source.onClosed = () => sink.markEndOfStream();
   source.onData = () => sink.write(source.read());
   // TODO(nweiz): propagate source errors to the sink. See issue 3657.
 }
 
+/// Takes all input from [source] and writes it to [sink], but does not close
+/// [sink] when [source] is closed. Returns a [Future] that completes when
+/// [source] is closed.
+Future writeInputToInput(InputStream source, ListInputStream sink) {
+  var completer = new Completer();
+  source.onClosed = () => completer.complete(null);
+  source.onData = () => sink.write(source.read());
+  // TODO(nweiz): propagate source errors to the sink. See issue 3657.
+  return completer.future;
+}
+
 /// Returns a [Future] that asynchronously completes to `null`.
 Future get async {
   var completer = new Completer();
   new Timer(0, (_) => completer.complete(null));
   return completer.future;
 }
+
+// TOOD(nweiz): Get rid of this once https://codereview.chromium.org/11293132/
+// is in.
+/// Runs [fn] for each element in [input] in order, moving to the next element
+/// only when the [Future] returned by [fn] completes. Returns a [Future] that
+/// completes when all elements have been processed.
+///
+/// The return values of all [Future]s are discarded. Any errors will cause the
+/// iteration to stop and will be piped through the return value.
+Future forEachFuture(Iterable input, Future fn(element)) {
+  var iterator = input.iterator();
+  Future nextElement(_) {
+    if (!iterator.hasNext) return new Future.immediate(null);
+    return fn(iterator.next()).chain(nextElement);
+  }
+  return nextElement(null);
+}