expose MDV addBindings

tools/dom/src/TemplateBindings.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 html;
 
 // This code is a port of Model-Driven-Views:
-// https://github.com/toolkitchen/mdv
+// https://github.com/polymer-project/mdv
 // The code mostly comes from src/template_element.js
 
 typedef void _ChangeHandler(value);
 
 /**
  * Model-Driven Views (MDV)'s native features enables a wide-range of use cases,
  * but (by design) don't attempt to implement a wide array of specialized
  * behaviors.
  *
  * Enabling these features in MDV is a matter of implementing and registering an
@@ skipping 11 matching lines @@
  *     class MySyntax extends CustomBindingSyntax {
  *       getBinding(model, path, name, node) {
  *         // The magic happens here!
  *       }
  *     }
  *
  *     ...
  *
  *     TemplateElement.syntax['MySyntax'] = new MySyntax();
  *
- * See <https://github.com/toolkitchen/mdv/blob/master/docs/syntax.md> for more
+ * See <https://github.com/polymer-project/mdv/blob/master/docs/syntax.md> for more
  * information about Custom Syntax.
  */
 // TODO(jmesserly): if this is just one method, a function type would make it
 // more Dart-friendly.
 @Experimental
 abstract class CustomBindingSyntax {
   /**
    * This syntax method allows for a custom interpretation of the contents of
    * mustaches (`{{` ... `}}`).
    *
@@ skipping 301 matching lines @@
     if (node == document || node.parentNode == document) return true;
     return document.documentElement.contains(node);
   }
 }
 
 class _Bindings {
   // TODO(jmesserly): not sure what kind of boolean conversion rules to
   // apply for template data-binding. HTML attributes are true if they're
   // present. However Dart only treats "true" as true. Since this is HTML we'll
   // use something closer to the HTML rules: null (missing) and false are false,
-  // everything else is true. See: https://github.com/toolkitchen/mdv/issues/59
+  // everything else is true. See: https://github.com/polymer-project/mdv/issues/59
   static bool _toBoolean(value) => null != value && false != value;
 
   static Node _createDeepCloneAndDecorateTemplates(Node node, String syntax) {
     var clone = node.clone(false); // Shallow clone.
     if (clone is Element && clone.isTemplate) {
       TemplateElement.decorate(clone, node);
       if (syntax != null) {
         clone.attributes.putIfAbsent('syntax', () => syntax);
       }
     }
@@ skipping 113 matching lines @@
   }
 
   static void _parseAndBind(Node node, String name, String text, model,
       CustomBindingSyntax syntax) {
 
     var tokens = _parseMustacheTokens(text);
     if (tokens.length == 0 || (tokens.length == 1 && tokens[0].isText)) {
       return;
     }
 
+    // If this is a custom element, give the .xtag a change to bind.
+    node = _nodeOrCustom(node);
+
     if (tokens.length == 1 && tokens[0].isBinding) {
       _bindOrDelegate(node, name, model, tokens[0].value, syntax);
       return;
     }
 
     var replacementBinding = new CompoundBinding();
     for (var i = 0; i < tokens.length; i++) {
       var token = tokens[i];
       if (token.isBinding) {
         _bindOrDelegate(replacementBinding, i, model, token.value, syntax);
@@ skipping 11 matching lines @@
           var value = values[i];
           if (value != null) {
             newValue.write(value);
           }
         }
       }
 
       return newValue.toString();
     };
 
-    _nodeOrCustom(node).bind(name, replacementBinding, 'value');
+    node.bind(name, replacementBinding, 'value');
   }
 
   static void _bindOrDelegate(node, name, model, String path,
       CustomBindingSyntax syntax) {
 
     if (syntax != null) {
       var delegateBinding = syntax.getBinding(model, path, name, node);
       if (delegateBinding != null) {
         model = delegateBinding;
         path = 'value';
       }
     }
 
-    _nodeOrCustom(node).bind(name, model, path);
+    node.bind(name, model, path);
   }
 
   /**
    * Gets the [node]'s custom [Element.xtag] if present, otherwise returns
    * the node. This is used so nodes can override [Node.bind], [Node.unbind],
    * and [Node.unbindAll] like InputElement does.
    */
   // TODO(jmesserly): remove this when we can extend Element for real.
   static _nodeOrCustom(node) => node is Element ? node.xtag : node;
 
@@ skipping 224 matching lines @@
     _sub.cancel();
     _sub = null;
   }
 
   void abandon() {
     unobserve();
     _valueBinding.cancel();
     inputs.dispose();
   }
 }