automatically clean up CompoundBinding

pkg/observe/lib/src/compound_binding.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.
 
 part of observe;
 
 /** The callback used in the [CompoundBinding.combinator] field. */
 typedef Object CompoundBindingCombinator(Map objects);
 
 /**
@@ skipping 14 matching lines @@
  *     binding.bind('name2', obj2, path2);
  *     //...
  *     binding.bind('nameN', objN, pathN);
  */
 // TODO(jmesserly): rename to something that indicates it's a computed value?
 class CompoundBinding extends ChangeNotifierBase {
   CompoundBindingCombinator _combinator;
 
   // TODO(jmesserly): ideally these would be String keys, but sometimes we
   // use integers.
-  Map<dynamic, StreamSubscription> _bindings = new Map();
+  Map<dynamic, StreamSubscription> _observers = new Map();
   Map _values = new Map();
   bool _scheduled = false;
-  bool _disposed = false;
   Object _value;
 
   CompoundBinding([CompoundBindingCombinator combinator]) {
     // TODO(jmesserly): this is a tweak to the original code, it seemed to me
     // that passing the combinator to the constructor should be equivalent to
     // setting it via the property.
     // I also added a null check to the combinator setter.
     this.combinator = combinator;
   }
 
   CompoundBindingCombinator get combinator => _combinator;
 
   set combinator(CompoundBindingCombinator combinator) {
     _combinator = combinator;
     if (combinator != null) _scheduleResolve();
   }
 
   static const _VALUE = const Symbol('value');
 
   get value => _value;
 
-  int get length => _bindings.length;
+  int get length => _observers.length;
 
   void set value(newValue) {
     _value = notifyPropertyChange(_VALUE, _value, newValue);
   }
 
   void bind(name, model, String path) {
     unbind(name);
 
-     // TODO(jmesserly): should we avoid observing until we are observed,
-     // similar to PathObserver? Similar for unobserving?
-    _bindings[name] = new PathObserver(model, path).bindSync((value) {
+     // TODO(jmesserly): should we delay observing until we are observed,
+     // similar to PathObserver?
+    _observers[name] = new PathObserver(model, path).bindSync((value) {
       _values[name] = value;
       _scheduleResolve();
     });
   }
 
   void unbind(name, {bool suppressResolve: false}) {
-    var binding = _bindings.remove(name);
+    var binding = _observers.remove(name);
     if (binding == null) return;
 
     binding.cancel();
     _values.remove(name);
     if (!suppressResolve) _scheduleResolve();
   }
 
   // TODO(rafaelw): Is this the right processing model?
   // TODO(rafaelw): Consider having a seperate ChangeSummary for
   // CompoundBindings so to excess dirtyChecks.
   void _scheduleResolve() {
     if (_scheduled) return;
     _scheduled = true;
     runAsync(resolve);
   }
 
   void resolve() {
-    if (_disposed) return;
+    if (_observers.isEmpty) return;
     _scheduled = false;
 
     if (_combinator == null) {
       throw new StateError(
           'CompoundBinding attempted to resolve without a combinator');
     }
 
     value = _combinator(_values);
   }
 
-  void dispose() {
-    for (var binding in _bindings.values) {
+  /**
+   * Closes the observer.
+   *
+   * This happens automatically if the [value] property is no longer observed,
+   * but this can also be called explicitly.
+   */
+  void close() {
+    for (var binding in _observers.values) {
       binding.cancel();
     }
-    _bindings.clear();
+    _observers.clear();
     _values.clear();
-
-    _disposed = true;
     value = null;
   }
+
+  _unobserved() => close();
 }