matcher: fixed status file, formatting, tweaks to readme

lib/src/core_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.core_matchers;
 
 import 'description.dart';
 import 'interfaces.dart';
 import 'util.dart';
 
@@ skipping 88 matching lines @@
 
 /// Returns a matcher that matches if the value is structurally equal to
 /// [expected].
 ///
 /// If [expected] is a [Matcher], then it matches using that. Otherwise it tests
 /// for equality using `==` on the expected value.
 ///
 /// For [Iterable]s and [Map]s, this will recursively match the elements. To
 /// handle cyclic structures a recursion depth [limit] can be provided. The
 /// default limit is 100. [Set]s will be compared order-independently.
-Matcher equals(expected, [int limit=100]) =>
-    expected is String
-        ? new _StringEqualsMatcher(expected)
-        : new _DeepMatcher(expected, limit);
+Matcher equals(expected, [int limit = 100]) => expected is String
+    ? new _StringEqualsMatcher(expected)
+    : new _DeepMatcher(expected, limit);
 
 class _DeepMatcher extends Matcher {
   final _expected;
   final int _limit;
   var count;
 
   _DeepMatcher(this._expected, [int limit = 1000]) : this._limit = limit;
 
   // Returns a pair (reason, location)
   List _compareIterables(expected, actual, matcher, depth, location) {
     if (actual is! Iterable) return ['is not Iterable', location];
 
     var expectedIterator = expected.iterator;
     var actualIterator = actual.iterator;
     for (var index = 0; ; index++) {
       // Advance in lockstep.
       var expectedNext = expectedIterator.moveNext();
       var actualNext = actualIterator.moveNext();
 
       // If we reached the end of both, we succeeded.
       if (!expectedNext && !actualNext) return null;
 
       // Fail if their lengths are different.
       var newLocation = '${location}[${index}]';
       if (!expectedNext) return ['longer than expected', newLocation];
       if (!actualNext) return ['shorter than expected', newLocation];
 
       // Match the elements.
-      var rp = matcher(expectedIterator.current, actualIterator.current,
-          newLocation, depth);
+      var rp = matcher(
+          expectedIterator.current, actualIterator.current, newLocation, depth);
       if (rp != null) return rp;
     }
   }
 
   List _compareSets(Set expected, actual, matcher, depth, location) {
     if (actual is! Iterable) return ['is not Iterable', location];
     actual = actual.toSet();
 
     for (var expectedElement in expected) {
       if (actual.every((actualElement) =>
@@ skipping 17 matching lines @@
       var matchState = {};
       if (expected.matches(actual, matchState)) return null;
 
       var description = new StringDescription();
       expected.describe(description);
       return ['does not match $description', location];
     } else {
       // Otherwise, test for equality.
       try {
         if (expected == actual) return null;
-      } catch (e, s) {
+      } catch (e) {
         // TODO(gram): Add a test for this case.
         return ['== threw "$e"', location];
       }
     }
 
     if (depth > _limit) return ['recursion depth limit exceeded', location];
 
     // If _limit is 1 we can only recurse one level into object.
     if (depth == 0 || _limit > 1) {
       if (expected is Set) {
-        return _compareSets(expected, actual, _recursiveMatch, depth + 1,
-            location);
+        return _compareSets(
+            expected, actual, _recursiveMatch, depth + 1, location);
       } else if (expected is Iterable) {
-        return _compareIterables(expected, actual, _recursiveMatch, depth + 1,
-            location);
+        return _compareIterables(
+            expected, actual, _recursiveMatch, depth + 1, location);
       } else if (expected is Map) {
         if (actual is! Map) return ['expected a map', location];
 
-        var err = (expected.length == actual.length) ? '' :
-                  'has different length and ';
+        var err = (expected.length == actual.length)
+            ? ''
+            : 'has different length and ';
         for (var key in expected.keys) {
           if (!actual.containsKey(key)) {
             return ["${err}is missing map key '$key'", location];
           }
         }
 
         for (var key in actual.keys) {
           if (!expected.containsKey(key)) {
             return ["${err}has extra map key '$key'", location];
           }
         }
 
         for (var key in expected.keys) {
-          var rp = _recursiveMatch(expected[key], actual[key],
-              "${location}['${key}']", depth + 1);
+          var rp = _recursiveMatch(
+              expected[key], actual[key], "${location}['${key}']", depth + 1);
           if (rp != null) return rp;
         }
 
         return null;
       }
     }
 
     var description = new StringDescription();
 
     // If we have recursed, show the expected value too; if not, expect() will
     // show it for us.
     if (depth > 0) {
-      description.add('was ').
-          addDescriptionOf(actual).
-          add(' instead of ').
-          addDescriptionOf(expected);
+      description
+          .add('was ')
+          .addDescriptionOf(actual)
+          .add(' instead of ')
+          .addDescriptionOf(expected);
       return [description.toString(), location];
     }
 
     // We're not adding any value to the actual value.
     return ["", location];
   }
 
   String _match(expected, actual, Map matchState) {
     var rp = _recursiveMatch(expected, actual, '', 0);
     if (rp == null) return null;
     var reason;
     if (rp[0].length > 0) {
       if (rp[1].length > 0) {
         reason = "${rp[0]} at location ${rp[1]}";
       } else {
         reason = rp[0];
       }
     } else {
       reason = '';
     }
     // Cache the failure reason in the matchState.
     addStateInfo(matchState, {'reason': reason});
     return reason;
   }
 
   bool matches(item, Map matchState) =>
       _match(_expected, item, matchState) == null;
 
   Description describe(Description description) =>
-    description.addDescriptionOf(_expected);
+      description.addDescriptionOf(_expected);
 
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) {
+  Description describeMismatch(
+      item, Description mismatchDescription, Map matchState, bool verbose) {
     var reason = matchState['reason'];
     // If we didn't get a good reason, that would normally be a
     // simple 'is <value>' message. We only add that if the mismatch
     // description is non empty (so we are supplementing the mismatch
     // description).
     if (reason.length == 0 && mismatchDescription.length > 0) {
       mismatchDescription.add('is ').addDescriptionOf(item);
     } else {
       mismatchDescription.add(reason);
     }
     return mismatchDescription;
   }
 }
 
 /// A special equality matcher for strings.
 class _StringEqualsMatcher extends Matcher {
   final String _value;
 
   _StringEqualsMatcher(this._value);
 
   bool get showActualValue => true;
 
   bool matches(item, Map matchState) => _value == item;
 
   Description describe(Description description) =>
       description.addDescriptionOf(_value);
 
-  Description describeMismatch(item, Description mismatchDescription,
-      Map matchState, bool verbose) {
+  Description describeMismatch(
+      item, Description mismatchDescription, Map matchState, bool verbose) {
     if (item is! String) {
       return mismatchDescription.addDescriptionOf(item).add('is not a string');
     } else {
       var buff = new StringBuffer();
       buff.write('is different.');
       var escapedItem = _escape(item);
       var escapedValue = _escape(_value);
-      int minLength = escapedItem.length < escapedValue.length ?
-          escapedItem.length : escapedValue.length;
+      int minLength = escapedItem.length < escapedValue.length
+          ? escapedItem.length
+          : escapedValue.length;
       int start;
       for (start = 0; start < minLength; start++) {
         if (escapedValue.codeUnitAt(start) != escapedItem.codeUnitAt(start)) {
           break;
         }
       }
       if (start == minLength) {
         if (escapedValue.length < escapedItem.length) {
           buff.write(' Both strings start the same, but the given value also'
               ' has the following trailing characters: ');
@@ skipping 96 matching lines @@
       return true;
     } catch (e, s) {
       addStateInfo(matchState, {'exception': e, 'stack': s});
       return false;
     }
   }
 
   Description describe(Description description) =>
       description.add("return normally");
 
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState,
-                               bool verbose) {
+  Description describeMismatch(
+      item, Description mismatchDescription, Map matchState, bool verbose) {
     mismatchDescription.add('threw ').addDescriptionOf(matchState['exception']);
     if (verbose) {
       mismatchDescription.add(' at ').add(matchState['stack'].toString());
     }
     return mismatchDescription;
   }
 }
 
 /*
  * Matchers for different exception types. Ideally we should just be able to
@@ skipping 51 matching lines @@
       // This is harmless code that will throw if no length property
       // but subtle enough that an optimizer shouldn't strip it out.
       if (item.length * item.length >= 0) {
         return _matcher.matches(item.length, matchState);
       }
     } catch (e) {}
     return false;
   }
 
   Description describe(Description description) =>
-    description.add('an object with length of ').
-        addDescriptionOf(_matcher);
+      description.add('an object with length of ').addDescriptionOf(_matcher);
 
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) {
+  Description describeMismatch(
+      item, Description mismatchDescription, Map matchState, bool verbose) {
     try {
       // We want to generate a different description if there is no length
       // property; we use the same trick as in matches().
       if (item.length * item.length >= 0) {
-        return mismatchDescription.add('has length of ').
-            addDescriptionOf(item.length);
+        return mismatchDescription
+            .add('has length of ')
+            .addDescriptionOf(item.length);
       }
     } catch (e) {}
     return mismatchDescription.add('has no length property');
   }
 }
 
 /// Returns a matcher that matches if the match argument contains the expected
 /// value.
 ///
 /// For [String]s this means substring matching;
@@ skipping 18 matching lines @@
       }
     } else if (item is Map) {
       return item.containsKey(_expected);
     }
     return false;
   }
 
   Description describe(Description description) =>
       description.add('contains ').addDescriptionOf(_expected);
 
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) {
+  Description describeMismatch(
+      item, Description mismatchDescription, Map matchState, bool verbose) {
     if (item is String || item is Iterable || item is Map) {
-      return super.describeMismatch(item, mismatchDescription, matchState,
-          verbose);
+      return super.describeMismatch(
+          item, mismatchDescription, matchState, verbose);
     } else {
       return mismatchDescription.add('is not a string, map or iterable');
     }
   }
 }
 
 /// Returns a matcher that matches if the match argument is in
 /// the expected value. This is the converse of [contains].
 Matcher isIn(expected) => new _In(expected);
 
@@ skipping 73 matching lines @@
   bool matches(item, Map matchState) {
     var f = featureValueOf(item);
     if (_matcher.matches(f, matchState)) return true;
     addStateInfo(matchState, {'feature': f});
     return false;
   }
 
   Description describe(Description description) =>
       description.add(_featureDescription).add(' ').addDescriptionOf(_matcher);
 
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) {
-    mismatchDescription.add('has ').add(_featureName).add(' with value ').
-        addDescriptionOf(matchState['feature']);
+  Description describeMismatch(
+      item, Description mismatchDescription, Map matchState, bool verbose) {
+    mismatchDescription
+        .add('has ')
+        .add(_featureName)
+        .add(' with value ')
+        .addDescriptionOf(matchState['feature']);
     var innerDescription = new StringDescription();
-    _matcher.describeMismatch(matchState['feature'], innerDescription,
-        matchState['state'], verbose);
+    _matcher.describeMismatch(
+        matchState['feature'], innerDescription, matchState['state'], verbose);
     if (innerDescription.length > 0) {
       mismatchDescription.add(' which ').add(innerDescription.toString());
     }
     return mismatchDescription;
   }
 }