html5lib-python/src/html5lib/treebuilders/simpletree.py at python3-old · DKChan/html5lib-python · GitHub

History

executable file

219 lines (180 loc) · 6.25 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

from . import _base

from ..constants import voidElements

from xml.sax.saxutils import escape

# Really crappy basic implementation of a DOM-core like thing

class Node(_base.Node):

type = -1

def __init__(self, name):

self.name = name

self.parent = None

self.value = None

self.childNodes = []

self._flags = []

def __iter__(self):

for node in self.childNodes:

yield node

for item in node:

yield item

def __str__(self):

return self.name

def toxml(self):

raise NotImplementedError

def printTree(self, indent=0):

tree = '\n|%s%s' % (' '* indent, str(self))

for child in self.childNodes:

tree += child.printTree(indent + 2)

return tree

def appendChild(self, node):

if (isinstance(node, TextNode) and self.childNodes and

isinstance(self.childNodes[-1], TextNode)):

self.childNodes[-1].value += node.value

else:

self.childNodes.append(node)

node.parent = self

def insertText(self, data, insertBefore=None):

if insertBefore is None:

self.appendChild(TextNode(data))

else:

self.insertBefore(TextNode(data), insertBefore)

def insertBefore(self, node, refNode):

index = self.childNodes.index(refNode)

if (isinstance(node, TextNode) and index > 0 and

isinstance(self.childNodes[index - 1], TextNode)):

self.childNodes[index - 1].value += node.value

else:

self.childNodes.insert(index, node)

node.parent = self

def removeChild(self, node):

try:

self.childNodes.remove(node)

except:

# XXX

raise

node.parent = None

def cloneNode(self):

newNode = type(self)(self.name)

if hasattr(self, 'namespace'):

newNode.namespace = self.namespace

if hasattr(self, 'attributes'):

for attr, value in self.attributes.items():

newNode.attributes[attr] = value

newNode.value = self.value

return newNode

def hasContent(self):

"""Return true if the node has children or text"""

return bool(self.childNodes)

class Document(Node):

type = 1

def __init__(self):

Node.__init__(self, None)

def __str__(self):

return "#document"

def appendChild(self, child):

Node.appendChild(self, child)

def toxml(self, encoding="utf=8"):

result = ""

for child in self.childNodes:

result += child.toxml()

return result.encode(encoding)

def hilite(self, encoding="utf-8"):

result = "<pre>"

for child in self.childNodes:

result += child.hilite()

return result.encode(encoding) + "</pre>"

def printTree(self):

tree = str(self)

for child in self.childNodes:

tree += child.printTree(2)

return tree

class DocumentFragment(Document):

type = 2

def __str__(self):

return "#document-fragment"

class DocumentType(Node):

type = 3

def __init__(self, name, publicId, systemId):

Node.__init__(self, name)

self.publicId = publicId

self.systemId = systemId

def __str__(self):

if self.publicId or self.systemId:

publicId = self.publicId or ""

systemId = self.systemId or ""

return """<!DOCTYPE %s "%s" "%s">"""%(

self.name, publicId, systemId)

else:

return "<!DOCTYPE %s>" % self.name

toxml = __str__

def hilite(self):

return '<code class="markup doctype"><!DOCTYPE %s></code>' % self.name

class TextNode(Node):

type = 4

def __init__(self, value):

Node.__init__(self, None)

self.value = value

def __str__(self):

return "\"%s\"" % self.value

def toxml(self):

return escape(self.value)

hilite = toxml

class Element(Node):

type = 5

def __init__(self, name, namespace=None):

Node.__init__(self, name)

self.namespace = namespace

self.attributes = {}

def __str__(self):

return "<%s>" % self.name

def toxml(self):

result = '<' + self.name

if self.attributes:

for name,value in self.attributes.items():

result += ' %s="%s"' % (name, escape(value,{'"':'"'}))

if self.childNodes:

result += '>'

for child in self.childNodes:

result += child.toxml()

result += '</%s>' % self.name

else:

result += '/>'

return result

def hilite(self):

result = '<<code class="markup element-name">%s</code>' % self.name

if self.attributes:

for name, value in self.attributes.items():

result += ' <code class="markup attribute-name">%s</code>=<code class="markup attribute-value">"%s"</code>' % (name, escape(value, {'"':'"'}))

if self.childNodes:

result += ">"

for child in self.childNodes:

result += child.hilite()

elif self.name in voidElements:

return result + ">"

return result + '</<code class="markup element-name">%s</code>>' % self.name

def printTree(self, indent):

tree = '\n|%s%s' % (' '*indent, str(self))

indent += 2

if self.attributes:

for name, value in self.attributes.items():

tree += '\n|%s%s="%s"' % (' ' * indent, name, value)

for child in self.childNodes:

tree += child.printTree(indent)

return tree

class CommentNode(Node):

type = 6

def __init__(self, data):

Node.__init__(self, None)

self.data = data

def __str__(self):

return "" % self.data

def toxml(self):

return "" % self.data

def hilite(self):

return '<code class="markup comment"></code>' % escape(self.data)

class TreeBuilder(_base.TreeBuilder):

documentClass = Document

doctypeClass = DocumentType

elementClass = Element

commentClass = CommentNode

fragmentClass = DocumentFragment

def testSerializer(self, node):

return node.printTree()

html5lib-python/src/html5lib/treebuilders/simpletree.py at python3-old · DKChan/html5lib-python · GitHub

Expand file tree

Breadcrumbs

simpletree.py

Latest commit

History

Breadcrumbs

simpletree.py

File metadata and controls