html5lib-python/src/html5lib/treebuilders/etree.py at python3-old · dstufft/html5lib-python · GitHub

History

executable file

290 lines (239 loc) · 10.5 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

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

from . import _base

import types

from html5lib import ihatexml

moduleCache = {}

def getETreeModule(ElementTreeImplementation, fullTree=False):

name = "_" + ElementTreeImplementation.__name__+"builder"

if name in moduleCache:

return moduleCache[name]

else:

mod = types.ModuleType("_" + ElementTreeImplementation.__name__+"builder")

objs = getETreeBuilder(ElementTreeImplementation, fullTree)

mod.__dict__.update(objs)

moduleCache[name] = mod

return mod

def getETreeBuilder(ElementTreeImplementation, fullTree=False):

ElementTree = ElementTreeImplementation

class Element(_base.Node):

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

if namespace is None:

etree_tag = name

else:

etree_tag = "{%s}%s"%(name, namespace)

self._element = ElementTree.Element(etree_tag)

self.name = name

self.namespace = namespace

self.parent = None

self._childNodes = []

self._flags = []

def _setName(self, name):

self._element.tag = name

def _getName(self):

return self._element.tag

name = property(_getName, _setName)

def _getAttributes(self):

return self._element.attrib

def _setAttributes(self, attributes):

#Delete existing attributes first

#XXX - there may be a better way to do this...

for key in list(self._element.attrib.keys()):

del self._element.attrib[key]

for key, value in attributes.items():

self._element.set(key, value)

attributes = property(_getAttributes, _setAttributes)

def _getChildNodes(self):

return self._childNodes

def _setChildNodes(self, value):

while len(self._element):

del self._element[0]

self._childNodes = []

for element in value:

self.insertChild(element)

childNodes = property(_getChildNodes, _setChildNodes)

def hasContent(self):

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

return bool(self._element.text or self._element.getchildren())

def appendChild(self, node):

self._childNodes.append(node)

self._element.append(node._element)

node.parent = self

def insertBefore(self, node, refNode):

index = self._element.getchildren().index(refNode._element)

self._element.insert(index, node._element)

node.parent = self

def removeChild(self, node):

self._element.remove(node._element)

node.parent=None

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

if not(len(self._element)):

if not self._element.text:

self._element.text = ""

self._element.text += data

elif insertBefore is None:

#Insert the text as the tail of the last child element

if not self._element[-1].tail:

self._element[-1].tail = ""

self._element[-1].tail += data

else:

#Insert the text before the specified node

children = self._element.getchildren()

index = children.index(insertBefore._element)

if index > 0:

if not self._element[index-1].tail:

self._element[index-1].tail = ""

self._element[index-1].tail += data

else:

if not self._element.text:

self._element.text = ""

self._element.text += data

def cloneNode(self):

element = Element(self.name)

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

element.attributes[name] = value

return element

def reparentChildren(self, newParent):

if newParent.childNodes:

newParent.childNodes[-1]._element.tail += self._element.text

else:

if not newParent._element.text:

newParent._element.text = ""

if self._element.text is not None:

newParent._element.text += self._element.text

self._element.text = ""

_base.Node.reparentChildren(self, newParent)

class Comment(Element):

def __init__(self, data):

#Use the superclass constructor to set all properties on the

#wrapper element

self._element = ElementTree.Comment(data)

self.parent = None

self._childNodes = []

self._flags = []

def _getData(self):

return self._element.text

def _setData(self, value):

self._element.text = value

data = property(_getData, _setData)

class DocumentType(Element):

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

Element.__init__(self, "<!DOCTYPE>")

self._element.text = name

self.publicId = publicId

self.systemId = systemId

def _getPublicId(self):

return self._element.get("publicId", "")

def _setPublicId(self, value):

if value is not None:

self._element.set("publicId", value)

publicId = property(_getPublicId, _setPublicId)

def _getSystemId(self):

return self._element.get("systemId", "")

def _setSystemId(self, value):

