html5lib-python/html5lib/treebuilders/base.py at master · awesome-python/html5lib-python · GitHub

History

383 lines (318 loc) · 13.6 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

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

from __future__ import absolute_import, division, unicode_literals

from six import text_type

from ..constants import scopingElements, tableInsertModeElements, namespaces

# The scope markers are inserted when entering object elements,

# marquees, table cells, and table captions, and are used to prevent formatting

# from "leaking" into tables, object elements, and marquees.

Marker = None

listElementsMap = {

None: (frozenset(scopingElements), False),

"button": (frozenset(scopingElements | set([(namespaces["html"], "button")])), False),

"list": (frozenset(scopingElements | set([(namespaces["html"], "ol"),

(namespaces["html"], "ul")])), False),

"table": (frozenset([(namespaces["html"], "html"),

(namespaces["html"], "table")]), False),

"select": (frozenset([(namespaces["html"], "optgroup"),

(namespaces["html"], "option")]), True)

}

class Node(object):

def __init__(self, name):

"""Node representing an item in the tree.

name - The tag name associated with the node

parent - The parent of the current node (or None for the document node)

value - The value of the current node (applies to text nodes and

comments

attributes - a dict holding name, value pairs for attributes of the node

childNodes - a list of child nodes of the current node. This must

include all elements but not necessarily other node types

_flags - A list of miscellaneous flags that can be set on the node

"""

self.name = name

self.parent = None

self.value = None

self.attributes = {}

self.childNodes = []

self._flags = []

def __str__(self):

attributesStr = " ".join(["%s=\"%s\"" % (name, value)

for name, value in

self.attributes.items()])

if attributesStr:

return "<%s %s>" % (self.name, attributesStr)

else:

return "<%s>" % (self.name)

def __repr__(self):

return "<%s>" % (self.name)

def appendChild(self, node):

"""Insert node as a child of the current node

"""

raise NotImplementedError

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

"""Insert data as text in the current node, positioned before the

start of node insertBefore or to the end of the node's text.

"""

raise NotImplementedError

def insertBefore(self, node, refNode):

"""Insert node as a child of the current node, before refNode in the

list of child nodes. Raises ValueError if refNode is not a child of

the current node"""

raise NotImplementedError

def removeChild(self, node):

"""Remove node from the children of the current node

"""

raise NotImplementedError

def reparentChildren(self, newParent):

"""Move all the children of the current node to newParent.

This is needed so that trees that don't store text as nodes move the

text in the correct way

"""

# XXX - should this method be made more general?

for child in self.childNodes:

newParent.appendChild(child)

self.childNodes = []

def cloneNode(self):

"""Return a shallow copy of the current node i.e. a node with the same

name and attributes but with no parent or child nodes

"""

raise NotImplementedError

def hasContent(self):

"""Return true if the node has children or text, false otherwise

"""

raise NotImplementedError

class ActiveFormattingElements(list):

def append(self, node):

equalCount = 0

if node != Marker:

for element in self[::-1]:

if element == Marker:

break

if self.nodesEqual(element, node):

equalCount += 1

if equalCount == 3:

self.remove(element)

break

list.append(self, node)

def nodesEqual(self, node1, node2):

if not node1.nameTuple == node2.nameTuple:

return False

if not node1.attributes == node2.attributes:

return False

return True

class TreeBuilder(object):

"""Base treebuilder implementation

documentClass - the class to use for the bottommost node of a document

elementClass - the class to use for HTML Elements

commentClass - the class to use for comments

doctypeClass - the class to use for doctypes

"""

# pylint:disable=not-callable

# Document class

documentClass = None

# The class to use for creating a node

elementClass = None

# The class to use for creating comments

commentClass = None

# The class to use for creating doctypes

doctypeClass = None

# Fragment class

fragmentClass = None

def __init__(self, namespaceHTMLElements):

if namespaceHTMLElements:

self.defaultNamespace = "http://www.w3.org/1999/xhtml"

else:

self.defaultNamespace = None

self.reset()

def reset(self):

self.openElements = []

self.activeFormattingElements = ActiveFormattingElements()

# XXX - rename these to headElement, formElement

self.headPointer = None

self.formPointer = None

self.insertFromTable = False

self.document = self.documentClass()

def elementInScope(self, target, variant=None):

# If we pass a node in we match that. if we pass a string

# match any node with that name

exactNode = hasattr(target, "nameTuple")

if not exactNode:

if isinstance(target, text_type):

target = (namespaces["html"], target)

assert isinstance(target, tuple)

listElements, invert = listElementsMap[variant]

for node in reversed(self.openElements):

if exactNode and node == target:

return True

elif not exactNode and node.nameTuple == target:

return True

elif (invert ^ (node.nameTuple in listElements)):

return False

assert False # We should never reach this point

def reconstructActiveFormattingElements(self):

# Within this algorithm the order of steps described in the

# specification is not quite the same as the order of steps in the

# code. It should still do the same though.

# Step 1: stop the algorithm when there's nothing to do.

if not self.activeFormattingElements:

return

# Step 2 and step 3: we start with the last element. So i is -1.

i = len(self.activeFormattingElements) - 1

entry = self.activeFormattingElements[i]

if entry == Marker or entry in self.openElements:

