diff options
author | Ionel Cristian Maries <contact@ionelmc.ro> | 2015-02-14 18:13:20 +0200 |
---|---|---|
committer | Ionel Cristian Maries <contact@ionelmc.ro> | 2015-02-14 18:13:20 +0200 |
commit | 6d8412476a296b3a3691af1ffabcb672d9a4920f (patch) | |
tree | e358c7e886ff4d67d0efc6263f0472655efddfff /pylint/utils.py | |
parent | 0369bd6a914af3ad92ce53eac3786bf8de785f7f (diff) | |
download | pylint-6d8412476a296b3a3691af1ffabcb672d9a4920f.tar.gz |
Move all package files to a pylint package.
Diffstat (limited to 'pylint/utils.py')
-rw-r--r-- | pylint/utils.py | 919 |
1 files changed, 919 insertions, 0 deletions
diff --git a/pylint/utils.py b/pylint/utils.py new file mode 100644 index 0000000..6685c4a --- /dev/null +++ b/pylint/utils.py @@ -0,0 +1,919 @@ +# Copyright (c) 2003-2014 LOGILAB S.A. (Paris, FRANCE). +# http://www.logilab.fr/ -- mailto:contact@logilab.fr +# +# This program is free software; you can redistribute it and/or modify it under +# the terms of the GNU General Public License as published by the Free Software +# Foundation; either version 2 of the License, or (at your option) any later +# version. +# +# This program is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +"""some various utilities and helper classes, most of them used in the +main pylint class +""" +from __future__ import print_function + +import collections +import os +import re +import sys +import tokenize +import warnings +from os.path import dirname, basename, splitext, exists, isdir, join, normpath + +import six +from six.moves import zip # pylint: disable=redefined-builtin + +from logilab.common.interface import implements +from logilab.common.textutils import normalize_text +from logilab.common.configuration import rest_format_section +from logilab.common.ureports import Section + +from astroid import nodes, Module +from astroid.modutils import modpath_from_file, get_module_files, \ + file_from_modpath, load_module_from_file + +from pylint.interfaces import IRawChecker, ITokenChecker, UNDEFINED + + +class UnknownMessage(Exception): + """raised when a unregistered message id is encountered""" + +class EmptyReport(Exception): + """raised when a report is empty and so should not be displayed""" + + +MSG_TYPES = { + 'I' : 'info', + 'C' : 'convention', + 'R' : 'refactor', + 'W' : 'warning', + 'E' : 'error', + 'F' : 'fatal' + } +MSG_TYPES_LONG = {v: k for k, v in six.iteritems(MSG_TYPES)} + +MSG_TYPES_STATUS = { + 'I' : 0, + 'C' : 16, + 'R' : 8, + 'W' : 4, + 'E' : 2, + 'F' : 1 + } + +_MSG_ORDER = 'EWRCIF' +MSG_STATE_SCOPE_CONFIG = 0 +MSG_STATE_SCOPE_MODULE = 1 +MSG_STATE_CONFIDENCE = 2 + +OPTION_RGX = re.compile(r'\s*#.*\bpylint:(.*)') + +# The line/node distinction does not apply to fatal errors and reports. +_SCOPE_EXEMPT = 'FR' + +class WarningScope(object): + LINE = 'line-based-msg' + NODE = 'node-based-msg' + +_MsgBase = collections.namedtuple( + '_MsgBase', + ['msg_id', 'symbol', 'msg', 'C', 'category', 'confidence', + 'abspath', 'path', 'module', 'obj', 'line', 'column']) + + +class Message(_MsgBase): + """This class represent a message to be issued by the reporters""" + def __new__(cls, msg_id, symbol, location, msg, confidence): + return _MsgBase.__new__( + cls, msg_id, symbol, msg, msg_id[0], MSG_TYPES[msg_id[0]], + confidence, *location) + + def format(self, template): + """Format the message according to the given template. + + The template format is the one of the format method : + cf. http://docs.python.org/2/library/string.html#formatstrings + """ + # For some reason, _asdict on derived namedtuples does not work with + # Python 3.4. Needs some investigation. + return template.format(**dict(zip(self._fields, self))) + + +def get_module_and_frameid(node): + """return the module name and the frame id in the module""" + frame = node.frame() + module, obj = '', [] + while frame: + if isinstance(frame, Module): + module = frame.name + else: + obj.append(getattr(frame, 'name', '<lambda>')) + try: + frame = frame.parent.frame() + except AttributeError: + frame = None + obj.reverse() + return module, '.'.join(obj) + +def category_id(cid): + cid = cid.upper() + if cid in MSG_TYPES: + return cid + return MSG_TYPES_LONG.get(cid) + + +def _decoding_readline(stream, module): + return lambda: stream.readline().decode(module.file_encoding, + 'replace') + + +def tokenize_module(module): + with module.stream() as stream: + readline = stream.readline + if sys.version_info < (3, 0): + if module.file_encoding is not None: + readline = _decoding_readline(stream, module) + return list(tokenize.generate_tokens(readline)) + return list(tokenize.tokenize(readline)) + +def build_message_def(checker, msgid, msg_tuple): + if implements(checker, (IRawChecker, ITokenChecker)): + default_scope = WarningScope.LINE + else: + default_scope = WarningScope.NODE + options = {} + if len(msg_tuple) > 3: + (msg, symbol, descr, options) = msg_tuple + elif len(msg_tuple) > 2: + (msg, symbol, descr) = msg_tuple[:3] + else: + # messages should have a symbol, but for backward compatibility + # they may not. + (msg, descr) = msg_tuple + warnings.warn("[pylint 0.26] description of message %s doesn't include " + "a symbolic name" % msgid, DeprecationWarning) + symbol = None + options.setdefault('scope', default_scope) + return MessageDefinition(checker, msgid, msg, descr, symbol, **options) + + +class MessageDefinition(object): + def __init__(self, checker, msgid, msg, descr, symbol, scope, + minversion=None, maxversion=None, old_names=None): + self.checker = checker + assert len(msgid) == 5, 'Invalid message id %s' % msgid + assert msgid[0] in MSG_TYPES, \ + 'Bad message type %s in %r' % (msgid[0], msgid) + self.msgid = msgid + self.msg = msg + self.descr = descr + self.symbol = symbol + self.scope = scope + self.minversion = minversion + self.maxversion = maxversion + self.old_names = old_names or [] + + def may_be_emitted(self): + """return True if message may be emitted using the current interpreter""" + if self.minversion is not None and self.minversion > sys.version_info: + return False + if self.maxversion is not None and self.maxversion <= sys.version_info: + return False + return True + + def format_help(self, checkerref=False): + """return the help string for the given message id""" + desc = self.descr + if checkerref: + desc += ' This message belongs to the %s checker.' % \ + self.checker.name + title = self.msg + if self.symbol: + msgid = '%s (%s)' % (self.symbol, self.msgid) + else: + msgid = self.msgid + if self.minversion or self.maxversion: + restr = [] + if self.minversion: + restr.append('< %s' % '.'.join([str(n) for n in self.minversion])) + if self.maxversion: + restr.append('>= %s' % '.'.join([str(n) for n in self.maxversion])) + restr = ' or '.join(restr) + if checkerref: + desc += " It can't be emitted when using Python %s." % restr + else: + desc += " This message can't be emitted when using Python %s." % restr + desc = normalize_text(' '.join(desc.split()), indent=' ') + if title != '%s': + title = title.splitlines()[0] + return ':%s: *%s*\n%s' % (msgid, title, desc) + return ':%s:\n%s' % (msgid, desc) + + +class MessagesHandlerMixIn(object): + """a mix-in class containing all the messages related methods for the main + lint class + """ + + def __init__(self): + self._msgs_state = {} + self.msg_status = 0 + + def disable(self, msgid, scope='package', line=None, ignore_unknown=False): + """don't output message of the given id""" + assert scope in ('package', 'module') + # handle disable=all by disabling all categories + if msgid == 'all': + for msgid in MSG_TYPES: + self.disable(msgid, scope, line) + return + # msgid is a category? + catid = category_id(msgid) + if catid is not None: + for _msgid in self.msgs_store._msgs_by_category.get(catid): + self.disable(_msgid, scope, line) + return + # msgid is a checker name? + if msgid.lower() in self._checkers: + msgs_store = self.msgs_store + for checker in self._checkers[msgid.lower()]: + for _msgid in checker.msgs: + if _msgid in msgs_store._alternative_names: + self.disable(_msgid, scope, line) + return + # msgid is report id? + if msgid.lower().startswith('rp'): + self.disable_report(msgid) + return + + try: + # msgid is a symbolic or numeric msgid. + msg = self.msgs_store.check_message_id(msgid) + except UnknownMessage: + if ignore_unknown: + return + raise + + if scope == 'module': + self.file_state.set_msg_status(msg, line, False) + if msg.symbol != 'locally-disabled': + self.add_message('locally-disabled', line=line, + args=(msg.symbol, msg.msgid)) + + else: + msgs = self._msgs_state + msgs[msg.msgid] = False + # sync configuration object + self.config.disable = [mid for mid, val in six.iteritems(msgs) + if not val] + + def enable(self, msgid, scope='package', line=None, ignore_unknown=False): + """reenable message of the given id""" + assert scope in ('package', 'module') + catid = category_id(msgid) + # msgid is a category? + if catid is not None: + for msgid in self.msgs_store._msgs_by_category.get(catid): + self.enable(msgid, scope, line) + return + # msgid is a checker name? + if msgid.lower() in self._checkers: + for checker in self._checkers[msgid.lower()]: + for msgid_ in checker.msgs: + self.enable(msgid_, scope, line) + return + # msgid is report id? + if msgid.lower().startswith('rp'): + self.enable_report(msgid) + return + + try: + # msgid is a symbolic or numeric msgid. + msg = self.msgs_store.check_message_id(msgid) + except UnknownMessage: + if ignore_unknown: + return + raise + + if scope == 'module': + self.file_state.set_msg_status(msg, line, True) + self.add_message('locally-enabled', line=line, args=(msg.symbol, msg.msgid)) + else: + msgs = self._msgs_state + msgs[msg.msgid] = True + # sync configuration object + self.config.enable = [mid for mid, val in six.iteritems(msgs) if val] + + def get_message_state_scope(self, msgid, line=None, confidence=UNDEFINED): + """Returns the scope at which a message was enabled/disabled.""" + if self.config.confidence and confidence.name not in self.config.confidence: + return MSG_STATE_CONFIDENCE + try: + if line in self.file_state._module_msgs_state[msgid]: + return MSG_STATE_SCOPE_MODULE + except (KeyError, TypeError): + return MSG_STATE_SCOPE_CONFIG + + def is_message_enabled(self, msg_descr, line=None, confidence=None): + """return true if the message associated to the given message id is + enabled + + msgid may be either a numeric or symbolic message id. + """ + if self.config.confidence and confidence: + if confidence.name not in self.config.confidence: + return False + try: + msgid = self.msgs_store.check_message_id(msg_descr).msgid + except UnknownMessage: + # The linter checks for messages that are not registered + # due to version mismatch, just treat them as message IDs + # for now. + msgid = msg_descr + if line is None: + return self._msgs_state.get(msgid, True) + try: + return self.file_state._module_msgs_state[msgid][line] + except KeyError: + return self._msgs_state.get(msgid, True) + + def add_message(self, msg_descr, line=None, node=None, args=None, confidence=UNDEFINED): + """Adds a message given by ID or name. + + If provided, the message string is expanded using args + + AST checkers should must the node argument (but may optionally + provide line if the line number is different), raw and token checkers + must provide the line argument. + """ + msg_info = self.msgs_store.check_message_id(msg_descr) + msgid = msg_info.msgid + # backward compatibility, message may not have a symbol + symbol = msg_info.symbol or msgid + # Fatal messages and reports are special, the node/scope distinction + # does not apply to them. + if msgid[0] not in _SCOPE_EXEMPT: + if msg_info.scope == WarningScope.LINE: + assert node is None and line is not None, ( + 'Message %s must only provide line, got line=%s, node=%s' % (msgid, line, node)) + elif msg_info.scope == WarningScope.NODE: + # Node-based warnings may provide an override line. + assert node is not None, 'Message %s must provide Node, got None' + + if line is None and node is not None: + line = node.fromlineno + if hasattr(node, 'col_offset'): + col_offset = node.col_offset # XXX measured in bytes for utf-8, divide by two for chars? + else: + col_offset = None + # should this message be displayed + if not self.is_message_enabled(msgid, line, confidence): + self.file_state.handle_ignored_message( + self.get_message_state_scope(msgid, line, confidence), + msgid, line, node, args, confidence) + return + # update stats + msg_cat = MSG_TYPES[msgid[0]] + self.msg_status |= MSG_TYPES_STATUS[msgid[0]] + self.stats[msg_cat] += 1 + self.stats['by_module'][self.current_name][msg_cat] += 1 + try: + self.stats['by_msg'][symbol] += 1 + except KeyError: + self.stats['by_msg'][symbol] = 1 + # expand message ? + msg = msg_info.msg + if args: + msg %= args + # get module and object + if node is None: + module, obj = self.current_name, '' + abspath = self.current_file + else: + module, obj = get_module_and_frameid(node) + abspath = node.root().file + path = abspath.replace(self.reporter.path_strip_prefix, '') + # add the message + self.reporter.handle_message( + Message(msgid, symbol, + (abspath, path, module, obj, line or 1, col_offset or 0), msg, confidence)) + + def print_full_documentation(self): + """output a full documentation in ReST format""" + print("Pylint global options and switches") + print("----------------------------------") + print("") + print("Pylint provides global options and switches.") + print("") + + by_checker = {} + for checker in self.get_checkers(): + if checker.name == 'master': + if checker.options: + for section, options in checker.options_by_section(): + if section is None: + title = 'General options' + else: + title = '%s options' % section.capitalize() + print(title) + print('~' * len(title)) + rest_format_section(sys.stdout, None, options) + print("") + else: + try: + by_checker[checker.name][0] += checker.options_and_values() + by_checker[checker.name][1].update(checker.msgs) + by_checker[checker.name][2] += checker.reports + except KeyError: + by_checker[checker.name] = [list(checker.options_and_values()), + dict(checker.msgs), + list(checker.reports)] + + print("Pylint checkers' options and switches") + print("-------------------------------------") + print("") + print("Pylint checkers can provide three set of features:") + print("") + print("* options that control their execution,") + print("* messages that they can raise,") + print("* reports that they can generate.") + print("") + print("Below is a list of all checkers and their features.") + print("") + + for checker, (options, msgs, reports) in six.iteritems(by_checker): + title = '%s checker' % (checker.replace("_", " ").title()) + print(title) + print('~' * len(title)) + print("") + print("Verbatim name of the checker is ``%s``." % checker) + print("") + if options: + title = 'Options' + print(title) + print('^' * len(title)) + rest_format_section(sys.stdout, None, options) + print("") + if msgs: + title = 'Messages' + print(title) + print('~' * len(title)) + for msgid, msg in sorted(six.iteritems(msgs), + key=lambda kv: (_MSG_ORDER.index(kv[0][0]), kv[1])): + msg = build_message_def(checker, msgid, msg) + print(msg.format_help(checkerref=False)) + print("") + if reports: + title = 'Reports' + print(title) + print('~' * len(title)) + for report in reports: + print(':%s: %s' % report[:2]) + print("") + print("") + + +class FileState(object): + """Hold internal state specific to the currently analyzed file""" + + def __init__(self, modname=None): + self.base_name = modname + self._module_msgs_state = {} + self._raw_module_msgs_state = {} + self._ignored_msgs = collections.defaultdict(set) + self._suppression_mapping = {} + + def collect_block_lines(self, msgs_store, module_node): + """Walk the AST to collect block level options line numbers.""" + for msg, lines in six.iteritems(self._module_msgs_state): + self._raw_module_msgs_state[msg] = lines.copy() + orig_state = self._module_msgs_state.copy() + self._module_msgs_state = {} + self._suppression_mapping = {} + self._collect_block_lines(msgs_store, module_node, orig_state) + + def _collect_block_lines(self, msgs_store, node, msg_state): + """Recursivly walk (depth first) AST to collect block level options line + numbers. + """ + for child in node.get_children(): + self._collect_block_lines(msgs_store, child, msg_state) + first = node.fromlineno + last = node.tolineno + # first child line number used to distinguish between disable + # which are the first child of scoped node with those defined later. + # For instance in the code below: + # + # 1. def meth8(self): + # 2. """test late disabling""" + # 3. # pylint: disable=E1102 + # 4. print self.blip + # 5. # pylint: disable=E1101 + # 6. print self.bla + # + # E1102 should be disabled from line 1 to 6 while E1101 from line 5 to 6 + # + # this is necessary to disable locally messages applying to class / + # function using their fromlineno + if isinstance(node, (nodes.Module, nodes.Class, nodes.Function)) and node.body: + firstchildlineno = node.body[0].fromlineno + else: + firstchildlineno = last + for msgid, lines in six.iteritems(msg_state): + for lineno, state in list(lines.items()): + original_lineno = lineno + if first <= lineno <= last: + # Set state for all lines for this block, if the + # warning is applied to nodes. + if msgs_store.check_message_id(msgid).scope == WarningScope.NODE: + if lineno > firstchildlineno: + state = True + first_, last_ = node.block_range(lineno) + else: + first_ = lineno + last_ = last + for line in range(first_, last_+1): + # do not override existing entries + if not line in self._module_msgs_state.get(msgid, ()): + if line in lines: # state change in the same block + state = lines[line] + original_lineno = line + if not state: + self._suppression_mapping[(msgid, line)] = original_lineno + try: + self._module_msgs_state[msgid][line] = state + except KeyError: + self._module_msgs_state[msgid] = {line: state} + del lines[lineno] + + def set_msg_status(self, msg, line, status): + """Set status (enabled/disable) for a given message at a given line""" + assert line > 0 + try: + self._module_msgs_state[msg.msgid][line] = status + except KeyError: + self._module_msgs_state[msg.msgid] = {line: status} + + def handle_ignored_message(self, state_scope, msgid, line, + node, args, confidence): # pylint: disable=unused-argument + """Report an ignored message. + + state_scope is either MSG_STATE_SCOPE_MODULE or MSG_STATE_SCOPE_CONFIG, + depending on whether the message was disabled locally in the module, + or globally. The other arguments are the same as for add_message. + """ + if state_scope == MSG_STATE_SCOPE_MODULE: + try: + orig_line = self._suppression_mapping[(msgid, line)] + self._ignored_msgs[(msgid, orig_line)].add(line) + except KeyError: + pass + + def iter_spurious_suppression_messages(self, msgs_store): + for warning, lines in six.iteritems(self._raw_module_msgs_state): + for line, enable in six.iteritems(lines): + if not enable and (warning, line) not in self._ignored_msgs: + yield 'useless-suppression', line, \ + (msgs_store.get_msg_display_string(warning),) + # don't use iteritems here, _ignored_msgs may be modified by add_message + for (warning, from_), lines in list(self._ignored_msgs.items()): + for line in lines: + yield 'suppressed-message', line, \ + (msgs_store.get_msg_display_string(warning), from_) + + +class MessagesStore(object): + """The messages store knows information about every possible message but has + no particular state during analysis. + """ + + def __init__(self): + # Primary registry for all active messages (i.e. all messages + # that can be emitted by pylint for the underlying Python + # version). It contains the 1:1 mapping from symbolic names + # to message definition objects. + self._messages = {} + # Maps alternative names (numeric IDs, deprecated names) to + # message definitions. May contain several names for each definition + # object. + self._alternative_names = {} + self._msgs_by_category = collections.defaultdict(list) + + @property + def messages(self): + """The list of all active messages.""" + return six.itervalues(self._messages) + + def add_renamed_message(self, old_id, old_symbol, new_symbol): + """Register the old ID and symbol for a warning that was renamed. + + This allows users to keep using the old ID/symbol in suppressions. + """ + msg = self.check_message_id(new_symbol) + msg.old_names.append((old_id, old_symbol)) + self._alternative_names[old_id] = msg + self._alternative_names[old_symbol] = msg + + def register_messages(self, checker): + """register a dictionary of messages + + Keys are message ids, values are a 2-uple with the message type and the + message itself + + message ids should be a string of len 4, where the two first characters + are the checker id and the two last the message id in this checker + """ + chkid = None + for msgid, msg_tuple in six.iteritems(checker.msgs): + msg = build_message_def(checker, msgid, msg_tuple) + assert msg.symbol not in self._messages, \ + 'Message symbol %r is already defined' % msg.symbol + # avoid duplicate / malformed ids + assert msg.msgid not in self._alternative_names, \ + 'Message id %r is already defined' % msgid + assert chkid is None or chkid == msg.msgid[1:3], \ + 'Inconsistent checker part in message id %r' % msgid + chkid = msg.msgid[1:3] + self._messages[msg.symbol] = msg + self._alternative_names[msg.msgid] = msg + for old_id, old_symbol in msg.old_names: + self._alternative_names[old_id] = msg + self._alternative_names[old_symbol] = msg + self._msgs_by_category[msg.msgid[0]].append(msg.msgid) + + def check_message_id(self, msgid): + """returns the Message object for this message. + + msgid may be either a numeric or symbolic id. + + Raises UnknownMessage if the message id is not defined. + """ + if msgid[1:].isdigit(): + msgid = msgid.upper() + for source in (self._alternative_names, self._messages): + try: + return source[msgid] + except KeyError: + pass + raise UnknownMessage('No such message id %s' % msgid) + + def get_msg_display_string(self, msgid): + """Generates a user-consumable representation of a message. + + Can be just the message ID or the ID and the symbol. + """ + return repr(self.check_message_id(msgid).symbol) + + def help_message(self, msgids): + """display help messages for the given message identifiers""" + for msgid in msgids: + try: + print(self.check_message_id(msgid).format_help(checkerref=True)) + print("") + except UnknownMessage as ex: + print(ex) + print("") + continue + + def list_messages(self): + """output full messages list documentation in ReST format""" + msgs = sorted(six.itervalues(self._messages), key=lambda msg: msg.msgid) + for msg in msgs: + if not msg.may_be_emitted(): + continue + print(msg.format_help(checkerref=False)) + print("") + + +class ReportsHandlerMixIn(object): + """a mix-in class containing all the reports and stats manipulation + related methods for the main lint class + """ + def __init__(self): + self._reports = collections.defaultdict(list) + self._reports_state = {} + + def report_order(self): + """ Return a list of reports, sorted in the order + in which they must be called. + """ + return list(self._reports) + + def register_report(self, reportid, r_title, r_cb, checker): + """register a report + + reportid is the unique identifier for the report + r_title the report's title + r_cb the method to call to make the report + checker is the checker defining the report + """ + reportid = reportid.upper() + self._reports[checker].append((reportid, r_title, r_cb)) + + def enable_report(self, reportid): + """disable the report of the given id""" + reportid = reportid.upper() + self._reports_state[reportid] = True + + def disable_report(self, reportid): + """disable the report of the given id""" + reportid = reportid.upper() + self._reports_state[reportid] = False + + def report_is_enabled(self, reportid): + """return true if the report associated to the given identifier is + enabled + """ + return self._reports_state.get(reportid, True) + + 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 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 expand_modules(files_or_modules, black_list): + """take a list of files/modules/packages and return the list of tuple + (file, module name) which have to be actually checked + """ + result = [] + errors = [] + for something in files_or_modules: + if exists(something): + # this is a file or a directory + try: + modname = '.'.join(modpath_from_file(something)) + except ImportError: + modname = splitext(basename(something))[0] + if isdir(something): + filepath = join(something, '__init__.py') + else: + filepath = something + else: + # suppose it's a module or package + modname = something + try: + filepath = file_from_modpath(modname.split('.')) + if filepath is None: + errors.append({'key' : 'ignored-builtin-module', 'mod': modname}) + continue + except (ImportError, SyntaxError) as ex: + # FIXME p3k : the SyntaxError is a Python bug and should be + # removed as soon as possible http://bugs.python.org/issue10588 + errors.append({'key': 'fatal', 'mod': modname, 'ex': ex}) + continue + filepath = normpath(filepath) + result.append({'path': filepath, 'name': modname, 'isarg': True, + 'basepath': filepath, 'basename': modname}) + if not (modname.endswith('.__init__') or modname == '__init__') \ + and '__init__.py' in filepath: + for subfilepath in get_module_files(dirname(filepath), black_list): + if filepath == subfilepath: + continue + submodname = '.'.join(modpath_from_file(subfilepath)) + result.append({'path': subfilepath, 'name': submodname, + 'isarg': False, + 'basepath': filepath, 'basename': modname}) + return result, errors + + +class PyLintASTWalker(object): + + def __init__(self, linter): + # callbacks per node types + self.nbstatements = 1 + self.visit_events = collections.defaultdict(list) + self.leave_events = collections.defaultdict(list) + self.linter = linter + + def _is_method_enabled(self, method): + if not hasattr(method, 'checks_msgs'): + return True + for msg_desc in method.checks_msgs: + if self.linter.is_message_enabled(msg_desc): + return True + return False + + def add_checker(self, checker): + """walk to the checker's dir and collect visit and leave methods""" + # XXX : should be possible to merge needed_checkers and add_checker + vcids = set() + lcids = set() + visits = self.visit_events + leaves = self.leave_events + for member in dir(checker): + cid = member[6:] + if cid == 'default': + continue + if member.startswith('visit_'): + v_meth = getattr(checker, member) + # don't use visit_methods with no activated message: + if self._is_method_enabled(v_meth): + visits[cid].append(v_meth) + vcids.add(cid) + elif member.startswith('leave_'): + l_meth = getattr(checker, member) + # don't use leave_methods with no activated message: + if self._is_method_enabled(l_meth): + leaves[cid].append(l_meth) + lcids.add(cid) + visit_default = getattr(checker, 'visit_default', None) + if visit_default: + for cls in nodes.ALL_NODE_CLASSES: + cid = cls.__name__.lower() + if cid not in vcids: + visits[cid].append(visit_default) + # for now we have no "leave_default" method in Pylint + + def walk(self, astroid): + """call visit events of astroid checkers for the given node, recurse on + its children, then leave events. + """ + cid = astroid.__class__.__name__.lower() + if astroid.is_statement: + self.nbstatements += 1 + # generate events for this node on each checker + for cb in self.visit_events.get(cid, ()): + cb(astroid) + # recurse on children + for child in astroid.get_children(): + self.walk(child) + for cb in self.leave_events.get(cid, ()): + cb(astroid) + + +PY_EXTS = ('.py', '.pyc', '.pyo', '.pyw', '.so', '.dll') + +def register_plugins(linter, directory): + """load all module and package in the given directory, looking for a + 'register' function in each one, used to register pylint checkers + """ + imported = {} + for filename in os.listdir(directory): + base, extension = splitext(filename) + if base in imported or base == '__pycache__': + continue + if extension in PY_EXTS and base != '__init__' or ( + not extension and isdir(join(directory, base))): + try: + module = load_module_from_file(join(directory, filename)) + except ValueError: + # empty module name (usually emacs auto-save files) + continue + except ImportError as exc: + print("Problem importing module %s: %s" % (filename, exc), + file=sys.stderr) + else: + if hasattr(module, 'register'): + module.register(linter) + imported[base] = 1 + +def get_global_option(checker, option, default=None): + """ Retrieve an option defined by the given *checker* or + by all known option providers. + + It will look in the list of all options providers + until the given *option* will be found. + If the option wasn't found, the *default* value will be returned. + """ + # First, try in the given checker's config. + # After that, look in the options providers. + + try: + return getattr(checker.config, option.replace("-", "_")) + except AttributeError: + pass + for provider in checker.linter.options_providers: + for options in provider.options: + if options[0] == option: + return getattr(provider.config, option.replace("-", "_")) + return default |