def compilefile(file, mode=None):
assert mode in ("html", "xml", None)
if mode is None:
ext = os.path.splitext(file)[1]
if ext.lower() in (".html", ".htm"):
mode = "html"
else:
mode = "xml"
# make sure we can find the file
prefix = os.path.dirname(os.path.abspath(__file__)) + os.path.sep
if (not os.path.exists(file)
and os.path.exists(os.path.join(prefix, file))):
file = os.path.join(prefix, file)
# normalize filenames for test output
filename = os.path.abspath(file)
if filename.startswith(prefix):
filename = filename[len(prefix):]
filename = filename.replace(os.sep, '/') # test files expect slashes
# parse
from zope.tal.talgenerator import TALGenerator
if mode == "html":
from zope.tal.htmltalparser import HTMLTALParser
p = HTMLTALParser(gen=TALGenerator(source_file=filename, xml=0))
else:
from zope.tal.talparser import TALParser
p = TALParser(gen=TALGenerator(source_file=filename))
p.parseFile(file)
return p.getCode()
def _cook(self):
"""Compile the TAL and METAL statments.
Cooking must not fail due to compilation errors in templates.
"""
engine = self.pt_getEngine()
source_file = self.pt_source_file()
if self.content_type == 'text/html':
gen = TALGenerator(engine, xml=0, source_file=source_file)
parser = HTMLTALParser(gen)
else:
gen = TALGenerator(engine, source_file=source_file)
parser = TALParser(gen)
self._v_errors = ()
try:
parser.parseString(self._text)
self._v_program, self._v_macros = parser.getCode()
except:
etype, e = sys.exc_info()[:2]
self._v_errors = [
"Compilation failed",
"%s.%s: %s" % (etype.__module__, etype.__name__, e)
]
self._v_cooked = 1
def emitStartElement(self, name, attrlist, taldict, metaldict, i18ndict,
position=(None, None), isend=0):
metaldict = {}
taldict = {}
i18ndict = {}
if self.enabled and self.repldict:
taldict["attributes"] = "x x"
TALGenerator.emitStartElement(self, name, attrlist,
taldict, metaldict, i18ndict,
position, isend)
def cook(cls, source_file, text, engine, content_type):
if content_type == 'text/html':
gen = TALGenerator(engine, xml=0, source_file=source_file)
parser = HTMLTALParser(gen)
else:
gen = TALGenerator(engine, source_file=source_file)
parser = TALParser(gen)
parser.parseString(text)
program, macros = parser.getCode()
return cls(program), macros
def emitStartElement(self,
name,
attrlist,
taldict,
metaldict,
i18ndict,
position=(None, None),
isend=0):
metaldict = {}
taldict = {}
i18ndict = {}
if self.enabled and self.repldict:
taldict["attributes"] = "x x"
TALGenerator.emitStartElement(self, name, attrlist, taldict, metaldict,
i18ndict, position, isend)
def talEval(expression, context, extra=None):
"""
Perform a TAL eval on the expression.
"""
# First, account for the possibility that it is merely TALES; if there are
# no <tal> in it at all (nor the ${python:} you can do with this function),
# just send it to talesEval
isTales = '<tal' not in expression and '${python:' not in expression
if isTales:
return talesEvalStr(expression, context, extra)
# Next, as a convenience, replace all ${} blocks that aren't inside a <tal>
# with <tal:block content="..."/> equivalent
chunks = TAG.split(expression)
modified = []
for chunk in chunks:
if chunk.startswith('<tal'):
modified.append(chunk)
else:
modified.append(TPLBLOCK.sub(_chunk_repl, chunk))
expression = ''.join(modified)
# Finally, compile the expression and apply context
gen = TALGenerator(Engine, xml=0)
parser = HTMLTALParser(gen)
parser.parseString(expression)
program, macros = parser.getCode()
output = cStringIO.StringIO()
context = Engine.getContext(context)
TALInterpreter(program, macros, context, output, tal=True)()
return output.getvalue()
def __call__(self, value, *args, **kw):
gen = TALGenerator(getEngine(), xml=1, source_file=None)
parser = HTMLTALParser(gen)
try:
parser.parseString(value)
except Exception, err:
return ("Validation Failed(%s): \n %s" % (self.name, err))
def __init__(self, gen=None, encoding=None): # Override
XMLParser.__init__(self, encoding)
if gen is None:
gen = TALGenerator()
self.gen = gen
self.nsStack = []
self.nsDict = {XML_NS: 'xml'}
self.nsNew = []
def __init__(self, gen=None):
HTMLParser.__init__(self)
if gen is None:
gen = TALGenerator(xml=0)
self.gen = gen
self.tagstack = []
self.nsstack = []
self.nsdict = {'tal': ZOPE_TAL_NS,
'metal': ZOPE_METAL_NS,
'i18n': ZOPE_I18N_NS,
}
def __init__(self, gen=None, encoding=None): # Override
"""
:keyword TALGenerator gen: The configured (with an expression compiler)
code generator to use. If one is not given, a default will be used.
"""
XMLParser.__init__(self, encoding)
if gen is None:
gen = TALGenerator()
self.gen = gen
self.nsStack = []
self.nsDict = {XML_NS: 'xml'}
self.nsNew = []
def compilefile(file, mode=None):
assert mode in ("html", "xml", None)
if mode is None:
ext = os.path.splitext(file)[1]
if ext.lower() in (".html", ".htm"):
mode = "html"
else:
mode = "xml"
from zope.tal.talgenerator import TALGenerator
filename = os.path.abspath(file)
prefix = os.path.dirname(os.path.abspath(__file__)) + os.path.sep
if filename.startswith(prefix):
filename = filename[len(prefix):]
filename = filename.replace(os.sep, '/') # test files expect slashes
if mode == "html":
from zope.tal.htmltalparser import HTMLTALParser
p = HTMLTALParser(gen=TALGenerator(source_file=filename, xml=0))
else:
from zope.tal.talparser import TALParser
p = TALParser(gen=TALGenerator(source_file=filename))
p.parseFile(file)
return p.getCode()
def __init__(self, gen=None):
"""
:keyword TALGenerator gen: The configured (with an expression compiler)
code generator to use. If one is not given, a default will be used.
"""
HTMLParser.__init__(self, **_html_parser_extras)
if gen is None:
gen = TALGenerator(xml=0)
self.gen = gen
self.tagstack = []
self.nsstack = []
self.nsdict = {
'tal': ZOPE_TAL_NS,
'metal': ZOPE_METAL_NS,
'i18n': ZOPE_I18N_NS,
}
def findStaticTranslationText(page_template, func_name_list):
def iterate(node, target_name, function):
if isinstance(node, list):
for i in node:
iterate(i, target_name, function)
elif isinstance(node, tuple) and node:
if node[0]==target_name:
function(node)
else:
for i in node[1:]:
iterate(i, target_name, function)
text_dict = {}
def addText(node):
if len(node)!=2:
node = (node[0], node[1:])
program = [node]
macros = {}
engine = MyDummyEngine(macros)
output = StringIO()
interpreter = MyDummyTALInterpreter(program, macros, engine, output)
interpreter()
if interpreter._i18n_message_id_dict is not None:
text_dict.update(interpreter._i18n_message_id_dict)
def addTextFromPythonExpression(node):
if node[0]=='insertText':
tal_expression = node[1]
if isinstance(tal_expression, (tuple, list)):
tal_expression = tal_expression[0]
elif node[0] in ('setLocal', 'setGlobal'):
if len(node)==2:
tal_expression = node[1][1]
elif len(node)==3:
tal_expression = node[2]
else:
return
else:
return
tal_expression = tal_expression[1:-1]
match = name_match(tal_expression)
if match:
type_, expression = match.group(1, 2)
if type_=='python':
# clean up expression
expression = expression.strip()
expression = expression.replace('\n', ' ')
Base_getFunctionFirstArgumentValue = page_template.Base_getFunctionFirstArgumentValue
for func_name in func_name_list:
for message in Base_getFunctionFirstArgumentValue(func_name, expression):
text_dict[message] = None
if page_template.html():
generator = TALGenerator(xml=0)
parser = HTMLTALParser(generator)
else:
generator = TALGenerator(xml=1)
parser = TALParser(generator)
parser.parseString(page_template._text)
iterate(parser.gen.program, 'insertTranslation', addText)
iterate(parser.gen.program, 'insertText', addTextFromPythonExpression)
iterate(parser.gen.program, 'setLocal', addTextFromPythonExpression)
iterate(parser.gen.program, 'setGlobal', addTextFromPythonExpression)
return text_dict.keys()
def replaceAttrs(self, attrlist, repldict):
if self.enabled and self.repldict:
repldict = self.repldict
self.repldict = None
return TALGenerator.replaceAttrs(self, attrlist, repldict)
def emit(self, *args):
if self.enabled:
TALGenerator.emit(self, *args)
def __init__(self, repldict, expressionCompiler=None, xml=0):
self.repldict = repldict
self.enabled = 1
TALGenerator.__init__(self, expressionCompiler, xml)
def replaceAttrs(self, attrlist, repldict):
if self.enabled and self.repldict:
repldict = self.repldict
self.repldict = None
return TALGenerator.replaceAttrs(self, attrlist, repldict)
def emit(self, *args):
if self.enabled:
TALGenerator.emit(self, *args)
def __init__(self, repldict, expressionCompiler=None, xml=0):
self.repldict = repldict
self.enabled = 1
TALGenerator.__init__(self, expressionCompiler, xml)
def _compile(self, source, source_file=None):
generator = TALGenerator(xml=0, source_file=source_file)
parser = HTMLTALParser(generator)
parser.parseString(source)
program, macros = parser.getCode()
return program, macros
def parse(self, eng, s, fn):
gen = TALGenerator(expressionCompiler=eng, xml=0, source_file=fn)
parser = HTMLTALParser(gen)
parser.parseString(s)
program, macros = parser.getCode()
return program, macros
