update polymer, nodebind, and templatebinding

pkg/template_binding/lib/src/template.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 template_binding;
 
 /** Extensions to [Element]s that behave as templates. */
 class TemplateBindExtension extends _ElementExtension {
   var _model;
   BindingDelegate _bindingDelegate;
   _TemplateIterator _iterator;
   bool _setModelScheduled = false;
 
   Element _templateInstanceRef;
 
   // Note: only used if `this is! TemplateElement`
   DocumentFragment _content;
   bool _templateIsDecorated;
 
   HtmlDocument _stagingDocument;
 
   _InstanceBindingMap _bindingMap;
 
+  Node _refContent;
+
   TemplateBindExtension._(Element node) : super(node);
 
   Element get _node => super._node;
 
   TemplateBindExtension get _self => super._node is TemplateBindExtension
       ? _node : this;
 
+  Bindable bind(String name, value, {bool oneTime: false}) {
+    if (name != 'ref') return super.bind(name, value, oneTime: oneTime);
+
+
+    var ref = oneTime ? value : value.open((ref) {
+      _node.attributes['ref'] = ref;
+      _refChanged();
+    });
+
+    _node.attributes['ref'] = ref;
+    _refChanged();
+    if (oneTime) return null;
+
+    return _updateBindings('ref', value);
+  }
+
   _TemplateIterator _processBindingDirectives(_TemplateBindingMap directives) {
     if (_iterator != null) _iterator._closeDependencies();
 
     if (directives._if == null &&
         directives._bind == null &&
         directives._repeat == null) {
 
       if (_iterator != null) {
         _iterator.close();
         _iterator = null;
-        bindings.remove('iterator');
       }
       return null;
     }
 
     if (_iterator == null) {
-      bindings['iterator'] = _iterator = new _TemplateIterator(this);
+      _iterator = new _TemplateIterator(this);
     }
 
     _iterator._updateDependencies(directives, model);
+
+    _templateObserver.observe(_node,
+        attributes: true, attributeFilter: ['ref']);
+
     return _iterator;
   }
 
   /**
    * Creates an instance of the template, using the provided [model] and
    * optional binding [delegate].
    *
    * If [instanceBindings] is supplied, each [Bindable] in the returned
    * instance will be added to the list. This makes it easy to close all of the
    * bindings without walking the tree. This is not normally necesssary, but is
    * used internally by the system.
    */
-  DocumentFragment createInstance([model, BindingDelegate delegate,
-      List<Bindable> instanceBindings]) {
+  DocumentFragment createInstance([model, BindingDelegate delegate]) {
+    if (delegate == null) delegate = _bindingDelegate;
+    if (_refContent == null) _refContent = templateBind(_ref).content;
 
-    final content = templateBind(ref).content;
-    // Dart note: we store _bindingMap on the TemplateBindExtension instead of
-    // the "content" because we already have an expando for it.
-    var map = _bindingMap;
-    if (map == null || !identical(map.content, content)) {
-      // TODO(rafaelw): Setup a MutationObserver on content to detect
-      // when the instanceMap is invalid.
-      map = _createInstanceBindingMap(content, delegate);
-      map.content = content;
-      _bindingMap = map;
-    }
+    var content = _refContent;
+    if (content.firstChild == null) return _emptyInstance;
 
+    final map = _getInstanceBindingMap(content, delegate);
     final staging = _getTemplateStagingDocument();
     final instance = _stagingDocument.createDocumentFragment();
-    _templateCreator[instance] = _node;
+
+    final instanceExt = new _InstanceExtension();
+    _instanceExtension[instance] = instanceExt;
+    instanceExt._templateCreator = _node;

[Siggi Cherem (dart-lang), 2014/06/03 17:41:03]

minor nit, might be worth using cascades for these:
final instanceExt = new _InstanceExtension()
    .._templateCreator = _node
    .._protoContent = content;

[Jennifer Messerly, 2014/06/04 04:42:17]

sure.

+    instanceExt._protoContent = content;
 
     final instanceRecord = new TemplateInstance(model);
+    nodeBindFallback(instance)._templateInstance = instanceRecord;
 
     var i = 0;
+    bool collectTerminator = false;
     for (var c = content.firstChild; c != null; c = c.nextNode, i++) {
+      // The terminator of the instance is the clone of the last child of the
+      // content. If the last child is an active template, it may produce
+      // instances as a result of production, so simply collecting the last
+      // child of the instance after it has finished producing may be wrong.
+      if (c.nextNode == null) collectTerminator = true;
+
       final childMap = map != null ? map.getChild(i) : null;
       var clone = _cloneAndBindInstance(c, instance, _stagingDocument,
-          childMap, model, delegate, instanceBindings);
+          childMap, model, delegate, instanceExt._bindings);
+
       nodeBindFallback(clone)._templateInstance = instanceRecord;
+      if (collectTerminator) instanceExt._terminator = clone;
     }
 
     instanceRecord._firstNode = instance.firstChild;
     instanceRecord._lastNode = instance.lastChild;
 
+    instanceExt._protoContent = null;
+    instanceExt._templateCreator = null;
     return instance;
   }
 
   /** The data model which is inherited through the tree. */
   get model => _model;
 
   void set model(value) {
     _model = value;
     _ensureSetModelScheduled();
   }
 
   static Node _deepCloneIgnoreTemplateContent(Node node, stagingDocument) {
     var clone = stagingDocument.importNode(node, false);
     if (isSemanticTemplate(clone)) return clone;
 
     for (var c = node.firstChild; c != null; c = c.nextNode) {
       clone.append(_deepCloneIgnoreTemplateContent(c, stagingDocument));
     }
     return clone;
   }
 
   /**
    * The binding delegate which is inherited through the tree. It can be used
    * to configure custom syntax for `{{bindings}}` inside this template.
    */
   BindingDelegate get bindingDelegate => _bindingDelegate;
 
+
   void set bindingDelegate(BindingDelegate value) {
+    if (_bindingDelegate != null) {
+      throw new StateError('Template must be cleared before a new '
+          'bindingDelegate can be assigned');
+    }
     _bindingDelegate = value;
 
     // Clear cached state based on the binding delegate.
     _bindingMap = null;
     if (_iterator != null) {
       _iterator._initPrepareFunctions = false;
       _iterator._instanceModelFn = null;
       _iterator._instancePositionChangedFn = null;
     }
   }
 
   _ensureSetModelScheduled() {
     if (_setModelScheduled) return;
     _decorate();
     _setModelScheduled = true;
     scheduleMicrotask(_setModel);
   }
 
   void _setModel() {
     _setModelScheduled = false;
     var map = _getBindings(_node, _bindingDelegate);
     _processBindings(_node, map, _model);
   }
 
+  _refChanged() {
+    if (_iterator == null || _refContent == templateBind(_ref).content) return;
+
+    _refContent = null;
+    _iterator._valueChanged(null);
+    _iterator._updateIteratedValue(null);
+  }
+
+  void clear() {
+    _model = null;
+    _bindingDelegate = null;
+    if (bindings != null) {
+      var ref = bindings.remove('ref');
+      if (ref != null) ref.close();
+    }
+    _refContent = null;
+    if (_iterator == null) return;
+    _iterator._valueChanged(null);
+    _iterator.close();
+    _iterator = null;
+  }
+
   /** Gets the template this node refers to. */
-  Element get ref {
+  Element get _ref {
     _decorate();
 
-    Element result = null;
-    var refId = _node.attributes['ref'];
-    if (refId != null) {
-      var treeScope = _getTreeScope(_node);
-      if (treeScope != null) {
-        result = treeScope.getElementById(refId);
-      }
-      if (result == null) {
-        var instanceRoot = _getInstanceRoot(_node);
-
-        // TODO(jmesserly): this won't work if refId is a number
-        // Similar to bug: https://github.com/Polymer/ShadowDOM/issues/340
-        if (instanceRoot != null) {
-          result = instanceRoot.querySelector('#$refId');
-        }
-      }
+    var ref = _searchRefId(_node, _node.attributes['ref']);
+    if (ref == null) {
+      ref = _templateInstanceRef;
+      if (ref == null) return _node;
     }
 
-    if (result == null) {
-      result = _templateInstanceRef;
-      if (result == null) return _node;
-    }
-
-    var nextRef = templateBind(result).ref;
-    return nextRef != null ? nextRef : result;
+    var nextRef = templateBindFallback(ref)._ref;
+    return nextRef != null ? nextRef : ref;
   }
 
   /**
    * Gets the content of this template.
    */
   DocumentFragment get content {
     _decorate();
     return _content != null ? _content : (_node as TemplateElement).content;
   }
 
   /**
    * Ensures proper API and content model for template elements.
    *
    * [instanceRef] can be used to set the [Element.ref] property of [template],
    * and use the ref's content will be used as source when createInstance() is
    * invoked.
    *
    * Returns true if this template was just decorated, or false if it was
    * already decorated.
    */
   static bool decorate(Element template, [Element instanceRef]) =>
       templateBindFallback(template)._decorate(instanceRef);
 
   bool _decorate([Element instanceRef]) {
     // == true check because it starts as a null field.
     if (_templateIsDecorated == true) return false;
 
     _injectStylesheet();
+    _globalBaseUriWorkaround();
 
     var templateElementExt = this;
     _templateIsDecorated = true;
     var isNativeHtmlTemplate = _node is TemplateElement;
     final bootstrapContents = isNativeHtmlTemplate;
     final liftContents = !isNativeHtmlTemplate;
     var liftRoot = false;
 
     if (!isNativeHtmlTemplate) {
       if (_isAttributeTemplate(_node)) {
@@ skipping 53 matching lines @@
     }
     return d;
   }
 
   HtmlDocument _getTemplateStagingDocument() {
     if (_stagingDocument == null) {
       var owner = _node.ownerDocument;
       var doc = _ownerStagingDocument[owner];
       if (doc == null) {
         doc = owner.implementation.createHtmlDocument('');
+        _isStagingDocument[doc] = true;
+        _baseUriWorkaround(doc);
         _ownerStagingDocument[owner] = doc;
       }
       _stagingDocument = doc;
     }
     return _stagingDocument;
   }
 
   // For non-template browsers, the parser will disallow <template> in certain
   // locations, so we allow "attribute templates" which combine the template
   // element with the top-level container node of the content, e.g.
@@ skipping 88 matching lines @@
   // This is to replicate template_element.css
   // TODO(jmesserly): move this to an opt-in CSS file?
   static void _injectStylesheet() {
     if (_initStyles == true) return;
     _initStyles = true;
 
     var style = new StyleElement()
         ..text = '$_allTemplatesSelectors { display: none; }';
     document.head.append(style);
   }
-}
 
-final _templateCreator = new Expando();
+  static bool _initBaseUriWorkaround;
 
-_getTreeScope(Node node) {
-  while (true) {
-    var parent = node.parentNode;
-    if (parent != null) {
-      node = parent;
-    } else {
-      var creator = _templateCreator[node];
-      if (creator == null) break;
+  static void _globalBaseUriWorkaround() {
+    if (_initBaseUriWorkaround == true) return;
+    _initBaseUriWorkaround = true;
 
-      node = creator;
+    var t = document.createElement('template');
+    if (t is TemplateElement) {
+      var d = t.content.ownerDocument;
+      if (d.documentElement == null) {
+        d.append(d.createElement('html')).append(d.createElement('head'));
+      }
+      // don't patch this if TemplateBinding.js already has.
+      if (d.head.querySelector('base') == null) {
+        _baseUriWorkaround(d);
+      }
     }
   }
 
-  // Note: JS code tests that getElementById is present. We can't do that
-  // easily, so instead check for the types known to implement it.
-  if (node is Document || node is ShadowRoot || node is SvgSvgElement) {
-    return node;
+  // TODO(rafaelw): Remove when fix for
+  // https://codereview.chromium.org/164803002/
+  // makes it to Chrome release.
+  static void _baseUriWorkaround(HtmlDocument doc) {
+    BaseElement base = doc.createElement('base');
+    base.href = document.baseUri;
+    doc.head.append(base);
   }
-  return null;
+
+  static final _templateObserver = new MutationObserver((records, _) {
+    for (MutationRecord record in records) {
+      templateBindFallback(record.target)._refChanged();
+    }
+  });
+
+}
+
+final DocumentFragment _emptyInstance = () {
+  var empty = new DocumentFragment();
+  _instanceExtension[empty] = new _InstanceExtension();
+  return empty;
+}();
+
+// TODO(jmesserly): if we merged this wtih TemplateInstance, it seems like it

[Siggi Cherem (dart-lang), 2014/06/03 17:41:03]

wtih -> with

[Jennifer Messerly, 2014/06/04 04:42:17]

Done.

+// would speed up some operations (e.g. _getInstanceRoot wouldn't need to walk
+// the parent chain).
+class _InstanceExtension {
+  final List _bindings = [];
+  Node _terminator;
+  Element _templateCreator;
+  DocumentFragment _protoContent;
+}
+
+// TODO(jmesserly): this is private in JS but public for us because pkg:polymer
+// uses it.
+List getTemplateInstanceBindings(DocumentFragment fragment) {
+  var ext = _instanceExtension[fragment];
+  return ext != null ? ext._bindings : ext;
+}
+
+/// Gets the root of the current node's parent chain
+_getFragmentRoot(Node node) {
+  var p;
+  while ((p = node.parentNode) != null) {
+    node = p;
+  }
+  return node;
+}
+
+Node _searchRefId(Node node, String id) {
+  if (id == null || id == '') return null;
+
+  final selector = '#$id';
+  while (true) {
+    node = _getFragmentRoot(node);
+
+    Node ref = null;
+
+    _InstanceExtension instance = _instanceExtension[node];
+    if (instance != null && instance._protoContent != null) {
+      ref = instance._protoContent.querySelector(selector);
+    } else if (_hasGetElementById(node)) {
+      ref = (node as dynamic).getElementById(id);
+    }
+
+    if (ref != null) return ref;
+
+    if (instance == null) return null;
+    node = instance._templateCreator;
+    if (node == null) return null;
+  }
 }
 
 _getInstanceRoot(node) {
   while (node.parentNode != null) {
     node = node.parentNode;
   }
-  return _templateCreator[node] != null ? node : null;
+  _InstanceExtension instance = _instanceExtension[node];
+  return instance != null && instance._templateCreator != null ? node : null;
 }
+
+final Expando<_InstanceExtension> _instanceExtension = new Expando();
+
+final _isStagingDocument = new Expando();