def end_mapping(self, name=None):
""" Create an end-mapping tag (a literal). If ``name`` is ``None``,
the name of this node will be used to generate the name in the tag.
See the :term:`Peppercorn` documentation for more information.
"""
if name is None:
name = self.name
tag = '<input type="hidden" name="__end__" value="%s:mapping"/>'
return Markup(tag % (name, ))
def start_sequence(self, name=None):
""" Create a start-sequence tag (a literal). If ``name`` is ``None``,
the name of this node will be used to generate the name in the tag.
See the :term:`Peppercorn` documentation for more information.
"""
if name is None:
name = self.name
tag = '<input type="hidden" name="__start__" value="%s:sequence"/>'
return Markup(tag % (name, ))
def save_coverage(tree, templates, output_dir, app_name, granularity):
groups = Utils2.get_groupped_classes(tree)
init_row = templates['init_row.pt']
init_table = templates['init_table.pt']
index_template = templates['index.pt']
rows = []
total_coverage_data = CoverageData()
for g in groups:
(package, path,
coverage_data) = save_package_indexhtml(g, templates, output_dir,
app_name, granularity)
coverage = coverage_data.get_formatted_coverage(granularity)
row = init_row(
elementlink=path,
type='package',
elementname=package,
coverage=coverage,
respath='',
coverage_data=coverage_data,
is_instruction_level=Granularity.is_instruction(granularity),
progress_covered=coverage_data.covered(granularity),
progress_missed=coverage_data.missed(granularity))
rows.append(Markup(row))
total_coverage_data.add_data(coverage_data)
total_coverage = total_coverage_data.get_formatted_coverage(granularity)
table = init_table(
rows=Markup("\n".join(rows)),
total_coverage=total_coverage,
total_coverage_data=total_coverage_data,
is_instruction_level=Granularity.is_instruction(granularity),
progress_covered=total_coverage_data.covered(granularity),
progress_all=total_coverage_data.coverable(granularity))
root_path = ''
html = index_template(table=Markup(table),
appname=app_name,
title=app_name,
package=None,
respath=root_path,
file_name=None,
granularity=Granularity.get(granularity))
path = os.path.join(output_dir, 'index.html')
with open(path, 'w') as f:
f.write(html)
def __call__(self, econtext):
name = super(TileExpression, self).__call__(econtext)
context = econtext.vars["context"]
request = econtext.vars["request"]
tile = getTile(context, request, name)
if tile is None: # XXX Use custom exception?
log.warning("Request for unknown tile %s", name)
return ""
return Markup(tile())
def populate_tos(self):
url = self.request.app.org.meta.get('tos_url', None)
if not url or self.request.current_user.data.get('tos_accepted', None):
self.delete_field('accept_tos')
return
layout = DefaultLayout(self.model, self.request)
self.accept_tos.description = Markup(
render_macro(layout.macros['accept_tos'], self.request,
{'url': url}))
def __init__(self,
schema,
action="",
method="POST",
buttons=(),
formid="deform",
use_ajax=False,
ajax_options="{}",
autocomplete=None,
focus="on",
**kw):
if autocomplete:
autocomplete = "on"
elif autocomplete is not None:
autocomplete = "off"
self.autocomplete = autocomplete
if str(focus).lower() == "off":
self.focus = "off"
else:
self.focus = "on"
# Use kwargs to pass flags to descendant fields; saves cluttering
# the constructor
kw["focus"] = self.focus
field.Field.__init__(self, schema, **kw)
_buttons = []
for button in buttons:
if isinstance(button, compat.string_types):
button = Button(button)
_buttons.append(button)
self.action = action
self.method = method
self.buttons = _buttons
self.formid = formid
self.use_ajax = use_ajax
self.ajax_options = Markup(ajax_options.strip())
form_widget = getattr(schema, "widget", None)
if form_widget is None:
form_widget = widget.FormWidget()
self.widget = form_widget
def __init__(self, schema, action='', method='POST', buttons=(),
formid='deform', use_ajax=False, ajax_options='{}',
autocomplete=None, **kw):
if autocomplete:
autocomplete = 'on'
elif autocomplete is not None:
autocomplete = 'off'
self.autocomplete = autocomplete
field.Field.__init__(self, schema, **kw)
_buttons = []
for button in buttons:
if isinstance(button, compat.string_types):
button = Button(button)
_buttons.append(button)
self.action = action
self.method = method
self.buttons = _buttons
self.formid = formid
self.use_ajax = use_ajax
self.ajax_options = Markup(ajax_options.strip())
form_widget = getattr(schema, 'widget', None)
if form_widget is None:
form_widget = widget.FormWidget()
self.widget = form_widget
def save_class(cl, class_template, output_dir, app_name, granularity):
dir = os.path.join(output_dir, cl.folder)
if not os.path.exists(dir):
os.makedirs(dir)
class_path = os.path.join(dir, cl.file_name + '.html')
buf = [LI_TAG(d) for d in cl.get_class_description()]
buf.append(LI_TAG(''))
buf.extend([LI_TAG(a) for a in cl.get_annotations()])
buf.append(LI_TAG(''))
buf.extend([LI_TAG(f) for f in cl.get_fields()])
buf.append(LI_TAG(''))
for m in cl.methods:
ins_buf = []
for ins in m.insns:
if ins.covered:
ins_buf.append(span_tab_tag(ins.buf, COV_CLASS))
else:
ins_buf.append(span_tab_tag(ins.buf))
# insert labels and tries
# sort the labels by index
count = 0
labels = m.labels.values()
labels = sorted(labels, key=attrgetter('index'))
for l in labels:
if l.covered:
ins_buf.insert(l.index + count, span_tab_tag(l.buf, COV_CLASS))
else:
ins_buf.insert(l.index + count, span_tab_tag(l.buf))
count += 1
for t in l.tries:
ins_buf.insert(l.index + count, span_tab_tag(t.buf))
count += 1
if l.switch:
for sl in l.switch.buf:
ins_buf.insert(l.index + count, span_tab_tag(sl))
count += 1
if l.array_data:
for sl in l.array_data.buf:
ins_buf.insert(l.index + count, span_tab_tag(sl))
count += 1
ins_buf.insert(0, LI_TAG(''))
for a in m.annotations:
a.reload()
ins_buf[0:0] = [span_tab_tag(d) for d in a.buf]
for p in reversed(m.parameters):
p.reload()
ins_buf[0:0] = [span_tab_tag(d) for d in p.buf]
ins_buf.insert(0, span_tab_tag(m.get_registers_line()))
html_method_line = span_tag(
cgi.escape(m.get_method_line()),
COV_CLASS) if m.called else m.get_method_line()
ins_buf.insert(0, html_method_line)
ins_buf.append(LI_TAG(".end method"))
buf.append(LI_TAG(''))
buf.extend(ins_buf)
slash_num = cl.name.count('/')
respath = ''
for i in range(slash_num):
respath += '../'
html = class_template(code=Markup("\n".join(buf)),
appname=app_name,
title=cl.file_name,
package=Utils2.get_standart_package_name(cl.name),
respath=respath,
granularity=Granularity.get(granularity))
with open(class_path, 'w') as f:
f.write(html)
def rendered_infos(self):
return Markup(''.join(
div_template(value=x) for x in self.iter_infos()))
def iter_items(self):
# make a copy for modification
data = dict(self.data)
if 'server_name' in data:
yield Info('Server Name', data.pop('server_name'))
platform = data.pop('platform', None)
if platform:
yield Info('Platform', platform)
if 'level' in data:
yield Info('Level', data.pop('level'))
data.pop('timestamp', None)
if 'transaction' in data:
yield Info('Transaction', data.pop('transaction'))
request = dict(data.pop('request', {}))
if 'method' in request:
yield Info('Request Method', request.get('method'))
if 'url' in request:
yield Info(
'Request URL',
Markup(url_template(url=request['url'], title=request['url'])))
if request.get('query_string'):
qs = request.get('query_string')
try:
qs = urlparse.parse_qs(qs)
yield Info(
'Request Query String',
Markup(tabled_dict_template(value=qs, pformat=pformat)))
except Exception:
yield Info('Request Query String', qs)
if platform == 'python' and 'values' in data.get('exception', {}):
exception = dict(data.pop('exception'))
values = exception.pop('values', [])
num_values = len(values)
if num_values > 1:
title_fmt = 'Exception {}/%s' % num_values
else:
title_fmt = 'Exception'
for index, value in enumerate(values, start=1):
if 'stacktrace' in value and 'frames' in value['stacktrace']:
frames = value['stacktrace'].pop('frames')
if not value['stacktrace']:
del value['stacktrace']
yield Info(title_fmt.format(index) + ' Frames',
Markup(''.join(render_frame(x)
for x in frames)),
toggle=True,
toggled=index > 1)
yield Info(
value.pop('type', None),
Markup(pre_wrap_template(value=value.pop('value', None))))
yield Info(
title_fmt.format(index) + ' Info',
Markup(tabled_dict_template(value=value, pformat=pformat)))
# in case there are more items
if exception:
yield Info(
'Exception Meta',
Markup(
tabled_dict_template(value=exception,
pformat=pformat)))
if 'logentry' in data:
yield Info(
'Log Entry',
Markup(
tabled_dict_template(value=data.pop('logentry'),
pformat=pformat)))
if 'logger' in data:
yield Info('Logger', data.pop('logger'))
if request:
yield Info(
'Request',
Markup(tabled_dict_template(value=request, pformat=pformat)))
for key, value in sorted(data.items()):
yield Info(key, Markup(pre_template(value=pformat(value))))
