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

-:d595f6f9cbf8
+:4ef3b78ebb4e
 if isinstance(message, (tuple, list)):
 code = message[0].strip()
 else:
 code = message.split(None, 1)[0].strip()
-if line <= len(self.__source) and \
+if (
-self.__codeMatch(code) and \
+line <= len(self.__source) and
-code in self.__fixes:
+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:
 elif code == "D113":
 insertChar = "u"
 else:
 return (0, "", 0)
-newText = self.__getIndent(self.__source[line]) + \
+newText = (
-insertChar + self.__source[line].lstrip()
+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):
 if not self.__source[line].lstrip().startswith(
 ('"""', 'r"""', 'u"""')):
 # only correctly formatted docstrings will be fixed
 return (0, "", 0)
-docstring = self.__source[line].rstrip() + \
+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] = ""
 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 \
+if (
-self.__source[line].lstrip().startswith(('"""', 'r"""', 'u"""')):
+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() + "." + \
+newText = (
-self.__source[line].rstrip()[-3:] + self.__eol
+self.__source[line].rstrip()[:-3].rstrip() +
-else:
+"." +
-if line < len(self.__source) - 1 and \
+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("@"))):
+not self.__source[line].lstrip().startswith("@")))
+):
 newText = self.__source[line].rstrip() + "." + self.__eol
 if newText:
 self.__source[line] = newText
 # Period added to summary line.
 else:
 first, second = source[:3], source[3:].strip()
 else:
 # trailing
 first, second = source[:-3].strip(), source[-3:]
-newText = indent + first + self.__eol + \
+newText = (
-indent + second + self.__eol
+indent +
+first +
+self.__eol +
+indent +
+second +
+self.__eol
+)
 self.__source[line] = newText
 if code == "D221":
 # Leading quotes put on separate line.
 msg = "FD221"
 else:
 if not modified:
 # fall back to simple method
 line = line - 1
 text = self.__source[line]
 indentation = self.__getIndent(text)
-self.__source[line] = indentation + \
+self.__source[line] = (
+indentation +
 self.__indentWord + text.lstrip()
+)
 # Missing indentation of continuation line corrected.
 return (1, "FE122", 0)
 return (0, "", 0)
 else:
 fixId = self.__getID()
 # 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.__source[row] = (
+self.__getIndent(text) +
 self.__indentWord + text.lstrip()
+)
 # Indentation level changed.
 return (1, "FE125", 0)
 return (0, "", 0)
 else:
 fixId = self.__getID()
 if logical:
 # Fix by deleting whitespace to the left.
 logicalLines = logical[2]
 row = line - 1
 text = self.__source[row]
-newText = self.__getIndent(logicalLines[0]) + \
+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
 row = line - 1
 text = self.__source[row]
 newText = text
 if logicalLines[0].rstrip().endswith('\\'):
-newText = self.__getIndent(logicalLines[0]) + \
+newText = (
-self.__indentWord + text.lstrip()
+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
 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] = (
-" " + self.__source[line][pos:]
+self.__source[line][:pos] +
+" " +
+self.__source[line][pos:]
+)
 # Missing whitespace added.
 return (1, "FE231", 0)
 def __fixE251(self, code, line, pos):
 """
 newText = text
 else:
 newText = text[:col].rstrip() + text[col:].lstrip()
 # There could be an escaped newline
-# like '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
 # 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.__eol + \
+newText = (
-self.__getIndent(text) + "import " + text[pos:].lstrip("\t ,")
+text[:pos].rstrip("\t ,") +
+self.__eol +
+self.__getIndent(text) +
+"import " +
+text[pos:].lstrip("\t ,")
+)
 self.__source[line] = newText
 # Imports were put on separate lines.
 return (1, "FE401", 0)
 else:
 fixId = self.__getID()
 @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:
-multilineStringLines, docStringLines = \
+multilineStringLines, docStringLines = (
 self.__multilineStringLines()
+)
 isDocString = line in docStringLines
 line = line - 1
 text = self.__source[line]
 if line > 0:
 prevText = self.__source[line - 1]
 @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)
 """
