Update charted to 0.4.8 and roll

packages/matcher/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';
 
 /// Returns a matcher which matches [Iterable]s in which all elements
 /// match the given [matcher].
 Matcher everyElement(matcher) => new _EveryElement(wrapMatcher(matcher));
 
 class _EveryElement extends _IterableMatcher {
@@ skipping 33 matching lines @@
           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 59 matching lines @@
 
 /// 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) {
     if (item is! 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 42 matching lines @@
     return null;
   }
 
   bool matches(item, Map mismatchState) => _test(item) == null;
 
   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) =>
-        new _PairwiseCompare(expected, comparator, description);
+        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) {
       return mismatchDescription.add('is not an Iterable');
     } else if (item.length != _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"]}');
     }
   }
 }
+
+/// Matches [Iterable]s which contain an element matching every value in
+/// [expected] in the same order, but may contain additional values interleaved
+/// throughout.
+///
+/// For example: `[0, 1, 0, 2, 0]` matches `containsAllInOrder([1, 2])` but not
+/// `containsAllInOrder([2, 1])` or `containsAllInOrder([1, 2, 3])`.
+Matcher containsAllInOrder(Iterable expected) =>
+    new _ContainsAllInOrder(expected);
+
+class _ContainsAllInOrder implements Matcher {
+  final Iterable _expected;
+
+  _ContainsAllInOrder(this._expected);
+
+  String _test(item, Map matchState) {
+    if (item is! Iterable) return 'not an iterable';
+    var matchers = _expected.map(wrapMatcher).toList();
+    var matcherIndex = 0;
+    for (var value in item) {
+      if (matchers[matcherIndex].matches(value, matchState)) matcherIndex++;
+      if (matcherIndex == matchers.length) return null;
+    }
+    return new StringDescription()
+        .add('did not find a value matching ')
+        .addDescriptionOf(matchers[matcherIndex])
+        .add(' following expected prior values')
+        .toString();
+  }
+
+  @override
+  bool matches(item, Map matchState) => _test(item, matchState) == null;
+
+  @override
+  Description describe(Description description) => description
+      .add('contains in order(')
+      .addDescriptionOf(_expected)
+      .add(')');
+
+  @override
+  Description describeMismatch(item, Description mismatchDescription,
+          Map matchState, bool verbose) =>
+      mismatchDescription.add(_test(item, matchState));
+}