PyLinter is no longer a reports handler

Author: AWhetter

pylint/lint.py

@@ -238,7 +238,6 @@ def report_messages_by_module_stats(sect, stats, _):
 
 # pylint: disable=too-many-instance-attributes
 class PyLinter(utils.MessagesHandlerMixIn,
-               utils.ReportsHandlerMixIn,
                checkers.BaseTokenChecker):
     """lint Python modules using external checkers.
 
@@ -416,7 +415,6 @@ def __init__(self, config=None):
         # visit variables
         self.current_name = None
         self.current_file = None
-        self.stats = None
 
         # TODO: Runner needs to give this to parser?
         full_version = '%%prog %s\nastroid %s\nPython %s' % (
@@ -439,12 +437,6 @@ def disable_noerror_messages(self):
                 for msgid in msgids:
                     self.disable(msgid)
 
-    def disable_reporters(self):
-        """disable all reporters"""
-        for _reporters in six.itervalues(self._reports):
-            for report_id, _, _ in _reporters:
-                self.disable_report(report_id)
-
     def error_mode(self):
         """error mode: enable only errors; no reports, no persistent"""
         self._error_mode = True
@@ -546,29 +538,6 @@ def process_tokens(self, tokens):
 
     # code checking methods ###################################################
 
-    def get_checkers(self):
-        """return all available checkers as a list"""
-        return [self] + [c for _checkers in six.itervalues(self._checkers)
-                         for c in _checkers if c is not self]
-
-    def prepare_checkers(self):
-        """return checkers needed for activated messages and reports"""
-        if not self.config.reports:
-            self.disable_reporters()
-        # get needed checkers
-        neededcheckers = [self]
-        for checker in self.get_checkers()[1:]:
-            messages = set(msg for msg in checker.msgs
-                           if self.is_message_enabled(msg))
-            if (messages or
-                    any(self.report_is_enabled(r[0]) for r in checker.reports)):
-                neededcheckers.append(checker)
-        # Sort checkers by priority
-        neededcheckers = sorted(neededcheckers,
-                                key=operator.attrgetter('priority'),
-                                reverse=True)
-        return neededcheckers
-
     # pylint: disable=unused-argument
     @staticmethod
     def should_analyze_file(modname, path, is_argument=False):
@@ -598,7 +567,7 @@ def _init_msg_states(self):
             if not msg.may_be_emitted():
                 self._msgs_state[msg.msgid] = False
 
-    def check(self, files_or_modules):
+    def check(self, files_or_modules, checkers_):
         """main checking entry: check a list of files or modules from their
         name.
         """
@@ -609,18 +578,17 @@ def check(self, files_or_modules):
         if not isinstance(files_or_modules, (list, tuple)):
             files_or_modules = (files_or_modules,)
 
-        self._do_check(files_or_modules)
+        self._do_check(files_or_modules, checkers_)
 
-    def _do_check(self, files_or_modules):
+    def _do_check(self, files_or_modules, checkers_):
         walker = utils.PyLintASTWalker(self)
-        _checkers = self.prepare_checkers()
-        tokencheckers = [c for c in _checkers
+        tokencheckers = [c for c in checkers_
                          if interfaces.implements(c, interfaces.ITokenChecker)
                          and c is not self]
-        rawcheckers = [c for c in _checkers
+        rawcheckers = [c for c in checkers_
                        if interfaces.implements(c, interfaces.IRawChecker)]
         # notify global begin
-        for checker in _checkers:
+        for checker in checkers_:
             checker.open()
             if interfaces.implements(checker, interfaces.IAstroidChecker):
                 walker.add_checker(checker)
@@ -657,7 +625,7 @@ def _do_check(self, files_or_modules):
                 self.add_message(msgid, line, None, args)
         # notify global end
         self.stats['statement'] = walker.nbstatements
-        for checker in reversed(_checkers):
+        for checker in reversed(checkers_):
             checker.close()
 
     def set_current_module(self, modname, filepath=None):
@@ -723,9 +691,10 @@ def check_astroid_module(self, ast_node, walker,
 
     def open(self):
         """initialize counters"""
-        self.stats = {'by_module' : {},
-                      'by_msg' : {},
-                     }
+        self.stats = {
+            'by_module': {},
+            'by_msg': {},
+        }
         MANAGER.always_load_extensions = self.config.unsafe_load_any_extension
         MANAGER.extension_package_whitelist.update(
             self.config.extension_pkg_whitelist)
@@ -778,8 +747,9 @@ def guess_lint_path(args):
 
     return value
 
-
-class PluginRegistry(object):
+# TODO: Split the ReportsHandlerMixIn, keeping register methods here,
+# and moving report_order and make_reports to the runner.
+class PluginRegistry(utils.ReportsHandlerMixIn):
     """A class to register checkers to."""
 
     def __init__(self, linter, register_options=(lambda options: None)):
@@ -789,12 +759,10 @@ def __init__(self, linter, register_options=(lambda options: None)):
         # TODO: Remove. This is needed for the MessagesHandlerMixIn for now.
         linter._checkers = self._checkers
         self._reporters = {}
-        linter._reporters = self._reporters
         self._linter = linter
 
-        # TODO: Move elsewhere
         for r_id, r_title, r_cb in linter.reports:
-            self._linter.register_post_report(r_id, r_title, r_cb)
+            self.register_post_report(r_id, r_title, r_cb)
 
         self.register_options(linter.options)
 
@@ -825,9 +793,8 @@ def register_checker(self, checker):
 
         self._checkers[checker.name].append(checker)
 
-        # TODO: Move elsewhere
         for r_id, r_title, r_cb in checker.reports:
-            self._linter.register_report(r_id, r_title, r_cb, checker)
+            self.register_report(r_id, r_title, r_cb, checker)
 
         self.register_options(checker.options)
 
@@ -850,7 +817,7 @@ def register_reporter(self, reporter_class):
 
         self._reporters[reporter_class.name] = reporter_class
 
-    # For now simply defer missing attributs to the linter,
+    # For now simply defer missing attributes to the linter,
     # until we know what API we want.
     def __getattr__(self, attribute):
         return getattr(self._linter, attribute)
@@ -943,7 +910,7 @@ class CLIRunner(Runner):
     )
 
     def __init__(self):
-        super(CLIRunner, self).__init__()
+        super().__init__()
         self._linter = PyLinter()
         self._plugin_registry = PluginRegistry(self._linter)
         self._loaded_plugins = set()
@@ -1074,9 +1041,14 @@ def register_options(options):
         for checker in self._plugin_registry.for_all_checkers():
             checker.config = self._global_config
 
+        if not self._global_config.reports:
+            self._plugin_registry.disable_reporters()
+
         with fix_import_path(self._global_config.module_or_package):
             assert self._global_config.jobs == 1
-            self._linter.check(self._global_config.module_or_package)
+            self._linter.check(
+                self._global_config.module_or_package, self.prepare_checkers(),
+            )
 
             self.generate_reports()
 
@@ -1147,7 +1119,8 @@ def generate_reports(self):
             # XXX code below needs refactoring to be more reporter agnostic
             self._reporter.on_close(self._linter.stats, previous_stats)
             if self._global_config.reports:
-                sect = self._linter.make_reports(self._linter.stats, previous_stats)
+                # TODO: The Runner should make reports, not the registry.
+                sect = self._plugin_registry.make_reports(self._linter.stats, previous_stats)
             else:
                 sect = report_nodes.Section()
 
@@ -1185,6 +1158,28 @@ def _report_evaluation(self):
             sect = report_nodes.EvaluationSection(msg)
             self._reporter.display_reports(sect)
 
+    def get_checkers(self):
+        """return all available checkers as a list"""
+        return [self._linter] + [
+            c for c in self._plugin_registry.for_all_checkers() if c is not self._linter
+        ]
+
+    def prepare_checkers(self):
+        """return checkers needed for activated messages and reports"""
+        # get needed checkers
+        neededcheckers = [self._linter]
+        for checker in self.get_checkers()[1:]:
+            messages = set(msg for msg in checker.msgs
+                           if self._linter.is_message_enabled(msg))
+            if (messages or
+                    any(self._plugin_registry.report_is_enabled(r[0]) for r in checker.reports)):
+                neededcheckers.append(checker)
+        # Sort checkers by priority
+        neededcheckers = sorted(neededcheckers,
+                                key=operator.attrgetter('priority'),
+                                reverse=True)
+        return neededcheckers
+
 
 if __name__ == '__main__':
      CLIRunner().run(sys.argv[1:])

pylint/utils.py

@@ -256,6 +256,10 @@ def __init__(self):
         self.msg_status = 0
         self.msgs_store = MessagesStore()
         self.reporter = None
+        self.stats = {
+            'by_module': {},
+            'by_msg': {},
+        }
         super().__init__()
 
     def _checker_messages(self, checker):
@@ -300,13 +304,7 @@ def _set_msg_status(self, msgid, enable, scope='package', line=None, ignore_unkn
                         self._set_msg_status(_msgid, enable, scope, line)
             return
 
-        # msgid is report id?
-        if msgid.lower().startswith('rp'):
-            if enable:
-                self.enable_report(msgid)
-            else:
-                self.disable_report(msgid)
-            return
+        # TODO: Need to add enable/disable report back?
 
         try:
             # msgid is a symbolic or numeric msgid.
@@ -555,6 +553,24 @@ def _print_checker_doc(checker_name, info, stream=None):
             print("", file=stream)
         print("", file=stream)
 
+    def add_stats(self, **kwargs):
+        """Add some stats entries to the statistic dictionary.
+
+        :param kwargs: The stats to add to the statistic dictionary.
+
+        :returns: The new statistic dictionary.
+        :rtype: dict
+
+        :raises AssertionError: If there is a key conflict.
+        """
+        for key, value in six.iteritems(kwargs):
+            if key[-1] == '_':
+                key = key[:-1]
+            assert key not in self.stats
+            self.stats[key] = value
+        return self.stats
+
+
 class FileState(object):
     """Hold internal state specific to the currently analyzed file"""
 
@@ -784,9 +800,7 @@ def list_messages(self):
 
 
 class ReportsHandlerMixIn(object):
-    """a mix-in class containing all the reports and stats manipulation
-    related methods for the main lint class
-    """
+    """A report handlers organises and calls report methods."""
 
     _POST_CHECKER = object()
 
@@ -847,6 +861,12 @@ def disable_report(self, reportid):
         reportid = reportid.upper()
         self._reports_state[reportid] = False
 
+    def disable_reporters(self):
+        """Disable all reporters."""
+        for _reporters in self._reports.values():
+            for report_id, _, _ in _reporters:
+                self.disable_report(report_id)
+
     def report_is_enabled(self, reportid):
         """return true if the report associated to the given identifier is
         enabled
@@ -856,7 +876,7 @@ def report_is_enabled(self, reportid):
     def make_reports(self, stats, old_stats):
         """render registered reports"""
         sect = Section('Report',
-                       '%s statements analysed.'% (self.stats['statement']))
+                       '%s statements analysed.'% (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):
@@ -870,16 +890,6 @@ def make_reports(self, stats, old_stats):
                 sect.append(report_sect)
         return sect
 
-    def add_stats(self, **kwargs):
-        """add some stats entries to the statistic dictionary
-        raise an AssertionError if there is a key conflict
-        """
-        for key, value in six.iteritems(kwargs):
-            if key[-1] == '_':
-                key = key[:-1]
-            assert key not in self.stats
-            self.stats[key] = value
-        return self.stats
 
 def _basename_in_blacklist_re(base_name, black_list_re):
     """Determines if the basename is matched in a regex blacklist