from xml.dom import Node

from xml.dom.pulldom import START_ELEMENT, END_ELEMENT, COMMENT, CHARACTERS

if node.nodeType in (Node.DOCUMENT_NODE, Node.DOCUMENT_FRAGMENT_NODE):

for childNode in node.childNodes:

for event in PullDOMAdapter(childNode):

yield event

elif node.nodeType == Node.DOCUMENT_TYPE_NODE:

raise NotImplementedError("DOCTYPE nodes are not supported by PullDOM")

elif node.nodeType == Node.COMMENT_NODE:

yield COMMENT, node

elif node.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):

yield CHARACTERS, node

elif node.nodeType == Node.ELEMENT_NODE:

yield START_ELEMENT, node

for childNode in node.childNodes:

for event in PullDOMAdapter(childNode):

yield event

yield END_ELEMENT, node

else:

"simpletree": {"builder": treebuilders.getTreeBuilder("simpletree"),

"walker": treewalkers.getTreeWalker("simpletree")},

"DOM": {"builder": treebuilders.getTreeBuilder("dom"),

"walker": treewalkers.getTreeWalker("dom")},

"PullDOM": {"builder": treebuilders.getTreeBuilder("dom"),

"adapter": PullDOMAdapter,

"walker": treewalkers.getTreeWalker("pulldom")},

text = None

for token in treewalkers.getTreeWalker("simpletree")(tree):

type = token["type"]

if type in ("Characters", "SpaceCharacters"):

if text is None:

text = token["data"]

else:

text += token["data"]

elif text is not None:

yield TEXT, text, (None, -1, -1)

text = None

if type in ("StartTag", "EmptyTag"):

yield (START,

(QName(token["name"]),

Attrs([(QName(attr),value) for attr,value in token["data"]])),

(None, -1, -1))

if type == "EmptyTag":

type = "EndTag"

if type == "EndTag":

yield END, QName(token["name"]), (None, -1, -1)

elif type == "Comment":

yield COMMENT, token["data"], (None, -1, -1)

elif type == "Doctype":

yield DOCTYPE, (token["name"], token["publicId"],

token["systemId"]), (None, -1, -1)

else:

pass # FIXME: What to do?

if text is not None:

charactersToken = None

for token in tokens:

type = token["type"]

if type in ("Characters", "SpaceCharacters"):

if charactersToken is None:

charactersToken = {"type": "Characters", "data": token["data"]}

else:

charactersToken["data"] += token["data"]

else:

if charactersToken is not None:

yield charactersToken

charactersToken = None

yield token

if charactersToken is not None:

output = []

indent = 0

for token in concatenateCharacterTokens(tokens):

type = token["type"]

if type in ("StartTag", "EmptyTag"):

output.append("%s<%s>" % (" "*indent, token["name"]))

indent += 2

attrs = token["data"]

if attrs:

if hasattr(attrs, "items"):

attrs = list(attrs.items())

attrs.sort()

for name, value in attrs:

output.append("%s%s=\"%s\"" % (" "*indent, name, value))

if type == "EmptyTag":

indent -= 2

elif type == "EndTag":

indent -= 2

elif type == "Comment":

output.append("%s<!-- %s -->" % (" "*indent, token["data"]))

elif type == "Doctype":

if token["name"]:

if token["publicId"] or token["systemId"]:

output.append("""%s<!DOCTYPE %s "%s" "%s">"""%

(" "*indent, token["name"],

token["publicId"] or "",

token["systemId"] or ""))

else:

output.append("%s<!DOCTYPE %s>"%(" "*indent,

token["name"]))

else:

output.append("%s<!DOCTYPE >" % (" "*indent,))

elif type in ("Characters", "SpaceCharacters"):

output.append("%s\"%s\"" % (" "*indent, token["data"]))

else:

pass # TODO: what to do with errors?

def runTest(self, innerHTML, input, expected, errors, treeClass):

if innerHTML is not None:

innerHTML = str(innerHTML, "utf8")

expected = str(expected, "utf8")

if errors is not None:

errors = str(errors, "utf8")

errors = errors.split("\n")

p = html5parser.HTMLParser(tree = treeClass["builder"])

try:

if innerHTML:

document = p.parseFragment(io.BytesIO(input), innerHTML)

else:

document = p.parse(io.BytesIO(input))

except constants.DataLossWarning:

#Ignore testcases we know we don't pass

return

document = treeClass.get("adapter", lambda x: x)(document)

try:

output = convertTokens(treeClass["walker"](document))

output = attrlist.sub(sortattrs, output)

expected = attrlist.sub(sortattrs, convertExpected(expected))

self.assertEquals(expected, output, "\n".join([

"", "Input:", str(input, "utf8"),

"", "Expected:", expected,

"", "Received:", output

]))

except NotImplementedError:

def test_all_tokens(self):

expected = [

{'data': [], 'type': 'StartTag', 'name': 'html'},

{'data': [], 'type': 'StartTag', 'name': 'head'},

{'data': [], 'type': 'EndTag', 'name': 'head'},

{'data': [], 'type': 'StartTag', 'name': 'body'},

{'data': 'a', 'type': 'Characters'},

{'data': [], 'type': 'StartTag', 'name': 'div'},

{'data': 'b', 'type': 'Characters'},

{'data': [], 'type': 'EndTag', 'name': 'div'},

{'data': 'c', 'type': 'Characters'},

{'data': [], 'type': 'EndTag', 'name': 'body'},

{'data': [], 'type': 'EndTag', 'name': 'html'}

]

for treeName, treeCls in treeTypes.items():

p = html5parser.HTMLParser(tree = treeCls["builder"])

document = p.parse("<html><head></head><body>a<div>b</div>c</body></html>")

document = treeCls.get("adapter", lambda x: x)(document)

output = treeCls["walker"](document)

for expectedToken, outputToken in zip(expected, output):

sys.stdout.write('Testing tree walkers '+ " ".join(list(treeTypes.keys())) + "\n")

for treeName, treeCls in treeTypes.items():

files = html5lib_test_files('tree-construction')

files = [f for f in files if

not f.split(".")[-2][-2:] in ("s9", "10", "11", "12")] #skip namespace tests for now

for filename in files:

testName = os.path.basename(filename).replace(".dat","")

if testName == "tests5": continue # TODO

tests = TestData(filename, "data")

for index, test in enumerate(tests):

(input, errors,

innerHTML, expected) = [test[key] for key in ("data", "errors",

"document-fragment",

"document")]

def testFunc(self, innerHTML=innerHTML, input=input,

expected=expected, errors=errors, treeCls=treeCls):

self.runTest(innerHTML, input, expected, errors, treeCls)

setattr(TestCase, "test_%s_%d_%s" % (testName,index+1,treeName),

testFunc)