Roll Observatory packages and add a roll script

petitparser/lib/src/core/repeaters.dart

Index: petitparser/lib/src/core/repeaters.dart
diff --git a/petitparser/lib/src/core/repeaters.dart b/petitparser/lib/src/core/repeaters.dart
deleted file mode 100644
index 79c8cd1b81801df77f5754da592d195e05a6a564..0000000000000000000000000000000000000000
--- a/petitparser/lib/src/core/repeaters.dart
+++ /dev/null
@@ -1,185 +0,0 @@
-part of petitparser;
-
-/**
- * An [int] used to mark an unbounded maximum repetition.
- */
-const int unbounded = -1;
-
-/**
- * An abstract parser that repeatedly parses between 'min' and 'max' instances of
- * its delegate.
- */
-abstract class RepeatingParser extends DelegateParser {
-  final int _min;
-  final int _max;
-
-  RepeatingParser(Parser parser, this._min, this._max) : super(parser) {
-    assert(0 <= _min);
-    assert(_max == unbounded || _min <= _max);
-  }
-
-  @override
-  String toString() {
-    var max = _max == unbounded ? '*' : _max;
-    return '${super.toString()}[$_min..$max]';
-  }
-
-  @override
-  bool hasEqualProperties(Parser other) {
-    return other is RepeatingParser
-        && super.hasEqualProperties(other)
-        && _min == other._min
-        && _max == other._max;
-  }
-}
-
-/**
- * A greedy parser that repeatedly parses between 'min' and 'max' instances of
- * its delegate.
- */
-class PossessiveRepeatingParser extends RepeatingParser {
-  PossessiveRepeatingParser(Parser parser, int min, int max)
-      : super(parser, min, max);
-
-  @override
-  Result parseOn(Context context) {
-    var current = context;
-    var elements = new List();
-    while (elements.length < _min) {
-      var result = _delegate.parseOn(current);
-      if (result.isFailure) {
-        return result;
-      }
-      elements.add(result.value);
-      current = result;
-    }
-    while (_max == unbounded || elements.length < _max) {
-      var result = _delegate.parseOn(current);
-      if (result.isFailure) {
-        return current.success(elements);
-      }
-      elements.add(result.value);
-      current = result;
-    }
-    return current.success(elements);
-  }
-
-  @override
-  Parser copy() => new PossessiveRepeatingParser(_delegate, _min, _max);
-}
-
-/**
- * An abstract parser that repeatedly parses between 'min' and 'max' instances of
- * its delegate and that requires the input to be completed with a specified parser
- * 'limit'. Subclasses provide repeating behavior as typically seen in regular
- * expression implementations (non-blind).
- */
-abstract class LimitedRepeatingParser extends RepeatingParser {
-  Parser _limit;
-
-  LimitedRepeatingParser(Parser parser, this._limit, int min, int max)
-      : super(parser, min, max);
-
-  @override
-  List<Parser> get children => [_delegate, _limit];
-
-  @override
-  void replace(Parser source, Parser target) {
-    super.replace(source, target);
-    if (_limit == source) {
-      _limit = target;
-    }
-  }
-}
-
-/**
- * A greedy repeating parser, commonly seen in regular expression implementations. It
- * aggressively consumes as much input as possible and then backtracks to meet the
- * 'limit' condition.
- */
-class GreedyRepeatingParser extends LimitedRepeatingParser {
-  GreedyRepeatingParser(Parser parser, Parser limit, int min, int max)
-      : super(parser, limit, min, max);
-
-  @override
-  Result parseOn(Context context) {
-    var current = context;
-    var elements = new List();
-    while (elements.length < _min) {
-      var result = _delegate.parseOn(current);
-      if (result.isFailure) {
-        return result;
-      }
-      elements.add(result.value);
-      current = result;
-    }
-    var contexts = new List.from([current]);
-    while (_max == unbounded || elements.length < _max) {
-      var result = _delegate.parseOn(current);
-      if (result.isFailure) {
-        break;
-      }
-      elements.add(result.value);
-      contexts.add(current = result);
-    }
-    while (true) {
-      var limit = _limit.parseOn(contexts.last);
-      if (limit.isSuccess) {
-        return contexts.last.success(elements);
-      }
-      if (elements.isEmpty) {
-        return limit;
-      }
-      contexts.removeLast();
-      elements.removeLast();
-      if (contexts.isEmpty) {
-        return limit;
-      }
-    }
-  }
-
-  @override
-  Parser copy() => new GreedyRepeatingParser(_delegate, _limit, _min, _max);
-}
-
-/**
- * A lazy repeating parser, commonly seen in regular expression implementations. It
- * limits its consumption to meet the 'limit' condition as early as possible.
- */
-class LazyRepeatingParser extends LimitedRepeatingParser {
-  LazyRepeatingParser(Parser parser, Parser limit, int min, int max)
-      : super(parser, limit, min, max);
-
-  @override
-  Result parseOn(Context context) {
-    var current = context;
-    var elements = new List();
-    while (elements.length < _min) {
-      var result = _delegate.parseOn(current);
-      if (result.isFailure) {
-        return result;
-      }
-      elements.add(result.value);
-      current = result;
-    }
-    while (true) {
-      var limit = _limit.parseOn(current);
-      if (limit.isSuccess) {
-        return current.success(elements);
-      } else {
-        if (_max != unbounded && elements.length >= _max) {
-          return limit;
-        }
-        var result = _delegate.parseOn(current);
-        if (result.isFailure) {
-          return limit;
-        }
-        elements.add(result.value);
-        current = result;
-      }
-    }
-  }
-
-  @override
-  Parser copy() => new LazyRepeatingParser(_delegate, _limit, _min, _max);
-}