[html5lib] api updates: localName

pkg/third_party/html5lib/lib/src/treebuilder.dart

 /// Internals to the tree builders.
 library treebuilder;
 
 import 'dart:collection';
 import 'package:html5lib/dom.dart';
+import 'package:html5lib/parser.dart' show getElementNameTuple;
 import 'package:source_maps/span.dart' show FileSpan;
 import 'constants.dart';
 import 'list_proxy.dart';
 import 'token.dart';
 import 'utils.dart';
 
 // The scope markers are inserted when entering object elements,
 // marquees, table cells, and table captions, and are used to prevent formatting
 // from "leaking" into tables, object elements, and marquees.
 const Node Marker = null;
 
-// TODO(jmesserly): this should extend ListBase<Node>, but my simple attempt
+// TODO(jmesserly): this should extend ListBase<Element>, but my simple attempt
 // didn't work.
-class ActiveFormattingElements extends ListProxy<Node> {
+class ActiveFormattingElements extends ListProxy<Element> {
   ActiveFormattingElements() : super();
 
   // Override the "add" method.
   // TODO(jmesserly): I'd rather not override this; can we do this in the
   // calling code instead?
-  void add(Node node) {
+  void add(Element node) {
     int equalCount = 0;
     if (node != Marker) {
-      for (Node element in reversed) {
+      for (var element in reversed) {
         if (element == Marker) {
           break;
         }
         if (_nodesEqual(element, node)) {
           equalCount += 1;
         }
         if (equalCount == 3) {
           remove(element);
           break;
         }
@@ skipping 15 matching lines @@
     }
 
     if (a[keyA] != valB) {
       return false;
     }
   }
   return true;
 }
 
 
-bool _nodesEqual(Node node1, Node node2) {
-  return node1.nameTuple == node2.nameTuple &&
+bool _nodesEqual(Element node1, Element node2) {
+  return getElementNameTuple(node1) == getElementNameTuple(node2) &&
       _mapEquals(node1.attributes, node2.attributes);
 }
 
 /// Basic treebuilder implementation.
 class TreeBuilder {
   final String defaultNamespace;
 
   Document document;
 
-  final openElements = <Node>[];
+  final List<Element> openElements = <Element>[];
 
   final activeFormattingElements = new ActiveFormattingElements();
 
   Node headPointer;
 
   Node formPointer;
 
   /// Switch the function used to insert an element from the
   /// normal one to the misnested table one and back again
   bool insertFromTable;
@@ skipping 12 matching lines @@
     formPointer = null;
 
     insertFromTable = false;
 
     document = new Document();
   }
 
   bool elementInScope(target, {String variant}) {
     //If we pass a node in we match that. if we pass a string
     //match any node with that name
-    bool exactNode = target is Node && target.nameTuple != null;
+    bool exactNode = target is Node;
 
     List listElements1 = scopingElements;
     List listElements2 = const [];
     bool invert = false;
     if (variant != null) {
       switch (variant) {
         case "button":
           listElements2 = const [const Pair(Namespaces.html, "button")];
           break;
         case "list":
           listElements2 = const [const Pair(Namespaces.html, "ol"),
                                  const Pair(Namespaces.html, "ul")];
           break;
         case "table":
           listElements1 = const [const Pair(Namespaces.html, "html"),
                                  const Pair(Namespaces.html, "table")];
           break;
         case "select":
           listElements1 = const [const Pair(Namespaces.html, "optgroup"),
                                  const Pair(Namespaces.html, "option")];
           invert = true;
           break;
         default:
           throw new StateError('We should never reach this point');
       }
     }
 
-    for (Node node in openElements.reversed) {
-      if (node.tagName == target && !exactNode ||
-          node == target && exactNode) {
+    for (var node in openElements.reversed) {
+      if (!exactNode && node.localName == target ||
+          exactNode && node == target) {
         return true;
       } else if (invert !=
-          (listElements1.contains(node.nameTuple) ||
-           listElements2.contains(node.nameTuple))) {
+          (listElements1.contains(getElementNameTuple(node)) ||
+           listElements2.contains(getElementNameTuple(node)))) {
         return false;
       }
     }
 
     throw new StateError('We should never reach this point');
   }
 
   void reconstructActiveFormattingElements() {
     // Within this algorithm the order of steps described in the
     // specification is not quite the same as the order of steps in the
@@ skipping 25 matching lines @@
 
     while (true) {
       // Step 7
       i += 1;
 
       // Step 8
       entry = activeFormattingElements[i];
 
       // TODO(jmesserly): optimize this. No need to create a token.
       var cloneToken = new StartTagToken(
-          entry.tagName,
-          namespace: entry.namespace,
+          entry.localName,
+          namespace: entry.namespaceUri,
           data: new LinkedHashMap.from(entry.attributes))
           ..span = entry.sourceSpan;
 
       // Step 9
       var element = insertElement(cloneToken);
 
       // Step 10
       activeFormattingElements[i] = element;
 
       // Step 11
       if (element == activeFormattingElements.last) {
         break;
       }
     }
   }
 
   void clearActiveFormattingElements() {
     var entry = activeFormattingElements.removeLast();
     while (activeFormattingElements.length > 0 && entry != Marker) {
       entry = activeFormattingElements.removeLast();
     }
   }
 
   /// Check if an element exists between the end of the active
   /// formatting elements and the last marker. If it does, return it, else
   /// return null.
-  Node elementInActiveFormattingElements(String name) {
-    for (Node item in activeFormattingElements.reversed) {
+  Element elementInActiveFormattingElements(String name) {
+    for (var item in activeFormattingElements.reversed) {
       // Check for Marker first because if it's a Marker it doesn't have a
       // name attribute.
       if (item == Marker) {
         break;
-      } else if (item.tagName == name) {
+      } else if (item.localName == name) {
         return item;
       }
     }
     return null;
   }
 
   void insertRoot(Token token) {
     var element = createElement(token);
     openElements.add(element);
     document.nodes.add(element);
@@ skipping 36 matching lines @@
         ..attributes = token.data
         ..sourceSpan = token.span;
     openElements.last.nodes.add(element);
     openElements.add(element);
     return element;
   }
 
   Element insertElementTable(token) {
     /// Create an element and insert it into the tree
     var element = createElement(token);
-    if (!tableInsertModeElements.contains(openElements.last.tagName)) {
+    if (!tableInsertModeElements.contains(openElements.last.localName)) {
       return insertElementNormal(token);
     } else {
       // We should be in the InTable mode. This means we want to do
       // special magic element rearranging
       var nodePos = getTableMisnestedNodePosition();
       if (nodePos[1] == null) {
         // TODO(jmesserly): I don't think this is reachable. If insertFromTable
         // is true, there will be a <table> element open, and it always has a
         // parent pointer.
         nodePos[0].nodes.add(element);
       } else {
         nodePos[0].insertBefore(element, nodePos[1]);
       }
       openElements.add(element);
     }
     return element;
   }
 
   /// Insert text data.
   void insertText(String data, FileSpan span) {
     var parent = openElements.last;
 
     if (!insertFromTable || insertFromTable &&
-        !tableInsertModeElements.contains(openElements.last.tagName)) {
+        !tableInsertModeElements.contains(openElements.last.localName)) {
       _insertText(parent, data, span);
     } else {
       // We should be in the InTable mode. This means we want to do
       // special magic element rearranging
       var nodePos = getTableMisnestedNodePosition();
       _insertText(nodePos[0], data, span, nodePos[1]);
     }
   }
 
   /// Insert [data] as text in the current node, positioned before the
@@ skipping 26 matching lines @@
 
   /// Get the foster parent element, and sibling to insert before
   /// (or null) when inserting a misnested table node
   List<Node> getTableMisnestedNodePosition() {
     // The foster parent element is the one which comes before the most
     // recently opened table element
     // XXX - this is really inelegant
     Node lastTable = null;
     Node fosterParent = null;
     var insertBefore = null;
-    for (Node elm in openElements.reversed) {
-      if (elm.tagName == "table") {
+    for (var elm in openElements.reversed) {
+      if (elm.localName == "table") {
         lastTable = elm;
         break;
       }
     }
     if (lastTable != null) {
       // XXX - we should really check that this parent is actually a
       // node here
       if (lastTable.parent != null) {
         fosterParent = lastTable.parent;
         insertBefore = lastTable;
       } else {
         fosterParent = openElements[openElements.indexOf(lastTable) - 1];
       }
     } else {
       fosterParent = openElements[0];
     }
     return [fosterParent, insertBefore];
   }
 
   void generateImpliedEndTags([String exclude]) {
-    var name = openElements.last.tagName;
+    var name = openElements.last.localName;
     // XXX td, th and tr are not actually needed
     if (name != exclude && const ["dd", "dt", "li", "option", "optgroup", "p",
         "rp", "rt"].contains(name)) {
       openElements.removeLast();
       // XXX This is not entirely what the specification says. We should
       // investigate it more closely.
       generateImpliedEndTags(exclude);
     }
   }
 
   /// Return the final tree.
   Document getDocument() => document;
 
   /// Return the final fragment.
   DocumentFragment getFragment() {
     //XXX assert innerHTML
     var fragment = new DocumentFragment();
     openElements[0].reparentChildren(fragment);
     return fragment;
   }
 }