124 lines
5.7 KiB
Python
124 lines
5.7 KiB
Python
# ------------------------------------------------------------------------------
|
|
from appy.shared.xml_parser import XmlEnvironment, XmlParser
|
|
from appy.pod.buffers import MemoryBuffer
|
|
|
|
# ------------------------------------------------------------------------------
|
|
class PxEnvironment(XmlEnvironment):
|
|
'''Environment for the PX parser.'''
|
|
|
|
def __init__(self):
|
|
# In the following buffer, we will create a single memory sub-buffer
|
|
# that will hold the result of parsing the PX = a hierarchy of memory
|
|
# buffers = PX's AST (Abstract Syntax Tree).
|
|
# A major difference between POD and PX: POD creates the AST and
|
|
# generates the result in the same step: one AST is generated, and then
|
|
# directly produces a single evaluation, in the root file buffer. PX
|
|
# works in 2 steps: the AST is initially created in self.ast. Then,
|
|
# several (concurrent) evaluations can occur, without re-generating the
|
|
# AST.
|
|
self.ast = MemoryBuffer(self, None)
|
|
# Buffer where we must dump the content we are currently reading
|
|
self.currentBuffer = self.ast
|
|
# Tag content we are currently reading. We will put something in this
|
|
# attribute only if we encounter content that is Python code.
|
|
# Else, we will directly dump the parsed content into the current
|
|
# buffer.
|
|
self.currentContent = ''
|
|
# The currently walked element. We redefine it here. This attribute is
|
|
# normally managed by the parent XmlEnvironment, but we do not use the
|
|
# standard machinery from this environmment and from the default
|
|
# XmlParser for better performance. Indeed, the base parser and env
|
|
# process namespaces, and we do not need this for the PX parser.
|
|
self.currentElem = None
|
|
|
|
def addSubBuffer(self):
|
|
subBuffer = self.currentBuffer.addSubBuffer()
|
|
self.currentBuffer = subBuffer
|
|
|
|
def isActionElem(self, elem):
|
|
'''Returns True if the currently walked p_elem is the same elem as the
|
|
main buffer elem.'''
|
|
action = self.currentBuffer.action
|
|
return action and (action.elem == elem)
|
|
|
|
# ------------------------------------------------------------------------------
|
|
class PxParser(XmlParser):
|
|
'''PX parser that is specific for parsing PX data.'''
|
|
pxAttributes = ('var', 'for', 'if')
|
|
# No-end tags
|
|
noEndTags = ('br', 'img', 'link', 'input')
|
|
noDumpTags = ('selected', 'checked')
|
|
|
|
def __init__(self, env, caller=None):
|
|
XmlParser.__init__(self, env, caller)
|
|
|
|
def startElement(self, elem, attrs):
|
|
'''A start p_elem with p_attrs is encountered in the PX.'''
|
|
e = self.env
|
|
self.currentElem = elem
|
|
# See if we have a PX attribute among p_attrs.
|
|
found = False
|
|
for name in self.pxAttributes:
|
|
if attrs.has_key(name):
|
|
if not found:
|
|
# This is the first PX attr we find.
|
|
# Create a sub-buffer with an action.
|
|
e.addSubBuffer()
|
|
found = True
|
|
# Add the action.
|
|
e.currentBuffer.createPxAction(elem, name, attrs[name])
|
|
if e.isActionElem(elem):
|
|
# Add a temp element in the buffer (that will be unreferenced
|
|
# later). This way, when encountering the corresponding end element,
|
|
# we will be able to check whether the end element corresponds to
|
|
# the main element or to a sub-element.
|
|
e.currentBuffer.addElement(elem, elemType='px')
|
|
if elem != 'x':
|
|
# Dump the start elements and its attributes. But as a preamble,
|
|
# manage special attributes that could not be dumped at all, like
|
|
# "selected" or "checked".
|
|
hook = None
|
|
ignorableAttrs = self.pxAttributes
|
|
for name in self.noDumpTags:
|
|
if attrs.has_key(name) and attrs[name].startswith(':'):
|
|
hook = (name, attrs[name][1:])
|
|
ignorableAttrs += (name,)
|
|
break
|
|
e.currentBuffer.dumpStartElement(elem, attrs,
|
|
ignoreAttrs=ignorableAttrs, noEndTag=elem in self.noEndTags,
|
|
hook=hook)
|
|
|
|
def endElement(self, elem):
|
|
e = self.env
|
|
# Manage the potentially collected Python expression in
|
|
# e.currentContent.
|
|
if e.currentContent:
|
|
e.currentBuffer.addExpression(e.currentContent)
|
|
e.currentContent = ''
|
|
# Dump the end element into the current buffer
|
|
if (elem != 'x') and (elem not in self.noEndTags):
|
|
e.currentBuffer.dumpEndElement(elem)
|
|
# If this element is the main element of the current buffer, we must
|
|
# pop it and continue to work in the parent buffer.
|
|
if e.isActionElem(elem):
|
|
# Is it the buffer main element?
|
|
isMainElement = e.currentBuffer.isMainElement(elem)
|
|
# Unreference the element among buffer.elements
|
|
e.currentBuffer.unreferenceElement(elem)
|
|
if isMainElement:
|
|
# Continue to work in the parent buffer
|
|
e.currentBuffer = e.currentBuffer.parent
|
|
|
|
def characters(self, content):
|
|
e = self.env
|
|
if not e.currentContent and content.startswith(':'):
|
|
# This content is not static content to dump as-is into the result:
|
|
# it is a Python expression.
|
|
e.currentContent += content[1:]
|
|
elif e.currentContent:
|
|
# We continue to dump the Python expression.
|
|
e.currentContent += content
|
|
else:
|
|
e.currentBuffer.dumpContent(content)
|
|
# ------------------------------------------------------------------------------
|