/pylint/checkers/format.py
Python | 361 lines | 329 code | 4 blank | 28 comment | 21 complexity | a96a65738126bf2a70be1ba3774ad1ab MD5 | raw file
Possible License(s): GPL-2.0
- # Copyright (c) 2003-2010 Sylvain Thenault (thenault@gmail.com).
- # Copyright (c) 2003-2012 LOGILAB S.A. (Paris, FRANCE).
- # 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.,
- # 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- """Python code format's checker.
- By default try to follow Guido's style guide :
- http://www.python.org/doc/essays/styleguide.html
- Some parts of the process_token method is based from The Tab Nanny std module.
- """
- import re, sys
- import tokenize
- if not hasattr(tokenize, 'NL'):
- raise ValueError("tokenize.NL doesn't exist -- tokenize module too old")
- from logilab.common.textutils import pretty_match
- from logilab.astng import nodes
- from pylint.interfaces import IRawChecker, IASTNGChecker
- from pylint.checkers import BaseRawChecker
- from pylint.checkers.utils import check_messages
- MSGS = {
- 'C0301': ('Line too long (%s/%s)',
- 'Used when a line is longer than a given number of characters.'),
- 'C0302': ('Too many lines in module (%s)', # was W0302
- 'Used when a module has too much lines, reducing its readability.'
- ),
- 'W0311': ('Bad indentation. Found %s %s, expected %s',
- 'Used when an unexpected number of indentation\'s tabulations or '
- 'spaces has been found.'),
- 'W0312': ('Found indentation with %ss instead of %ss',
- 'Used when there are some mixed tabs and spaces in a module.'),
- 'W0301': ('Unnecessary semicolon', # was W0106
- 'Used when a statement is ended by a semi-colon (";"), which \
- isn\'t necessary (that\'s python, not C ;).'),
- 'C0321': ('More than one statement on a single line',
- 'Used when more than on statement are found on the same line.'),
- 'C0322': ('Operator not preceded by a space\n%s',
- 'Used when one of the following operator (!= | <= | == | >= | < '
- '| > | = | \+= | -= | \*= | /= | %) is not preceded by a space.'),
- 'C0323': ('Operator not followed by a space\n%s',
- 'Used when one of the following operator (!= | <= | == | >= | < '
- '| > | = | \+= | -= | \*= | /= | %) is not followed by a space.'),
- 'C0324': ('Comma not followed by a space\n%s',
- 'Used when a comma (",") is not followed by a space.'),
- }
- if sys.version_info < (3, 0):
- MSGS.update({
- 'W0331': ('Use of the <> operator',
- 'Used when the deprecated "<>" operator is used instead \
- of "!=".'),
- 'W0332': ('Use of "l" as long integer identifier',
- 'Used when a lower case "l" is used to mark a long integer. You '
- 'should use a upper case "L" since the letter "l" looks too much '
- 'like the digit "1"'),
- 'W0333': ('Use of the `` operator',
- 'Used when the deprecated "``" (backtick) operator is used '
- 'instead of the str() function.'),
- })
- # simple quoted string rgx
- SQSTRING_RGX = r'"([^"\\]|\\.)*?"'
- # simple apostrophed rgx
- SASTRING_RGX = r"'([^'\\]|\\.)*?'"
- # triple quoted string rgx
- TQSTRING_RGX = r'"""([^"]|("(?!"")))*?(""")'
- # triple apostrophed string rgx # FIXME english please
- TASTRING_RGX = r"'''([^']|('(?!'')))*?(''')"
- # finally, the string regular expression
- STRING_RGX = re.compile('(%s)|(%s)|(%s)|(%s)' % (TQSTRING_RGX, TASTRING_RGX,
- SQSTRING_RGX, SASTRING_RGX),
- re.MULTILINE|re.DOTALL)
- COMMENT_RGX = re.compile("#.*$", re.M)
- OPERATORS = r'!=|<=|==|>=|<|>|=|\+=|-=|\*=|/=|%'
- OP_RGX_MATCH_1 = r'[^(]*(?<!\s|\^|<|>|=|\+|-|\*|/|!|%%|&|\|)(%s).*' % OPERATORS
- OP_RGX_SEARCH_1 = r'(?<!\s|\^|<|>|=|\+|-|\*|/|!|%%|&|\|)(%s)' % OPERATORS
- OP_RGX_MATCH_2 = r'[^(]*(%s)(?!\s|=|>|<).*' % OPERATORS
- OP_RGX_SEARCH_2 = r'(%s)(?!\s|=|>)' % OPERATORS
- BAD_CONSTRUCT_RGXS = (
- (re.compile(OP_RGX_MATCH_1, re.M),
- re.compile(OP_RGX_SEARCH_1, re.M),
- 'C0322'),
- (re.compile(OP_RGX_MATCH_2, re.M),
- re.compile(OP_RGX_SEARCH_2, re.M),
- 'C0323'),
- (re.compile(r'.*,[^(\s|\]|}|\))].*', re.M),
- re.compile(r',[^\s)]', re.M),
- 'C0324'),
- )
- def get_string_coords(line):
- """return a list of string positions (tuple (start, end)) in the line
- """
- result = []
- for match in re.finditer(STRING_RGX, line):
- result.append( (match.start(), match.end()) )
- return result
- def in_coords(match, string_coords):
- """return true if the match is in the string coord"""
- mstart = match.start()
- for start, end in string_coords:
- if mstart >= start and mstart < end:
- return True
- return False
- def check_line(line):
- """check a line for a bad construction
- if it founds one, return a message describing the problem
- else return None
- """
- cleanstr = COMMENT_RGX.sub('', STRING_RGX.sub('', line))
- for rgx_match, rgx_search, msg_id in BAD_CONSTRUCT_RGXS:
- if rgx_match.match(cleanstr):
- string_positions = get_string_coords(line)
- for match in re.finditer(rgx_search, line):
- if not in_coords(match, string_positions):
- return msg_id, pretty_match(match, line.rstrip())
- class FormatChecker(BaseRawChecker):
- """checks for :
- * unauthorized constructions
- * strict indentation
- * line length
- * use of <> instead of !=
- """
- __implements__ = (IRawChecker, IASTNGChecker)
- # configuration section name
- name = 'format'
- # messages
- msgs = MSGS
- # configuration options
- # for available dict keys/values see the optik parser 'add_option' method
- options = (('max-line-length',
- {'default' : 80, 'type' : "int", 'metavar' : '<int>',
- 'help' : 'Maximum number of characters on a single line.'}),
- ('max-module-lines',
- {'default' : 1000, 'type' : 'int', 'metavar' : '<int>',
- 'help': 'Maximum number of lines in a module'}
- ),
- ('indent-string',
- {'default' : ' ', 'type' : "string", 'metavar' : '<string>',
- 'help' : 'String used as indentation unit. This is usually \
- " " (4 spaces) or "\\t" (1 tab).'}),
- )
- def __init__(self, linter=None):
- BaseRawChecker.__init__(self, linter)
- self._lines = None
- self._visited_lines = None
- def process_module(self, node):
- """extracts encoding from the stream and decodes each line, so that
- international text's length is properly calculated.
- """
- stream = node.file_stream
- stream.seek(0) # XXX may be removed with astng > 0.23
- readline = stream.readline
- if sys.version_info < (3, 0):
- if node.file_encoding is not None:
- readline = lambda: stream.readline().decode(node.file_encoding, 'replace')
- self.process_tokens(tokenize.generate_tokens(readline))
- def new_line(self, tok_type, line, line_num, junk):
- """a new line has been encountered, process it if necessary"""
- if not tok_type in junk:
- self._lines[line_num] = line.split('\n')[0]
- self.check_lines(line, line_num)
- def process_tokens(self, tokens):
- """process tokens and search for :
- _ non strict indentation (i.e. not always using the <indent> parameter as
- indent unit)
- _ too long lines (i.e. longer than <max_chars>)
- _ optionally bad construct (if given, bad_construct must be a compiled
- regular expression).
- """
- indent = tokenize.INDENT
- dedent = tokenize.DEDENT
- newline = tokenize.NEWLINE
- junk = (tokenize.COMMENT, tokenize.NL)
- indents = [0]
- check_equal = 0
- line_num = 0
- previous = None
- self._lines = {}
- self._visited_lines = {}
- for (tok_type, token, start, _, line) in tokens:
- if start[0] != line_num:
- if previous is not None and previous[0] == tokenize.OP and previous[1] == ';':
- self.add_message('W0301', line=previous[2])
- previous = None
- line_num = start[0]
- self.new_line(tok_type, line, line_num, junk)
- if tok_type not in (indent, dedent, newline) + junk:
- previous = tok_type, token, start[0]
- if tok_type == tokenize.OP:
- if token == '<>':
- self.add_message('W0331', line=line_num)
- elif tok_type == tokenize.NUMBER:
- if token.endswith('l'):
- self.add_message('W0332', line=line_num)
- elif tok_type == newline:
- # a program statement, or ENDMARKER, will eventually follow,
- # after some (possibly empty) run of tokens of the form
- # (NL | COMMENT)* (INDENT | DEDENT+)?
- # If an INDENT appears, setting check_equal is wrong, and will
- # be undone when we see the INDENT.
- check_equal = 1
- elif tok_type == indent:
- check_equal = 0
- self.check_indent_level(token, indents[-1]+1, line_num)
- indents.append(indents[-1]+1)
- elif tok_type == dedent:
- # there's nothing we need to check here! what's important is
- # that when the run of DEDENTs ends, the indentation of the
- # program statement (or ENDMARKER) that triggered the run is
- # equal to what's left at the top of the indents stack
- check_equal = 1
- if len(indents) > 1:
- del indents[-1]
- elif check_equal and tok_type not in junk:
- # this is the first "real token" following a NEWLINE, so it
- # must be the first token of the next program statement, or an
- # ENDMARKER; the "line" argument exposes the leading whitespace
- # for this statement; in the case of ENDMARKER, line is an empty
- # string, so will properly match the empty string with which the
- # "indents" stack was seeded
- check_equal = 0
- self.check_indent_level(line, indents[-1], line_num)
- line_num -= 1 # to be ok with "wc -l"
- if line_num > self.config.max_module_lines:
- self.add_message('C0302', args=line_num, line=1)
- @check_messages('C0321' ,'C03232', 'C0323', 'C0324')
- def visit_default(self, node):
- """check the node line number and check it if not yet done"""
- if not node.is_statement:
- return
- if not node.root().pure_python:
- return # XXX block visit of child nodes
- prev_sibl = node.previous_sibling()
- if prev_sibl is not None:
- prev_line = prev_sibl.fromlineno
- else:
- prev_line = node.parent.statement().fromlineno
- line = node.fromlineno
- assert line, node
- if prev_line == line and self._visited_lines.get(line) != 2:
- # py2.5 try: except: finally:
- if not (isinstance(node, nodes.TryExcept)
- and isinstance(node.parent, nodes.TryFinally)
- and node.fromlineno == node.parent.fromlineno):
- self.add_message('C0321', node=node)
- self._visited_lines[line] = 2
- return
- if line in self._visited_lines:
- return
- try:
- tolineno = node.blockstart_tolineno
- except AttributeError:
- tolineno = node.tolineno
- assert tolineno, node
- lines = []
- for line in xrange(line, tolineno + 1):
- self._visited_lines[line] = 1
- try:
- lines.append(self._lines[line].rstrip())
- except KeyError:
- lines.append('')
- try:
- msg_def = check_line('\n'.join(lines))
- if msg_def:
- self.add_message(msg_def[0], node=node, args=msg_def[1])
- except KeyError:
- # FIXME: internal error !
- pass
- @check_messages('W0333')
- def visit_backquote(self, node):
- self.add_message('W0333', node=node)
- def check_lines(self, lines, i):
- """check lines have less than a maximum number of characters
- """
- max_chars = self.config.max_line_length
- for line in lines.splitlines():
- if len(line) > max_chars:
- self.add_message('C0301', line=i, args=(len(line), max_chars))
- i += 1
- def check_indent_level(self, string, expected, line_num):
- """return the indent level of the string
- """
- indent = self.config.indent_string
- if indent == '\\t': # \t is not interpreted in the configuration file
- indent = '\t'
- level = 0
- unit_size = len(indent)
- while string[:unit_size] == indent:
- string = string[unit_size:]
- level += 1
- suppl = ''
- while string and string[0] in ' \t':
- if string[0] != indent[0]:
- if string[0] == '\t':
- args = ('tab', 'space')
- else:
- args = ('space', 'tab')
- self.add_message('W0312', args=args, line=line_num)
- return level
- suppl += string[0]
- string = string [1:]
- if level != expected or suppl:
- i_type = 'spaces'
- if indent[0] == '\t':
- i_type = 'tabs'
- self.add_message('W0311', line=line_num,
- args=(level * unit_size + len(suppl), i_type,
- expected * unit_size))
- def register(linter):
- """required method to auto register this checker """
- linter.register_checker(FormatChecker(linter))