Change the format of attributes within the treebuilder to be a list of dicts with "namespace", "name", and "value". Moving towards foreign content support in the serializer…

Author: gsnedders

html5lib/filters/inject_meta_charset.py

@@ -21,9 +21,14 @@ def __iter__(self):
                    # replace charset with actual encoding
                    has_http_equiv_content_type = False
                    content_index = -1
-                   for i,(name,value) in enumerate(token["data"]):
-                       if name.lower() == 'charset':
-                          token["data"][i] = (u'charset', self.encoding)
+                   for i,attr in enumerate(token["data"]):
+                       namespace = attr["namespace"]
+                       name = attr["name"]
+                       value = attr["value"]
+                       if namespace != None:
+                           continue
+                       elif name.lower() == 'charset':
+                          token["data"][i]["value"] = self.encoding
                           meta_found = True
                           break
                        elif name == 'http-equiv' and value.lower() == 'content-type':
@@ -32,15 +37,15 @@ def __iter__(self):
                            content_index = i
                    else:
                        if has_http_equiv_content_type and content_index >= 0:
-                           token["data"][content_index] = (u'content', u'text/html; charset=%s' % self.encoding)
+                           token["data"][content_index]["value"] = u'text/html; charset=%s' % self.encoding
                            meta_found = True
 
                 elif token["name"].lower() == "head" and not meta_found:
                     # insert meta into empty head
                     yield {"type": "StartTag", "name": "head",
                            "data": token["data"]}
                     yield {"type": "EmptyTag", "name": "meta",
-                           "data": [["charset", self.encoding]]}
+                           "data": [{"namespace": None, "name": "charset", "value": self.encoding}]}
                     yield {"type": "EndTag", "name": "head"}
                     meta_found = True
                     continue
@@ -51,7 +56,7 @@ def __iter__(self):
                     yield pending.pop(0)
                     if not meta_found:
                         yield {"type": "EmptyTag", "name": "meta",
-                               "data": [["charset", self.encoding]]}
+                               "data": [{"namespace": None, "name": "charset", "value": self.encoding}]}
                     while pending:
                         yield pending.pop(0)
                     meta_found = True

html5lib/serializer/htmlserializer.py

@@ -224,7 +224,10 @@ def serialize(self, treewalker, encoding=None):
                     attrs = attrs.items()
                 attrs.sort()
                 attributes = []
-                for k,v in attrs:
+                for attr in attrs:
+                    #TODO: Add namespace support here
+                    k = attr["name"]
+                    v = attr["value"]
                     if encoding:
                         k = k.encode(encoding, "strict")
                     attributes.append(' ')

html5lib/tests/test_treewalkers.py

@@ -196,11 +196,17 @@ def convertTokens(tokens):
             indent += 2
             attrs = token["data"]
             if attrs:
-                if hasattr(attrs, "items"):
-                    attrs = attrs.items()
-                attrs.sort()
-                for name, value in attrs:
-                    output.append(u"%s%s=\"%s\"" % (" "*indent, name, value))
+                attrs.sort(lambda a,b: cmp(a["name"], b["name"]))
+                for attr in attrs:
+                    if attr["namespace"]:
+                        if attr["namespace"] in constants.prefixes:
+                            name = constants.prefixes[attr["namespace"]]
+                        else:
+                            name = attr["namespace"]
+                        name += u" " + attr["name"]
+                    else:
+                        name = attr["name"]
+                    output.append(u"%s%s=\"%s\"" % (" "*indent, name, attr["value"]))
             if type == "EmptyTag":
                 indent -= 2
         elif type == "EndTag":

html5lib/treewalkers/_base.py

@@ -17,9 +17,11 @@ def error(self, msg):
     def normalizeAttrs(self, attrs):
         if not attrs:
             attrs = []
-        elif hasattr(attrs, 'items'):
-            attrs = attrs.items()
-        return [(unicode(name),unicode(value)) for name,value in attrs]
+        for attr in attrs:
+            attr["namespace"] = unicode(attr["namespace"]) if attr["namespace"] else None
+            attr["name"] = unicode(attr["name"])
+            attr["value"] = unicode(attr["value"])
+        return attrs
 
     def emptyTag(self, namespace, name, attrs, hasChildren=False):
         yield {"type": "EmptyTag", "name": unicode(name), 

html5lib/treewalkers/dom.py

@@ -15,8 +15,14 @@ def getNodeDetails(self, node):
             return _base.TEXT, node.nodeValue
 
         elif node.nodeType == Node.ELEMENT_NODE:
+            attrs = []
+            for attr in node.attributes.keys():
+                attr = node.getAttributeNode(attr)
+                attrs.append({"namespace": attr.namespaceURI,
+                              "name": attr.localName,
+                              "value": attr.value})
             return (_base.ELEMENT, node.namespaceURI, node.nodeName, 
-                    node.attributes.items(), node.hasChildNodes)
+                    attrs, node.hasChildNodes)
 
         elif node.nodeType == Node.COMMENT_NODE:
             return _base.COMMENT, node.nodeValue

html5lib/treewalkers/etree.py

@@ -69,8 +69,19 @@ def getNodeDetails(self, node):
                 else:
                     namespace = None
                     tag = node.tag
+                attrs = []
+                for name, value in node.attrib.items():
+                    match = tag_regexp.match(name)
+                    if match:
+                        attrs.append({"namespace": match.group(1),
+                                      "name": match.group(2),
+                                      "value": value})
+                    else:
+                        attrs.append({"namespace": None,
+                                      "name": name,
+                                      "value": value})
                 return (_base.ELEMENT, namespace, tag, 
-                        node.attrib.items(), len(node) or node.text)
+                        attrs, len(node) or node.text)
 
         def getFirstChild(self, node):
             if isinstance(node, tuple):

html5lib/treewalkers/lxmletree.py

@@ -140,10 +140,19 @@ def getNodeDetails(self, node):
             else:
                 namespace = None
                 tag = node.tag
+            attrs = []
+            for name, value in node.attrib.items():
+                match = tag_regexp.match(name)
+                if match:
+                    attrs.append({"namespace": match.group(1),
+                                  "name": match.group(2),
+                                  "value": value})
+                else:
+                    attrs.append({"namespace": None,
+                                  "name": name,
+                                  "value": value})
             return (_base.ELEMENT, namespace, self.filter.fromXmlName(tag), 
-                    [(self.filter.fromXmlName(name), value) for 
-                     name,value in node.attrib.iteritems()], 
-                     len(node) > 0 or node.text)
+                    attrs, len(node) > 0 or node.text)
 
     def getFirstChild(self, node):
         assert not isinstance(node, tuple), _("Text nodes have no children")

html5lib/treewalkers/pulldom.py

@@ -30,14 +30,20 @@ def tokens(self, event, next):
         if type == START_ELEMENT:
             name = node.nodeName
             namespace = node.namespaceURI
+            attrs = []
+            for attr in node.attributes.keys():
+                attr = node.getAttributeNode(attr)
+                attrs.append({"namespace": attr.namespaceURI,
+                              "name": attr.localName,
+                              "value": attr.value})
             if name in voidElements:
                 for token in self.emptyTag(namespace,
                                            name,
-                                           node.attributes.items(), 
+                                           attrs,
                                            not next or next[1] is not node):
                     yield token
             else:
-                yield self.startTag(namespace, name, node.attributes.items())
+                yield self.startTag(namespace, name, attrs)
 
         elif type == END_ELEMENT:
             name = node.nodeName

html5lib/treewalkers/simpletree.py

@@ -32,8 +32,18 @@ def getNodeDetails(self, node):
             return _base.TEXT, node.value
 
         elif node.type == 5: # Element
+            attrs = []
+            for name, value in node.attributes.items():
+                if isinstance(name, tuple):
+                    attrs.append({"namespace": name[2],
+                                  "name": name[1],
+                                  "value": value})
+                else:
+                    attrs.append({"namespace": None,
+                                  "name": name,
+                                  "value": value})
             return (_base.ELEMENT, node.namespace, node.name, 
-                    node.attributes.items(), node.hasContent())
+                    attrs, node.hasContent())
 
         elif node.type == 6: # CommentNode
             return _base.COMMENT, node.data