eric: comparison eric6/Plugins/CheckerPlugins/CodeStyleChecker/pycodestyle.py

-:fb0ef164f536
+:698ae46f40a4
 from configparser import RawConfigParser
 from io import TextIOWrapper
 except ImportError:
 from ConfigParser import RawConfigParser            # __IGNORE_WARNING__
-__version__ = '2.6.0-eric'
+__version__ = '2.7.0-eric'
 DEFAULT_EXCLUDE = '.svn,CVS,.bzr,.hg,.git,__pycache__,.tox'
 DEFAULT_IGNORE = 'E121,E123,E126,E226,E24,E704,W503,W504'
 try:
 if sys.platform == 'win32':
 'top_level': 2,
 # Methods and nested class and function.
 'method': 1,
 }
 MAX_DOC_LENGTH = 72
+INDENT_SIZE = 4
 REPORT_FORMAT = {
 'default': '%(path)s:%(row)d:%(col)d: %(code)s %(text)s',
 'pylint': '%(path)s:%(row)d: [%(code)s] %(text)s',
 }
 W391: spam(1)\n
 However the last line should end with a new line (warning W292).
 """
 if line_number == total_lines:
-stripped_last_line = physical_line.rstrip()
+stripped_last_line = physical_line.rstrip('\r\n')
 if physical_line and not stripped_last_line:
 return 0, "W391 blank line at end of file"
 if stripped_last_line == physical_line:
 return len(lines[-1]), "W292 no newline at end of file"
 yield index, "E231 missing whitespace after '%s'", char
 @register_check
 def indentation(logical_line, previous_logical, indent_char,
-indent_level, previous_indent_level):
+indent_level, previous_indent_level,
-r"""Use 4 spaces per indentation level.
+indent_size, indent_size_str):
+r"""Use indent_size (PEP8 says 4) spaces per indentation level.
 For really old code that you don't want to mess up, you can continue
 to use 8-space tabs.
 Okay: a = 1
 E113: a = 1\n    b = 2
 E116: a = 1\n    # b = 2
 """
 c = 0 if logical_line else 3
 tmpl = "E11%d %s" if logical_line else "E11%d %s (comment)"
