eric: comparison src/eric7/Plugins/CheckerPlugins/CodeStyleChecker/CodeStyleFixer.py

-:f6881d10e995
+:2f70ca07f0af
 def saveFile(self, encoding):
 """
 Public method to save the modified file.
-@param encoding encoding of the source file (string)
+@param encoding encoding of the source file
-@return error message on failure (tuple of str)
+@type str
+@return error message on failure
+@rtype tuple of (str, [str])
 """
 if not self.__modified:
 # no need to write
 return None
 def __codeMatch(self, code):
 """
 Private method to check, if the code should be fixed.
-@param code to check (string)
+@param code to check
-@return flag indicating it should be fixed (boolean)
+@type str
+@return flag indicating it should be fixed
+@rtype bool
 """
 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)
+@rtype bool
 """
 return b.startswith(a) or a.startswith(b)
 if self.__noFixCodes and any(
 mutualStartswith(code.lower(), noFixCode.lower())
 def finalize(self):
 """
 Public method to apply all deferred fixes.
 @return dictionary containing the fix results
+@rtype dict
 """
 results = {}
 # step 1: do fixes operating on logical lines first
 for id_, code, line, pos in self.__stackLogical:
 def __getID(self):
 """
 Private method to get the ID for a deferred fix.
-@return ID for a deferred fix (integer)
+@return ID for a deferred fix
+@rtype int
 """
 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
+@rtype tuple of ([int, int], [int, int])
 """
 logical_start = []
 logical_end = []
 last_newline = True
 sio = StringIO("".join(self.__source))
 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 line line number of the issue
-@param pos position inside line (integer)
+@type int
+@param pos position inside line
+@type int
 @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
+@rtype tuple of ((int, int), (int, int), [str])
 """
 try:
 (logical_start, logical_end) = self.__findLogical()
 except (SyntaxError, tokenize.TokenError):
 return None
 def __getIndentWord(self):
 """
 Private method to determine the indentation type.
-@return string to be used for an indentation (string)
+@return string to be used for an indentation
+@rtype str
 """
 sio = StringIO("".join(self.__source))
 indentWord = "    "  # default in case of failure
 with contextlib.suppress(SyntaxError, tokenize.TokenError):
 for token in tokenize.generate_tokens(sio.readline):
 def __getIndent(self, line):
 """
 Private method to get the indentation string.