return

# Step 6

while entry != Marker and entry not in self.openElements:

if i == 0:

# This will be reset to 0 below

i = -1

break

i -= 1

# Step 5: let entry be one earlier in the list.

entry = self.activeFormattingElements[i]

while True:

# Step 7

i += 1

# Step 8

entry = self.activeFormattingElements[i]

clone = entry.cloneNode() # Mainly to get a new copy of the attributes

# Step 9

element = self.insertElement({"type": "StartTag",

"name": clone.name,

"namespace": clone.namespace,

"data": clone.attributes})

# Step 10

self.activeFormattingElements[i] = element

# Step 11

if element == self.activeFormattingElements[-1]:

break

def clearActiveFormattingElements(self):

entry = self.activeFormattingElements.pop()

while self.activeFormattingElements and entry != Marker:

entry = self.activeFormattingElements.pop()

def elementInActiveFormattingElements(self, name):

"""Check if an element exists between the end of the active

formatting elements and the last marker. If it does, return it, else

return false"""

for item in self.activeFormattingElements[::-1]:

# Check for Marker first because if it's a Marker it doesn't have a

# name attribute.

if item == Marker:

break

elif item.name == name:

return item

return False

def insertRoot(self, token):

element = self.createElement(token)

self.openElements.append(element)

self.document.appendChild(element)

def insertDoctype(self, token):

name = token["name"]

publicId = token["publicId"]

systemId = token["systemId"]

doctype = self.doctypeClass(name, publicId, systemId)

self.document.appendChild(doctype)

def insertComment(self, token, parent=None):

if parent is None:

parent = self.openElements[-1]

parent.appendChild(self.commentClass(token["data"]))

def createElement(self, token):

"""Create an element but don't insert it anywhere"""

name = token["name"]

namespace = token.get("namespace", self.defaultNamespace)

element = self.elementClass(name, namespace)

element.attributes = token["data"]

return element

def _getInsertFromTable(self):

return self._insertFromTable

def _setInsertFromTable(self, value):

"""Switch the function used to insert an element from the

normal one to the misnested table one and back again"""

self._insertFromTable = value

if value:

self.insertElement = self.insertElementTable

else:

self.insertElement = self.insertElementNormal

insertFromTable = property(_getInsertFromTable, _setInsertFromTable)

def insertElementNormal(self, token):

name = token["name"]

assert isinstance(name, text_type), "Element %s not unicode" % name

namespace = token.get("namespace", self.defaultNamespace)

element = self.elementClass(name, namespace)

element.attributes = token["data"]

self.openElements[-1].appendChild(element)

self.openElements.append(element)

return element

def insertElementTable(self, token):

"""Create an element and insert it into the tree"""

element = self.createElement(token)

if self.openElements[-1].name not in tableInsertModeElements:

return self.insertElementNormal(token)

else:

# We should be in the InTable mode. This means we want to do

# special magic element rearranging

parent, insertBefore = self.getTableMisnestedNodePosition()

if insertBefore is None:

parent.appendChild(element)

else:

parent.insertBefore(element, insertBefore)

self.openElements.append(element)

return element

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

"""Insert text data."""

if parent is None:

parent = self.openElements[-1]

if (not self.insertFromTable or (self.insertFromTable and

self.openElements[-1].name

not in tableInsertModeElements)):

parent.insertText(data)

else:

# We should be in the InTable mode. This means we want to do

# special magic element rearranging

parent, insertBefore = self.getTableMisnestedNodePosition()

parent.insertText(data, insertBefore)

def getTableMisnestedNodePosition(self):

"""Get the foster parent element, and sibling to insert before

(or None) when inserting a misnested table node"""

# The foster parent element is the one which comes before the most

# recently opened table element

# XXX - this is really inelegant

lastTable = None

fosterParent = None

insertBefore = None

for elm in self.openElements[::-1]:

if elm.name == "table":

lastTable = elm

break

if lastTable:

# XXX - we should really check that this parent is actually a

# node here

if lastTable.parent:

fosterParent = lastTable.parent

insertBefore = lastTable

else:

fosterParent = self.openElements[

self.openElements.index(lastTable) - 1]

else:

fosterParent = self.openElements[0]

return fosterParent, insertBefore

def generateImpliedEndTags(self, exclude=None):

name = self.openElements[-1].name

# XXX td, th and tr are not actually needed

if (name in frozenset(("dd", "dt", "li", "option", "optgroup", "p", "rp", "rt")) and

name != exclude):

self.openElements.pop()

# XXX This is not entirely what the specification says. We should

# investigate it more closely.

self.generateImpliedEndTags(exclude)

def getDocument(self):

"Return the final tree"

return self.document

def getFragment(self):

"Return the final fragment"

# assert self.innerHTML

fragment = self.fragmentClass()

self.openElements[0].reparentChildren(fragment)

return fragment

def testSerializer(self, node):

"""Serialize the subtree of node in the format required by unit tests

node - the node from which to start serializing"""

raise NotImplementedError

html5lib-python/html5lib/treebuilders/base.py at master · awesome-python/html5lib-python · GitHub

Uh oh!

Expand file tree

Breadcrumbs

base.py

Latest commit

History

Breadcrumbs

base.py

File metadata and controls