-if indent_level % 4:
+if indent_level % indent_size:
-yield 0, tmpl % (1 + c, "indentation is not a multiple of four")
+yield 0, tmpl % (
+1 + c,
+"indentation is not a multiple of " + indent_size_str,
+)
 indent_expect = previous_logical.endswith(':')
 if indent_expect and indent_level <= previous_indent_level:
 yield 0, tmpl % (2 + c, "expected an indented block")
 elif not indent_expect and indent_level > previous_indent_level:
 yield 0, tmpl % (3 + c, "unexpected indentation")
 yield 0, tmpl % (7, 'over-indented')
 @register_check
 def continued_indentation(logical_line, tokens, indent_level, hang_closing,
-indent_char, noqa, verbose):
+indent_char, indent_size, indent_size_str, noqa,
+verbose):
 r"""Continuation lines indentation.
 Continuation lines should align wrapped elements either vertically
 using Python's implicit line joining inside parentheses, brackets
 and braces, or using a hanging indent.
 # indents on the final continuation line; in turn, some other
 # indents are allowed to have an extra 4 spaces.
 indent_next = logical_line.endswith(':')
 row = depth = 0
-valid_hangs = (4,) if indent_char != '\t' else (4, 8)
+valid_hangs = (indent_size,) if indent_char != '\t' \
+else (indent_size, indent_size * 2)
 # remember how many brackets were opened on each line
 parens = [0] * nrows
 # relative indents of physical lines
 rel_indent = [0] * nrows
 # for each depth, collect a list of opening rows
 elif indent[depth] and start[1] < indent[depth]:
 if visual_indent is not True:
 # visual indent is broken
 yield (start, "E128 continuation line "
 "under-indented for visual indent")
-elif hanging_indent or (indent_next and rel_indent[row] == 8):
+elif hanging_indent or (indent_next and
+rel_indent[row] == 2 * indent_size):
 # hanging indent is verified
 if close_bracket and not hang_closing:
 yield (start, "E123 closing bracket does not match "
 "indentation of opening bracket's line")
 hangs[depth] = hang
 error = "E127", "over-indented for visual indent"
 elif not close_bracket and hangs[depth]:
 error = "E131", "unaligned for hanging indent"
 else:
 hangs[depth] = hang
-if hang > 4:
+if hang > indent_size:
 error = "E126", "over-indented for hanging indent"
 else:
 error = "E121", "under-indented for hanging indent"
 yield start, "%s continuation line %s" % error
 last_token_multiline = (start[0] != end[0])
 if last_token_multiline:
 rel_indent[end[0] - first_row] = rel_indent[row]
-if indent_next and expand_indent(line) == indent_level + 4:
+if indent_next and expand_indent(line) == indent_level + indent_size:
-pos = (start[0], indent[0] + 4)
+pos = (start[0], indent[0] + indent_size)
 if visual_indent:
 code = "E129 visually indented line"
 else:
 code = "E125 continuation line"
 yield pos, "%s with same indent as next logical line" % code
 Okay: import os
 Okay: # this is a comment\nimport os
 Okay: '''this is a module docstring'''\nimport os
 Okay: r'''this is a module docstring'''\nimport os
 Okay:
 try:\n\timport x\nexcept ImportError:\n\tpass\nelse:\n\tpass\nimport y
 Okay:
 try:\n\timport x\nexcept ImportError:\n\tpass\nfinally:\n\tpass\nimport y
 E402: a=1\nimport os
 E402: 'One string'\n"Two string"\nimport os
 E402: a=1\nfrom sys import x
 if prev_text == 'def':
 if text in idents_to_avoid:
 yield start, "E743 ambiguous function definition '%s'", text
 if ident:
 yield pos, "E741 ambiguous variable name '%s'", ident
+prev_type = token_type
 prev_text = text
 prev_start = start
 @register_check
 else:
 # Python 3
 def readlines(filename):
 """Read the source code."""
 try:
-with open(filename, 'rb') as f:
+with tokenize.open(filename) as f:
-(coding, lines) = tokenize.detect_encoding(f.readline)
+return f.readlines()
-f = TextIOWrapper(f, coding, line_buffering=True)
-return [line.decode(coding) for line in lines] + f.readlines()
 except (LookupError, SyntaxError, UnicodeError):
 # Fall back if file encoding is improperly declared
 with open(filename, encoding='latin-1') as f:
 return f.readlines()
 isidentifier = str.isidentifier
 self._physical_checks = options.physical_checks
 self._logical_checks = options.logical_checks
 self._ast_checks = options.ast_checks
 self.max_line_length = options.max_line_length
 self.max_doc_length = options.max_doc_length
+self.indent_size = options.indent_size
 self.multiline = False  # in a multiline string?
 self.hang_closing = options.hang_closing
+self.indent_size = options.indent_size
+self.indent_size_str = ({2: 'two', 4: 'four', 8: 'eight'}
+.get(self.indent_size, str(self.indent_size)))
 self.verbose = options.verbose
 self.filename = filename
 # Dictionary where a checker can store its custom state.
 self._checker_states = {}
 if filename is None:
 """Tokenize file, run physical line checks and yield tokens."""
 if self._io_error:
 self.report_error_args(1, 0, 'E902', self._io_error, readlines)
 tokengen = tokenize.generate_tokens(self.readline)
 try:
+prev_physical = ''
 for token in tokengen:
 if token[2][0] > self.total_lines:
 return
 self.noqa = token[4] and noqa(token[4])
-self.maybe_check_physical(token)
+self.maybe_check_physical(token, prev_physical)
 yield token
+prev_physical = token[4]
 except (SyntaxError, tokenize.TokenError):
 self.report_invalid_syntax()
-def maybe_check_physical(self, token):
+def maybe_check_physical(self, token, prev_physical):
 """If appropriate for token, check current physical line(s)."""
 # Called after every token, but act only on end of line.
+# a newline token ends a single physical line.
 if _is_eol_token(token):
-# Obviously, a newline token ends a single physical line.
+# if the file does not end with a newline, the NEWLINE
-self.check_physical(token[4])
+# token is inserted by the parser, but it does not contain
+# the previous physical line in `token[4]`
+if token[4] == '':
+self.check_physical(prev_physical)
+else:
+self.check_physical(token[4])
 elif token[0] == tokenize.STRING and '\n' in token[1]:
 # Less obviously, a string that contains newlines is a
 # multiline string, either triple-quoted or with internal
 # newlines backslash-escaped. Check every physical line in
 # the string *except* for the last one: its newline is
 class StandardReport(BaseReport):
 """Collect and print the results of the checks."""
 def __init__(self, options):
-super(StandardReport, self).__init__(options)
+super().__init__(options)
 self._fmt = REPORT_FORMAT.get(options.format.lower(),
 options.format)
 self._repeat = options.repeat
 self._show_source = options.show_source
 self._show_pep8 = options.show_pep8
 def init_file(self, filename, lines, expected, line_offset):
 """Signal a new file."""
 self._deferred_print = []
-return super(StandardReport, self).init_file(
+return super().init_file(
 filename, lines, expected, line_offset)
 def error(self, line_number, offset, text, check):
 """Report an error, according to options."""
-code = super(StandardReport, self).error(line_number, offset,
+code = super().error(line_number, offset,
 text, check)
 if code and (self.counters[code] == 1 or self._repeat):
 self._deferred_print.append(
 (line_number, offset, code, text[5:], check.__doc__))
 return code
 def error_args(self, line_number, offset, code, check, *args):
 """Report an error, according to options."""
-code = super(StandardReport, self).error_args(line_number, offset,
+code = super().error_args(line_number, offset,
 code, check, *args)
 if code and (self.counters[code] == 1 or self._repeat):
 self._deferred_print.append(
 (line_number, offset, code, args, check.__doc__))
 return code
 class DiffReport(StandardReport):
 """Collect and print the results for the changed lines only."""
 def __init__(self, options):
-super(DiffReport, self).__init__(options)
+super().__init__(options)
 self._selected = options.selected_lines
 def error(self, line_number, offset, text, check):
 if line_number not in self._selected[self.filename]:
 return
-return super(DiffReport, self).error(line_number, offset, text, check)
+return super().error(line_number, offset, text, check)
 class StyleGuide(object):
 """Initialize a PEP-8 instance with few options."""
 """Create the parser for the program."""
 parser = OptionParser(prog=prog, version=version,
 usage="%prog [options] input ...")
 parser.config_options = [
 'exclude', 'filename', 'select', 'ignore', 'max-line-length',
-'max-doc-length', 'hang-closing', 'count', 'format', 'quiet',
+'max-doc-length', 'indent-size', 'hang-closing', 'count', 'format',
-'show-pep8', 'show-source', 'statistics', 'verbose']
+'quiet', 'show-pep8', 'show-source', 'statistics', 'verbose']
 parser.add_option('-v', '--verbose', default=0, action='count',
 help="print status messages, or debug with -vv")
 parser.add_option('-q', '--quiet', default=0, action='count',
 help="report only file names, or nothing with -qq")
 parser.add_option('-r', '--repeat', default=True, action='store_true',
 "(default: %default)")
 parser.add_option('--max-doc-length', type='int', metavar='n',
 default=None,
 help="set maximum allowed doc line length and perform "
 "these checks (unchecked if not set)")
+parser.add_option('--indent-size', type='int', metavar='n',
+default=INDENT_SIZE,
+help="set how many spaces make up an indent "
+"(default: %default)")
 parser.add_option('--hang-closing', action='store_true',
 help="hang closing bracket instead of matching "
 "indentation of opening bracket's line")
 parser.add_option('--format', metavar='format', default='default',
 help="set the error format [default|pylint|<custom>]")

Mercurial Repositories > eric / file comparison

comparison: eric6/Plugins/CheckerPlugins/CodeStyleChecker/pycodestyle.py

eric6/Plugins/CheckerPlugins/CodeStyleChecker/pycodestyle.py