eric: Plugins/CheckerPlugins/Pep8/Pep8Fixer.py@61042247f793 (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", "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,
             "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
     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
         # apply deferred fixes
         self.__finalize()
         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 flag indicating an applied fix (boolean) and a message for
             the fix (string)
         """
         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]:
                 self.__modified = True
                 self.fixed += 1
         else:
             res = (False, "")
         return res
     def __finalize(self):
         """
         Private method to apply all deferred fixes.
         """
         # step 1: do fixes operating on logical lines first
         for code, line, pos in self.__stackLogical:
             self.__fixes[code](code, line, pos, apply=True)
         # step 2: do fixes that change the number of lines
         for code, line, pos in reversed(self.__stack):
             self.__fixes[code](code, line, pos, apply=True)
     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 __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 flag indicating an applied fix (boolean) and a message for
             the fix (string)
         """
         if self.__reindenter is None:
             self.__reindenter = Pep8Reindenter(self.__source)
             self.__reindenter.run()
         fixedLine = self.__reindenter.fixedLine(line - 1)
         if fixedLine is not None:
             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 (True, msg)
         else:
             return (False, self.trUtf8("Fix for {0} failed.").format(code))
     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 flag indicating an applied fix (boolean) and a message for
             the fix (string)
         """
         if apply:
             logical = self.__getLogical(line, pos)
             if logical:
                 # Fix by adjusting initial indent level.
                 self.__fixReindent(line, pos, logical)
         else:
             self.__stackLogical.append((code, line, pos))
         if code == "E121":
             msg = self.trUtf8("Indentation of continuation line corrected.")
         elif code == "E124":
             msg = self.trUtf8("Indentation of closing bracket corrected.")
         return (True, msg)
     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 flag indicating an applied fix (boolean) and a message for
             the fix (string)
         """
         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()
         else:
             self.__stackLogical.append((code, line, pos))
         return (True, self.trUtf8("Missing indentation of continuation line corrected."))
     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 flag indicating an applied fix (boolean) and a message for
             the fix (string)
         """
         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
                     self.__fixReindent(line, pos, logical)
                 else:
                     self.__source[row] = newText
         else:
             self.__stackLogical.append((code, line, pos))
         return (True, self.trUtf8("Closing bracket aligned to opening bracket."))
     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 flag indicating an applied fix (boolean) and a message for
             the fix (string)
         """
         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()
         else:
             self.__stackLogical.append((code, line, pos))
         return (True, self.trUtf8("Indentation level changed."))
     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 flag indicating an applied fix (boolean) and a message for
             the fix (string)
         """
         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
                     self.__fixReindent(line, pos, logical)
                 else:
                     self.__source[row] = newText
         else:
             self.__stackLogical.append((code, line, pos))
         return (True, self.trUtf8("Indentation level of hanging indentation changed."))
     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 flag indicating an applied fix (boolean) and a message for
             the fix (string)
         """
         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
                     self.__fixReindent(line, pos, logical)
                 else:
                     self.__source[row] = newText
         else:
             self.__stackLogical.append((code, line, pos))
         return (True, self.trUtf8("Visual indentation corrected."))
     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 flag indicating an applied fix (boolean) and a message for
             the fix (string)
         """
         line = line - 1
         text = self.__source[line]
         if '"""' in text or "'''" in text or text.rstrip().endswith('\\'):
             return (False, self.trUtf8("Extraneous whitespace cannot be removed."))
         newText = self.__fixWhitespace(text, pos, '')
         if newText == text:
             return (False, "")
         self.__source[line] = newText
         return (True, self.trUtf8("Extraneous whitespace removed."))
     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 flag indicating an applied fix (boolean) and a message for
             the fix (string)
         """
         line = line - 1
         text = self.__source[line]
         if '"""' in text or "'''" in text or text.rstrip().endswith('\\'):
             return (False, self.trUtf8("Extraneous whitespace cannot be removed."))
         newText = self.__fixWhitespace(text, pos, ' ')
         if newText == text:
             return (False, "")
         self.__source[line] = newText
         if code in ["E225", "E226", "E227", "E228"]:
             return (True, self.trUtf8("Missing whitespace added."))
         else:
             return (True, self.trUtf8("Extraneous whitespace removed."))
     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 flag indicating an applied fix (boolean) and a message for
             the fix (string)
         """
         line = line - 1
         pos = pos + 1
         self.__source[line] = self.__source[line][:pos] + \
                                " " + \
                                self.__source[line][pos:]
         return (True, self.trUtf8("Missing whitespace added."))
     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 flag indicating an applied fix (boolean) and a message for
             the fix (string)
         """
         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 (True, self.trUtf8("Extraneous whitespace removed."))
     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 flag indicating an applied fix (boolean) and a message for
             the fix (string)
         """
         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 (True, self.trUtf8("Whitespace around comment sign corrected."))
     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 flag indicating an applied fix (boolean) and a message for
             the fix (string)
         """
         if apply:
             self.__source.insert(line - 1, self.__getEol())
         else:
             self.__stack.append((code, line, pos))
         return (True, self.trUtf8("One blank line inserted."))
     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 flag indicating an applied fix (boolean) and a message for
             the fix (string)
         """
         # 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
         if apply:
             line -= 1
             if delta < 0:
                 # insert blank lines (one or two)
                 while delta < 0:
                     self.__source.insert(line, self.__getEol())
                     delta += 1
             elif delta > 0:
                 # delete superfluous blank lines
                 while delta > 0:
                     del self.__source[line - 1]
                     line -= 1
                     delta -= 1
         else:
             self.__stack.append((code, line, pos))
         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 (True, msg)
     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 flag indicating an applied fix (boolean) and a message for
             the fix (string)
         """
         if apply:
             index = line - 3
             while index:
                 if self.__source[index].strip() == "":
                     del self.__source[index]
                     index -= 1
                 else:
                     break
         else:
             self.__stack.append((code, line, pos))
         return (True, self.trUtf8("Superfluous blank lines removed."))
     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 flag indicating an applied fix (boolean) and a message for
             the fix (string)
         """
         if apply:
             index = line - 2
             while index:
                 if self.__source[index].strip() == "":
                     del self.__source[index]
                     index -= 1
                 else:
                     break
         else:
             self.__stack.append((code, line, pos))
         return (True, self.trUtf8(
             "Superfluous blank lines after function decorator removed."))
     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 flag indicating an applied fix (boolean) and a message for
             the fix (string)
         """
         if apply:
             line = line - 1
             text = self.__source[line]
             if not text.lstrip().startswith("import"):
                 return (False, "")
             # 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 (False, "")
             newText = text[:pos].rstrip("\t ,") + self.__getEol() + \
                 self.__getIndent(text) + "import " + text[pos:].lstrip("\t ,")
             self.__source[line] = newText
         else:
             self.__stack.append((code, line, pos))
         return (True, self.trUtf8("Imports were put on separate lines."))
     def __fixE502(self, code, line, pos):
         """
         Private method to fix redundant backslash within brackets (E502).
         @param code code of the issue (string)
         @param line line number of the issue (integer)
         @param pos position inside line (integer)
         @return flag indicating an applied fix (boolean) and a message for
             the fix (string)
         """
         self.__source[line - 1] = self.__source[line - 1].rstrip("\n\r \t\\") + \
             self.__getEol()
         return (True, self.trUtf8("Redundant backslash in brackets removed."))
     def __fixE701(self, code, line, pos, apply=False):
         """
         Private method to fix colon-separated compund statements (E701).
         @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 flag indicating an applied fix (boolean) and a message for
             the fix (string)
         """
         if apply:
             line = line - 1
             text = self.__source[line]
             pos = pos + 1
             newText = text[:pos] + self.__getEol() + self.__getIndent(text) + \
                 self.__indentWord + text[pos:].lstrip("\n\r \t\\") + \
                 self.__getEol()
             self.__source[line] = newText
         else:
             self.__stack.append((code, line, pos))
         return (True, self.trUtf8("Compound statement corrected."))
     def __fixE702(self, code, line, pos, apply=False):
         """
         Private method to fix semicolon-separated compound statements
         (E702, E703).
         @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 flag indicating an applied fix (boolean) and a message for
             the fix (string)
         """
         if apply:
             line = line - 1
             text = self.__source[line]
             if text.rstrip().endswith("\\"):
                 # normalize '1; \\\n2' into '1; 2'
                 self.__source[line] = text.rstrip("\n\r \t\\")
                 self.__source[line + 1] = self.__source[line + 1].lstrip()
             elif text.rstrip().endswith(";"):
                 self.__source[line] = text.rstrip("\n\r \t;") + self.__getEol()
             else:
                 first = text[:pos].rstrip("\n\r \t;") + self.__getEol()
                 second = text[pos:].lstrip("\n\r \t;")
                 self.__source[line] = first + self.__getIndent(text) + second
         else:
             self.__stack.append((code, line, pos))
         return (True, self.trUtf8("Compound statement corrected."))
     def __fixE711(self, code, line, pos):
         """
         Private method to fix comparison with None (E711, E712).
         @param code code of the issue (string)
         @param line line number of the issue (integer)
         @param pos position inside line (integer)
         @return flag indicating an applied fix (boolean) and a message for
             the fix (string)
         """
         line = line - 1
         text = self.__source[line]
         rightPos = pos + 2
         if rightPos >= len(text):
             return (False, "")
         left = text[:pos].rstrip()
         center = text[pos:rightPos]
         right = text[rightPos:].lstrip()
         if not right.startswith(("None", "True", "False")):
             return (False, "")
         if center.strip() == "==":
             center = "is"
         elif center.strip() == "!=":
             center = "is not"
         else:
             return (False, "")
         self.__source[line] = " ".join([left, center, right])
         return (True, self.trUtf8("Comparison to None/True/False corrected."))
     def __fixW291(self, code, line, pos):
         """
         Private method to fix trailing whitespace (W291, W293).
         @param code code of the issue (string)
         @param line line number of the issue (integer)
         @param pos position inside line (integer)
         @return flag indicating an applied fix (boolean) and a message for
             the fix (string)
         """
         self.__source[line - 1] = re.sub(r'[\t ]+(\r?)$', r"\1",
                                          self.__source[line - 1])
         return (True, self.trUtf8("Whitespace stripped from end of line."))
     def __fixW292(self, code, line, pos):
         """
         Private method to fix a missing newline at the end of file (W292).
         @param code code of the issue (string)
         @param line line number of the issue (integer)
         @param pos position inside line (integer)
         @return flag indicating an applied fix (boolean) and a message for
             the fix (string)
         """
         self.__source[line - 1] += self.__getEol()
         return (True, self.trUtf8("newline added to end of file."))
     def __fixW391(self, code, line, pos):
         """
         Private method to fix trailing blank lines (W391).
         @param code code of the issue (string)
         @param line line number of the issue (integer)
         @param pos position inside line (integer)
         @return flag indicating an applied fix (boolean) and a message for
             the fix (string)
         """
         index = line - 1
         while index:
             if self.__source[index].strip() == "":
                 del self.__source[index]
                 index -= 1
             else:
                 break
         return (True, self.trUtf8(
             "Superfluous trailing blank lines removed from end of file."))
     def __fixW603(self, code, line, pos):
         """
         Private method to fix the not equal notation (W603).
         @param code code of the issue (string)
         @param line line number of the issue (integer)
         @param pos position inside line (integer)
         @return flag indicating an applied fix (boolean) and a message for
             the fix (string)
         """
         self.__source[line - 1] = self.__source[line - 1].replace("<>", "!=")
         return (True, self.trUtf8("'<>' replaced by '!='."))
 d30ec2

Mercurial Repositories > eric / annotate

Plugins/CheckerPlugins/Pep8/Pep8Fixer.py@61042247f793 (annotated)

Plugins/CheckerPlugins/Pep8/Pep8Fixer.py