if value is not None:

self._element.set("systemId", value)

systemId = property(_getSystemId, _setSystemId)

class Document(Element):

def __init__(self):

Element.__init__(self, "<DOCUMENT_ROOT>")

class DocumentFragment(Element):

def __init__(self):

Element.__init__(self, "<DOCUMENT_FRAGMENT>")

def testSerializer(element):

rv = []

finalText = None

def serializeElement(element, indent=0):

if not(hasattr(element, "tag")):

element = element.getroot()

if element.tag == "<!DOCTYPE>":

if element.get("publicId") or element.get("systemId"):

publicId = element.get("publicId") or ""

systemId = element.get("systemId") or ""

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

element.text, publicId, systemId))

else:

rv.append("<!DOCTYPE %s>"%(element.text,))

elif element.tag == "<DOCUMENT_ROOT>":

rv.append("#document")

if element.text:

rv.append("|%s\"%s\""%(' '*(indent+2), element.text))

if element.tail:

finalText = element.tail

elif type(element.tag) == type(ElementTree.Comment):

rv.append("|%s"%(' '*indent, element.text))

else:

rv.append("|%s<%s>"%(' '*indent, element.tag))

if hasattr(element, "attrib"):

for name, value in element.attrib.items():

rv.append('|%s%s="%s"' % (' '*(indent+2), name, value))

if element.text:

rv.append("|%s\"%s\"" %(' '*(indent+2), element.text))

indent += 2

for child in element.getchildren():

serializeElement(child, indent)

if element.tail:

rv.append("|%s\"%s\"" %(' '*(indent-2), element.tail))

serializeElement(element, 0)

if finalText is not None:

rv.append("|%s\"%s\""%(' '*2, finalText))

return "\n".join(rv)

def tostring(element):

"""Serialize an element and its child nodes to a string"""

rv = []

finalText = None

filter = ihatexml.InfosetFilter()

def serializeElement(element):

if type(element) == type(ElementTree.ElementTree):

element = element.getroot()

if element.tag == "<!DOCTYPE>":

if element.get("publicId") or element.get("systemId"):

publicId = element.get("publicId") or ""

systemId = element.get("systemId") or ""

rv.append( """<!DOCTYPE %s PUBLIC "%s" "%s">"""%(

element.text, publicId, systemId))

else:

rv.append("<!DOCTYPE %s>"%(element.text,))

elif element.tag == "<DOCUMENT_ROOT>":

if element.text:

rv.append(element.text)

if element.tail:

finalText = element.tail

for child in element.getchildren():

serializeElement(child)

elif type(element.tag) == type(ElementTree.Comment):

rv.append(""%(element.text,))

else:

#This is assumed to be an ordinary element

if not element.attrib:

rv.append("<%s>"%(filter.fromXmlName(element.tag),))

else:

attr = " ".join(["%s=\"%s\""%(

filter.fromXmlName(name), value)

for name, value in element.attrib.items()])

rv.append("<%s %s>"%(element.tag, attr))

if element.text:

rv.append(element.text)

for child in element.getchildren():

serializeElement(child)

rv.append("</%s>"%(element.tag,))

if element.tail:

rv.append(element.tail)

serializeElement(element)

if finalText is not None:

rv.append("%s\""%(' '*2, finalText))

return "".join(rv)

class TreeBuilder(_base.TreeBuilder):

documentClass = Document

doctypeClass = DocumentType

elementClass = Element

commentClass = Comment

fragmentClass = DocumentFragment

def testSerializer(self, element):

return testSerializer(element)

def getDocument(self):

if fullTree:

return self.document._element

else:

return self.document._element.find("html")

def getFragment(self):

return _base.TreeBuilder.getFragment(self)._element

return locals()

html5lib-python/src/html5lib/treebuilders/etree.py at python3-old · dstufft/html5lib-python · GitHub

Expand file tree

Breadcrumbs

etree.py

Latest commit

History

Breadcrumbs

etree.py

File metadata and controls