big update to observe, template_binding, polymer

pkg/observe/lib/src/observable_list.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.
 
 library observe.src.observable_list;
 
 import 'dart:async';
 import 'dart:collection' show ListBase, UnmodifiableListView;
 import 'package:observe/observe.dart';
 import 'list_diff.dart' show projectListSplices, calcSplices;
@@ skipping 237 matching lines @@
     }
     _listRecords.add(record);
   }
 
   void _notifyChangeLength(int oldValue, int newValue) {
     notifyPropertyChange(#length, oldValue, newValue);
     notifyPropertyChange(#isEmpty, oldValue == 0, newValue == 0);
     notifyPropertyChange(#isNotEmpty, oldValue != 0, newValue != 0);
   }
 
+  void discardListChages() {
+    // Leave _listRecords set so we don't schedule another delivery.
+    if (_listRecords != null) _listRecords = [];
+  }
+
   bool deliverListChanges() {
     if (_listRecords == null) return false;
     var records = projectListSplices(this, _listRecords);
     _listRecords = null;
 
-    if (_hasListObservers) {
+    if (_hasListObservers && !records.isEmpty) {
       _listChanges.add(new UnmodifiableListView<ListChangeRecord>(records));
       return true;
     }
     return false;
   }
 
   /**
    * Calculates the changes to the list, if lacking individual splice mutation
    * information.
    *
    * This is not needed for change records produced by [ObservableList] itself,
    * but it can be used if the list instance was replaced by another list.
    *
    * The minimal set of splices can be synthesized given the previous state and
    * final state of a list. The basic approach is to calculate the edit distance
    * matrix and choose the shortest path through it.
    *
    * Complexity is `O(l * p)` where `l` is the length of the current list and
    * `p` is the length of the old list.
    */
   static List<ListChangeRecord> calculateChangeRecords(
       List<Object> oldValue, List<Object> newValue) =>
       calcSplices(newValue, 0, newValue.length, oldValue, 0, oldValue.length);
+
+  /**
+   * Updates the [previous] list using the change [records]. For added items,
+   * the [current] list is used to find the current value.
+   */
+  static void applyChangeRecords(List<Object> previous, List<Object> current,
+      List<ListChangeRecord> changeRecords) {
+
+    if (identical(previous, current)) {
+      throw new ArgumentError("can't use same list for previous and current");
+    }
+
+    for (var change in changeRecords) {
+      int addEnd = change.index + change.addedCount;
+      int removeEnd = change.index + change.removed.length;
+
+      var addedItems = current.getRange(change.index, addEnd);
+      previous.replaceRange(change.index, removeEnd, addedItems);
+    }
+  }
 }