Update libs

2013-11-22 16:09:15 +01:00
parent f53364eb6c
commit 88d6148500
119 changed files with 18448 additions and 8923 deletions
@@ -1,94 +1,9 @@
+from __future__ import absolute_import, division, unicode_literals
+from six import text_type, string_types
+
 import gettext
 _ = gettext.gettext

-from html5lib.constants import voidElements, spaceCharacters
-spaceCharacters = u"".join(spaceCharacters)
-
-class TreeWalker(object):
-    def __init__(self, tree):
-        self.tree = tree
-
-    def __iter__(self):
-        raise NotImplementedError
-
-    def error(self, msg):
-        return {"type": "SerializeError", "data": msg}
-
-    def normalizeAttrs(self, attrs):
-        newattrs = {}
-        if attrs:
-            #TODO: treewalkers should always have attrs
-            for (namespace,name),value in attrs.iteritems():
-                namespace = unicode(namespace) if namespace else None
-                name = unicode(name)
-                value = unicode(value)
-                newattrs[(namespace,name)] = value
-        return newattrs
-
-    def emptyTag(self, namespace, name, attrs, hasChildren=False):
-        yield {"type": "EmptyTag", "name": unicode(name), 
-               "namespace":unicode(namespace),
-               "data": self.normalizeAttrs(attrs)}
-        if hasChildren:
-            yield self.error(_("Void element has children"))
-
-    def startTag(self, namespace, name, attrs):
-        return {"type": "StartTag", 
-                "name": unicode(name),
-                "namespace":unicode(namespace),
-                "data": self.normalizeAttrs(attrs)}
-
-    def endTag(self, namespace, name):
-        return {"type": "EndTag", 
-                "name": unicode(name),
-                "namespace":unicode(namespace),
-                "data": {}}
-
-    def text(self, data):
-        data = unicode(data)
-        middle = data.lstrip(spaceCharacters)
-        left = data[:len(data)-len(middle)]
-        if left:
-            yield {"type": "SpaceCharacters", "data": left}
-        data = middle
-        middle = data.rstrip(spaceCharacters)
-        right = data[len(middle):]
-        if middle:
-            yield {"type": "Characters", "data": middle}
-        if right:
-            yield {"type": "SpaceCharacters", "data": right}
-
-    def comment(self, data):
-        return {"type": "Comment", "data": unicode(data)}
-
-    def doctype(self, name, publicId=None, systemId=None, correct=True):
-        return {"type": "Doctype",
-                "name": name is not None and unicode(name) or u"",
-                "publicId": publicId,
-                "systemId": systemId,
-                "correct": correct}
-
-    def entity(self, name):
-        return {"type": "Entity", "name": unicode(name)}
-
-    def unknown(self, nodeType):
-        return self.error(_("Unknown node type: ") + nodeType)
-
-class RecursiveTreeWalker(TreeWalker):
-    def walkChildren(self, node):
-        raise NodeImplementedError
-
-    def element(self, node, namespace, name, attrs, hasChildren):
-        if name in voidElements:
-            for token in self.emptyTag(namespace, name, attrs, hasChildren):
-                yield token
-        else:
-            yield self.startTag(name, attrs)
-            if hasChildren:
-                for token in self.walkChildren(node):
-                    yield token
-            yield self.endTag(name)
-
 from xml.dom import Node

 DOCUMENT = Node.DOCUMENT_NODE
@@ -99,16 +14,127 @@ COMMENT = Node.COMMENT_NODE
 ENTITY = Node.ENTITY_NODE
 UNKNOWN = "<#UNKNOWN#>"

