matcher: fixed status file, formatting, tweaks to readme

lib/src/iterable_matchers.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 matcher.iterable_matchers;
 
 import 'core_matchers.dart';
 import 'description.dart';
 import 'interfaces.dart';
 import 'util.dart';
@@ skipping 18 matching lines @@
         return false;
       }
       ++i;
     }
     return true;
   }
 
   Description describe(Description description) =>
       description.add('every element(').addDescriptionOf(_matcher).add(')');
 
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) {
+  Description describeMismatch(
+      item, Description mismatchDescription, Map matchState, bool verbose) {
     if (matchState['index'] != null) {
       var index = matchState['index'];
       var element = matchState['element'];
-      mismatchDescription.add('has value ').addDescriptionOf(element).
-          add(' which ');
+      mismatchDescription
+          .add('has value ')
+          .addDescriptionOf(element)
+          .add(' which ');
       var subDescription = new StringDescription();
-      _matcher.describeMismatch(element, subDescription, matchState['state'],
-          verbose);
+      _matcher.describeMismatch(
+          element, subDescription, matchState['state'], verbose);
       if (subDescription.length > 0) {
         mismatchDescription.add(subDescription.toString());
       } else {
         mismatchDescription.add("doesn't match ");
         _matcher.describe(mismatchDescription);
       }
       mismatchDescription.add(' at index $index');
       return mismatchDescription;
     }
-    return super.describeMismatch(item, mismatchDescription,
-          matchState, verbose);
+    return super.describeMismatch(
+        item, mismatchDescription, matchState, verbose);
   }
 }
 
 /// Returns a matcher which matches [Iterable]s in which at least one
 /// element matches the given [matcher].
 Matcher anyElement(matcher) => new _AnyElement(wrapMatcher(matcher));
 
 class _AnyElement extends _IterableMatcher {
   final Matcher _matcher;
 
@@ skipping 20 matching lines @@
   _OrderedEquals(this._expected) {
     _matcher = equals(_expected, 1);
   }
 
   bool matches(item, Map matchState) =>
       (item is Iterable) && _matcher.matches(item, matchState);
 
   Description describe(Description description) =>
       description.add('equals ').addDescriptionOf(_expected).add(' ordered');
 
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) {
-    if (item is !Iterable) {
+  Description describeMismatch(
+      item, Description mismatchDescription, Map matchState, bool verbose) {
+    if (item is! Iterable) {
       return mismatchDescription.add('is not an Iterable');
     } else {
-      return _matcher.describeMismatch(item, mismatchDescription,
-          matchState, verbose);
+      return _matcher.describeMismatch(
+          item, mismatchDescription, matchState, verbose);
     }
   }
 }
 
 /// Returns a matcher which matches [Iterable]s that have the same length and
 /// the same elements as [expected], but not necessarily in the same order.
 ///
 /// Note that this is O(n^2) so should only be used on small objects.
 Matcher unorderedEquals(Iterable expected) => new _UnorderedEquals(expected);
 
 class _UnorderedEquals extends _UnorderedMatches {
   final List _expectedValues;
 
   _UnorderedEquals(Iterable expected)
       : super(expected.map(equals)),
         _expectedValues = expected.toList();
 
-  Description describe(Description description) =>
-    description
-        .add('equals ')
-        .addDescriptionOf(_expectedValues)
-        .add(' unordered');
+  Description describe(Description description) => description
+      .add('equals ')
+      .addDescriptionOf(_expectedValues)
+      .add(' unordered');
 }
 
 /// Iterable matchers match against [Iterable]s. We add this intermediate
 /// class to give better mismatch error messages than the base Matcher class.
 abstract class _IterableMatcher extends Matcher {
   const _IterableMatcher();
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) {
+  Description describeMismatch(
+      item, Description mismatchDescription, Map matchState, bool verbose) {
     if (item is! Iterable) {
-      return mismatchDescription.
-          addDescriptionOf(item).
-          add(' not an Iterable');
+      return mismatchDescription.addDescriptionOf(item).add(' not an Iterable');
     } else {
-      return super.describeMismatch(item, mismatchDescription, matchState,
-          verbose);
+      return super.describeMismatch(
+          item, mismatchDescription, matchState, verbose);
     }
   }
 }
 
 /// Returns a matcher which matches [Iterable]s whose elements match the
 /// matchers in [expected], but not necessarily in the same order.
 ///
 ///  Note that this is `O(n^2)` and so should only be used on small objects.
 Matcher unorderedMatches(Iterable expected) => new _UnorderedMatches(expected);
 
@@ skipping 37 matching lines @@
             .toString();
       }
 
       ++expectedPosition;
     }
     return null;
   }
 
   bool matches(item, Map mismatchState) => _test(item) == null;
 
-  Description describe(Description description) =>
-    description
+  Description describe(Description description) => description
       .add('matches ')
       .addAll('[', ', ', ']', _expected)
       .add(' unordered');
 
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) =>
+  Description describeMismatch(
+      item, Description mismatchDescription, Map matchState, bool verbose) =>
       mismatchDescription.add(_test(item));
 }
 
 /// A pairwise matcher for [Iterable]s.
 ///
 /// The [comparator] function, taking an expected and an actual argument, and
 /// returning whether they match, will be applied to each pair in order.
 /// [description] should be a meaningful name for the comparator.
-Matcher pairwiseCompare(Iterable expected, bool comparator(a, b),
-    String description) =>
+Matcher pairwiseCompare(
+    Iterable expected, bool comparator(a, b), String description) =>
         new _PairwiseCompare(expected, comparator, description);
 
 typedef bool _Comparator(a, b);
 
 class _PairwiseCompare extends _IterableMatcher {
   final Iterable _expected;
   final _Comparator _comparator;
   final String _description;
 
   _PairwiseCompare(this._expected, this._comparator, this._description);
 
   bool matches(item, Map matchState) {
     if (item is! Iterable) return false;
     if (item.length != _expected.length) return false;
     var iterator = item.iterator;
     var i = 0;
     for (var e in _expected) {
       iterator.moveNext();
       if (!_comparator(e, iterator.current)) {
-        addStateInfo(matchState, {'index': i, 'expected': e,
-            'actual': iterator.current});
+        addStateInfo(matchState, {
+          'index': i,
+          'expected': e,
+          'actual': iterator.current
+        });
         return false;
       }
       i++;
     }
     return true;
   }
 
   Description describe(Description description) =>
       description.add('pairwise $_description ').addDescriptionOf(_expected);
 
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) {
-    if (item is !Iterable) {
+  Description describeMismatch(
+      item, Description mismatchDescription, Map matchState, bool verbose) {
+    if (item is! Iterable) {
       return mismatchDescription.add('is not an Iterable');
     } else if (item.length != _expected.length) {
-      return mismatchDescription.
-          add('has length ${item.length} instead of ${_expected.length}');
+      return mismatchDescription
+          .add('has length ${item.length} instead of ${_expected.length}');
     } else {
-      return mismatchDescription.
-          add('has ').
-          addDescriptionOf(matchState["actual"]).
-          add(' which is not $_description ').
-          addDescriptionOf(matchState["expected"]).
-          add(' at index ${matchState["index"]}');
+      return mismatchDescription
+          .add('has ')
+          .addDescriptionOf(matchState["actual"])
+          .add(' which is not $_description ')
+          .addDescriptionOf(matchState["expected"])
+          .add(' at index ${matchState["index"]}');
     }
   }
 }