-self.__source[line - 1] = \
+self.__source[line - 1] = (
-self.__source[line - 1].rstrip("\n\r \t\\") + self.__eol
+self.__source[line - 1].rstrip("\n\r \t\\") +
+self.__eol
+)
 # Redundant backslash in brackets removed.
 return (1, "FE502", 0)
 def __fixE701(self, code, line, pos, apply=False):
 """
 if apply:
 line = line - 1
 text = self.__source[line]
 pos = pos + 1
-newText = text[:pos] + self.__eol + self.__getIndent(text) + \
+newText = (
-self.__indentWord + text[pos:].lstrip("\n\r \t\\") + \
+text[:pos] +
+self.__eol +
+self.__getIndent(text) +
+self.__indentWord +
+text[pos:].lstrip("\n\r \t\\") +
 self.__eol
+)
 self.__source[line] = newText
 # Compound statement corrected.
 return (1, "FE701", 0)
 else:
 fixId = self.__getID()
 arg = "cls"
 else:
 arg = "self"
 if text.rstrip().endswith("("):
-newText = text + self.__getIndent(text) + \
+newText = (
-self.__indentWord + arg + "," + self.__eol
+text +
+self.__getIndent(text) +
+self.__indentWord +
+arg +
+"," +
+self.__eol
+)
 else:
 index = text.find("(") + 1
 left = text[:index]
 right = text[index:]
 if right.startswith(")"):
 right = right[4:]
 arg = "self"
 right = right.lstrip(", ")
 if right.startswith("):"):
 # merge with previous line
-self.__source[line - 1] = \
+self.__source[line - 1] = (
 self.__source[line - 1].rstrip() + right
+)
 self.__source[line] = ""
 else:
 self.__source[line] = indent + right
 # '{0}' argument removed.
 # in which case we should shift it like its base
 # line got shifted.
 for j in range(i - 1, -1, -1):
 jline, jlevel = stats[j]
 if jlevel >= 0:
-want = \
+want = (
-have + \
+have +
-self.__getlspace(after[jline - 1]) - \
+self.__getlspace(after[jline - 1]) -
 self.__getlspace(lines[jline])
+)
 break
 if want < 0:
 # Still no luck -- leave it alone.
 want = have
 else:
 # Returning to original continuation_line_indentation() from
 # pycodestyle.
 visual_indent = indent_chances.get(start[1])
 last_indent = start
-rel_indent[row] = \
+rel_indent[row] = (
 pycodestyle.expand_indent(line) - indent_level
+)
 hang = rel_indent[row] - rel_indent[open_row]
 if token_type == tokenize.OP and text in ']})':
 pass
 elif visual_indent is True:
 return False, "", ""
 else:
 return True, newText, ""
 elif '#' in self.__text:
 pos = self.__text.rfind("#")
-newText = self.__text[:pos].rstrip() + self.__eol + \
+newText = (
-self.__getIndent(self.__text) + self.__text[pos:]
+self.__text[:pos].rstrip() +
+self.__eol +
+self.__getIndent(self.__text) +
+self.__text[pos:]
+)
 if newText == self.__text:
 return False, "", ""
 else:
 return True, newText, ""
 second = self.__text[blank:].lstrip()
 if self.__nextText.strip():
 if self.__nextText.lstrip().startswith("@"):
 # eric doc comment
 # create a new line and indent it
-newText = first + self.__eol + \
+newText = (
-self.__getIndent(first) + self.__indentWord + \
+first +
+self.__eol +
+self.__getIndent(first) +
+self.__indentWord +
 second
+)
 newNext = ""
 else:
 newText = first + self.__eol
-newNext = self.__getIndent(self.__nextText) + \
+newNext = (
-second.rstrip() + " " + self.__nextText.lstrip()
+self.__getIndent(self.__nextText) +
+second.rstrip() +
+" " +
+self.__nextText.lstrip()
+)
 else:
 # empty line, add a new line
-newText = first + self.__eol + self.__getIndent(first) + \
+newText = (
+first +
+self.__eol +
+self.__getIndent(first) +
 second
+)
 newNext = ""
 return True, newText, newNext
 indent = self.__getIndent(self.__text)
 source = self.__text[len(indent):]
 tokens = list(tokenize.generate_tokens(sio.readline))
 except (SyntaxError, tokenize.TokenError):
 if source.rstrip().endswith("\\"):
 # just join the continuation line and let the next run
 # handle it once it tokenizes ok
-newText = indent + source.rstrip()[:-1].rstrip() + " " + \
+newText = (
+indent +
+source.rstrip()[:-1].rstrip() +
+" " +
 self.__nextText.lstrip()
+)
 if indent:
 newNext = indent
 else:
 newNext = " "
 return True, newText, newNext
 indentation = self.__getIndent(newText) + '# '
 maxLength = min(self.__maxLength,
 len(indentation) + 72)
 MIN_CHARACTER_REPEAT = 5
-if len(newText) - len(newText.rstrip(newText[-1])) >= \
+if (
-MIN_CHARACTER_REPEAT and \
+len(newText) - len(newText.rstrip(newText[-1])) >=
-not newText[-1].isalnum():
+MIN_CHARACTER_REPEAT and
+not newText[-1].isalnum()
+):
 # Trim comments that end with things like ---------
 return newText[:maxLength] + self.__eol
 elif isLast and re.match(r"\s*#+\s*\w+", newText):
 import textwrap
 splitLines = textwrap.wrap(newText.lstrip(" \t#"),
 if second.endswith(")"):
 # don't merge with next line
 newText += self.__getIndent(newText) + second + self.__eol
 newNext = ""
 else:
-newNext = self.__getIndent(newNext) + \
+newNext = (
-second + " " + newNext.lstrip()
+self.__getIndent(newNext) +
+second +
+" " +
+newNext.lstrip()
+)
 else:
 # empty line, add a new line
 newText = first + self.__eol
-newNext = self.__getIndent(newNext) + \
+newNext = (
-second + self.__eol + newNext.lstrip()
+self.__getIndent(newNext) +
+second +
+self.__eol +
+newNext.lstrip()
+)
 return newText, newNext
 else:
 return None
 def __isProbablyInsideStringOrComment(self, line, index):
 if currentLine.startswith(badStart):
 rank += 100
 for ending in '([{':
 # Avoid lonely opening. They result in longer lines.
-if currentLine.endswith(ending) and \
+if (
-len(currentLine.strip()) <= len(self.__indentWord):
+currentLine.endswith(ending) and
+len(currentLine.strip()) <= len(self.__indentWord)
+):
 rank += 100
 if currentLine.endswith('%'):
 rank -= 20

Mercurial Repositories > eric / file comparison

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

eric6/Plugins/CheckerPlugins/CodeStyleChecker/CodeStyleFixer.py