+from ..constants import voidElements, spaceCharacters
+spaceCharacters = "".join(spaceCharacters)
+
+
+def to_text(s, blank_if_none=True):
+    """Wrapper around six.text_type to convert None to empty string"""
+    if s is None:
+        if blank_if_none:
+            return ""
+        else:
+            return None
+    elif isinstance(s, text_type):
+        return s
+    else:
+        return text_type(s)
+
+
+def is_text_or_none(string):
+    """Wrapper around isinstance(string_types) or is None"""
+    return string is None or isinstance(string, string_types)
+
+
+class TreeWalker(object):
+    def __init__(self, tree):
+        self.tree = tree
+
+    def __iter__(self):
+        raise NotImplementedError
+
+    def error(self, msg):
+        return {"type": "SerializeError", "data": msg}
+
+    def emptyTag(self, namespace, name, attrs, hasChildren=False):
+        assert namespace is None or isinstance(namespace, string_types), type(namespace)
+        assert isinstance(name, string_types), type(name)
+        assert all((namespace is None or isinstance(namespace, string_types)) and
+                   isinstance(name, string_types) and
+                   isinstance(value, string_types)
+                   for (namespace, name), value in attrs.items())
+
+        yield {"type": "EmptyTag", "name": to_text(name, False),
+               "namespace": to_text(namespace),
+               "data": attrs}
+        if hasChildren:
+            yield self.error(_("Void element has children"))
+
+    def startTag(self, namespace, name, attrs):
+        assert namespace is None or isinstance(namespace, string_types), type(namespace)
+        assert isinstance(name, string_types), type(name)
+        assert all((namespace is None or isinstance(namespace, string_types)) and
+                   isinstance(name, string_types) and
+                   isinstance(value, string_types)
+                   for (namespace, name), value in attrs.items())
+
+        return {"type": "StartTag",
+                "name": text_type(name),
+                "namespace": to_text(namespace),
+                "data": dict(((to_text(namespace, False), to_text(name)),
+                              to_text(value, False))
+                             for (namespace, name), value in attrs.items())}
+
+    def endTag(self, namespace, name):
+        assert namespace is None or isinstance(namespace, string_types), type(namespace)
+        assert isinstance(name, string_types), type(namespace)
+
+        return {"type": "EndTag",
+                "name": to_text(name, False),
+                "namespace": to_text(namespace),
+                "data": {}}
+
+    def text(self, data):
+        assert isinstance(data, string_types), type(data)
+
+        data = to_text(data)
+        middle = data.lstrip(spaceCharacters)
+        left = data[:len(data) - len(middle)]
+        if left:
+            yield {"type": "SpaceCharacters", "data": left}
+        data = middle
+        middle = data.rstrip(spaceCharacters)
+        right = data[len(middle):]
+        if middle:
+            yield {"type": "Characters", "data": middle}
+        if right:
+            yield {"type": "SpaceCharacters", "data": right}
+
+    def comment(self, data):
+        assert isinstance(data, string_types), type(data)
+
+        return {"type": "Comment", "data": text_type(data)}
+
+    def doctype(self, name, publicId=None, systemId=None, correct=True):
+        assert is_text_or_none(name), type(name)
+        assert is_text_or_none(publicId), type(publicId)
+        assert is_text_or_none(systemId), type(systemId)
+
+        return {"type": "Doctype",
+                "name": to_text(name),
+                "publicId": to_text(publicId),
+                "systemId": to_text(systemId),
+                "correct": to_text(correct)}
+
+    def entity(self, name):
+        assert isinstance(name, string_types), type(name)
+
+        return {"type": "Entity", "name": text_type(name)}
+
+    def unknown(self, nodeType):
+        return self.error(_("Unknown node type: ") + nodeType)
+
+
 class NonRecursiveTreeWalker(TreeWalker):
    def getNodeDetails(self, node):
        raise NotImplementedError
-    
+
    def getFirstChild(self, node):
        raise NotImplementedError
-    
+
    def getNextSibling(self, node):
        raise NotImplementedError
-    
+
    def getParentNode(self, node):
        raise NotImplementedError

@@ -118,7 +144,6 @@ class NonRecursiveTreeWalker(TreeWalker):
            details = self.getNodeDetails(currentNode)
            type, details = details[0], details[1:]
            hasChildren = False
-            endTag = None

            if type == DOCTYPE:
                yield self.doctype(*details)
@@ -130,12 +155,11 @@ class NonRecursiveTreeWalker(TreeWalker):
            elif type == ELEMENT:
                namespace, name, attributes, hasChildren = details
                if name in voidElements:
-                    for token in self.emptyTag(namespace, name, attributes, 
+                    for token in self.emptyTag(namespace, name, attributes,
                                               hasChildren):
                        yield token
                    hasChildren = False
                else:
-                    endTag = name
                    yield self.startTag(namespace, name, attributes)

            elif type == COMMENT:
@@ -149,12 +173,12 @@ class NonRecursiveTreeWalker(TreeWalker):

            else:
                yield self.unknown(details[0])
-            
+
            if hasChildren:
                firstChild = self.getFirstChild(currentNode)
            else:
                firstChild = None
-            
+
            if firstChild is not None:
                currentNode = firstChild
            else: