def close(self):
"""close the whole package /module, it's time to make reports !
if persistent run, pickle results for later comparison
"""
if self.file_state.base_name is not None:
# load previous results if any
previous_stats = config.load_results(self.file_state.base_name)
# XXX code below needs refactoring to be more reporter agnostic
self.reporter.on_close(self.stats, previous_stats)
if self.config.reports:
sect = self.make_reports(self.stats, previous_stats)
if self.config.files_output:
filename = 'pylint_global.' + self.reporter.extension
self.reporter.set_output(open(filename, 'w'))
else:
sect = Section()
if self.config.reports or self.config.output_format == 'html':
self.reporter.display_results(sect)
# save results if persistent run
if self.config.persistent:
config.save_results(self.stats, self.file_state.base_name)
else:
if self.config.output_format == 'html':
# No output will be emitted for the html
# reporter if the file doesn't exist, so emit
# the results here.
self.reporter.display_results(Section())
self.reporter.on_close(self.stats, {})
def make_reports(self, stats, old_stats):
"""render registered reports"""
sect = Section("Report", "%s statements analysed." % (self.stats["statement"]))
for checker in self._reports:
for reportid, r_title, r_cb in self._reports[checker]:
if not self.report_is_enabled(reportid):
continue
report_sect = Section(r_title)
try:
r_cb(report_sect, stats, old_stats)
except EmptyReport:
continue
report_sect.report_id = reportid
sect.append(report_sect)
return sect
def set_output(self, output=None):
"""set output stream
messages buffered for old output is processed first"""
if self.out and self.msgs:
self._display(Section())
BaseReporter.set_output(self, output)
def test_html_reporter_msg_template(self):
expected = '''
<html>
<body>
<div>
<div>
<h2>Messages</h2>
<table>
<tr class="header">
<th>category</th>
<th>msg_id</th>
</tr>
<tr class="even">
<td>warning</td>
<td>W0332</td>
</tr>
</table>
</div>
</div>
</body>
</html>'''.strip().splitlines()
output = six.StringIO()
linter = PyLinter(reporter=HTMLReporter())
checkers.initialize(linter)
linter.config.persistent = 0
linter.reporter.set_output(output)
linter.set_option('msg-template', '{category}{msg_id}')
linter.open()
linter.set_current_module('0123')
linter.add_message('lowercase-l-suffix', line=1)
linter.reporter.display_results(Section())
self.assertEqual(output.getvalue().splitlines(), expected)
def _display(self, layout):
"""launch layouts display
overridden from BaseReporter to add insert the messages section
(in add_message, message is not displayed, just collected so it
can be displayed in an html table)
"""
if self.msgs:
# add stored messages to the layout
msgs = ['type', 'module', 'object', 'line', 'message']
msgs += self.msgs
sect = Section('Messages')
layout.append(sect)
sect.append(Table(cols=5, children=msgs, rheaders=1))
self.msgs = []
HTMLWriter().format(layout, self.out)
def _display(self, layout):
"""launch layouts display
overridden from BaseReporter to add insert the messages section
(in add_message, message is not displayed, just collected so it
can be displayed in an html table)
"""
if self.msgs:
# add stored messages to the layout
msgs = ['type', 'module', 'object', 'line', 'col_offset', 'message']
msgs += self.msgs
sect = Section('Messages')
layout.append(sect)
sect.append(Table(cols=6, children=msgs, rheaders=1))
self.msgs = []
HTMLWriter().format(layout, self.out)
def make_reports(self, stats, old_stats):
"""render registered reports"""
if self.config.files_output:
filename = 'pylint_global.' + self.reporter.extension
self.reporter.set_output(open(filename, 'w'))
sect = Section('Report',
'%s statements analysed.'% (self.stats['statement']))
for checker in self._reports:
for reportid, r_title, r_cb in self._reports[checker]:
if not self.report_is_enabled(reportid):
continue
report_sect = Section(r_title)
try:
r_cb(report_sect, stats, old_stats)
except EmptyReport:
continue
report_sect.report_id = reportid
sect.append(report_sect)
self.reporter.display_results(sect)
def make_reports(self, stats, old_stats):
"""render registered reports"""
if self.config.files_output:
filename = "pylint_global." + self.reporter.extension
self.reporter.set_output(open(filename, "w"))
sect = Section("Report", "%s statements analysed." % (self.stats["statement"]))
checkers = self.sort_checkers(self._reports)
checkers.reverse()
for checker in checkers:
for reportid, r_title, r_cb in self._reports[checker]:
if not self.is_report_enabled(reportid):
continue
report_sect = Section(r_title)
try:
r_cb(report_sect, stats, old_stats)
except EmptyReport:
continue
report_sect.report_id = reportid
sect.append(report_sect)
self.reporter.display_results(sect)
def close(self):
"""close the whole package /module, it's time to make reports !
if persistent run, pickle results for later comparison
"""
if self.base_name is not None:
# load old results if any
old_stats = config.load_results(self.base_name)
if self.config.reports:
self.make_reports(self.stats, old_stats)
elif self.config.output_format == 'html':
self.reporter.display_results(Section())
# save results if persistent run
if self.config.persistent:
config.save_results(self.stats, self.base_name)
def make_reports(self, stats, old_stats):
"""render registered reports"""
sect = Section('Report',
'%s statements analysed.' % (self.stats['statement']))
for checker in self.report_order():
for reportid, r_title, r_cb in self._reports[checker]:
if not self.report_is_enabled(reportid):
continue
report_sect = Section(r_title)
try:
r_cb(report_sect, stats, old_stats)
except EmptyReport:
continue
report_sect.report_id = reportid
sect.append(report_sect)
return sect
def test_html_reporter_type(self):
# Integration test for issue #263
# https://bitbucket.org/logilab/pylint/issue/263/html-report-type-problems
expected = '''<html>
<body>
<div>
<div>
<h2>Messages</h2>
<table>
<tr class="header">
<th>type</th>
<th>module</th>
<th>object</th>
<th>line</th>
<th>col_offset</th>
<th>message</th>
</tr>
<tr class="even">
<td>convention</td>
<td>0123</td>
<td> </td>
<td>1</td>
<td>0</td>
<td>Exactly one space required before comparison
a< 5: print "zero"</td>
</tr>
</table>
</div>
</div>
</body>
</html>
'''
output = six.StringIO()
linter = PyLinter(reporter=HTMLReporter())
checkers.initialize(linter)
linter.config.persistent = 0
linter.reporter.set_output(output)
linter.open()
linter.set_current_module('0123')
linter.add_message('bad-whitespace',
line=1,
args=('Exactly one', 'required', 'before',
'comparison', 'a< 5: print "zero"'))
linter.reporter.display_results(Section())
self.assertMultiLineEqual(output.getvalue(), expected)
def make_reports(self, stats, old_stats):
"""render registered reports"""
if self.config.files_output:
filename = 'pylint_global.' + self.reporter.extension
self.reporter.set_output(open(filename, 'w'))
sect = Section('Report',
'%s statements analysed.' % (self.stats['statement']))
for checker in self._reports:
for reportid, r_title, r_cb in self._reports[checker]:
if not self.report_is_enabled(reportid):
continue
report_sect = Section(r_title)
try:
r_cb(report_sect, stats, old_stats)
except EmptyReport:
continue
report_sect.report_id = reportid
sect.append(report_sect)
self.reporter.display_results(sect)
def visit_schema(self, schema, display_relations=0, skiptypes=()):
"""get a layout for a whole schema"""
title = Title(self._('Schema %s') % schema.name,
klass='titleUnderline')
layout = Section(children=(title, ))
esection = Section(
children=(Title(self._('Entities'), klass='titleUnderline'), ))
layout.append(esection)
eschemas = [
eschema for eschema in schema.entities()
if not (eschema.final or eschema in skiptypes)
]
for eschema in sorted(eschemas, key=TYPE_GETTER):
esection.append(self.visit_entityschema(eschema, skiptypes))
if display_relations:
title = Title(self._('Relations'), klass='titleUnderline')
rsection = Section(children=(title, ))
layout.append(rsection)
relations = [
rschema
for rschema in sorted(schema.relations(), key=TYPE_GETTER)
if not (rschema.final or rschema.type in skiptypes)
]
keys = [(rschema.type, rschema) for rschema in relations]
for key, rschema in sorted(keys, key=itemgetter(1)):
relstr = self.visit_relationschema(rschema)
rsection.append(relstr)
return layout
def visit_relationschema(self, rschema, title=True):
"""get a layout for a relation schema"""
_ = self._
if title:
title = self.format_rschema(rschema)
stereotypes = []
if rschema.meta:
stereotypes.append('meta')
if rschema.symmetric:
stereotypes.append('symmetric')
if rschema.inlined:
stereotypes.append('inlined')
title = Section(children=(title, ), klass='title')
if stereotypes:
title.append(self.stereotype(','.join(stereotypes)))
layout = Section(children=(title, ), klass='schema')
else:
layout = Section(klass='schema')
data = [_('from'), _('to')]
schema = rschema.schema
rschema_objects = rschema.objects()
if rschema_objects:
# might be empty
properties = [
p for p in RelationDefinitionSchema.rproperty_defs(
rschema_objects[0])
if p not in ('cardinality', 'composite', 'eid')
]
else:
properties = []
data += [_(prop) for prop in properties]
cols = len(data)
done = set()
for subjtype, objtypes in sorted(rschema.associations()):
for objtype in objtypes:
if (subjtype, objtype) in done:
continue
done.add((subjtype, objtype))
if rschema.symmetric:
done.add((objtype, subjtype))
data.append(self.format_eschema(schema[subjtype]))
data.append(self.format_eschema(schema[objtype]))
rdef = rschema.rdef(subjtype, objtype)
for prop in properties:
val = getattr(rdef, prop)
if val is None:
val = ''
elif prop == 'constraints':
val = ', '.join([c.expression for c in val])
elif isinstance(val, dict):
for key, value in val.items():
if isinstance(value, (list, tuple)):
val[key] = ', '.join(
sorted(str(v) for v in value))
val = str(val)
elif isinstance(val, (list, tuple)):
val = sorted(val)
val = ', '.join(str(v) for v in val)
elif val and isinstance(val, str):
val = _(val)
else:
val = str(val)
data.append(Text(val))
table = Table(cols=cols, rheaders=1, children=data, klass='listing')
layout.append(Section(children=(table, ), klass='relationDefinition'))
layout.append(Section(children='', klass='clear'))
return layout
def visit_entityschema(self, eschema, skiptypes=()):
"""get a layout for an entity schema"""
etype = eschema.type
layout = Section(children=' ', klass='clear')
layout.append(Link(etype, ' ', id=etype)) # anchor
title = self.format_eschema(eschema)
boxchild = [Section(children=(title, ), klass='title')]
data = []
data.append(Section(children=boxchild, klass='box'))
data.append(Section(children='', klass='vl'))
data.append(Section(children='', klass='hl'))
t_vars = []
rels = []
first = True
rel_defs = sorted(eschema.relation_definitions(),
key=lambda el: el[0].type)
for rschema, targetschemas, role in rel_defs:
if rschema.type in skiptypes:
continue
for oeschema in sorted(targetschemas, key=TYPE_GETTER):
rdef = rschema.role_rdef(eschema, oeschema, role)
if not self.may_read(rdef):
continue
label = rschema.type
if role == 'subject':
cards = rschema.rdef(eschema, oeschema).cardinality
else:
cards = rschema.rdef(oeschema, eschema).cardinality
cards = cards[::-1]
label = '%s %s %s' % (CARD_MAP[cards[1]], label,
CARD_MAP[cards[0]])
rlink = self.format_rschema(rschema, label)
elink = self.format_eschema(oeschema)
if first:
t_vars.append(Section(children=(elink, ),
klass='firstvar'))
rels.append(Section(children=(rlink, ), klass='firstrel'))
first = False
else:
t_vars.append(Section(children=(elink, ), klass='var'))
rels.append(Section(children=(rlink, ), klass='rel'))
data.append(Section(children=rels, klass='rels'))
data.append(Section(children=t_vars, klass='vars'))
layout.append(Section(children=data, klass='entityAttributes'))
return layout
