matcher: fixed status file, formatting, tweaks to readme

lib/src/string_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.string_matchers;
 
 import 'interfaces.dart';
 
 /// Returns a matcher which matches if the match argument is a string and
 /// is equal to [value] when compared case-insensitively.
@@ skipping 39 matching lines @@
   final String _matchValue;
 
   _IsEqualIgnoringWhitespace(String value)
       : _value = value,
         _matchValue = collapseWhitespace(value);
 
   bool matches(item, Map matchState) =>
       item is String && _matchValue == collapseWhitespace(item);
 
   Description describe(Description description) =>
-    description.addDescriptionOf(_matchValue).add(' ignoring whitespace');
+      description.addDescriptionOf(_matchValue).add(' ignoring whitespace');
 
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) {
+  Description describeMismatch(
+      item, Description mismatchDescription, Map matchState, bool verbose) {
     if (item is String) {
-      return mismatchDescription.add('is ').
-          addDescriptionOf(collapseWhitespace(item)).
-          add(' with whitespace compressed');
+      return mismatchDescription
+          .add('is ')
+          .addDescriptionOf(collapseWhitespace(item))
+          .add(' with whitespace compressed');
     } else {
-      return super.describeMismatch(item, mismatchDescription,
-          matchState, verbose);
+      return super.describeMismatch(
+          item, mismatchDescription, matchState, verbose);
     }
   }
 }
 
 /// Returns a matcher that matches if the match argument is a string and
 /// starts with [prefixString].
 Matcher startsWith(String prefixString) => new _StringStartsWith(prefixString);
 
 class _StringStartsWith extends _StringMatcher {
   final String _prefix;
@@ skipping 42 matching lines @@
       return false;
     }
     var from_index = 0;
     for (var s in _substrings) {
       from_index = item.indexOf(s, from_index);
       if (from_index < 0) return false;
     }
     return true;
   }
 
-  Description describe(Description description) =>
-      description.addAll('a string containing ', ', ', ' in order',
-                                                  _substrings);
+  Description describe(Description description) => description.addAll(
+      'a string containing ', ', ', ' in order', _substrings);
 }
 
 /// Returns a matcher that matches if the match argument is a string and
 /// matches the regular expression given by [re].
 ///
 /// [re] can be a [RegExp] instance or a [String]; in the latter case it will be
 /// used to create a RegExp instance.
 Matcher matches(re) => new _MatchesRegExp(re);
 
 class _MatchesRegExp extends _StringMatcher {
   RegExp _regexp;
 
   _MatchesRegExp(re) {
     if (re is String) {
       _regexp = new RegExp(re);
     } else if (re is RegExp) {
       _regexp = re;
     } else {
       throw new ArgumentError('matches requires a regexp or string');
     }
   }
 
   bool matches(item, Map matchState) =>
-    item is String ? _regexp.hasMatch(item) : false;
+      item is String ? _regexp.hasMatch(item) : false;
 
   Description describe(Description description) =>
       description.add("match '${_regexp.pattern}'");
 }
 
 // String matchers match against a string. We add this intermediate
 // class to give better mismatch error messages than the base Matcher class.
 abstract class _StringMatcher extends Matcher {
   const _StringMatcher();
-  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(' not a string');
+      return mismatchDescription.addDescriptionOf(item).add(' not a string');
     } else {
-      return super.describeMismatch(item, mismatchDescription,
-          matchState, verbose);
+      return super.describeMismatch(
+          item, mismatchDescription, matchState, verbose);
     }
   }
 }
 
 /// Utility function to collapse whitespace runs to single spaces
 /// and strip leading/trailing whitespace.
 String collapseWhitespace(String string) {
   var result = new StringBuffer();
   var skipSpace = true;
   for (var i = 0; i < string.length; i++) {
     var character = string[i];
     if (_isWhitespace(character)) {
       if (!skipSpace) {
         result.write(' ');
         skipSpace = true;
       }
     } else {
       result.write(character);
       skipSpace = false;
     }
   }
   return result.toString().trim();
 }
 
 bool _isWhitespace(String ch) =>
     ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';