| # -*- coding: utf-8 -*- |
| # Copyright (c) 2006-2015 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr> |
| # Copyright (c) 2008 Fabrice Douchant <Fabrice.Douchant@logilab.fr> |
| # Copyright (c) 2009 Vincent |
| # Copyright (c) 2009 Mads Kiilerich <mads@kiilerich.com> |
| # Copyright (c) 2011-2014 Google, Inc. |
| # Copyright (c) 2012 David Pursehouse <david.pursehouse@sonymobile.com> |
| # Copyright (c) 2012 Kevin Jing Qiu <kevin.jing.qiu@gmail.com> |
| # Copyright (c) 2012 FELD Boris <lothiraldan@gmail.com> |
| # Copyright (c) 2012 JT Olds <jtolds@xnet5.com> |
| # Copyright (c) 2014-2018 Claudiu Popa <pcmanticore@gmail.com> |
| # Copyright (c) 2014-2015 Michal Nowikowski <godfryd@gmail.com> |
| # Copyright (c) 2014 Brett Cannon <brett@python.org> |
| # Copyright (c) 2014 Alexandru Coman <fcoman@bitdefender.com> |
| # Copyright (c) 2014 Daniel Harding <dharding@living180.net> |
| # Copyright (c) 2014 Arun Persaud <arun@nubati.net> |
| # Copyright (c) 2014 Dan Goldsmith <djgoldsmith@googlemail.com> |
| # Copyright (c) 2015-2016 Florian Bruhin <me@the-compiler.org> |
| # Copyright (c) 2015 Aru Sahni <arusahni@gmail.com> |
| # Copyright (c) 2015 Steven Myint <hg@stevenmyint.com> |
| # Copyright (c) 2015 Simu Toni <simutoni@gmail.com> |
| # Copyright (c) 2015 Mihai Balint <balint.mihai@gmail.com> |
| # Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro> |
| # Copyright (c) 2016-2017 Łukasz Rogalski <rogalski.91@gmail.com> |
| # Copyright (c) 2016 Glenn Matthews <glenn@e-dad.net> |
| # Copyright (c) 2016 Alan Evangelista <alanoe@linux.vnet.ibm.com> |
| # Copyright (c) 2017-2018 Ville Skyttä <ville.skytta@iki.fi> |
| # Copyright (c) 2017-2018 hippo91 <guillaume.peillex@gmail.com> |
| # Copyright (c) 2017 Daniel Miller <millerdev@gmail.com> |
| # Copyright (c) 2017 Roman Ivanov <me@roivanov.com> |
| # Copyright (c) 2017 Ned Batchelder <ned@nedbatchelder.com> |
| # Copyright (c) 2018 Randall Leeds <randall@bleeds.info> |
| # Copyright (c) 2018 Mike Frysinger <vapier@gmail.com> |
| # Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com> |
| # Copyright (c) 2018 Ville Skyttä <ville.skytta@upcloud.com> |
| # Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com> |
| # Copyright (c) 2018 Anthony Sottile <asottile@umich.edu> |
| # Copyright (c) 2018 Jason Owen <jason.a.owen@gmail.com> |
| # Copyright (c) 2018 Gary Tyler McLeod <mail@garytyler.com> |
| # Copyright (c) 2018 Yuval Langer <yuvallanger@mail.tau.ac.il> |
| # Copyright (c) 2018 Nick Drozd <nicholasdrozd@gmail.com> |
| # Copyright (c) 2018 kapsh <kapsh@kap.sh> |
| |
| # Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html |
| # For details: https://github.com/PyCQA/pylint/blob/master/COPYING |
| |
| # pylint: disable=broad-except |
| |
| """ %prog [options] modules_or_packages |
| |
| Check that module(s) satisfy a coding standard (and more !). |
| |
| %prog --help |
| |
| Display this help message and exit. |
| |
| %prog --help-msg <msg-id>[,<msg-id>] |
| |
| Display help messages about given message identifiers and exit. |
| """ |
| from __future__ import print_function |
| |
| import argparse |
| import collections |
| import contextlib |
| import operator |
| import os |
| import sys |
| import tokenize |
| import warnings |
| |
| import astroid |
| from astroid.__pkginfo__ import version as astroid_version |
| from astroid import modutils |
| from pylint import checkers |
| from pylint import interfaces |
| from pylint import reporters |
| from pylint import exceptions |
| from pylint import utils |
| from pylint import config |
| from pylint.__pkginfo__ import version |
| from pylint.reporters.ureports import nodes as report_nodes |
| |
| |
| FULL_VERSION = "%%(prog)s %s\nastroid %s\nPython %s" % ( |
| version, |
| astroid_version, |
| sys.version, |
| ) |
| |
| MANAGER = astroid.MANAGER |
| |
| |
| def _get_python_path(filepath): |
| dirname = os.path.realpath(os.path.expanduser(filepath)) |
| if not os.path.isdir(dirname): |
| dirname = os.path.dirname(dirname) |
| while True: |
| if not os.path.exists(os.path.join(dirname, "__init__.py")): |
| return dirname |
| old_dirname = dirname |
| dirname = os.path.dirname(dirname) |
| if old_dirname == dirname: |
| return os.getcwd() |
| return None |
| |
| |
| def _merge_stats(stats): |
| merged = {} |
| by_msg = collections.Counter() |
| nested_keys = set() |
| for stat in stats: |
| message_stats = stat.pop("by_msg", {}) |
| by_msg.update(message_stats) |
| |
| for key, item in stat.items(): |
| if key not in merged: |
| merged[key] = item |
| else: |
| if isinstance(item, dict): |
| nested_keys.add(key) |
| elif isinstance(item, set): |
| merged[key].update(item) |
| else: |
| merged[key] = merged[key] + item |
| |
| for key in nested_keys: |
| merged[key] = _merge_stats(stat.get(key, {}) for stat in stats) |
| |
| if by_msg: |
| merged["by_msg"] = by_msg |
| return merged |
| |
| |
| # some reporting functions #################################################### |
| |
| |
| def report_total_messages_stats(sect, stats, previous_stats, _, __): |
| """make total errors / warnings report""" |
| lines = ["type", "number", "previous", "difference"] |
| lines += checkers.table_lines_from_stats( |
| stats, previous_stats, ("convention", "refactor", "warning", "error") |
| ) |
| sect.append(report_nodes.Table(children=lines, cols=4, rheaders=1)) |
| |
| |
| def report_messages_stats(sect, stats, _, __, ___): |
| """make messages type report""" |
| if not stats["by_msg"]: |
| # don't print this report when we didn't detected any errors |
| raise exceptions.EmptyReportError() |
| in_order = sorted( |
| [ |
| (value, msg_id) |
| for msg_id, value in stats["by_msg"].items() |
| if not msg_id.startswith("I") |
| ] |
| ) |
| in_order.reverse() |
| lines = ("message id", "occurrences") |
| for value, msg_id in in_order: |
| lines += (msg_id, str(value)) |
| sect.append(report_nodes.Table(children=lines, cols=2, rheaders=1)) |
| |
| |
| def report_messages_by_module_stats(sect, stats, _, __, ____): |
| """make errors / warnings by modules report""" |
| if len(stats["by_module"]) == 1: |
| # don't print this report when we are analysing a single module |
| raise exceptions.EmptyReportError() |
| by_mod = collections.defaultdict(dict) |
| for m_type in ("fatal", "error", "warning", "refactor", "convention"): |
| total = stats[m_type] |
| for module in stats["by_module"]: |
| mod_total = stats["by_module"][module][m_type] |
| if total == 0: |
| percent = 0 |
| else: |
| percent = float((mod_total) * 100) / total |
| by_mod[module][m_type] = percent |
| sorted_result = [] |
| for module, mod_info in by_mod.items(): |
| sorted_result.append( |
| ( |
| mod_info["error"], |
| mod_info["warning"], |
| mod_info["refactor"], |
| mod_info["convention"], |
| module, |
| ) |
| ) |
| sorted_result.sort() |
| sorted_result.reverse() |
| lines = ["module", "error", "warning", "refactor", "convention"] |
| for line in sorted_result: |
| # Don't report clean modules. |
| if all(entry == 0 for entry in line[:-1]): |
| continue |
| lines.append(line[-1]) |
| for val in line[:-1]: |
| lines.append("%.2f" % val) |
| if len(lines) == 5: |
| raise exceptions.EmptyReportError() |
| sect.append(report_nodes.Table(children=lines, cols=5, rheaders=1)) |
| |
| |
| # Python Linter class ######################################################### |
| |
| MSGS = { |
| "F0001": ( |
| "%s", |
| "fatal", |
| "Used when an error occurred preventing the analysis of a \ |
| module (unable to find it for instance).", |
| ), |
| "F0002": ( |
| "%s: %s", |
| "astroid-error", |
| "Used when an unexpected error occurred while building the " |
| "Astroid representation. This is usually accompanied by a " |
| "traceback. Please report such errors !", |
| ), |
| "F0010": ( |
| "error while code parsing: %s", |
| "parse-error", |
| "Used when an exception occurred while building the Astroid " |
| "representation which could be handled by astroid.", |
| ), |
| "I0001": ( |
| "Unable to run raw checkers on built-in module %s", |
| "raw-checker-failed", |
| "Used to inform that a built-in module has not been checked " |
| "using the raw checkers.", |
| ), |
| "I0010": ( |
| "Unable to consider inline option %r", |
| "bad-inline-option", |
| "Used when an inline option is either badly formatted or can't " |
| "be used inside modules.", |
| ), |
| "I0011": ( |
| "Locally disabling %s (%s)", |
| "locally-disabled", |
| "Used when an inline option disables a message or a messages category.", |
| ), |
| "I0013": ( |
| "Ignoring entire file", |
| "file-ignored", |
| "Used to inform that the file will not be checked", |
| ), |
| "I0020": ( |
| "Suppressed %s (from line %d)", |
| "suppressed-message", |
| "A message was triggered on a line, but suppressed explicitly " |
| "by a disable= comment in the file. This message is not " |
| "generated for messages that are ignored due to configuration " |
| "settings.", |
| ), |
| "I0021": ( |
| "Useless suppression of %s", |
| "useless-suppression", |
| "Reported when a message is explicitly disabled for a line or " |
| "a block of code, but never triggered.", |
| ), |
| "I0022": ( |
| 'Pragma "%s" is deprecated, use "%s" instead', |
| "deprecated-pragma", |
| "Some inline pylint options have been renamed or reworked, " |
| "only the most recent form should be used. " |
| "NOTE:skip-all is only available with pylint >= 0.26", |
| {"old_names": [("I0014", "deprecated-disable-all")]}, |
| ), |
| "E0001": ("%s", "syntax-error", "Used when a syntax error is raised for a module."), |
| "E0011": ( |
| "Unrecognized file option %r", |
| "unrecognized-inline-option", |
| "Used when an unknown inline option is encountered.", |
| ), |
| "E0012": ( |
| "Bad option value %r", |
| "bad-option-value", |
| "Used when a bad value for an inline option is encountered.", |
| ), |
| } |
| |
| |
| # pylint: disable=too-many-instance-attributes |
| class PyLinter(utils.MessagesHandlerMixIn, checkers.BaseTokenChecker): |
| """lint Python modules using external checkers. |
| |
| This is the main checker controlling the other ones and the reports |
| generation. It is itself both a raw checker and an astroid checker in order |
| to: |
| * handle message activation / deactivation at the module level |
| * handle some basic but necessary stats'data (number of classes, methods...) |
| |
| IDE plugin developers: you may have to call |
| `astroid.builder.MANAGER.astroid_cache.clear()` across runs if you want |
| to ensure the latest code version is actually checked. |
| """ |
| |
| __implements__ = (interfaces.ITokenChecker,) |
| |
| name = "master" |
| priority = 0 |
| level = 0 |
| msgs = MSGS |
| |
| options = ( |
| ( |
| "ignore", |
| { |
| "type": "csv", |
| "metavar": "<file>,...", |
| "dest": "black_list", |
| "default": ("CVS",), |
| "help": "Add files or directories to the blacklist. " |
| "They should be base names, not paths.", |
| }, |
| ), |
| ( |
| "ignore-patterns", |
| { |
| "type": "regexp_csv", |
| "metavar": "<pattern>,...", |
| "dest": "black_list_re", |
| "default": (), |
| "help": "Add files or directories matching the regex patterns to the" |
| " blacklist. The regex matches against base names, not paths.", |
| }, |
| ), |
| ( |
| "persistent", |
| { |
| "default": True, |
| "type": "yn", |
| "metavar": "<y_or_n>", |
| "level": 1, |
| "help": "Pickle collected data for later comparisons.", |
| }, |
| ), |
| ( |
| "load-plugins", |
| { |
| "type": "csv", |
| "metavar": "<modules>", |
| "default": (), |
| "level": 1, |
| "help": "List of plugins (as comma separated values of " |
| "python modules names) to load, usually to register " |
| "additional checkers.", |
| }, |
| ), |
| ( |
| "output-format", |
| { |
| "default": "text", |
| "type": "string", |
| "metavar": "<format>", |
| "short": "f", |
| "group": "Reports", |
| "help": "Set the output format. Available formats are text," |
| " parseable, colorized, json and msvs (visual studio)." |
| " You can also give a reporter class, e.g. mypackage.mymodule." |
| "MyReporterClass.", |
| }, |
| ), |
| ( |
| "reports", |
| { |
| "default": False, |
| "type": "yn", |
| "metavar": "<y_or_n>", |
| "short": "r", |
| "group": "Reports", |
| "help": "Tells whether to display a full report or only the " |
| "messages", |
| }, |
| ), |
| ( |
| "evaluation", |
| { |
| "type": "string", |
| "metavar": "<python_expression>", |
| "group": "Reports", |
| "level": 1, |
| "default": "10.0 - ((float(5 * error + warning + refactor + " |
| "convention) / statement) * 10)", |
| "help": "Python expression which should return a note less " |
| "than 10 (10 is the highest note). You have access " |
| "to the variables errors warning, statement which " |
| "respectively contain the number of errors / " |
| "warnings messages and the total number of " |
| "statements analyzed. This is used by the global " |
| "evaluation report (RP0004).", |
| }, |
| ), |
| ( |
| "score", |
| { |
| "default": True, |
| "type": "yn", |
| "metavar": "<y_or_n>", |
| "short": "s", |
| "group": "Reports", |
| "help": "Activate the evaluation score.", |
| }, |
| ), |
| ( |
| "confidence", |
| { |
| "type": "multiple_choice", |
| "metavar": "<levels>", |
| "default": "", |
| "choices": [c.name for c in interfaces.CONFIDENCE_LEVELS], |
| "group": "Messages control", |
| "help": "Only show warnings with the listed confidence levels." |
| " Leave empty to show all. Valid levels: %s" |
| % (", ".join(c.name for c in interfaces.CONFIDENCE_LEVELS),), |
| }, |
| ), |
| ( |
| "enable", |
| { |
| "type": "_msg_on", |
| "metavar": "<msg ids>", |
| "dest": "msg_toggles", |
| "action": "append", |
| "short": "e", |
| "default": [], |
| "group": "Messages control", |
| "help": "Enable the message, report, category or checker with the " |
| "given id(s). You can either give multiple identifiers " |
| "separated by comma (,) or put this option multiple times " |
| "(only on the command line, not in the configuration file " |
| "where it should appear only once). " |
| 'See also the "--disable" option for examples. ', |
| }, |
| ), |
| ( |
| "disable", |
| { |
| "type": "_msg_off", |
| "metavar": "<msg ids>", |
| "dest": "msg_toggles", |
| "action": "append", |
| "short": "d", |
| "default": [], |
| "group": "Messages control", |
| "help": "Disable the message, report, category or checker " |
| "with the given id(s). You can either give multiple identifiers" |
| " separated by comma (,) or put this option multiple times " |
| "(only on the command line, not in the configuration file " |
| "where it should appear only once)." |
| 'You can also use "--disable=all" to disable everything first ' |
| "and then reenable specific checks. For example, if you want " |
| "to run only the similarities checker, you can use " |
| '"--disable=all --enable=similarities". ' |
| "If you want to run only the classes checker, but have no " |
| "Warning level messages displayed, use" |
| '"--disable=all --enable=classes --disable=W"', |
| }, |
| ), |
| ( |
| "msg-template", |
| { |
| "type": "string", |
| "metavar": "<template>", |
| "default": "", |
| "group": "Reports", |
| "help": ( |
| "Template used to display messages. " |
| "This is a python new-style format string " |
| "used to format the message information. " |
| "See doc for all details" |
| ), |
| }, |
| ), |
| ( |
| "jobs", |
| { |
| "type": "int", |
| "metavar": "<n-processes>", |
| "short": "j", |
| "default": 1, |
| "help": """Use multiple processes to speed up Pylint.""", |
| }, |
| ), |
| ( |
| "unsafe-load-any-extension", |
| { |
| "type": "yn", |
| "metavar": "<yn>", |
| "default": False, |
| "hide": True, |
| "help": ( |
| "Allow loading of arbitrary C extensions. Extensions" |
| " are imported into the active Python interpreter and" |
| " may run arbitrary code." |
| ), |
| }, |
| ), |
| ( |
| "limit-inference-results", |
| { |
| "type": "int", |
| "metavar": "<number-of-results>", |
| "default": 100, |
| "help": ( |
| "Control the amount of potential inferred values when inferring " |
| "a single object. This can help the performance when dealing with " |
| "large functions or complex, nested conditions. " |
| ), |
| }, |
| ), |
| ( |
| "extension-pkg-whitelist", |
| { |
| "type": "csv", |
| "metavar": "<pkg>,...", |
| "default": [], |
| "help": ( |
| "A comma-separated list of package or module names" |
| " from where C extensions may be loaded. Extensions are" |
| " loading into the active Python interpreter and may run" |
| " arbitrary code" |
| ), |
| }, |
| ), |
| ( |
| "suggestion-mode", |
| { |
| "type": "yn", |
| "metavar": "<yn>", |
| "default": True, |
| "help": ( |
| "When enabled, pylint would attempt to guess common " |
| "misconfiguration and emit user-friendly hints instead " |
| "of false-positive error messages" |
| ), |
| }, |
| ), |
| ( |
| "exit-zero", |
| { |
| "type": "yn", |
| "default": False, |
| "help": ( |
| "Always return a 0 (non-error) status code, even if " |
| "lint errors are found. This is primarily useful in " |
| "continuous integration scripts." |
| ), |
| }, |
| ), |
| ) |
| |
| option_groups = ( |
| ("Messages control", "Options controlling analysis messages"), |
| ("Reports", "Options related to output formatting and reporting"), |
| ) |
| |
| reports = () |
| |
| def __init__(self, config=None): |
| # some stuff has to be done before ancestors initialization... |
| # |
| # messages store / checkers / reporter / astroid manager |
| self.config = config |
| self._checkers = collections.defaultdict(list) |
| self._pragma_lineno = {} |
| self._ignore_file = False |
| # visit variables |
| self.current_name = None |
| self.current_file = None |
| |
| super().__init__(config) |
| # provided reports |
| self._dynamic_plugins = set() |
| |
| def load_plugin_configuration(self): |
| """Call the configuration hook for plugins |
| |
| This walks through the list of plugins, grabs the "load_configuration" |
| hook, if exposed, and calls it to allow plugins to configure specific |
| settings. |
| """ |
| for modname in self._dynamic_plugins: |
| module = modutils.load_module_from_name(modname) |
| if hasattr(module, "load_configuration"): |
| module.load_configuration(self) |
| |
| # checkers manipulation methods ############################################ |
| def disable(self, msgid, scope="module", line=None, ignore_unknown=False): |
| """Do not output messages that have the given ID. |
| |
| :param msgid: The ID of the message to disable. |
| This can also be "all" to disable all messages, |
| the ID of a category to disable all messages of that category, |
| or the name of a checker to disable all messages from the checker. |
| :type msgid: str |
| |
| :param scope: Must be "module". Provided for backwards compatibility. |
| :type scope: str. |
| |
| :param line: The line number that the message is disabled on. |
| :type line: int |
| |
| :param ignore_unknown: If this is False, |
| an :exc:`UnknownMessageError` is raised when a message with the |
| given ID cannot be found. |
| If this is True, the exception is not raised. |
| :param ignore_unknown: bool |
| |
| :raises ValueError: If `scope` is anything other than "module". |
| """ |
| self._set_msg_status( |
| msgid, enable=False, scope=scope, line=line, ignore_unknown=ignore_unknown |
| ) |
| |
| def enable(self, msgid, scope="module", line=None, ignore_unknown=False): |
| """Enable outputting messages that have the given ID. |
| |
| :param msgid: The ID of the message to enable. |
| This can also be "all" to enable all messages, |
| the ID of a category to enable all messages of that category, |
| or the name of a checker to enable all messages from the checker. |
| :type msgid: str |
| |
| :param scope: Must be "module". Provided for backwards compatibility. |
| :type scope: str. |
| |
| :param line: The line number that the message is enabled on. |
| :type line: int |
| |
| :param ignore_unknown: If this is False, |
| an :exc:`UnknownMessageError` is raised when a message with the |
| given ID cannot be found. |
| If this is True, the exception is not raised. |
| :param ignore_unknown: bool |
| """ |
| self._set_msg_status( |
| msgid, enable=True, scope=scope, line=line, ignore_unknown=ignore_unknown |
| ) |
| |
| # block level option handling ############################################# |
| # |
| # see func_block_disable_msg.py test case for expected behaviour |
| |
| def process_tokens(self, tokens): |
| """process tokens from the current module to search for module/block |
| level options |
| """ |
| options_methods = {"enable": self.enable, "disable": self.disable} |
| control_pragmas = {"disable", "enable"} |
| for (tok_type, content, start, _, _) in tokens: |
| if tok_type != tokenize.COMMENT: |
| continue |
| match = utils.OPTION_RGX.search(content) |
| if match is None: |
| continue |
| |
| first_group = match.group(1) |
| if ( |
| first_group.strip() == "disable-all" |
| or first_group.strip() == "skip-file" |
| ): |
| if first_group.strip() == "disable-all": |
| self.add_message( |
| "deprecated-pragma", |
| line=start[0], |
| args=("disable-all", "skip-file"), |
| ) |
| self.add_message("file-ignored", line=start[0]) |
| self._ignore_file = True |
| return |
| try: |
| opt, value = first_group.split("=", 1) |
| except ValueError: |
| self.add_message( |
| "bad-inline-option", args=first_group.strip(), line=start[0] |
| ) |
| continue |
| opt = opt.strip() |
| if opt in options_methods: |
| meth = options_methods[opt] |
| for msgid in utils._splitstrip(value): |
| # Add the line where a control pragma was encountered. |
| if opt in control_pragmas: |
| self._pragma_lineno[msgid] = start[0] |
| |
| try: |
| if (opt, msgid) == ("disable", "all"): |
| self.add_message( |
| "deprecated-pragma", |
| line=start[0], |
| args=("disable=all", "skip-file"), |
| ) |
| self.add_message("file-ignored", line=start[0]) |
| self._ignore_file = True |
| return |
| meth(msgid, "module", start[0]) |
| except exceptions.UnknownMessageError: |
| self.add_message("bad-option-value", args=msgid, line=start[0]) |
| else: |
| self.add_message("unrecognized-inline-option", args=opt, line=start[0]) |
| |
| # code checking methods ################################################### |
| |
| def check(self, module_desc, walker, rawcheckers, tokencheckers): |
| modname = module_desc.name |
| filepath = module_desc.path |
| self.set_current_module(modname, filepath) |
| # get the module representation |
| ast_node = self.get_ast(filepath, modname) |
| if ast_node is None: |
| return |
| # XXX to be correct we need to keep module_msgs_state for every |
| # analyzed module (the problem stands with localized messages which |
| # are only detected in the .close step) |
| self.file_state = utils.FileState(module_desc.basename) |
| self._ignore_file = False |
| # fix the current file (if the source file was not available or |
| # if it's actually a c extension) |
| self.current_file = ast_node.file # pylint: disable=maybe-no-member |
| self.check_astroid_module(ast_node, walker, rawcheckers, tokencheckers) |
| # warn about spurious inline messages handling |
| spurious_messages = self.file_state.iter_spurious_suppression_messages( |
| self.msgs_store |
| ) |
| for msgid, line, args in spurious_messages: |
| self.add_message(msgid, line, None, args) |
| |
| def set_current_module(self, modname, filepath=None): |
| """set the name of the currently analyzed module and |
| init statistics for it |
| """ |
| if not modname and filepath is None: |
| return |
| self.reporter.on_set_current_module(modname, filepath) |
| self.current_name = modname |
| self.current_file = filepath or modname |
| self.stats["by_module"][modname] = {} |
| self.stats["by_module"][modname]["statement"] = 0 |
| for msg_cat in utils.MSG_TYPES.values(): |
| self.stats["by_module"][modname][msg_cat] = 0 |
| |
| def get_ast(self, filepath, modname): |
| """return an ast(roid) representation for a module""" |
| try: |
| return MANAGER.ast_from_file(filepath, modname, source=True) |
| except astroid.AstroidSyntaxError as ex: |
| # pylint: disable=no-member |
| self.add_message( |
| "syntax-error", line=getattr(ex.error, "lineno", 0), args=str(ex.error) |
| ) |
| except astroid.AstroidBuildingException as ex: |
| self.add_message("parse-error", args=ex) |
| except Exception as ex: |
| import traceback |
| |
| traceback.print_exc() |
| self.add_message("astroid-error", args=(ex.__class__, ex)) |
| |
| def check_astroid_module(self, ast_node, walker, rawcheckers, tokencheckers): |
| """Check a module from its astroid representation.""" |
| try: |
| tokens = utils.tokenize_module(ast_node) |
| except tokenize.TokenError as ex: |
| self.add_message("syntax-error", line=ex.args[1][0], args=ex.args[0]) |
| return None |
| |
| if not ast_node.pure_python: |
| self.add_message("raw-checker-failed", args=ast_node.name) |
| else: |
| # assert astroid.file.endswith('.py') |
| # invoke ITokenChecker interface on self to fetch module/block |
| # level options |
| self.process_tokens(tokens) |
| if self._ignore_file: |
| return False |
| # walk ast to collect line numbers |
| self.file_state.collect_block_lines(self.msgs_store, ast_node) |
| # run raw and tokens checkers |
| for checker in rawcheckers: |
| checker.process_module(ast_node) |
| for checker in tokencheckers: |
| checker.process_tokens(tokens) |
| # generate events to astroid checkers |
| walker.walk(ast_node) |
| return True |
| |
| def open(self): |
| self._init_msg_states() |
| |
| 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 kwargs.items(): |
| if key[-1] == "_": |
| key = key[:-1] |
| assert key not in self.stats |
| self.stats[key] = value |
| return self.stats |
| |
| |
| # utilities ################################################################### |
| |
| |
| @contextlib.contextmanager |
| def fix_import_path(args): |
| """Prepare sys.path for running the linter checks. |
| Within this context, each of the given arguments is importable. |
| Paths are added to sys.path in corresponding order to the arguments. |
| We avoid adding duplicate directories to sys.path. |
| `sys.path` is reset to its original value upon exiting this context. |
| """ |
| orig = list(sys.path) |
| changes = [] |
| for arg in args: |
| path = _get_python_path(arg) |
| if path in changes: |
| continue |
| else: |
| changes.append(path) |
| sys.path[:] = changes + ["."] + sys.path |
| try: |
| yield |
| finally: |
| sys.path[:] = orig |
| |
| |
| def guess_lint_path(args): |
| """Attempt to determine the file being linted from a list of arguments. |
| |
| :param args: The list of command line arguments to guess from. |
| :type args: list(str) |
| |
| :returns: The path to file being linted if it can be guessed. |
| None otherwise. |
| :rtype: str or None |
| """ |
| value = None |
| |
| # We only care if it's a path. If it's a module, |
| # we can't get a config from it |
| if args and os.path.exists(args[-1]): |
| value = args[-1] |
| |
| return value |
| |
| |
| class ReportRegistry: |
| def __init__(self): |
| self.reports = {} |
| self._reports_state = {} |
| super().__init__() |
| |
| self.register_report( |
| "RP0001", "Messages by category", report_total_messages_stats |
| ) |
| self.register_report( |
| "RP0002", "% errors / warnings by module", report_messages_by_module_stats |
| ) |
| self.register_report("RP0003", "Messages", report_messages_stats) |
| |
| def register_report(self, reportid, r_title, r_cb, checker_classes=()): |
| """Register a report |
| |
| :param reportid: The unique identifier for the report. |
| :type reportid: str |
| :param r_title: The report's title. |
| :type r_title: str |
| :param r_cb: The method to call to make the report. |
| :type r_cb: callable |
| :param checker_classes: The checkers that create states |
| needed by this report. |
| :type checker_classes: class |
| """ |
| reportid = reportid.upper() |
| self.reports[reportid] = (r_title, r_cb, checker_classes) |
| |
| def enable_report(self, reportid): |
| """Enable the report of the given id. |
| |
| :param reportid: The unique identifier of the report to enable. |
| :type reportid: str |
| """ |
| reportid = reportid.upper() |
| self._reports_state[reportid] = True |
| |
| def disable_report(self, reportid): |
| """Disable the report of the given id. |
| |
| :param reportid: The unique identifier of the report to disable. |
| :type reportid: str |
| """ |
| reportid = reportid.upper() |
| self._reports_state[reportid] = False |
| |
| def disable_reporters(self): |
| """Disable all reporters.""" |
| for report_id in self.reports: |
| self.disable_report(report_id) |
| |
| def report_is_enabled(self, reportid): |
| """Check if the report with the given id is enabled. |
| |
| :param reportid: The unique identifier of the report to check. |
| :type reportid: str |
| |
| :returns: True if the report is enabled, False otherwise. |
| :rtype: bool |
| """ |
| return self._reports_state.get(reportid, True) |
| |
| |
| class PluginRegistry(utils.MessagesHandlerMixIn, ReportRegistry): |
| """A class to register checkers to.""" |
| |
| def __init__(self, config, register_options=(lambda options: None)): |
| super().__init__(config) |
| self.register_options = register_options |
| self._checkers = collections.defaultdict(list) |
| self._reporters = {} |
| |
| self._python3_porting_mode = False |
| self._error_mode = False |
| |
| self.register_options(PyLinter.options) |
| |
| self.msgs_store.register_messages_from_checker(PyLinter) |
| |
| def for_all_checkers(self): |
| """Loop through all registered checkers. |
| |
| :returns: Each registered checker. |
| :rtype: iterable(BaseChecker) |
| """ |
| for checkers in self._checkers.values(): |
| yield from checkers |
| |
| def register_checker(self, checker): |
| """Register a checker. |
| |
| :param checker: The checker to register. |
| :type checker: BaseChecker |
| |
| :raises InvalidCheckerError: If the priority of the checker is |
| invalid. |
| """ |
| # Allow instances to be passed for backwards compatibility |
| if isinstance(checker, checkers.BaseChecker): |
| checker = checker.__class__ |
| |
| existing_checker_types = set( |
| existing_checker |
| for name_checkers in self._checkers.values() |
| for existing_checker in name_checkers |
| ) |
| if checker in existing_checker_types: |
| msg_fmt = ( |
| "Not registering checker {}. A checker of type {} has " |
| "already been registered." |
| ) |
| msg = msg_fmt.format(checker.name, checker.__name__) |
| warnings.warn(msg) |
| return |
| |
| if checker.priority > 0: |
| msg = "{}.priority must be <= 0".format(checker.__class__) |
| raise exceptions.InvalidCheckerError(msg) |
| |
| self._checkers[checker.name].append(checker) |
| |
| self.register_options(checker.options) |
| |
| if hasattr(checker, "msgs"): |
| self.msgs_store.register_messages_from_checker(checker) |
| |
| # Register the checker, but disable all of its messages. |
| # TODO(cpopa): we should have a better API for this. |
| if not getattr(checker, "enabled", True): |
| self.disable(checker.name) |
| |
| def register_reporter(self, reporter_class): |
| if reporter_class.name in self._reporters: |
| # TODO: Raise if classes are the same |
| duplicate = self._reporters[reporter_class.name] |
| msg = "A reporter called {} has already been registered ({})." |
| msg = msg.format(reporter.name, duplicate.__class__) |
| warnings.warn(msg) |
| |
| self._reporters[reporter_class.name] = reporter_class |
| |
| def disable(self, msgid, scope="package", line=None, ignore_unknown=False): |
| """Do not output messages that have the given ID. |
| |
| :param msgid: The ID of the message to disable. |
| This can also be "all" to disable all messages, |
| the ID of a category to disable all messages of that category, |
| or the name of a checker to disable all messages from the checker. |
| :type msgid: str |
| |
| :param scope: Must be "package". Provided for backwards compatibility. |
| :type scope: str. |
| |
| :param line: The line number that the message is disabled on. |
| This is not used and is provided for backwards compatibility only. |
| :type line: int |
| |
| :param ignore_unknown: If this is False, |
| an :exc:`UnknownMessageError` is raised when a message with the |
| given ID cannot be found. |
| If this is True, the exception is not raised. |
| :param ignore_unknown: bool |
| |
| :raises ValueError: If `scope` is anything other than "package". |
| """ |
| self._set_msg_status( |
| msgid, enable=False, scope=scope, line=line, ignore_unknown=ignore_unknown |
| ) |
| |
| def enable(self, msgid, scope="package", line=None, ignore_unknown=False): |
| """Enable outputting messages that have the given ID. |
| |
| :param msgid: The ID of the message to enable. |
| This can also be "all" to enable all messages, |
| the ID of a category to enable all messages of that category, |
| or the name of a checker to enable all messages from the checker. |
| :type msgid: str |
| |
| :param scope: Must be "package". Provided for backwards compatibility. |
| :type scope: str. |
| |
| :param line: The line number that the message is enabled on. |
| This is not used and is provided for backwards compatibility only. |
| :type line: int |
| |
| :param ignore_unknown: If this is False, |
| an :exc:`UnknownMessageError` is raised when a message with the |
| given ID cannot be found. |
| If this is True, the exception is not raised. |
| :param ignore_unknown: bool |
| |
| :raises ValueError: If `scope` is anything other than "package". |
| """ |
| self._set_msg_status( |
| msgid, enable=True, scope=scope, line=line, ignore_unknown=ignore_unknown |
| ) |
| |
| def error_mode(self): |
| """Enable only errors; no reports, no persistent""" |
| self._error_mode = True |
| self.disable_noerror_messages() |
| self.disable("miscellaneous") |
| if self._python3_porting_mode: |
| self.disable("all") |
| for msg_id in self._checker_messages("python3"): |
| if msg_id.startswith("E"): |
| self.enable(msg_id) |
| else: |
| self.disable("python3") |
| |
| def python3_porting_mode(self): |
| """Disable all other checkers and enable Python 3 warnings.""" |
| self.disable("all") |
| self.enable("python3") |
| if self._error_mode: |
| # The error mode was activated, using the -E flag. |
| # So we'll need to enable only the errors from the |
| # Python 3 porting checker. |
| for msg_id in self._checker_messages("python3"): |
| if msg_id.startswith("E"): |
| self.enable(msg_id) |
| else: |
| self.disable(msg_id) |
| self._python3_porting_mode = True |
| |
| |
| class Runner(object): |
| """A class to manager how the linter runs.""" |
| |
| option_definitions = () |
| """The runner specific configuration options. |
| |
| :type: set(OptionDefinition) |
| """ |
| |
| |
| class CLIRunner(Runner): |
| option_definitions = ( |
| ("module_or_package", {"positional": True, "nargs": argparse.REMAINDER}), |
| ( |
| "rcfile", |
| { |
| "type": "string", |
| "metavar": "<file>", |
| "help": "Specify a configuration file.", |
| }, |
| ), |
| ( |
| "init-hook", |
| { |
| "type": "string", |
| "metavar": "<code>", |
| "level": 1, |
| "help": "Python code to execute, usually for sys.path " |
| "manipulation such as pygtk.require().", |
| }, |
| ), |
| ( |
| "help-msg", |
| { |
| "type": "string", |
| "metavar": "<msg-id>", |
| "group": "Commands", |
| "default": None, |
| "help": "Display a help message for the given message id and " |
| "exit. The value may be a comma separated list of message ids.", |
| }, |
| ), |
| ( |
| "list-msgs", |
| { |
| "group": "Commands", |
| "level": 1, |
| "action": "store_true", |
| "default": False, |
| "help": "Generate pylint's messages.", |
| }, |
| ), |
| ( |
| "list-conf-levels", |
| { |
| "group": "Commands", |
| "level": 1, |
| "action": "store_true", |
| "default": False, |
| "help": "Generate pylint's confidence levels.", |
| }, |
| ), |
| ( |
| "full-documentation", |
| { |
| "metavar": "<msg-id>", |
| "default": None, |
| "group": "Commands", |
| "level": 1, |
| "help": "Generate pylint's full documentation.", |
| }, |
| ), |
| ( |
| "generate-rcfile", |
| { |
| "group": "Commands", |
| "action": "store_true", |
| "default": False, |
| "help": "Generate a sample configuration file according to " |
| "the current configuration. You can put other options " |
| "before this one to get them in the generated " |
| "configuration.", |
| }, |
| ), |
| ( |
| "generate-man", |
| { |
| "group": "Commands", |
| "action": "store_true", |
| "default": False, |
| "help": "Generate pylint's man page.", |
| "hide": True, |
| }, |
| ), |
| ( |
| "errors-only", |
| { |
| "short": "E", |
| "action": "store_true", |
| "default": False, |
| "help": "In error mode, checkers without error messages are " |
| "disabled and for others, only the ERROR messages are " |
| "displayed, and no reports are done by default" |
| "", |
| }, |
| ), |
| ( |
| "py3k", |
| { |
| "action": "store_true", |
| "default": False, |
| "help": "In Python 3 porting mode, all checkers will be " |
| "disabled and only messages emitted by the porting " |
| "checker will be displayed", |
| }, |
| ), |
| ( |
| "version", |
| { |
| "group": "Commands", |
| "action": "version", |
| "version": FULL_VERSION, |
| "help": "Print the version of pylint and important " "dependencies", |
| }, |
| ), |
| ) |
| |
| option_groups = ( |
| ( |
| "Commands", |
| "Options which are actually commands. Options in this \ |
| group are mutually exclusive.", |
| ), |
| ) |
| |
| description = ( |
| "pylint [options] module_or_package\n" |
| "\n" |
| " Check that a module satisfies a coding standard (and more !).\n" |
| "\n" |
| " pylint --help\n" |
| "\n" |
| " Display this help message and exit.\n" |
| "\n" |
| " pylint --help-msg <msg-id>[,<msg-id>]\n" |
| "\n" |
| " Display help messages about given message identifiers and exit.\n" |
| ) |
| |
| def __init__(self): |
| super().__init__() |
| self._global_config = config.Configuration() |
| self._plugin_registry = PluginRegistry(self._global_config) |
| self._loaded_plugins = set() |
| self._reporter = None |
| self._config_parsers = [] |
| |
| def run(self, args): |
| # Phase 1: Preprocessing |
| option_definitions = self.option_definitions + PyLinter.options |
| parser = config.CLIParser(self.description) |
| parser.add_option_definitions(option_definitions) |
| parser.add_help_section("Environment variables", config.ENV_HELP, level=1) |
| # pylint: disable=bad-continuation |
| parser.add_help_section( |
| "Output", |
| "Using the default text output, the message format is : \n" |
| " \n" |
| " MESSAGE_TYPE: LINE_NUM:[OBJECT:] MESSAGE \n" |
| " \n" |
| "There are 5 kind of message types : \n" |
| " * (C) convention, for programming standard violation \n" |
| " * (R) refactor, for bad code smell \n" |
| " * (W) warning, for python specific problems \n" |
| " * (E) error, for probable bugs in the code \n" |
| " * (F) fatal, if an error occurred which prevented pylint from doing further\n" |
| "processing.\n", |
| level=1, |
| ) |
| parser.add_help_section( |
| "Output status code", |
| "Pylint should leave with following status code: \n" |
| " * 0 if everything went fine \n" |
| " * 1 if a fatal message was issued \n" |
| " * 2 if an error message was issued \n" |
| " * 4 if a warning message was issued \n" |
| " * 8 if a refactor message was issued \n" |
| " * 16 if a convention message was issued \n" |
| " * 32 on usage error \n" |
| " \n" |
| "status 1 to 16 will be bit-ORed so you can know which different categories has\n" |
| "been issued by analysing pylint output status code\n", |
| level=1, |
| ) |
| |
| self._global_config.add_options(option_definitions) |
| |
| parsed = parser.preprocess(args, "init_hook", "rcfile", "load_plugins") |
| |
| # Call init-hook |
| if parsed.init_hook: |
| exec(parsed.init_hook) |
| |
| # Load rcfile, else system rcfile |
| file_parser = config.IniFileParser() |
| file_parser.add_option_definitions(PyLinter.options) |
| rcfile = parsed.rcfile or config.PYLINTRC |
| if rcfile: |
| file_parsed = file_parser.preprocess(rcfile, "init_hook", "load_plugins") |
| if file_parsed.init_hook: |
| exec(file_parsed.init_hook) |
| if file_parsed.load_plugins: |
| old_value = getattr(parsed, "load_plugins", []) |
| parsed.load_plugins = old_value + file_parsed.load_plugins |
| |
| def register_options(options): |
| self._global_config.add_options(options) |
| parser.add_option_definitions(options) |
| file_parser.add_option_definitions(options) |
| |
| self._plugin_registry.register_options = register_options |
| self._file_parser = file_parser |
| self._cli_parser = parser |
| |
| checkers.initialize(self._plugin_registry) |
| |
| # Load plugins from CLI |
| plugins = parsed.load_plugins or [] |
| for plugin in plugins: |
| self.load_plugin(plugin) |
| |
| # TODO: This is for per directory config support (#618) |
| # Phase 2: Discover more plugins found in config files |
| # Walk and discover config files, watching for blacklists as we go |
| |
| # Load plugins from config files |
| |
| # Phase 3: Full load |
| # Fully load config files |
| if rcfile: |
| file_parser.parse(rcfile, self._global_config) |
| # Fully load CLI into global config |
| self._cli_config = config.Configuration() |
| parser.parse(args, self._cli_config) |
| self._global_config += self._cli_config |
| |
| if self._global_config.generate_rcfile: |
| file_parser.write() |
| sys.exit(0) |
| |
| # TODO: if global_config.generate_man |
| |
| if self._global_config.errors_only: |
| self._plugin_registry.error_mode() |
| if file_parser.has_option("MESSAGES CONTROL", "disable"): |
| value = file_parser.get("MESSAGES CONTROL", "disable") |
| self.config.set_option("disable", value) |
| self._global_config.reports = False |
| self._global_config.persistent = False |
| self._global_config.score = False |
| |
| if self._global_config.py3k: |
| self._plugin_registry.python3_porting_mode() |
| if file_parser.has_option("MESSAGES CONTROL", "disable"): |
| value = file_parser.get("MESSAGES CONTROL", "disable") |
| self._global_config.set_option("disable", value) |
| |
| if self._global_config.full_documentation: |
| self._plugin_registry.print_full_documentation() |
| sys.exit(0) |
| |
| if self._global_config.list_conf_levels: |
| for level in interfaces.CONFIDENCE_LEVELS: |
| print("%-18s: %s" % level) |
| sys.exit(0) |
| |
| if self._global_config.list_msgs: |
| self._plugin_registry.msgs_store.list_messages() |
| sys.exit(0) |
| |
| if self._global_config.help_msg: |
| msg = utils._splitstrip(self._global_config.help_msg) |
| self._plugin_registry.msgs_store.help_message(msg) |
| sys.exit(0) |
| |
| if not self._global_config.module_or_package: |
| sys.exit(0) |
| |
| self.load_default_plugins() |
| |
| self._plugin_registry.disable("I") |
| self._plugin_registry.enable("c-extension-no-member") |
| |
| 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 |
| base_name, all_states, status_code = self.check( |
| self._global_config.module_or_package |
| ) |
| |
| self.generate_reports(base_name, all_states) |
| |
| if self._global_config.exit_zero: |
| sys.exit(0) |
| else: |
| sys.exit(status_code) |
| |
| def load_plugin(self, module_name): |
| if module_name in self._loaded_plugins: |
| msg = "Already loaded plugin {0}. Ignoring".format(module_name) |
| warnings.warn(msg) |
| else: |
| module = astroid.modutils.load_module_from_name(module_name) |
| module.register(self._plugin_registry) |
| |
| def load_plugins(self, module_names): |
| """Load a plugin. |
| |
| Args: |
| module_names (list(str)): The name of plugin modules to load. |
| """ |
| for module_name in module_names: |
| self.load_plugin(module_name) |
| |
| def load_default_plugins(self): |
| """Load all of the default plugins.""" |
| reporters.initialize(self._plugin_registry) |
| # Make sure to load the default reporter, because |
| # the option has been set before the plugins had been loaded. |
| if not self._reporter: |
| self.load_reporter() |
| |
| def load_reporter(self): |
| name = self._global_config.output_format.lower() |
| if name in self._plugin_registry._reporters: |
| self._reporter = self._plugin_registry._reporters[name]( |
| config=self._global_config |
| ) |
| self._plugin_registry.reporter = self._reporter |
| else: |
| try: |
| reporter_class = self._load_reporter_class() |
| except (ImportError, AttributeError): |
| raise exceptions.InvalidReporterError(name) |
| else: |
| self._reporter = reporter_class(config=self._global_config) |
| self._plugin_registry.reporter = self._reporter |
| |
| def _load_reporter_class(self): |
| qname = self._global_config.output_format |
| module = modutils.load_module_from_name(modutils.get_module_part(qname)) |
| class_name = qname.split(".")[-1] |
| reporter_class = getattr(module, class_name) |
| return reporter_class |
| |
| def generate_reports(self, base_name, all_states): |
| """close the whole package /module, it's time to make reports ! |
| |
| if persistent run, pickle results for later comparison |
| """ |
| # Display whatever messages are left on the reporter. |
| self._reporter.display_messages(report_nodes.Section()) |
| |
| if base_name is not None: |
| # load previous results if any |
| previous_stats = config.load_results(base_name) |
| # XXX code below needs refactoring to be more reporter agnostic |
| self._reporter.on_close(self._plugin_registry.stats, previous_stats) |
| if self._global_config.reports: |
| sect = self.make_reports( |
| self._plugin_registry.stats, previous_stats, all_states |
| ) |
| else: |
| sect = report_nodes.Section() |
| |
| if self._global_config.reports: |
| self._reporter.display_reports(sect) |
| self._report_evaluation(base_name) |
| # save results if persistent run |
| if self._global_config.persistent: |
| config.save_results(self._plugin_registry.stats, base_name) |
| else: |
| self._reporter.on_close(self._plugin_registry.stats, {}) |
| |
| def report_order(self): |
| """A list of reports, sorted in the order in which they must be called. |
| |
| :returns: The list of reports. |
| :rtype: list(str) |
| """ |
| reports = sorted(self._plugin_registry.reports) |
| for final_report in ("RP0001", "RP0002", "RP0003"): |
| try: |
| reports.remove(final_report) |
| except ValueError: |
| pass |
| else: |
| reports.append(final_report) |
| return reports |
| |
| def make_reports(self, stats, old_stats, all_states): |
| """Render the registered reports. |
| |
| :param stats: The statistics dictionary for this run. |
| :type stats: dict |
| :param old_stats: The statistics dictionary for the previous run. |
| :type old_stats: dict |
| |
| :returns: The complete report. |
| :rtype: pylint.reporters.ureports.nodes.Section |
| """ |
| sect = report_nodes.Section( |
| "Report", "%s statements analysed." % (stats["statement"]) |
| ) |
| for report_id in self.report_order(): |
| r_title, r_cb, checker_classes = self._plugin_registry.reports[report_id] |
| states = [ |
| all_states.get(checker_class) for checker_class in checker_classes |
| ] |
| if not self._plugin_registry.report_is_enabled(report_id): |
| continue |
| report_sect = report_nodes.Section(r_title) |
| try: |
| r_cb(report_sect, stats, old_stats, self._global_config, states) |
| except exceptions.EmptyReportError: |
| continue |
| report_sect.report_id = report_id |
| sect.append(report_sect) |
| return sect |
| |
| def _report_evaluation(self, base_name): |
| """make the global evaluation report""" |
| # check with at least check 1 statements (usually 0 when there is a |
| # syntax error preventing pylint from further processing) |
| previous_stats = config.load_results(base_name) |
| if self._plugin_registry.stats["statement"] == 0: |
| return |
| |
| # get a global note for the code |
| evaluation = self._global_config.evaluation |
| try: |
| note = eval( |
| evaluation, {}, self._plugin_registry.stats |
| ) # pylint: disable=eval-used |
| except Exception as ex: |
| msg = "An exception occurred while rating: %s" % ex |
| else: |
| self._plugin_registry.stats["global_note"] = note |
| msg = "Your code has been rated at %.2f/10" % note |
| pnote = previous_stats.get("global_note") |
| if pnote is not None: |
| msg += " (previous run: %.2f/10, %+.2f)" % (pnote, note - pnote) |
| |
| if self._global_config.score: |
| sect = report_nodes.EvaluationSection(msg) |
| self._reporter.display_reports(sect) |
| |
| def get_checkers(self): |
| """return all available checkers as a list""" |
| return [c for c in self._plugin_registry.for_all_checkers()] |
| |
| def prepare_checkers(self, linter): |
| """return checkers needed for activated messages and reports""" |
| # get needed checkers |
| neededcheckers = set() |
| for checker_cls in self.get_checkers()[1:]: |
| if any(linter.is_message_enabled(msg) for msg in checker_cls.msgs): |
| neededcheckers.add(checker_cls) |
| |
| for report_id, (_, _, checker_classes) in self._plugin_registry.reports.items(): |
| if self._plugin_registry.report_is_enabled(report_id): |
| neededcheckers.update(checker_classes) |
| |
| # 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): |
| """Returns whether or not a module should be checked. |
| |
| This implementation returns True for all python source files, |
| indicating that all files should be linted. |
| |
| Subclasses may override this method to indicate that modules satisfying |
| certain conditions should not be linted. |
| |
| :param str modname: The name of the module to be checked. |
| :param str path: The full path to the source code of the module. |
| :param bool is_argument: Whetter the file is an argument to pylint or not. |
| Files which respect this property are always |
| checked, since the user requested it explicitly. |
| :returns: True if the module should be checked. |
| :rtype: bool |
| """ |
| if is_argument: |
| return True |
| return path.endswith(".py") |
| |
| # pylint: enable=unused-argument |
| |
| def close_registration(self): |
| """Stop registering plugins and prepare everything for checking.""" |
| MANAGER.always_load_extensions = self._global_config.unsafe_load_any_extension |
| MANAGER.max_inferable_values = self._global_config.limit_inference_results |
| MANAGER.extension_package_whitelist.update( |
| self._global_config.extension_pkg_whitelist |
| ) |
| |
| def check(self, files_or_modules): |
| """main checking entry: check a list of files or modules from their |
| name. |
| """ |
| # initialize msgs_state now that all messages have been registered into the store |
| self.close_registration() |
| |
| if not isinstance(files_or_modules, (list, tuple)): |
| files_or_modules = (files_or_modules,) |
| |
| # notify global begin |
| all_states = collections.defaultdict(list) |
| all_stats = [self._plugin_registry.stats] |
| # build ast and check modules or packages |
| expanded_files = utils.expand_files( |
| files_or_modules, |
| self._plugin_registry, |
| self._global_config.black_list, |
| self._global_config.black_list_re, |
| ) |
| config_store = config.ConfigurationStore() |
| for module_desc in expanded_files: |
| directory = os.path.dirname(module_desc.path) |
| |
| local_config = config_store[directory] |
| if not local_config: |
| local_file = config.find_nearby_pylintrc(directory) |
| if not local_file: |
| local_config = self._global_config |
| else: |
| local_config = self._global_config.copy() |
| self._file_parser.parse(local_file, local_config) |
| local_config += self._cli_config |
| |
| config_store[directory] = local_config |
| |
| for module_desc in expanded_files: |
| modname = module_desc.name |
| filepath = module_desc.path |
| if not module_desc.isarg and not self.should_analyze_file( |
| modname, filepath |
| ): |
| continue |
| |
| directory = os.path.dirname(module_desc.path) |
| local_config = config_store.get_config_for(directory) |
| linter = PyLinter(local_config) |
| linter.msgs_store = self._plugin_registry.msgs_store |
| for msg_ids, enable in local_config.msg_toggles: |
| for msg_id in msg_ids: |
| if enable: |
| linter.enable(msg_id, scope="directory") |
| else: |
| linter.disable(msg_id, scope="directory") |
| linter.open() |
| |
| walker = utils.PyLintASTWalker(self._plugin_registry) |
| allcheckers = [] |
| tokencheckers = [linter] |
| rawcheckers = [] |
| for checker_cls in self.prepare_checkers(linter): |
| checker = checker_cls(linter) |
| checker.linter = linter |
| all_states[checker_cls].append(checker.open()) |
| allcheckers.append(checker) |
| if interfaces.implements(checker, interfaces.ITokenChecker): |
| tokencheckers.append(checker) |
| if interfaces.implements(checker, interfaces.IRawChecker): |
| rawcheckers.append(checker) |
| if interfaces.implements(checker, interfaces.IAstroidChecker): |
| walker.add_checker(checker) |
| |
| linter.reporter = self._reporter |
| linter.check(module_desc, walker, rawcheckers, tokencheckers) |
| self._plugin_registry.stats["statement"] += walker.nbstatements |
| all_stats.append(linter.stats) |
| |
| for checker in reversed(allcheckers): |
| checker.close() |
| |
| linter = PyLinter(self._global_config) |
| linter.msgs_store = self._plugin_registry.msgs_store |
| linter.reporter = self._reporter |
| for msg_ids, enable in self._global_config.msg_toggles: |
| for msg_id in msg_ids: |
| if enable: |
| linter.enable(msg_id, scope="directory") |
| else: |
| linter.disable(msg_id, scope="directory") |
| linter.open() |
| # TODO: What about checkers that have been enabled in a local config? |
| for checker_cls in reversed(self.get_checkers()): |
| checker = checker_cls(linter) |
| checker.linter = linter |
| checker.global_close(all_states[checker_cls]) |
| |
| all_stats.append(linter.stats) |
| self._plugin_registry.stats = _merge_stats(all_stats) |
| |
| return module_desc.basename, all_states, linter.msg_status |
| |
| |
| if __name__ == "__main__": |
| CLIRunner().run(sys.argv[1:]) |
