adding codereview file, formatting, adding gitignore

lib/src/errors.dart

 // Copyright (c) 2015, 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.
 
 // TODO(lrn): This should be in package:async?
 /**
  * Helper functions for working with errors.
  *
  * The [MultiError] class combines multiple errors into one object,
  * and the [MultiError.wait] function works like [Future.wait] except
@@ skipping 29 matching lines @@
    * Waits for all [futures] to complete, like [Future.wait].
    *
    * Where `Future.wait` only reports one error, even if multiple
    * futures complete with errors, this function will complete
    * with a [MultiError] if more than one future completes with an error.
    *
    * The order of values is not preserved (if that is needed, use
    * [wait]).
    */
   static Future<List> waitUnordered(Iterable<Future> futures,
-                                    {cleanUp(successResult)}) {
+      {cleanUp(successResult)}) {

[Lasse Reichstein Nielsen, 2015/02/26 10:59:15]

Indent as original.

     Completer completer;
     int count = 0;
     int errors = 0;
     int values = 0;
     // Initilized to `new List(count)` when count is known.
     // Filled up with values on the left, errors on the right.
     // Order is not preserved.
     List results;
     void checkDone() {
       if (errors + values < count) return;
@@ skipping 38 matching lines @@
    * Waits for all [futures] to complete, like [Future.wait].
    *
    * Where `Future.wait` only reports one error, even if multiple
    * futures complete with errors, this function will complete
    * with a [MultiError] if more than one future completes with an error.
    *
    * The order of values is preserved, and if any error occurs, the
    * [MultiError.errors] list will have errors in the corresponding slots,
    * and `null` for non-errors.
    */
-  Future<List> wait(Iterable<Future> futures,
-                    {cleanUp(successResult)}) {
+  Future<List> wait(Iterable<Future> futures, {cleanUp(successResult)}) {
     Completer completer;
     int count = 0;
     bool hasError = false;
     int completed = 0;
     // Initalized to `new List(count)` when count is known.
     // Filled with values until the first error, then cleared
     // and filled with errors.
     List results;
     void checkDone() {
       completed++;
@@ skipping 28 matching lines @@
         results[i] = e;
         checkDone();
       });
     }
     if (count == 0) return new Future.value(new List(0));
     results = new List(count);
     completer = new Completer();
     return completer.future;
   }
 
-
   String toString() {
     StringBuffer buffer = new StringBuffer();
     buffer.write("Multiple Errors:\n");
     int linesPerError = _MAX_LINES ~/ errors.length;
     if (linesPerError < _MIN_LINES_PER_ERROR) {
       linesPerError = _MIN_LINES_PER_ERROR;
     }
 
     for (int index = 0; index < errors.length; index++) {
       var error = errors[index];
       if (error == null) continue;
       String errorString = error.toString();
       int end = 0;
       for (int i = 0; i < linesPerError; i++) {
         end = errorString.indexOf('\n', end) + 1;
         if (end == 0) {
           end = errorString.length;
           break;
         }
       }
       buffer.write("#$index: ");
       buffer.write(errorString.substring(0, end));
       if (end < errorString.length) {
         buffer.write("...\n");
       }
     }
     return buffer.toString();
   }
 }