You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
362 lines
14 KiB
Python
362 lines
14 KiB
Python
# Copyright (c) 2003-2010 Sylvain Thenault (thenault@gmail.com).
|
|
# Copyright (c) 2003-2010 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 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))
|