def parseTag(self, match_ob, command=None, sargs=''):
"""Parse a tag using an already matched re
Return: tag, args, command, coname
where: tag is the tag,
args is the tag\'s argument string,
command is a corresponding command info structure if the
tag is a start tag, or None otherwise, and
coname is the name of a continue tag (e.g. else)
or None otherwise
"""
tag, end, name, args = match_ob.group(0, 'end', 'name', 'args')
args = args.strip()
if end:
if not command or name != command.name:
raise ParseError('unexpected end tag', tag)
return tag, args, None, None
if command and name in command.blockContinuations:
if name == 'else' and args:
# Waaaaaah! Have to special case else because of
# old else start tag usage. Waaaaaaah!
l_ = len(args)
if not (args == sargs
or args == sargs[:l_] and sargs[l_:l_ + 1] in ' \t\n'):
return tag, args, self.commands[name], None
return tag, args, None, name
try:
return tag, args, self.commands[name], None
except KeyError:
raise ParseError('Unexpected tag', tag)
def __init__(self, blocks, encoding=None):
self.encoding = encoding
tname, args, section = blocks[0]
args = parse_params(
args,
name=None,
expr=None,
nowrap=1,
expand=None,
leaves=None,
header=None,
footer=None,
branches=None,
branches_expr=None,
sort=None,
reverse=1,
skip_unauthorized=1,
id=None,
single=1,
url=None,
# opened_decoration=None,
# closed_decoration=None,
# childless_decoration=None,
assume_children=1,
urlparam=None,
prefix=None)
if '' in args or 'name' in args or 'expr' in args:
name, expr = name_param(args, 'tree', 1)
if expr is not None:
args['expr'] = expr
elif '' in args:
args['name'] = name
else:
name = 'a tree tag'
if 'branches_expr' in args:
if 'branches' in args:
raise ParseError('branches and and branches_expr given',
'tree')
args['branches_expr'] = Eval(args['branches_expr']).eval
elif 'branches' not in args:
args['branches'] = 'tpValues'
if 'id' not in args:
args['id'] = 'tpId'
if 'url' not in args:
args['url'] = 'tpURL'
if 'childless_decoration' not in args:
args['childless_decoration'] = ''
prefix = args.get('prefix')
if prefix and not simple_name(prefix):
raise ParseError('prefix is not a simple name', 'tree')
self.__name__ = name
self.section = section.blocks
self.args = args
def __init__(self, args):
args = parse_params(args, name='', expr='', type=None, optional=1)
name, expr = name_param(args, 'sqlvar', 1)
if expr is None: expr = name
else: expr = expr.eval
self.__name__, self.expr = name, expr
self.args = args
if not args.has_key('type'):
raise ParseError('the type attribute is required', 'dtvar')
t = args['type']
if not valid_type(t):
raise ParseError('invalid type, %s' % t, 'dtvar')
def parse_let_params(
text,
result=None,
tag='let',
parmre=re.compile('([\000- ]*([^\000- ="]+)=([^\000- ="]+))'),
qparmre=re.compile('([\000- ]*([^\000- ="]+)="([^"]*)")'),
**parms):
result = result or []
mo = parmre.match(text)
mo1 = qparmre.match(text)
if mo is not None:
name = mo.group(2)
value = mo.group(3)
l_ = len(mo.group(1))
elif mo1 is not None:
name = mo1.group(2)
value = '"%s"' % mo1.group(3)
l_ = len(mo1.group(1))
else:
if not text or not text.strip():
return result
raise ParseError('invalid parameter: "%s"' % text, tag)
result.append((name, value))
text = text[l_:].strip()
if text:
return parse_let_params(text, result, tag, **parms)
else:
return result
def __init__(self, args, encoding=None):
self.encoding = encoding
args = parse_params(args, name='', expr='', type=None, optional=1)
name, expr = name_param(args, 'sqlvar', 1)
if expr is None:
expr = name
else:
expr = expr.eval
self.__name__, self.expr = name, expr
self.args = args
if 'type' not in args:
raise ParseError('the type attribute is required', 'dtvar')
t = args['type']
if t not in valid_types:
raise ParseError('invalid type, %s' % t, 'dtvar')
def __init__(self, blocks, encoding=None):
tname, args, section = blocks[0]
self.args = parse_params(args)
self.section = section.blocks
self.encoding = encoding
# Find out if this is a try..finally type
if len(blocks) == 2 and blocks[1][0] == 'finally':
self.finallyBlock = blocks[1][2].blocks
# This is a try [except]* [else] block.
else:
# store handlers as tuples (name,block)
self.handlers = []
defaultHandlerFound = 0
for tname, nargs, nsection in blocks[1:]:
if tname == 'else':
if self.elseBlock is not None:
raise ParseError(
'No more than one else block is allowed',
self.name)
self.elseBlock = nsection.blocks
elif tname == 'finally':
raise ParseError(
'A try..finally combination cannot contain '
'any other else, except or finally blocks', self.name)
else:
if self.elseBlock is not None:
raise ParseError(
'The else block should be the last block '
'in a try tag', self.name)
for errname in nargs.split():
self.handlers.append((errname, nsection.blocks))
if nargs.strip() == '':
if defaultHandlerFound:
raise ParseError(
'Only one default exception handler '
'is allowed', self.name)
else:
defaultHandlerFound = 1
self.handlers.append(('', nsection.blocks))
def __init__(self, args, encoding=None):
self.encoding = encoding
args = parse_params(args,
name='',
expr='',
type=None,
column=None,
multiple=1,
optional=1,
op=None)
name, expr = name_param(args, 'sqlvar', 1)
if expr is None:
expr = name
else:
expr = expr.eval
self.__name__, self.expr = name, expr
self.args = args
if 'type' not in args:
raise ParseError('the type attribute is required', 'sqltest')
self.type = t = args['type']
if t not in valid_types:
raise ParseError('invalid type, %s' % t, 'sqltest')
if 'optional' in args:
self.optional = args['optional']
if 'multiple' in args:
self.multiple = args['multiple']
if 'column' in args:
self.column = args['column']
elif self.__name__ is None:
err = ' the column attribute is required if an expression is used'
raise ParseError(err, 'sqltest')
else:
self.column = self.__name__
# Deal with optional operator specification
op = '=' # Default
if 'op' in args:
op = args['op']
# Try to get it from the chart, otherwise use the one provided
op = comparison_operators.get(op, op)
self.op = op
def __init__(self, blocks, encoding=None):
tname, args, section = blocks[0]
args = parse_params(args, name='', expr='')
name, expr = name_param(args, 'if', 1)
self.__name__ = name
self.encoding = encoding
if expr is None:
cond = name
else:
cond = expr.eval
sections = [cond, section.blocks]
if blocks[-1][0] == 'else':
tname, args, section = blocks[-1]
del blocks[-1]
args = parse_params(args, name='')
if args:
ename, expr = name_param(args, 'else', 1)
if ename != name:
raise ParseError('name in else does not match if', 'in')
elses = section.blocks
else:
elses = None
for tname, args, section in blocks[1:]:
if tname == 'else':
raise ParseError('more than one else tag for a single if tag',
'in')
args = parse_params(args, name='', expr='')
name, expr = name_param(args, 'elif', 1)
if expr is None:
cond = name
else:
cond = expr.eval
sections.append(cond)
sections.append(section.blocks)
if elses is not None:
sections.append(elses)
self.simple_form = ('i', ) + tuple(sections)
def name_or_expr(mapping, name_attr, expr_attr, default):
name = mapping.get(name_attr, None)
expr = mapping.get(expr_attr, None)
if name is None:
if expr is None:
return default
return Eval(expr)
if expr is None:
return name
raise ParseError('%s and %s given' % (name_attr, expr_attr), 'calendar')
def __init__(self, blocks):
tname, args, section = blocks[0]
self.__name__ = args
self.section = section.blocks
self.args = args = parse_let_params(args)
for i in range(len(args)):
name, expr = args[i]
if expr[:1] == '"' and expr[-1:] == '"' and len(expr) > 1:
# expr shorthand
expr = expr[1:-1]
try:
args[i] = name, Eval(expr).eval
except SyntaxError as v:
m, (huh, l, c, src) = v
raise ParseError(
'<strong>Expression (Python) Syntax error</strong>:'
'\n<pre>\n%s\n</pre>\n' % v[0], 'let')
def __init__(self, blocks):
tname, args, section = blocks[0]
args = parse_params(args,
name='',
start='1',
end='-1',
size='10',
orphan='0',
overlap='1',
mapping=1,
no_push_item=1,
skip_unauthorized=1,
previous=1,
next=1,
expr='',
sort='',
reverse=1,
sort_expr='',
reverse_expr='',
prefix='')
self.args = args
if 'sort' in args:
self.sort = sort = args['sort']
if sort == 'sequence-item':
self.sort = ''
if 'sort_expr' in args:
self.sort_expr = Eval(args['sort_expr'])
if 'reverse_expr' in args:
self.reverse_expr = Eval(args['reverse_expr'])
if 'reverse' in args:
self.reverse = args['reverse']
if 'no_push_item' in args:
self.no_push_item = args['no_push_item']
if 'mapping' in args:
self.mapping = args['mapping']
for n in 'start', 'size', 'end':
if n in args:
self.batch = 1
prefix = args.get('prefix')
if prefix and not simple_name(prefix):
raise ParseError('prefix is not a simple name', 'in')
for n in ('orphan', 'overlap', 'previous', 'next'):
if n in args and not self.batch:
raise ParseError(
"""
The %s attribute was used but neither of the
<code>start</code>, <code>end</code>, or <code>size</code>
attributes were used.
""" % n, 'in')
if 'start' in args:
v = args['start']
if isinstance(v, str):
try:
int(v)
except Exception:
self.start_name_re = re.compile(
'&+' + ''.join(["[%s]" % c for c in v]) + '=[0-9]+&+')
name, expr = name_param(args, 'in', 1)
if expr is not None:
expr = expr.eval
self.__name__, self.expr = name, expr
self.section = section.blocks
if len(blocks) > 1:
if len(blocks) != 2:
raise ParseError('too many else blocks', 'in')
tname, args, section = blocks[1]
args = parse_params(args, name='')
if args:
ename = name_param(args)
if ename != name:
raise ParseError('name in else does not match in', 'in')
self.elses = section.blocks
def parse_error(self, mess, tag, text, start):
raise ParseError(
"%s, for tag %s, on line %s of %s" %
(mess, self.errQuote(tag), len(
text[:start].split('\n')), self.errQuote(self.__name__)))
def __init__(self, blocks, encoding=None):
self.encoding = encoding
self.sections = []
self.multipart = 'mixed'
for tname, args, section in blocks:
if tname == 'mime':
args = parse_params(args,
type=None,
type_expr=None,
disposition=None,
disposition_expr=None,
encode=None,
encode_expr=None,
name=None,
name_expr=None,
filename=None,
filename_expr=None,
cid=None,
cid_expr=None,
charset=None,
charset_expr=None,
skip_expr=None,
multipart=None)
self.multipart = args.get('multipart', 'mixed')
else:
args = parse_params(args,
type=None,
type_expr=None,
disposition=None,
disposition_expr=None,
encode=None,
encode_expr=None,
name=None,
name_expr=None,
filename=None,
filename_expr=None,
cid=None,
cid_expr=None,
charset=None,
charset_expr=None,
skip_expr=None)
if 'type_expr' in args:
if 'type' in args:
raise ParseError('dtml-mime: type and type_expr given')
args['type_expr'] = Eval(args['type_expr'])
elif 'type' not in args:
args['type'] = 'application/octet-stream'
if 'disposition_expr' in args:
if 'disposition' in args:
raise ParseError(
'dtml-mime: disposition and disposition_expr given')
args['disposition_expr'] = Eval(args['disposition_expr'])
elif 'disposition' not in args:
args['disposition'] = ''
if 'encode_expr' in args:
if 'encode' in args:
raise ParseError('dtml-mime: encode and encode_expr given')
args['encode_expr'] = Eval(args['encode_expr'])
elif 'encode' not in args:
args['encode'] = 'base64'
if 'name_expr' in args:
if 'name' in args:
raise ParseError('dtml-mime: name and name_expr given')
args['name_expr'] = Eval(args['name_expr'])
elif 'name' not in args:
args['name'] = ''
if 'filename_expr' in args:
if 'filename' in args:
raise ParseError(
'dtml-mime: filename and filename_expr given')
args['filename_expr'] = Eval(args['filename_expr'])
elif 'filename' not in args:
args['filename'] = ''
if 'cid_expr' in args:
if 'cid' in args:
raise ParseError('dtml-mime: cid and cid_expr given')
args['cid_expr'] = Eval(args['cid_expr'])
elif 'cid' not in args:
args['cid'] = ''
if 'charset_expr' in args:
if 'charset' in args:
raise ParseError(
'dtml-mime: charset and charset_expr given')
args['charset_expr'] = Eval(args['charset_expr'])
elif 'charset' not in args:
args['charset'] = 'us-ascii' # Default for text parts
if 'skip_expr' in args:
args['skip_expr'] = Eval(args['skip_expr'])
if args['encode'] not in ENCODINGS:
raise MIMEError('An unsupported encoding was specified in tag')
self.sections.append((args, section.blocks))