eric: Plugins/CheckerPlugins/Pep8/Pep8Fixer.py@b601ede6dbbf (annotated)

 # -*- coding: utf-8 -*-
 # Copyright (c) 2011 - 2013 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 """
 Module implementing a class to fix certain PEP 8 issues.
 """
 import os
 import re
 import tokenize
 import io
 from PyQt4.QtCore import QObject
 from E5Gui import E5MessageBox
 from . import pep8
 import Utilities
 Pep8FixableIssues = ["E101", "E111", "E121", "E122", "E123", "E124",
                      "E125", "E126", "E127", "E128", "E133", "W191",
                      "E201", "E202", "E203", "E211", "E221", "E222",
                      "E223", "E224", "E225", "E226", "E227", "E228",
                      "E231", "E241", "E242", "E251", "E261", "E262",
                      "E271", "E272", "E273", "E274", "W291", "W292",
                      "W293", "E301", "E302", "E303", "E304", "W391",
                      "E401", "E501", "E502", "W603", "E701", "E702",
                      "E703", "E711", "E712"
                      ]
 class Pep8Fixer(QObject):
     """
     Class implementing a fixer for certain PEP 8 issues.
     """
     def __init__(self, project, filename, sourceLines, fixCodes, noFixCodes,
                  maxLineLength, inPlace):
         """
         Constructor
         @param project  reference to the project object (Project)
         @param filename name of the file to be fixed (string)
         @param sourceLines list of source lines including eol marker
             (list of string)
         @param fixCodes list of codes to be fixed as a comma separated
             string (string)
         @param noFixCodes list of codes not to be fixed as a comma
             separated string (string)
         @param maxLineLength maximum allowed line length (integer)
         @param inPlace flag indicating to modify the file in place (boolean)
         """
         super().__init__()
         self.__project = project
         self.__filename = filename
         self.__origName = ""
         self.__source = sourceLines[:]  # save a copy
         self.__fixCodes = [c.strip() for c in fixCodes.split(",") if c.strip()]
         self.__noFixCodes = [
             c.strip() for c in noFixCodes.split(",") if c.strip()]
         self.__maxLineLength = maxLineLength
         self.fixed = 0
         self.__reindenter = None
         self.__eol = ""
         self.__indentWord = self.__getIndentWord()
         if not inPlace:
             self.__origName = self.__filename
             self.__filename = os.path.join(
                 os.path.dirname(self.__filename),
                 "fixed_" + os.path.basename(self.__filename))
         self.__fixes = {
             "E101": self.__fixE101,
             "E111": self.__fixE101,
             "E121": self.__fixE121,
             "E122": self.__fixE122,
             "E123": self.__fixE123,
             "E124": self.__fixE121,
             "E125": self.__fixE125,
             "E126": self.__fixE126,
             "E127": self.__fixE127,
             "E128": self.__fixE127,
             "E133": self.__fixE126,
             "W191": self.__fixE101,
             "E201": self.__fixE201,
             "E202": self.__fixE201,
             "E203": self.__fixE201,
             "E211": self.__fixE201,
             "E221": self.__fixE221,
             "E222": self.__fixE221,
             "E223": self.__fixE221,
             "E224": self.__fixE221,
             "E225": self.__fixE221,
             "E226": self.__fixE221,
             "E227": self.__fixE221,
             "E228": self.__fixE221,
             "E231": self.__fixE231,
             "E241": self.__fixE221,
             "E242": self.__fixE221,
             "E251": self.__fixE251,
             "E261": self.__fixE261,
             "E262": self.__fixE261,
             "E271": self.__fixE221,
             "E272": self.__fixE221,
             "E273": self.__fixE221,
             "E274": self.__fixE221,
             "W291": self.__fixW291,
             "W292": self.__fixW292,
             "W293": self.__fixW291,
             "E301": self.__fixE301,
             "E302": self.__fixE302,
             "E303": self.__fixE303,
             "E304": self.__fixE304,
             "W391": self.__fixW391,
             "E401": self.__fixE401,
             "E501": self.__fixE501,
             "E502": self.__fixE502,
             "W603": self.__fixW603,
             "E701": self.__fixE701,
             "E702": self.__fixE702,
             "E703": self.__fixE702,
             "E711": self.__fixE711,
             "E712": self.__fixE711,
         }
         self.__modified = False
         self.__stackLogical = []    # these need to be fixed before the file
                                     # is saved but after all other inline
                                     # fixes. These work with logical lines.
         self.__stack = []           # these need to be fixed before the file
                                     # is saved but after all inline fixes
         self.__multiLineNumbers = None
         self.__docLineNumbers = None
         self.__lastID = 0
     def saveFile(self, encoding):
         """
         Public method to save the modified file.
         @param encoding encoding of the source file (string)
         @return flag indicating success (boolean)
         """
         if not self.__modified:
             # no need to write
             return True
         txt = "".join(self.__source)
         try:
             Utilities.writeEncodedFile(self.__filename, txt, encoding)
         except (IOError, Utilities.CodingError, UnicodeError) as err:
             E5MessageBox.critical(
                 self,
                 self.trUtf8("Fix PEP 8 issues"),
                 self.trUtf8(
                     """<p>Could not save the file <b>{0}</b>."""
                     """ Skipping it.</p><p>Reason: {1}</p>""")
                 .format(self.__filename, str(err))
             )
             return False
         return True
     def __codeMatch(self, code):
         """
         Private method to check, if the code should be fixed.
         @param code to check (string)
         @return flag indicating it should be fixed (boolean)
         """
         def mutualStartswith(a, b):
             """
             Local helper method to compare the beginnings of two strings
             against each other.
             @return flag indicating that one string starts with the other
                 (boolean)
             """
             return b.startswith(a) or a.startswith(b)
         if self.__noFixCodes:
             for noFixCode in [c.strip() for c in self.__noFixCodes]:
                 if mutualStartswith(code.lower(), noFixCode.lower()):
                     return False
         if self.__fixCodes:
             for fixCode in [c.strip() for c in self.__fixCodes]:
                 if mutualStartswith(code.lower(), fixCode.lower()):
                     return True
             return False
         return True
     def fixIssue(self, line, pos, message):
         """
         Public method to fix the fixable issues.
         @param line line number of issue (integer)
         @param pos character position of issue (integer)
         @param message message text (string)
         @return value indicating an applied/deferred fix (-1, 0, 1),
             a message for the fix (string) and an ID for a deferred
             fix (integer)
         """
         code = message.split(None, 1)[0].strip()
         if line <= len(self.__source) and \
            self.__codeMatch(code) and \
            code in self.__fixes:
             res = self.__fixes[code](code, line, pos)
             if res[0] == 1:
                 self.__modified = True
                 self.fixed += 1
         else:
             res = (0, "", 0)
         return res
     def finalize(self):
         """
         Public method to apply all deferred fixes.
         """
         results = {}
         # step 1: do fixes operating on logical lines first
         for id_, code, line, pos in self.__stackLogical:
             res, msg, _ = self.__fixes[code](code, line, pos, apply=True)
             if res == 1:
                 self.__modified = True
                 self.fixed += 1
             results[id_] = (res, msg)
         # step 2: do fixes that change the number of lines
         for id_, code, line, pos in reversed(self.__stack):
             res, msg, _ = self.__fixes[code](code, line, pos, apply=True)
             if res == 1:
                 self.__modified = True
                 self.fixed += 1
             results[id_] = (res, msg)
         return results
     def __getID(self):
         """
         Private method to get the ID for a deferred fix.
         @return ID for a deferred fix (integer)
         """
         self.__lastID += 1
         return self.__lastID
     def __getEol(self):
         """
         Private method to get the applicable eol string.
         @return eol string (string)
         """
         if not self.__eol:
             if self.__origName:
                 fn = self.__origName
             else:
                 fn = self.__filename
             if self.__project.isOpen() and self.__project.isProjectFile(fn):
                 self.__eol = self.__project.getEolString()
             else:
                 self.__eol = Utilities.linesep()
         return self.__eol
     def __findLogical(self):
         """
         Private method to extract the index of all the starts and ends of
         lines.
         @return tuple containing two lists of integer with start and end tuples
             of lines
         """
         logical_start = []
         logical_end = []
         last_newline = True
         sio = io.StringIO("".join(self.__source))
         parens = 0
         for t in tokenize.generate_tokens(sio.readline):
             if t[0] in [tokenize.COMMENT, tokenize.DEDENT,
                         tokenize.INDENT, tokenize.NL,
                         tokenize.ENDMARKER]:
                 continue
             if not parens and t[0] in [tokenize.NEWLINE, tokenize.SEMI]:
                 last_newline = True
                 logical_end.append((t[3][0] - 1, t[2][1]))
                 continue
             if last_newline and not parens:
                 logical_start.append((t[2][0] - 1, t[2][1]))
                 last_newline = False
             if t[0] == tokenize.OP:
                 if t[1] in '([{':
                     parens += 1
                 elif t[1] in '}])':
                     parens -= 1
         return logical_start, logical_end
     def __getLogical(self, line, pos):
         """
         Private method to get the logical line corresponding to the given
         position.
         @param line line number of the issue (integer)
         @param pos position inside line (integer)
         @return tuple of a tuple of two integers giving the start of the
             logical line, another tuple of two integers giving the end
             of the logical line and a list of strings with the original
             source lines
         """
         try:
             (logical_start, logical_end) = self.__findLogical()
         except (SyntaxError, tokenize.TokenError):
             return None
         line = line - 1
         ls = None
         le = None
         for i in range(0, len(logical_start)):
             x = logical_end[i]
             if x[0] > line or (x[0] == line and x[1] > pos):
                 le = x
                 ls = logical_start[i]
                 break
         if ls is None:
             return None
         original = self.__source[ls[0]:le[0] + 1]
         return ls, le, original
     def __getIndentWord(self):
         """
         Private method to determine the indentation type.
         @return string to be used for an indentation (string)
         """
         sio = io.StringIO("".join(self.__source))
         indentWord = "    "     # default in case of failure
         try:
             for token in tokenize.generate_tokens(sio.readline):
                 if token[0] == tokenize.INDENT:
                     indentWord = token[1]
                     break
         except (SyntaxError, tokenize.TokenError):
             pass
         return indentWord
     def __getIndent(self, line):
         """
         Private method to get the indentation string.
         @param line line to determine the indentation string from (string)
         @return indentation string (string)
         """
         return line.replace(line.lstrip(), "")
     def __multilineStringLines(self):
         """
         Private method to determine the line numbers that are within multi line
         strings and these which are part of a documentation string.
         @return tuple of a set of line numbers belonging to a multi line
             string and a set of line numbers belonging to a multi line
             documentation string (tuple of two set of integer)
         """
         if self.__multiLineNumbers is None:
             source = "".join(self.__source)
             sio = io.StringIO(source)
             self.__multiLineNumbers = set()
             self.__docLineNumbers = set()
             previousTokenType = ''
             try:
                 for t in tokenize.generate_tokens(sio.readline):
                     tokenType = t[0]
                     startRow = t[2][0]
                     endRow = t[3][0]
                     if (tokenType == tokenize.STRING and startRow != endRow):
                         if previousTokenType != tokenize.INDENT:
                             self.__multiLineNumbers |= set(
                                 range(startRow, 1 + endRow))
                         else:
                             self.__docLineNumbers |= set(
                                 range(startRow, 1 + endRow))
                     previousTokenType = tokenType
             except (SyntaxError, tokenize.TokenError):
                 pass
         return self.__multiLineNumbers, self.__docLineNumbers
     def __fixReindent(self, line, pos, logical):
         """
         Private method to fix a badly indented line.
         This is done by adding or removing from its initial indent only.
         @param line line number of the issue (integer)
         @param pos position inside line (integer)
         @return flag indicating a change was done (boolean)
         """
         assert logical
         ls, _, original = logical
         rewrapper = Pep8IndentationWrapper(original)
         valid_indents = rewrapper.pep8Expected()
         if not rewrapper.rel_indent:
             return False
         if line > ls[0]:
             # got a valid continuation line number
             row = line - ls[0] - 1
             # always pick the first option for this
             valid = valid_indents[row]
             got = rewrapper.rel_indent[row]
         else:
             return False
         line1 = ls[0] + row
         # always pick the expected indent, for now.
         indent_to = valid[0]
         if got != indent_to:
             orig_line = self.__source[line1]
             new_line = ' ' * (indent_to) + orig_line.lstrip()
             if new_line == orig_line:
                 return False
             else:
                 self.__source[line1] = new_line
                 return True
         else:
             return False
     def __fixWhitespace(self, line, offset, replacement):
         """
         Private method to correct whitespace at the given offset.
         @param line line to be corrected (string)
         @param offset offset within line (integer)
         @param replacement replacement string (string)
         @return corrected line
         """
         left = line[:offset].rstrip(" \t")
         right = line[offset:].lstrip(" \t")
         if right.startswith("#"):
             return line
         else:
             return left + replacement + right
     def __fixE101(self, code, line, pos):
         """
         Private method to fix obsolete tab usage and indentation errors
         (E101, E111, W191).
         @param code code of the issue (string)
         @param line line number of the issue (integer)
         @param pos position inside line (integer)
         @return value indicating an applied/deferred fix (-1, 0, 1),
             a message for the fix (string) and an ID for a deferred
             fix (integer)
         """
         if self.__reindenter is None:
             self.__reindenter = Pep8Reindenter(self.__source)
             self.__reindenter.run()
         fixedLine = self.__reindenter.fixedLine(line - 1)
         if fixedLine is not None and fixedLine != self.__source[line - 1]:
             self.__source[line - 1] = fixedLine
             if code in ["E101", "W191"]:
                 msg = self.trUtf8("Tab converted to 4 spaces.")
             else:
                 msg = self.trUtf8(
                     "Indentation adjusted to be a multiple of four.")
             return (1, msg, 0)
         else:
             return (0, "", 0)
     def __fixE121(self, code, line, pos, apply=False):
         """
         Private method to fix the indentation of continuation lines and
         closing brackets (E121,E124).
         @param code code of the issue (string)
         @param line line number of the issue (integer)
         @param pos position inside line (integer)
         @keyparam apply flag indicating, that the fix should be applied
             (boolean)
         @return value indicating an applied/deferred fix (-1, 0, 1),
             a message for the fix (string) and an ID for a deferred
             fix (integer)
         """
         if apply:
             logical = self.__getLogical(line, pos)
             if logical:
                 # Fix by adjusting initial indent level.
                 changed = self.__fixReindent(line, pos, logical)
                 if changed:
                     if code == "E121":
                         msg = self.trUtf8(
                             "Indentation of continuation line corrected.")
                     elif code == "E124":
                         msg = self.trUtf8(
                             "Indentation of closing bracket corrected.")
                     return (1, msg, 0)
             return (0, "", 0)
         else:
             id = self.__getID()
             self.__stackLogical.append((id, code, line, pos))
             return (-1, "", id)
     def __fixE122(self, code, line, pos, apply=False):
         """
         Private method to fix a missing indentation of continuation lines
         (E122).
         @param code code of the issue (string)
         @param line line number of the issue (integer)
         @param pos position inside line (integer)
         @keyparam apply flag indicating, that the fix should be applied
             (boolean)
         @return value indicating an applied/deferred fix (-1, 0, 1),
             a message for the fix (string) and an ID for a deferred
             fix (integer)
         """
         if apply:
             logical = self.__getLogical(line, pos)
             if logical:
                 # Fix by adding an initial indent.
                 modified = self.__fixReindent(line, pos, logical)
                 if not modified:
                     # fall back to simple method
                     line = line - 1
                     text = self.__source[line]
                     indentation = self.__getIndent(text)
                     self.__source[line] = indentation + \
                         self.__indentWord + text.lstrip()
                 return (
 ,
                     self.trUtf8(
                         "Missing indentation of continuation line corrected."),
 )
             return (0, "", 0)
         else:
             id = self.__getID()
             self.__stackLogical.append((id, code, line, pos))
             return (-1, "", id)
     def __fixE123(self, code, line, pos, apply=False):
         """
         Private method to fix the indentation of a closing bracket lines
         (E123).
         @param code code of the issue (string)
         @param line line number of the issue (integer)
         @param pos position inside line (integer)
         @keyparam apply flag indicating, that the fix should be applied
             (boolean)
         @return value indicating an applied/deferred fix (-1, 0, 1),
             a message for the fix (string) and an ID for a deferred
             fix (integer)
         """
         if apply:
             logical = self.__getLogical(line, pos)
             if logical:
                 # Fix by deleting whitespace to the correct level.
                 logicalLines = logical[2]
                 row = line - 1
                 text = self.__source[row]
                 newText = self.__getIndent(logicalLines[0]) + text.lstrip()
                 if newText == text:
                     # fall back to slower method
                     changed = self.__fixReindent(line, pos, logical)
                 else:
                     self.__source[row] = newText
                     changed = True
                 if changed:
                     return (1, self.trUtf8(
                         "Closing bracket aligned to opening bracket."),
 )
             return (0, "", 0)
         else:
             id = self.__getID()
             self.__stackLogical.append((id, code, line, pos))
             return (-1, "", id)
     def __fixE125(self, code, line, pos, apply=False):
         """
         Private method to fix the indentation of continuation lines not
         distinguishable from next logical line (E125).
         @param code code of the issue (string)
         @param line line number of the issue (integer)
         @param pos position inside line (integer)
         @keyparam apply flag indicating, that the fix should be applied
             (boolean)
         @return value indicating an applied/deferred fix (-1, 0, 1),
             a message for the fix (string) and an ID for a deferred
             fix (integer)
         """
         if apply:
             logical = self.__getLogical(line, pos)
             if logical:
                 # Fix by adjusting initial indent level.
                 modified = self.__fixReindent(line, pos, logical)
                 if not modified:
                     row = line - 1
                     text = self.__source[row]
                     self.__source[row] = self.__getIndent(text) + \
                         self.__indentWord + text.lstrip()
                 return (1, self.trUtf8("Indentation level changed."), 0)
             return (0, "", 0)
         else:
             id = self.__getID()
             self.__stackLogical.append((id, code, line, pos))
             return (-1, "", id)
     def __fixE126(self, code, line, pos, apply=False):
         """
         Private method to fix over-indented/under-indented hanging
         indentation (E126, E133).
         @param code code of the issue (string)
         @param line line number of the issue (integer)
         @param pos position inside line (integer)
         @keyparam apply flag indicating, that the fix should be applied
             (boolean)
         @return value indicating an applied/deferred fix (-1, 0, 1),
             a message for the fix (string) and an ID for a deferred
             fix (integer)
         """
         if apply:
             logical = self.__getLogical(line, pos)
             if logical:
                 # Fix by deleting whitespace to the left.
                 logicalLines = logical[2]
                 row = line - 1
                 text = self.__source[row]
                 newText = self.__getIndent(logicalLines[0]) + \
                     self.__indentWord + text.lstrip()
                 if newText == text:
                     # fall back to slower method
                     changed = self.__fixReindent(line, pos, logical)
                 else:
                     self.__source[row] = newText
                     changed = True
                 if changed:
                     return (1, self.trUtf8(
                         "Indentation level of hanging indentation changed."),
 )
             return (0, "", 0)
         else:
             id = self.__getID()
             self.__stackLogical.append((id, code, line, pos))
             return (-1, "", id)
     def __fixE127(self, code, line, pos, apply=False):
         """
         Private method to fix over/under indented lines (E127, E128).
         @param code code of the issue (string)
         @param line line number of the issue (integer)
         @param pos position inside line (integer)
         @keyparam apply flag indicating, that the fix should be applied
             (boolean)
         @return value indicating an applied/deferred fix (-1, 0, 1),
             a message for the fix (string) and an ID for a deferred
             fix (integer)
         """
         if apply:
             logical = self.__getLogical(line, pos)
             if logical:
                 # Fix by inserting/deleting whitespace to the correct level.
                 logicalLines = logical[2]
                 row = line - 1
                 text = self.__source[row]
                 newText = text
                 if logicalLines[0].rstrip().endswith('\\'):
                     newText = self.__getIndent(logicalLines[0]) + \
                         self.__indentWord + text.lstrip()
                 else:
                     startIndex = None
                     for symbol in '([{':
                         if symbol in logicalLines[0]:
                             foundIndex = logicalLines[0].find(symbol) + 1
                             if startIndex is None:
                                 startIndex = foundIndex
                             else:
                                 startIndex = min(startIndex, foundIndex)
                     if startIndex is not None:
                         newText = startIndex * ' ' + text.lstrip()
                 if newText == text:
                     # fall back to slower method
                     changed = self.__fixReindent(line, pos, logical)
                 else:
                     self.__source[row] = newText
                     changed = True
                 if changed:
                     return (1, self.trUtf8("Visual indentation corrected."), 0)
             return (0, "", 0)
         else:
             id = self.__getID()
             self.__stackLogical.append((id, code, line, pos))
             return (-1, "", id)
     def __fixE201(self, code, line, pos):
         """
         Private method to fix extraneous whitespace (E201, E202,
         E203, E211).
         @param code code of the issue (string)
         @param line line number of the issue (integer)
         @param pos position inside line (integer)
         @return value indicating an applied/deferred fix (-1, 0, 1),
             a message for the fix (string) and an ID for a deferred
             fix (integer)
         """
         line = line - 1
         text = self.__source[line]
         if '"""' in text or "'''" in text or text.rstrip().endswith('\\'):
             return (0, "", 0)
         newText = self.__fixWhitespace(text, pos, '')
         if newText == text:
             return (0, "", 0)
         self.__source[line] = newText
         return (1, self.trUtf8("Extraneous whitespace removed."), 0)
     def __fixE221(self, code, line, pos):
         """
         Private method to fix extraneous whitespace around operator or
         keyword (E221, E222, E223, E224, E225, E226, E227, E228, E241,
         E242, E271, E272, E273, E274).
         @param code code of the issue (string)
         @param line line number of the issue (integer)
         @param pos position inside line (integer)
         @return value indicating an applied/deferred fix (-1, 0, 1),
             a message for the fix (string) and an ID for a deferred
             fix (integer)
         """
         line = line - 1
         text = self.__source[line]
         if '"""' in text or "'''" in text or text.rstrip().endswith('\\'):
             return (0, "", 0)
         newText = self.__fixWhitespace(text, pos, ' ')
         if newText == text:
             return (0, "", 0)
         self.__source[line] = newText
         if code in ["E225", "E226", "E227", "E228"]:
             return (1, self.trUtf8("Missing whitespace added."), 0)
         else:
             return (1, self.trUtf8("Extraneous whitespace removed."), 0)
     def __fixE231(self, code, line, pos):
         """
         Private method to fix missing whitespace after ',;:'.
         @param code code of the issue (string)
         @param line line number of the issue (integer)
         @param pos position inside line (integer)
         @return value indicating an applied/deferred fix (-1, 0, 1),
             a message for the fix (string) and an ID for a deferred
             fix (integer)
         """
         line = line - 1
         pos = pos + 1
         self.__source[line] = self.__source[line][:pos] + \
             " " + self.__source[line][pos:]
         return (1, self.trUtf8("Missing whitespace added."), 0)
     def __fixE251(self, code, line, pos):
         """
         Private method to fix extraneous whitespace around keyword and
         default parameter equals (E251).
         @param code code of the issue (string)
         @param line line number of the issue (integer)
         @param pos position inside line (integer)
         @return value indicating an applied/deferred fix (-1, 0, 1),
             a message for the fix (string) and an ID for a deferred
             fix (integer)
         """
         line = line - 1
         text = self.__source[line]
         # This is necessary since pep8 sometimes reports columns that goes
         # past the end of the physical line. This happens in cases like,
         # foo(bar\n=None)
         col = min(pos, len(text) - 1)
         if text[col].strip():
             newText = text
         else:
             newText = text[:col].rstrip() + text[col:].lstrip()
         # There could be an escaped newline
         #
         #     def foo(a=\
         #             1)
         if newText.endswith(('=\\\n', '=\\\r\n', '=\\\r')):
             self.__source[line] = newText.rstrip("\n\r \t\\")
             self.__source[line + 1] = self.__source[line + 1].lstrip()
         else:
             self.__source[line] = newText
         return (1, self.trUtf8("Extraneous whitespace removed."), 0)
     def __fixE261(self, code, line, pos):
         """
         Private method to fix whitespace before or after inline comment
         (E261, E262).
         @param code code of the issue (string)
         @param line line number of the issue (integer)
         @param pos position inside line (integer)
         @return value indicating an applied/deferred fix (-1, 0, 1),
             a message for the fix (string) and an ID for a deferred
             fix (integer)
         """
         line = line - 1
         text = self.__source[line]
         left = text[:pos].rstrip(' \t#')
         right = text[pos:].lstrip(' \t#')
         newText = left + ("  # " + right if right.strip() else right)
         self.__source[line] = newText
         return (1, self.trUtf8("Whitespace around comment sign corrected."), 0)
     def __fixE301(self, code, line, pos, apply=False):
         """
         Private method to fix the need for one blank line (E301).
         @param code code of the issue (string)
         @param line line number of the issue (integer)
         @param pos position inside line (integer)
         @keyparam apply flag indicating, that the fix should be applied
             (boolean)
         @return value indicating an applied/deferred fix (-1, 0, 1),
             a message for the fix (string) and an ID for a deferred
             fix (integer)
         """
         if apply:
             self.__source.insert(line - 1, self.__getEol())
             return (1, self.trUtf8("One blank line inserted."), 0)
         else:
             id = self.__getID()
             self.__stack.append((id, code, line, pos))
             return (-1, "", id)
     def __fixE302(self, code, line, pos, apply=False):
         """
         Private method to fix the need for two blank lines (E302).
         @param code code of the issue (string)
         @param line line number of the issue (integer)
         @param pos position inside line (integer)
         @keyparam apply flag indicating, that the fix should be applied
             (boolean)
         @return value indicating an applied/deferred fix (-1, 0, 1),
             a message for the fix (string) and an ID for a deferred
             fix (integer)
         """
         if apply:
             # count blank lines
             index = line - 1
             blanks = 0
             while index:
                 if self.__source[index - 1].strip() == "":
                     blanks += 1
                     index -= 1
                 else:
                     break
             delta = blanks - 2
             line -= 1
             if delta < 0:
                 # insert blank lines (one or two)
                 while delta < 0:
                     self.__source.insert(line, self.__getEol())
                     delta += 1
                 changed = True
             elif delta > 0:
                 # delete superfluous blank lines
                 while delta > 0:
                     del self.__source[line - 1]
                     line -= 1
                     delta -= 1
                 changed = True
             else:
                 changed = False
             if changed:
                 if delta < 0:
                     msg = self.trUtf8(
                         "%n blank line(s) inserted.", "", -delta)
                 elif delta > 0:
                     msg = self.trUtf8(
                         "%n superfluous lines removed", "", delta)
                 else:
                     msg = ""
                 return (1, msg, 0)
             return (0, "", 0)
         else:
             id = self.__getID()
             self.__stack.append((id, code, line, pos))
             return (-1, "", id)
     def __fixE303(self, code, line, pos, apply=False):
         """
         Private method to fix superfluous blank lines (E303).
         @param code code of the issue (string)
         @param line line number of the issue (integer)
         @param pos position inside line (integer)
         @keyparam apply flag indicating, that the fix should be applied
             (boolean)
         @return value indicating an applied/deferred fix (-1, 0, 1),
             a message for the fix (string) and an ID for a deferred
             fix (integer)
         """
         if apply:
             index = line - 3
             while index:
                 if self.__source[index].strip() == "":
                     del self.__source[index]
                     index -= 1
                 else:
                     break
             return (1, self.trUtf8("Superfluous blank lines removed."), 0)
         else:
             id = self.__getID()
             self.__stack.append((id, code, line, pos))
             return (-1, "", id)
     def __fixE304(self, code, line, pos, apply=False):
         """
         Private method to fix superfluous blank lines after a function
         decorator (E304).
         @param code code of the issue (string)
         @param line line number of the issue (integer)
         @param pos position inside line (integer)
         @keyparam apply flag indicating, that the fix should be applied
             (boolean)
         @return value indicating an applied/deferred fix (-1, 0, 1),
             a message for the fix (string) and an ID for a deferred
             fix (integer)
         """
         if apply:
             index = line - 2
             while index:
                 if self.__source[index].strip() == "":
                     del self.__source[index]
                     index -= 1
                 else:
                     break
             return (1, self.trUtf8(
                 "Superfluous blank lines after function decorator removed."),
 )
         else:
             id = self.__getID()
             self.__stack.append((id, code, line, pos))
             return (-1, "", id)
     def __fixE401(self, code, line, pos, apply=False):
         """
         Private method to fix multiple imports on one line (E401).
         @param code code of the issue (string)
         @param line line number of the issue (integer)
         @param pos position inside line (integer)
         @keyparam apply flag indicating, that the fix should be applied
             (boolean)
         @return value indicating an applied/deferred fix (-1, 0, 1),
             a message for the fix (string) and an ID for a deferred
             fix (integer)
         """
         if apply:
             line = line - 1
             text = self.__source[line]
             if not text.lstrip().startswith("import"):
                 return (0, "", 0)
             # pep8 (1.3.1) reports false positive if there is an import
             # statement followed by a semicolon and some unrelated
             # statement with commas in it.
             if ';' in text:
                 return (0, "", 0)
             newText = text[:pos].rstrip("\t ,") + self.__getEol() + \
                 self.__getIndent(text) + "import " + text[pos:].lstrip("\t ,")
             self.__source[line] = newText
             return (1, self.trUtf8("Imports were put on separate lines."), 0)
         else:
             id = self.__getID()
             self.__stack.append((id, code, line, pos))
             return (-1, "", id)
     def __fixE501(self, code, line, pos, apply=False):
         """
         Private method to fix the long lines by breaking them (E501).
 b97bc92fdda
Continued implementing the PEP-8 line shortener class.

Detlev Offenbach <detlev@die-offenbachs.de>
parents: 
2880
diff

Mercurial Repositories > eric / annotate

Plugins/CheckerPlugins/Pep8/Pep8Fixer.py@b601ede6dbbf (annotated)

Plugins/CheckerPlugins/Pep8/Pep8Fixer.py