Make sure 'enumerate' changes when the underlying collection changes.

pkg/polymer_expressions/lib/src/globals.dart

 // Copyright (c) 2013, 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.
 
 /**
  * Contains functions that are included by default in [PolymerExpressions].
  *
  *   - [enumerate]: a convenient way to iterate over items and the indexes.
  */
 // Code from https://github.com/google/quiver-dart/commit/52edc4baf37e99ff6a8f99c648b29b135fc0b880

[Jennifer Messerly, 2013/11/13 23:51:45]

this comment seems wrong now :)

 library polymer_expressions.src.globals;
 
-import 'dart:collection';
-import 'package:observe/observe.dart' show reflectable;
+import 'package:logging/logging.dart';
+import 'package:observe/observe.dart';
 
 /**
  * Returns an [Iterable] of [IndexedValue]s where the nth value holds the nth
  * element of [iterable] and its index.
  */
-Iterable<IndexedValue> enumerate(Iterable iterable) =>
-    new EnumerateIterable(iterable);
+Iterable<IndexedValue> enumerate(Iterable iterable) {
+  var i = 0;
+  var result = iterable.map((e) => new IndexedValue(i++, e));

[Jennifer Messerly, 2013/11/13 23:51:45]

I don't think this works. It looks awfully like a bug I fixed :)

here's the issue: if you iterate over the same iterable twice, the "i" doesn't
reset, so it keeps counting up. That's the reason why I wrote EnumerateIterable
by hand ... not just for the fun of it ;)

[Jennifer Messerly, 2013/11/13 23:53:42]

original context:
https://github.com/google/quiver-dart/pull/39

+  if (iterable is! ObservableList) return result;
 
-@reflectable class IndexedValue<V> {
-  final int index;
-  final V value;
+  result = new ObservableList.from(result);
+  (iterable as ObservableList).listChanges.listen(
+      (changes) => _propagateChange(iterable, result, changes));
+  return result;
+}
+
+class IndexedValue<V> {

[Jennifer Messerly, 2013/11/13 23:51:45]

should mixin Observable or probably ChangeNotifier

since this object is so simple, ChangeNotifier would be good, that way you can
make "index" setter private, e.g.

int _index

get index => _index;
_setIndex(i) {
  _index = notifyPropertyChange(#index, _index, i);
}

+  @observable int index;

[Jennifer Messerly, 2013/11/13 23:51:45]

make this immutable? so people don't accidentally two-way bind it

+  @reflectable final V value;
 
   IndexedValue(this.index, this.value);
 }
 
-/**
- * An [Iterable] of [IndexedValue]s where the nth value holds the nth
- * element of [iterable] and its index. See [enumerate].
- */
-// This was inspired by MappedIterable internal to Dart collections.
-class EnumerateIterable<V> extends IterableBase<IndexedValue<V>> {
-  final Iterable<V> _iterable;
+final _logger = new Logger('polymer_expressions');
 
-  EnumerateIterable(this._iterable);
+void _propagateChange(ObservableList original, ObservableList target,
+    List<ListChangeRecord> changes) {
+  // TODO(sigmund): maybe we can expose ObservableList._hasListObservers so we

[Jennifer Messerly, 2013/11/13 23:51:45]

problem is, you'd need the pair of observed/unobserved events on the object
you're returning, so you can register/unregister on the source observable list

+  // can skip this work when nobody is listening?
 
-  Iterator<IndexedValue<V>> get iterator =>
-      new EnumerateIterator<V>(_iterable.iterator);
+  for (var change in changes) {
+    var index = change.index; 
+    var added = change.addedCount; 
+    var removed = change.removed.length; 
+    if (index < 0 || index > target.length) {
+      _logger.error('enumerate filter seems to be in an inconsistent state. '
+          'Please report an error at dartbug.com/new with some information '
+          'to help us reproduce the problem.');
+      return;
+    }
+    
+    // Apply the same changes on our view of the original list:
+    target.removeRange(index, index + removed);
+    for (int i = added - 1; i >= 0; i--) {
+      target.insert(index, new IndexedValue(index + i, original[index + i]));
+    }
 
-  // Length related functions are independent of the mapping.
-  int get length => _iterable.length;
-  bool get isEmpty => _iterable.isEmpty;
+    // Update indices of the later [IndexedValue]s, if necessary.
+    if (added == removed) continue;
 
-  // Index based lookup can be done before transforming.
-  IndexedValue<V> get first => new IndexedValue<V>(0, _iterable.first);
-  IndexedValue<V> get last => new IndexedValue<V>(length - 1, _iterable.last);
-  IndexedValue<V> get single => new IndexedValue<V>(0, _iterable.single);
-  IndexedValue<V> elementAt(int index) =>
-      new IndexedValue<V>(index, _iterable.elementAt(index));
-}
-
-/** The [Iterator] returned by [EnumerateIterable.iterator]. */
-class EnumerateIterator<V> extends Iterator<IndexedValue<V>> {
-  final Iterator<V> _iterator;
-  int _index = 0;
-  IndexedValue<V> _current;
-
-  EnumerateIterator(this._iterator);
-
-  IndexedValue<V> get current => _current;
-
-  bool moveNext() {
-    if (_iterator.moveNext()) {
-      _current = new IndexedValue(_index++, _iterator.current);
-      return true;
+    for (int i = index + added; i < target.length; i++) {
+      target[i].index = i;
     }
-    _current = null;
-    return false;
   }
 }