-@param line line to determine the indentation string from (string)
+@param line line to determine the indentation string from
-@return indentation string (string)
+@type str
+@return indentation string
+@rtype str
 """
 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)
+documentation string
+@rtype tuple of (set of int, set of int)
 """
 if self.__multiLineNumbers is None:
 source = "".join(self.__source)
 sio = StringIO(source)
 self.__multiLineNumbers = set()
 """
 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 line line number of the issue
-@param pos position inside line (integer)
+@type int
+@param pos position inside line
+@type int
 @param logical logical line structure
-@return flag indicating a change was done (boolean)
+@type str
+@return flag indicating a change was done
+@rtype bool
 @exception ValueError raised to indicate a bad 'logical' parameter
 """
 if not logical:
 raise ValueError("Bad value for 'logical' parameter.")
 def __fixWhitespace(self, line, offset, replacement):
 """
 Private method to correct whitespace at the given offset.
-@param line line to be corrected (string)
+@param line line to be corrected
-@param offset offset within line (integer)
+@type str
-@param replacement replacement string (string)
+@param offset offset within line
+@type int
+@param replacement replacement string
+@type str
 @return corrected line
+@rtype str
 """
 left = line[:offset].rstrip(" \t")
 right = line[offset:].lstrip(" \t")
 if right.startswith("#"):
 return line
 def __init__(self, sourceLines):
 """
 Constructor
 @param sourceLines list of source lines including eol marker
-(list of string)
+@type list of str
 """
 # Raw file lines.
 self.raw = sourceLines
 self.after = []
 def run(self):
 """
 Public method to run the re-indenter.
-@return flag indicating that a change was done (boolean)
+@return flag indicating that a change was done
+@rtype bool
 """
 try:
 stats = self.__genStats(tokenize.generate_tokens(self.getline))
 except (SyntaxError, tokenize.TokenError):
 return False
 def fixedLine(self, line):
 """
 Public method to get a fixed line.
-@param line number of the line to retrieve (integer)
+@param line number of the line to retrieve
-@return fixed line (string)
+@type int
+@return fixed line
+@rtype str
 """
 if line < len(self.after):
 return self.after[line]
 return ""
 def getline(self):
 """
 Public method to get a line of text for tokenize.
-@return line of text (string)
+@return line of text
+@rtype str
 """
 if self.index >= len(self.lines):
 line = ""
 else:
 line = self.lines[self.index]
 def __genStats(self, tokens):
 """
 Private method to generate the re-indent statistics.
 @param tokens tokens generator (tokenize._tokenize)
+@type function
 @return reference to the generated statistics
+@rtype dict
 """
 find_stmt = True  # next token begins a fresh stmt?
 level = 0  # current indent level
 stats = []
 def __getlspace(self, line):
 """
 Private method to count number of leading blanks.
-@param line line to check (string)
+@param line line to check
-@return number of leading blanks (integer)
+@type str
+@return number of leading blanks
+@rtype int
 """
 i = 0
 n = len(line)
 while i < n and line[i] == " ":
 i += 1
 def __init__(self, physical_lines):
 """
 Constructor
 @param physical_lines list of physical lines to operate on
-(list of strings)
+@type list of str
 """
 self.lines = physical_lines
 self.tokens = []
 self.rel_indent = None
 sio = StringIO("".join(physical_lines))
 def __buildTokensLogical(self, tokens):
 """
 Private method to build a logical line from a list of tokens.
 @param tokens list of tokens as generated by tokenize.generate_tokens
-@return logical line (string)
+@type list of Token
+@return logical line
+@rtype str
 """
 # from pycodestyle.py with minor modifications
 logical = []
 previous = None
 for t in tokens:
 """
 Public method to replicate logic in pycodestyle.py, to know what level
 to indent things to.
 @return list of lists, where each list represents valid indent levels
 for the line in question, relative from the initial indent. However,
 the first entry is the indent level which was expected.
+@rtype list of list
 """
 # What follows is an adjusted version of
 # pycodestyle.py:continuation_line_indentation. All of the comments
 # have been stripped and the 'yield' statements replaced with 'pass'.
 if not self.tokens:
 isDocString=False,
 ):
 """
 Constructor
-@param curLine text to work on (string)
+@param curLine text to work on
-@param prevLine line before the text to work on (string)
+@type str
-@param nextLine line after the text to work on (string)
+@param prevLine line before the text to work on
-@param maxLength maximum allowed line length (integer)
+@type str
-@param eol eond-of-line marker (string)
+@param nextLine line after the text to work on
-@param indentWord string used for indentation (string)
+@type str
+@param maxLength maximum allowed line length
+@type int
+@param eol eond-of-line marker
+@type str
+@param indentWord string used for indentation
+@type str
 @param isDocString flag indicating that the line belongs to
-a documentation string (boolean)
+a documentation string
+@type bool
 """
 self.__text = curLine
 self.__prevText = prevLine
 self.__nextText = nextLine
 self.__maxLength = maxLength
 def shorten(self):
 """
 Public method to shorten the line wrapped by the class instance.
 @return tuple of a flag indicating successful shortening, the
-shortened line and the changed next line (boolean, string, string)
+shortened line and the changed next line
+@rtype tuple of (bool, str, str)
 """
 # 1. check for comment
 if self.__text.lstrip().startswith("#"):
 lastComment = True
 if self.__nextText.lstrip().startswith("#"):
 def __shortenComment(self, isLast):
 """
 Private method to shorten a comment line.
 @param isLast flag indicating, that the line is the last comment line
-(boolean)
+@type bool
-@return shortened comment line (string)
+@return shortened comment line
+@rtype str
 """
 if len(self.__text) <= self.__maxLength:
 return self.__text
 newText = self.__text.rstrip()
 def __breakMultiline(self):
 """
 Private method to break multi line strings.
 @return tuple of the shortened line and the changed next line
-(string, string)
+@rtype tuple of (str, str)
 """
 indentation = self.__getIndent(self.__text)
 # Handle special case.
 for symbol in "([{":
 def __isProbablyInsideStringOrComment(self, line, index):
 """
 Private method to check, if the given string might be inside a string
 or comment.
-@param line line to check (string)
+@param line line to check
-@param index position inside line to check (integer)
+@type str
+@param index position inside line to check
+@type int
 @return flag indicating the possibility of being inside a string
 or comment
+@rtype bool
 """
 # Check against being in a string.
 for quote in ['"', "'"]:
 pos = line.find(quote)
 if pos != -1 and pos <= index:
 def __shortenLine(self, tokens, source, indent):
 """
 Private method to shorten a line of code at an operator.
 @param tokens tokens of the line as generated by tokenize
-(list of token)
+@type list of Token
-@param source code string to work at (string)
+@param source code string to work at
-@param indent indentation string of the code line (string)
+@type str
-@return list of candidates (list of string)
+@param indent indentation string of the code line
+@type str
+@return list of candidates
+@rtype list of str
 """
 candidates = []
 for tkn in tokens:
 tokenType = tkn[0]
 def __normalizeMultiline(self, text):
 """
 Private method to remove multiline-related code that will cause syntax
 error.
-@param text code line to work on (string)
+@param text code line to work on
-@return normalized code line (string)
+@type str
+@return normalized code line
+@rtype str
 """
 for quote in "'\"":
 dictPattern = r"^{q}[^{q}]*{q} *: *".format(q=quote)
 if re.match(dictPattern, text):
 if not text.strip().endswith("}"):
 def __lineShorteningRank(self, candidate):
 """
 Private method to rank a candidate.
-@param candidate candidate line to rank (string)
+@param candidate candidate line to rank
-@return rank of the candidate (integer)
+@type str
+@return rank of the candidate
+@rtype int
 """
 rank = 0
 if candidate.strip():
 if candidate == self.__text:
 # give the original a disadvantage
 def __countUnbalancedBrackets(self, line):
 """
 Private method to determine the number of unmatched open/close
 brackets.
-@param line line to work at (string)
+@param line line to work at
-@return number of unmatched open/close brackets (integer)
+@type str
+@return number of unmatched open/close brackets
+@rtype int
 """
 count = 0
 for opening, closing in ["()", "[]", "{}"]:
 # __IGNORE_WARNING_M613__
 count += abs(line.count(opening) - line.count(closing))
 def __getIndent(self, line):
 """
 Private method to get the indentation string.
-@param line line to determine the indentation string from (string)
+@param line line to determine the indentation string from
-@return indentation string (string)
+@type str
+@return indentation string
+@rtype str
 """
 # copied from CodeStyleFixer
 return line.replace(line.lstrip(), "")
 def __checkSyntax(self, code):
 """
 Private method to check the syntax of the given code fragment.
-@param code code fragment to check (string)
+@param code code fragment to check
-@return flag indicating syntax is ok (boolean)
+@type str
+@return flag indicating syntax is ok
+@rtype bool
 """
 code = code.replace("\r\n", "\n").replace("\r", "\n")
 try:
 return compile(code, "<string>", "exec")
 except (SyntaxError, TypeError, UnicodeDecodeError):

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Plugins/CheckerPlugins/CodeStyleChecker/CodeStyleFixer.py

src/eric7/Plugins/CheckerPlugins/CodeStyleChecker/CodeStyleFixer.py