eric: eric6/Plugins/CheckerPlugins/CodeStyleChecker/CodeStyleFixer.py@9190402e4505 (annotated)

 # -*- coding: utf-8 -*-
 # Copyright (c) 2011 - 2020 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 """
 Module implementing a class to fix certain code style issues.
 """
 from __future__ import unicode_literals
 try:
     # Python 2
     from StringIO import StringIO       # __IGNORE_EXCEPTION__
 except ImportError:
     # Python 3
     from io import StringIO             # __IGNORE_WARNING__
 import os
 import re
 import tokenize
 # CodeStyleCheckerDialog tries to import FixableCodeStyleIssues what fail under
 # Python3. So ignore it.
 try:
     import pycodestyle
 except ImportError:
     pass
 FixableCodeStyleIssues = [
     "D111", "D112", "D113", "D121", "D131", "D141",
     "D142", "D143", "D144", "D145",
     "D221", "D222", "D231", "D242", "D243", "D244",
     "D245", "D246", "D247",
     "E101", "E111", "E121", "E122", "E123", "E124",
     "E125", "E126", "E127", "E128", "E133", "E201",
     "E202", "E203", "E211", "E221", "E222", "E223",
     "E224", "E225", "E226", "E227", "E228", "E231",
     "E241", "E242", "E251", "E261", "E262", "E271",
     "E272", "E273", "E274", "E301", "E302", "E303",
     "E304", "E305", "E306", "E307", "E308", "E401",
     "E501", "E502", "E701", "E702", "E703", "E711",
     "E712",
     "N804", "N805", "N806",
     "W191", "W291", "W292", "W293", "W391", "W603",
 ]
 class CodeStyleFixer(object):
     """
     Class implementing a fixer for certain code style issues.
     """
     def __init__(self, filename, sourceLines, fixCodes, noFixCodes,
                  maxLineLength, blankLines, inPlace, eol, backup=False):
         """
         Constructor
         @param filename name of the file to be fixed
         @type str
         @param sourceLines list of source lines including eol marker
         @type list of str
         @param fixCodes list of codes to be fixed as a comma separated
             string
         @type str
         @param noFixCodes list of codes not to be fixed as a comma
             separated string
         @type str
         @param maxLineLength maximum allowed line length
         @type int
         @param blankLines tuple containg the number of blank lines before
             a top level class or function and before a method or nested class
             or function
         @type tuple of (int, int)
         @param inPlace flag indicating to modify the file in place
         @type bool
         @param eol end of line character(s)
         @type str
         @param backup flag indicating to create a backup before fixing
             anything
         @type bool
         """
         super(CodeStyleFixer, self).__init__()
         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.__blankLines = {
             "toplevel": blankLines[0],
             "method": blankLines[1],
         }
         self.fixed = 0
         self.__reindenter = None
         self.__indentWord = self.__getIndentWord()
         if inPlace:
             self.__createBackup = backup
         else:
             self.__origName = self.__filename
             self.__filename = os.path.join(
                 os.path.dirname(self.__filename),
                 "fixed_" + os.path.basename(self.__filename))
             self.__createBackup = False
         self.__eol = eol
         self.__fixes = {
             "D111": self.__fixD111,
             "D112": self.__fixD112,
             "D113": self.__fixD112,
             "D121": self.__fixD121,
             "D131": self.__fixD131,
             "D141": self.__fixD141,
             "D142": self.__fixD142,
             "D143": self.__fixD143,
             "D144": self.__fixD144,
             "D145": self.__fixD145,
             "D221": self.__fixD221,
             "D222": self.__fixD221,
             "D231": self.__fixD131,
             "D242": self.__fixD242,
             "D243": self.__fixD243,
             "D244": self.__fixD242,
             "D245": self.__fixD243,
             "D246": self.__fixD144,
             "D247": self.__fixD247,
             "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,
             "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.__fixE225,
             "E226": self.__fixE225,
             "E227": self.__fixE225,
             "E228": self.__fixE225,
             "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,
             "E301": self.__fixBlankLinesBefore,
             "E302": self.__fixBlankLinesBefore,
             "E303": self.__fixBlankLinesBefore,
             "E304": self.__fixE304,
             "E305": self.__fixBlankLinesBefore,
             "E306": self.__fixBlankLinesBefore,
             "E307": self.__fixBlankLinesBefore,
             "E308": self.__fixBlankLinesBefore,
             "E401": self.__fixE401,
             "E501": self.__fixE501,
             "E502": self.__fixE502,
             "E701": self.__fixE701,
             "E702": self.__fixE702,
             "E703": self.__fixE702,
             "E711": self.__fixE711,
             "E712": self.__fixE711,
             "N804": self.__fixN804,
             "N805": self.__fixN804,
             "N806": self.__fixN806,
             "W191": self.__fixE101,
             "W291": self.__fixW291,
             "W292": self.__fixW292,
             "W293": self.__fixW291,
             "W391": self.__fixW391,
             "W603": self.__fixW603,
         }
         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 error message on failure (tuple of str)
         """
         import codecs
         if not self.__modified:
             # no need to write
             return None
         if self.__createBackup:
             # create a backup file before writing any changes
             if os.path.islink(self.__filename):
                 bfn = '{0}~'.format(os.path.realpath(self.__filename))
             else:
                 bfn = '{0}~'.format(self.__filename)
             try:
                 os.remove(bfn)
             except EnvironmentError:
                 # if there was an error, ignore it
                 pass
             try:
                 os.rename(self.__filename, bfn)
             except EnvironmentError:
                 # if there was an error, ignore it
                 pass
         txt = "".join(self.__source)
         try:
             enc = 'utf-8' if encoding == 'utf-8-bom' else encoding
             txt = txt.encode(enc)
             if encoding == 'utf-8-bom':
                 txt = codecs.BOM_UTF8 + txt
             with open(self.__filename, "wb") as fp:
                 fp.write(txt)
         except (IOError, UnicodeError) as err:
             # Could not save the file! Skipping it. Reason: {0}
             return ("FWRITE_ERROR", (str(err),))
         return None
     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)
         """
         if isinstance(message, (tuple, list)):
             code = message[0].strip()
         else:
             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.
         @return dictionary containing the fix results
         """
         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 __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 = 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 = 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 = 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)
         @param logical logical line structure
         @return flag indicating a change was done (boolean)
         """
         assert logical
         ls, _, original = logical
         rewrapper = IndentationWrapper(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 __fixD111(self, code, line, pos):
         """
         Private method to fix docstring enclosed in wrong quotes.
         Codes: D111
         @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
         quotes = re.match(r"""\s*[ru]?('''|'|\")""",
                           self.__source[line]).group(1)
         left, right = self.__source[line].split(quotes, 1)
         self.__source[line] = left + '"""' + right
         while line < len(self.__source):
             if self.__source[line].rstrip().endswith(quotes):
                 left, right = self.__source[line].rsplit(quotes, 1)
                 self.__source[line] = left + '"""' + right
                 break
             line += 1
         # Triple single quotes converted to triple double quotes.
         return (1, "FD111", 0)
     def __fixD112(self, code, line, pos):
         """
         Private method to fix docstring 'r' or 'u' in leading quotes.
         Codes: D112, D113
         @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
         if code == "D112":
             insertChar = "r"
         elif code == "D113":
             insertChar = "u"
         else:
             return (0, "", 0)
         newText = (
             self.__getIndent(self.__source[line]) +
             insertChar +
             self.__source[line].lstrip()
         )
         self.__source[line] = newText
         # Introductory quotes corrected to be {0}"""
         return (1, ('FD112', (insertChar,)), 0)
     def __fixD121(self, code, line, pos, apply=False):
         """
         Private method to fix a single line docstring on multiple lines.
         Codes: D121
         @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
             if not self.__source[line].lstrip().startswith(
                     ('"""', 'r"""', 'u"""')):
                 # only correctly formatted docstrings will be fixed
                 return (0, "", 0)
             docstring = (
                 self.__source[line].rstrip() +
                 self.__source[line + 1].strip()
             )
             if docstring.endswith('"""'):
                 docstring += self.__eol
             else:
                 docstring += self.__source[line + 2].lstrip()
                 self.__source[line + 2] = ""
             self.__source[line] = docstring
             self.__source[line + 1] = ""
             # Single line docstring put on one line.
             return (1, "FD121", 0)
         else:
             fixId = self.__getID()
             self.__stack.append((fixId, code, line, pos))
             return (-1, "", fixId)
     def __fixD131(self, code, line, pos):
         """
         Private method to fix a docstring summary not ending with a
         period.
         Codes: D131
         @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
         newText = ""
         if (
             self.__source[line].rstrip().endswith(('"""', "'''")) and
             self.__source[line].lstrip().startswith(('"""', 'r"""', 'u"""'))
         ):
             # it is a one-liner
             newText = (
                 self.__source[line].rstrip()[:-3].rstrip() +
                 "." +
                 self.__source[line].rstrip()[-3:] +
                 self.__eol
             )
         else:
             if (
                 line < len(self.__source) - 1 and
                 (not self.__source[line + 1].strip() or
                  self.__source[line + 1].lstrip().startswith("@") or
                  (self.__source[line + 1].strip() in ('"""', "'''") and
                   not self.__source[line].lstrip().startswith("@")))
             ):
                 newText = self.__source[line].rstrip() + "." + self.__eol
         if newText:
             self.__source[line] = newText
             # Period added to summary line.
             return (1, "FD131", 0)
         else:
             return (0, "", 0)
     def __fixD141(self, code, line, pos, apply=False):
         """
         Private method to fix a function/method docstring preceded by a
         blank line.
         Codes: D141
         @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
             self.__source[line - 1] = ""
             # Blank line before function/method docstring removed.
             return (1, "FD141", 0)
         else:
             fixId = self.__getID()
             self.__stack.append((fixId, code, line, pos))
             return (-1, "", fixId)
     def __fixD142(self, code, line, pos, apply=False):
         """
         Private method to fix a class docstring not preceded by a
         blank line.
         Codes: D142
         @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
             self.__source[line] = self.__eol + self.__source[line]
             # Blank line inserted before class docstring.
             return (1, "FD142", 0)
         else:
             fixId = self.__getID()
             self.__stack.append((fixId, code, line, pos))
             return (-1, "", fixId)
     def __fixD143(self, code, line, pos, apply=False):
         """
         Private method to fix a class docstring not followed by a
         blank line.
         Codes: D143
         @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
             self.__source[line] += self.__eol
             # Blank line inserted after class docstring.
             return (1, "FD143", 0)
         else:
             fixId = self.__getID()
             self.__stack.append((fixId, code, line, pos))
             return (-1, "", fixId)
     def __fixD144(self, code, line, pos, apply=False):
         """
         Private method to fix a docstring summary not followed by a
         blank line.
         Codes: D144
         @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
             if not self.__source[line].rstrip().endswith("."):
                 # only correct summary lines can be fixed here
                 return (0, "", 0)
             self.__source[line] += self.__eol
             # Blank line inserted after docstring summary.
             return (1, "FD144", 0)
         else:
             fixId = self.__getID()
             self.__stack.append((fixId, code, line, pos))
             return (-1, "", fixId)
     def __fixD145(self, code, line, pos, apply=False):
         """
         Private method to fix the last paragraph of a multi-line docstring
         not followed by a blank line.
         Codes: D143
         @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
             self.__source[line] = self.__eol + self.__source[line]
             # Blank line inserted after last paragraph of docstring.
             return (1, "FD145", 0)
         else:
             fixId = self.__getID()
             self.__stack.append((fixId, code, line, pos))
             return (-1, "", fixId)
     def __fixD221(self, code, line, pos, apply=False):
         """
         Private method to fix leading and trailing quotes of docstring
         not on separate lines.
         Codes: D221, D222
         @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
             indent = self.__getIndent(self.__source[line])
             source = self.__source[line].strip()
             if code == "D221":
                 # leading
                 if source.startswith(("r", "u")):
                     first, second = source[:4], source[4:].strip()
                 else:
                     first, second = source[:3], source[3:].strip()
             else:
                 # trailing
                 first, second = source[:-3].strip(), source[-3:]
             newText = (
                 indent +
                 first +
                 self.__eol +
                 indent +
                 second +
                 self.__eol
             )
             self.__source[line] = newText
             if code == "D221":
                 # Leading quotes put on separate line.
                 msg = "FD221"
             else:
                 # Trailing quotes put on separate line.
                 msg = "FD222"
             return (1, msg, 0)
         else:
             fixId = self.__getID()
             self.__stack.append((fixId, code, line, pos))
             return (-1, "", fixId)
     def __fixD242(self, code, line, pos, apply=False):
         """
         Private method to fix a class or function/method docstring preceded
         by a blank line.
         Codes: D242, D244
         @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
             self.__source[line - 1] = ""
             if code == "D242":
                 # Blank line before class docstring removed.
                 msg = "FD242"
             else:
                 # Blank line before function/method docstring removed.
                 msg = "FD244"
             return (1, msg, 0)
         else:
             fixId = self.__getID()
             self.__stack.append((fixId, code, line, pos))
             return (-1, "", fixId)
     def __fixD243(self, code, line, pos, apply=False):
         """
         Private method to fix a class or function/method docstring followed
         by a blank line.
         Codes: D243, D245
         @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
             self.__source[line + 1] = ""
             if code == "D243":
                 # Blank line after class docstring removed.
                 msg = "FD243"
             else:
                 # Blank line after function/method docstring removed.
                 msg = "FD245"
             return (1, msg, 0)
         else:
             fixId = self.__getID()
             self.__stack.append((fixId, code, line, pos))
             return (-1, "", fixId)
     def __fixD247(self, code, line, pos, apply=False):
         """
         Private method to fix a last paragraph of a docstring followed
         by a blank line.
         Codes: D247
         @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
             self.__source[line - 1] = ""
             # Blank line after last paragraph removed.
             return (1, "FD247", 0)
         else:
             fixId = self.__getID()
             self.__stack.append((fixId, code, line, pos))
             return (-1, "", fixId)
     def __fixE101(self, code, line, pos):
         """
         Private method to fix obsolete tab usage and indentation errors.
         Codes: 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 = Reindenter(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"]:
                 # Tab converted to 4 spaces.
                 msg = "FE101"
             else:
                 # Indentation adjusted to be a multiple of four.
                 msg = "FE111"
             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.
         Codes: 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":
                         # Indentation of continuation line corrected.
                         msg = "FE121"
                     elif code == "E124":
                         # Indentation of closing bracket corrected.
                         msg = "FE124"
                     return (1, msg, 0)
             return (0, "", 0)
         else:
             fixId = self.__getID()
             self.__stackLogical.append((fixId, code, line, pos))
             return (-1, "", fixId)
     def __fixE122(self, code, line, pos, apply=False):
         """
         Private method to fix a missing indentation of continuation lines.
-efa25fd5
Continued correcting doc strings by using the new doc string checker.

Detlev Offenbach <detlev@die-offenbachs.de>
parents: 
2937
diff
changeset
+
<

Mercurial Repositories > eric / annotate

eric6/Plugins/CheckerPlugins/CodeStyleChecker/CodeStyleFixer.py@9190402e4505 (annotated)

eric6/Plugins/CheckerPlugins/CodeStyleChecker/CodeStyleFixer.py