eric: comparison src/eric7/Plugins/CheckerPlugins/CodeStyleChecker/DocStyle/DocStyleChecker.py

-:fc45672fae42
+:73d80859079c
 # The routines of the checker class are modeled after the ones found in
 # pep257.py (version 0.2.4).
 #
 import ast
+import collections
 import contextlib
 import tokenize
 from io import StringIO
 try:
 ast.AsyncFunctionDef  # __IGNORE_EXCEPTION__
 except AttributeError:
 ast.AsyncFunctionDef = ast.FunctionDef
+from CodeStyleTopicChecker import CodeStyleTopicChecker
 class DocStyleContext:
 """
 Class implementing the source context.
 @rtype str
 """
 return self.__special
-class DocStyleChecker:
+class DocStyleChecker(CodeStyleTopicChecker):
 """
 Class implementing a checker for documentation string conventions.
 """
 Codes = [
 "D-270",
 "D-271",
 "D-272",
 "D-273",
 ]
+Category = "D"
 def __init__(
 self,
 source,
 filename,
 @param maxLineLength allowed line length
 @type int
 @param docType type of the documentation strings (one of 'eric' or 'pep257')
 @type str
 """
-self.__select = tuple(select)
+super().__init__(
-self.__ignore = tuple(ignore)
+DocStyleChecker.Category,
-self.__expected = expected[:]
+source,
-self.__repeat = repeat
+filename,
+None,
+select,
+ignore,
+expected,
+repeat,
+[],
+)
 self.__maxLineLength = maxLineLength
 self.__docType = docType
-self.__filename = filename
-self.__source = source[:]
-# statistics counters
-self.counters = {}
-# collection of detected errors
-self.errors = []
 self.__lineNumber = 0
 # caches
 self.__functionsCache = None
 self.__classesCache = None
 (self.__checkEricNBlankAfterLastParagraph, ("D-247",)),
 (self.__checkEricQuotesOnSeparateLines, ("D-222", "D-223")),
 ],
 }
-self.__checkers = {}
+self.__checkers = collections.defaultdict(list)
 for key, checkers in checkersWithCodes.items():
 for checker, codes in checkers:
-if any(not (code and self.__ignoreCode(code)) for code in codes):
+if any(
-if key not in self.__checkers:
+not (msgCode and self._ignoreCode(msgCode)) for msgCode in codes
-self.__checkers[key] = []
+):
 self.__checkers[key].append(checker)
-def __ignoreCode(self, code):
+def addError(self, lineNumber, offset, msgCode, *args):
 """
-Private method to check if the error code should be ignored.
+Public method to record an issue.
-@param code message code to check for
+@param lineNumber line number of the issue (zero based)
-@type str
-@return flag indicating to ignore the given code
-@rtype bool
-"""
-return code in self.__ignore or (
-code.startswith(self.__ignore) and not code.startswith(self.__select)
-)
-def __error(self, lineNumber, offset, code, *args):
-"""
-Private method to record an issue.
-@param lineNumber line number of the issue
 @type int
 @param offset position within line of the issue
 @type int
-@param code message code
+@param msgCode message code
 @type str
 @param args arguments for the message
 @type list
 """
-if self.__ignoreCode(code):
+# call super class method with one based line number
-return
+super().addError(lineNumber + 1, offset, msgCode, *args)
-if code in self.counters:
-self.counters[code] += 1
-else:
-self.counters[code] = 1
-# Don't care about expected codes
-if code in self.__expected:
-return
-if code and (self.counters[code] == 1 or self.__repeat):
-# record the issue with one based line number
-self.errors.append(
-{
-"file": self.__filename,
-"line": lineNumber + 1,
-"offset": offset,
-"code": code,
-"args": args,
-}
-)
 def __resetReadline(self):
 """
 Private method to reset the internal readline function.
 """
 @return next line of source
 @rtype str
 """
 self.__lineNumber += 1
-if self.__lineNumber > len(self.__source):
+if self.__lineNumber > len(self.source):
 return ""
-return self.__source[self.__lineNumber - 1]
+return self.source[self.__lineNumber - 1]
 def run(self):
 """
 Public method to check the given source for violations of doc string
 conventions.
 """
-if not self.__filename:
+if not self.filename:
 # don't do anything, if essential data is missing
 return
 if not self.__checkers:
 # don't do anything, if no codes were selected
 return
-for keyword in self.__keywords:
+for key in self.__keywords:
-if keyword in self.__checkers:
+if key in self.__checkers:
-for check in self.__checkers[keyword]:
+for check in self.__checkers[key]:
-for context in self.__parseContexts(keyword):
+for context in self.__parseContexts(key):
-docstring = self.__parseDocstring(context, keyword)
+docstring = self.__parseDocstring(context, key)
 check(docstring, context)
 def __getSummaryLine(self, docstringContext):
 """
 Private method to extract the summary line.
 start = line - 1, char
 while not (kind == tokenize.DEDENT and value == "" and char == 0):
 kind, value, (line, char), _, _ = next(tokenGenerator)
 end = line - 1, char
 contexts.append(
-DocStyleContext(self.__source[start[0] : end[0]], start[0], keyword)
+DocStyleContext(self.source[start[0] : end[0]], start[0], keyword)
 )
 except StopIteration:
 return contexts
 def __parseFunctions(self):
 )
 end = line - 1, char
 startLine = classContext.start() + start[0]
 endLine = classContext.start() + end[0]
 context = DocStyleContext(
-self.__source[startLine:endLine], startLine, "def"
+self.source[startLine:endLine], startLine, "def"
 )
 if startLine > 0:
-if self.__source[startLine - 1].strip() == "@staticmethod":
+if self.source[startLine - 1].strip() == "@staticmethod":
 context.setSpecial("staticmethod")
-elif self.__source[startLine - 1].strip() == "@classmethod":
+elif self.source[startLine - 1].strip() == "@classmethod":
 context.setSpecial("classmethod")
 contexts.append(context)
 self.__methodsCache = contexts
 return self.__methodsCache
 @type str
 @return requested contexts
 @rtype list of DocStyleContext
 """
 if kind == "moduleDocstring":
-return [DocStyleContext(self.__source, 0, "module")]
+return [DocStyleContext(self.source, 0, "module")]
 if kind == "functionDocstring":
 return self.__parseFunctions()
 if kind == "classDocstring":
 return self.__parseClasses()
 if kind == "methodDocstring":
 return self.__parseMethods()
 if kind == "defDocstring":
 return self.__parseFunctions() + self.__parseMethods()
 if kind == "docstring":
 return (
-[DocStyleContext(self.__source, 0, "module")]
+[DocStyleContext(self.source, 0, "module")]
 + self.__parseFunctions()
 + self.__parseClasses()
 + self.__parseMethods()
 )
 return []  # fall back
 @type DocStyleContext
 @param context context of the docstring
 @type DocStyleContext
 """
 if docstringContext is None:
-self.__error(context.start(), 0, "D-101")
+self.addError(context.start(), 0, "D-101")
 return
 docstring = docstringContext.ssource()
 if not docstring or not docstring.strip() or not docstring.strip("'\""):
-self.__error(context.start(), 0, "D-101")
+self.addError(context.start(), 0, "D-101")
 if (
 self.__docType == "eric"
 and docstring.strip("'\"").strip() == "Module documentation goes here."
 ):
-self.__error(docstringContext.end(), 0, "D-201")
+self.addError(docstringContext.end(), 0, "D-201")
 return
 def __checkFunctionDocstring(self, docstringContext, context):
 """
 Private method to check, that all public functions and methods
 code = "D-103"
 else:
 code = "D-102"
 if docstringContext is None:
-self.__error(context.start(), 0, code)
+self.addError(context.start(), 0, code)
 return
 docstring = docstringContext.ssource()
 if not docstring or not docstring.strip() or not docstring.strip("'\""):
-self.__error(context.start(), 0, code)
+self.addError(context.start(), 0, code)
 if self.__docType == "eric":
 if docstring.strip("'\"").strip() == "Function documentation goes here.":
-self.__error(docstringContext.end(), 0, "D-202.1")
+self.addError(docstringContext.end(), 0, "D-202.1")
 return
 if "DESCRIPTION" in docstring or "TYPE" in docstring:
-self.__error(docstringContext.end(), 0, "D-202.2")
+self.addError(docstringContext.end(), 0, "D-202.2")
 return
 def __checkClassDocstring(self, docstringContext, context):
 """
 Private method to check, that all public functions and methods
 code = "D-105"
 else:
 code = "D-104"
 if docstringContext is None:
-self.__error(context.start(), 0, code)
+self.addError(context.start(), 0, code)
 return
 docstring = docstringContext.ssource()
 if not docstring or not docstring.strip() or not docstring.strip("'\""):
-self.__error(context.start(), 0, code)
+self.addError(context.start(), 0, code)
 return
 if (
 self.__docType == "eric"
 and docstring.strip("'\"").strip() == "Class documentation goes here."
 ):
-self.__error(docstringContext.end(), 0, "D-206")
+self.addError(docstringContext.end(), 0, "D-206")
 return
 def __checkTripleDoubleQuotes(self, docstringContext, _context):
 """
 Private method to check, that all docstrings are surrounded
 if docstringContext is None:
 return
 docstring = docstringContext.ssource().strip()
 if not docstring.startswith(('"""', 'r"""', 'u"""')):
-self.__error(docstringContext.start(), 0, "D-111")
+self.addError(docstringContext.start(), 0, "D-111")
 def __checkBackslashes(self, docstringContext, _context):
 """
 Private method to check, that all docstrings containing
 backslashes are surrounded by raw triple double quotes.
 if docstringContext is None:
 return
 docstring = docstringContext.ssource().strip()
 if "\\" in docstring and not docstring.startswith('r"""'):
-self.__error(docstringContext.start(), 0, "D-112")
+self.addError(docstringContext.start(), 0, "D-112")
 def __checkOneLiner(self, docstringContext, context):
 """
 Private method to check, that one-liner docstrings fit on
 one line with quotes.
 modLen += 4
 if not nonEmptyLines[0].strip().endswith("."):
 # account for a trailing dot
 modLen += 1
 if modLen <= self.__maxLineLength:
-self.__error(docstringContext.start(), 0, "D-121")
+self.addError(docstringContext.start(), 0, "D-121")
 def __checkIndent(self, docstringContext, context):
 """
 Private method to check, that docstrings are properly indented.
 indent = min(len(line) - len(line.strip()) for line in nonEmptyLines)
 expectedIndent = (
 0 if context.contextType() == "module" else len(context.indent()) + 4
 )
 if indent != expectedIndent:
-self.__error(docstringContext.start(), 0, "D-122")
+self.addError(docstringContext.start(), 0, "D-122")
 def __checkSummary(self, docstringContext, _context):
 """
 Private method to check, that docstring summaries contain some text.
 if docstringContext is None:
 return
 summary, lineNumber = self.__getSummaryLine(docstringContext)
 if summary == "":
-self.__error(docstringContext.start() + lineNumber, 0, "D-130")
+self.addError(docstringContext.start() + lineNumber, 0, "D-130")
 def __checkEndsWithPeriod(self, docstringContext, _context):
 """
 Private method to check, that docstring summaries end with a period.
 if docstringContext is None:
 return
 summary, lineNumber = self.__getSummaryLine(docstringContext)
 if not summary.endswith("."):
-self.__error(docstringContext.start() + lineNumber, 0, "D-131")
+self.addError(docstringContext.start() + lineNumber, 0, "D-131")
 def __checkImperativeMood(self, docstringContext, _context):
 """
 Private method to check, that docstring summaries are in
 imperative mood.
 summary, lineNumber = self.__getSummaryLine(docstringContext)
 if summary:
 firstWord = summary.strip().split()[0]
 if firstWord.endswith("s") and not firstWord.endswith("ss"):
-self.__error(docstringContext.start() + lineNumber, 0, "D-132")
+self.addError(docstringContext.start() + lineNumber, 0, "D-132")
 def __checkNoSignature(self, docstringContext, context):
 """
 Private method to check, that docstring summaries don't repeat
 the function's signature.
 summary, lineNumber = self.__getSummaryLine(docstringContext)
 if functionName + "(" in summary.replace(
 " ", ""
 ) and functionName + "()" not in summary.replace(" ", ""):
 # report only, if it is not an abbreviated form (i.e. function() )
-self.__error(docstringContext.start() + lineNumber, 0, "D-133")
+self.addError(docstringContext.start() + lineNumber, 0, "D-133")
 def __checkReturnType(self, docstringContext, context):
 """
 Private method to check, that docstrings mention the return value type.
 ]
 if (
 set(return_) - {tokenize.COMMENT, tokenize.NL, tokenize.NEWLINE}
 != set()
 ):
-self.__error(docstringContext.end(), 0, "D-134")
+self.addError(docstringContext.end(), 0, "D-134")
 def __checkNoBlankLineBefore(self, docstringContext, context):
 """
 Private method to check, that function/method docstrings are not
 preceded by a blank line.
 cti += 1
 if cti == len(contextLines):
 return
 if not contextLines[cti - 1].strip():
-self.__error(docstringContext.start(), 0, "D-141")
+self.addError(docstringContext.start(), 0, "D-141")
 def __checkBlankBeforeAndAfterClass(self, docstringContext, context):
 """
 Private method to check, that class docstrings have one
 blank line around them.
 end = cti
 if cti >= len(contextLines) - 1:
 return
 if contextLines[start - 1].strip():
-self.__error(docstringContext.start(), 0, "D-142")
+self.addError(docstringContext.start(), 0, "D-142")
 if contextLines[end + 1].strip():
-self.__error(docstringContext.end(), 0, "D-143")
+self.addError(docstringContext.end(), 0, "D-143")
 def __checkBlankAfterSummary(self, docstringContext, _context):
 """
 Private method to check, that docstring summaries are followed
 by a blank line.
 # correct/invalid one-liner
 return
 summary, lineNumber = self.__getSummaryLine(docstringContext)
 if len(docstrings) > 2 and docstrings[lineNumber + 1].strip():
-self.__error(docstringContext.start() + lineNumber, 0, "D-144")
+self.addError(docstringContext.start() + lineNumber, 0, "D-144")
 def __checkBlankAfterLastParagraph(self, docstringContext, _context):
 """
 Private method to check, that the last paragraph of docstrings is
 followed by a blank line.
 if len(docstrings) <= 3:
 # correct/invalid one-liner
 return
 if docstrings[-2].strip():
-self.__error(docstringContext.end(), 0, "D-145")
+self.addError(docstringContext.end(), 0, "D-145")
 ##################################################################
 ## Checking functionality below (eric specific ones)
 ##################################################################
 if docstringContext is None:
 return
 lines = docstringContext.source()
 if lines[0].strip().strip("ru\"'"):
-self.__error(docstringContext.start(), 0, "D-221")
+self.addError(docstringContext.start(), 0, "D-221")
 if lines[-1].strip().strip("\"'"):
-self.__error(docstringContext.end(), 0, "D-222")
+self.addError(docstringContext.end(), 0, "D-222")
 def __checkEricEndsWithPeriod(self, docstringContext, _context):
 """
 Private method to check, that docstring summaries end with a period.
 if (
 summary
 and not summary.endswith(".")
 and summary.split(None, 1)[0].lower() != "constructor"
 ):
-self.__error(
+self.addError(
 docstringContext.start() + lineNumber + len(summaryLines) - 1,
 0,
 "D-231",
 )
 if "@return" not in docstringContext.ssource():
 if (
 set(return_) - {tokenize.COMMENT, tokenize.NL, tokenize.NEWLINE}
 != set()
 ):
-self.__error(docstringContext.end(), 0, "D-234r")
+self.addError(docstringContext.end(), 0, "D-234r")
 else:
 if (
 set(return_) - {tokenize.COMMENT, tokenize.NL, tokenize.NEWLINE}
 == set()
 ):
-self.__error(docstringContext.end(), 0, "D-235r")
+self.addError(docstringContext.end(), 0, "D-235r")
 def __checkEricYield(self, docstringContext, context):
 """
 Private method to check, that docstrings contain an &#64;yield line
 if they return anything and don't otherwise.
 yield_ = [
 tokens[i + 1][0] for i, token in enumerate(tokens) if token[1] == "yield"
 ]
 if "@yield" not in docstringContext.ssource():
 if set(yield_) - {tokenize.COMMENT, tokenize.NL, tokenize.NEWLINE} != set():
-self.__error(docstringContext.end(), 0, "D-234y")
+self.addError(docstringContext.end(), 0, "D-234y")
 else:
 if set(yield_) - {tokenize.COMMENT, tokenize.NL, tokenize.NEWLINE} == set():
-self.__error(docstringContext.end(), 0, "D-235y")
+self.addError(docstringContext.end(), 0, "D-235y")
 def __checkEricFunctionArguments(self, docstringContext, context):
 """
 Private method to check, that docstrings contain an &#64;param and/or
 &#64;keyparam line for each argument.
 if line.lstrip().startswith("@")
 )
 if tagstring.count("@param") + tagstring.count("@keyparam") < len(
 argNames + kwNames
 ):
-self.__error(docstringContext.end(), 0, "D-236")
+self.addError(docstringContext.end(), 0, "D-236")
 elif tagstring.count("@param") + tagstring.count("@keyparam") > len(
 argNames + kwNames
 ):
-self.__error(docstringContext.end(), 0, "D-237")
+self.addError(docstringContext.end(), 0, "D-237")
 else:
 # extract @param and @keyparam from docstring
 args = []
 kwargs = []
 for line in docstringContext.source():
 args.append(name.lstrip("*"))
 # do the checks
 for name in kwNames:
 if name not in kwargs:
-self.__error(docstringContext.end(), 0, "D-238")
+self.addError(docstringContext.end(), 0, "D-238")
 return
 if argNames + kwNames != args:
-self.__error(docstringContext.end(), 0, "D-239")
+self.addError(docstringContext.end(), 0, "D-239")
 def __checkEricException(self, docstringContext, context):
 """
 Private method to check, that docstrings contain an &#64;exception line
 if they raise an exception and don't otherwise.
 "@exception" not in docstringContext.ssource()
 and "@throws" not in docstringContext.ssource()
 and "@raise" not in docstringContext.ssource()
 ):
 if exceptions - {tokenize.COMMENT, tokenize.NL, tokenize.NEWLINE} != set():
-self.__error(docstringContext.end(), 0, "D-250")
+self.addError(docstringContext.end(), 0, "D-250")
 else:
 if exceptions - {tokenize.COMMENT, tokenize.NL, tokenize.NEWLINE} == set():
-self.__error(docstringContext.end(), 0, "D-251")
+self.addError(docstringContext.end(), 0, "D-251")
 else:
 # step 1: extract documented exceptions
 documentedExceptions = set()
 for line in docstringContext.source():
 line = line.strip()
 documentedExceptions.add(exceptionTokens[1])
 # step 2: report undocumented exceptions
 for exception in raisedExceptions:
 if exception not in documentedExceptions:
-self.__error(docstringContext.end(), 0, "D-252", exception)
+self.addError(docstringContext.end(), 0, "D-252", exception)
 # step 3: report undefined signals
 for exception in documentedExceptions:
 if exception not in raisedExceptions:
-self.__error(docstringContext.end(), 0, "D-253", exception)
+self.addError(docstringContext.end(), 0, "D-253", exception)
 def __checkEricSignal(self, docstringContext, context):
 """
 Private method to check, that docstrings contain an &#64;signal line
 if they define signals and don't otherwise.
 definedSignals.add(tokens[i - 4][1])
 elif tokens[i - 1][1] == "=":
 definedSignals.add(tokens[i - 2][1])
 if "@signal" not in docstringContext.ssource() and definedSignals:
-self.__error(docstringContext.end(), 0, "D-260")
+self.addError(docstringContext.end(), 0, "D-260")
 elif "@signal" in docstringContext.ssource():
 if not definedSignals:
-self.__error(docstringContext.end(), 0, "D-261")
+self.addError(docstringContext.end(), 0, "D-261")
 else:
 # step 1: extract documented signals
 documentedSignals = set()
 for line in docstringContext.source():
 line = line.strip()
 documentedSignals.add(signal)
 # step 2: report undocumented signals
 for signal in definedSignals:
 if signal not in documentedSignals:
-self.__error(docstringContext.end(), 0, "D-262", signal)
+self.addError(docstringContext.end(), 0, "D-262", signal)
 # step 3: report undefined signals
 for signal in documentedSignals:
 if signal not in definedSignals:
-self.__error(docstringContext.end(), 0, "D-263", signal)
+self.addError(docstringContext.end(), 0, "D-263", signal)
 def __checkEricBlankAfterSummary(self, docstringContext, _context):
 """
 Private method to check, that docstring summaries are followed
 by a blank line.
 summaryLines, lineNumber = self.__getSummaryLines(docstringContext)
 if (
 len(docstrings) - 2 > lineNumber + len(summaryLines) - 1
 and docstrings[lineNumber + len(summaryLines)].strip()
 ):
-self.__error(docstringContext.start() + lineNumber, 0, "D-246")
+self.addError(docstringContext.start() + lineNumber, 0, "D-246")
 def __checkEricNoBlankBeforeAndAfterClassOrFunction(
 self, docstringContext, context
 ):
 """
 if cti >= len(contextLines) - 1:
 return
 if isClassContext:
 if not contextLines[start - 1].strip():
-self.__error(docstringContext.start(), 0, "D-242")
+self.addError(docstringContext.start(), 0, "D-242")
 if not contextLines[end + 1].strip() and self.__docType == "eric":
-self.__error(docstringContext.end(), 0, "D-243")
+self.addError(docstringContext.end(), 0, "D-243")
 elif contextLines[end + 1].strip() and self.__docType == "eric_black":
-self.__error(docstringContext.end(), 0, "D-143")
+self.addError(docstringContext.end(), 0, "D-143")
 else:
 if not contextLines[start - 1].strip():
-self.__error(docstringContext.start(), 0, "D-244")
+self.addError(docstringContext.start(), 0, "D-244")
 if not contextLines[end + 1].strip():
 if (
 self.__docType == "eric_black"
 and len(contextLines) > end + 2
 and contextLines[end + 2].strip().startswith("def ")
 ):
 return
-self.__error(docstringContext.end(), 0, "D-245")
+self.addError(docstringContext.end(), 0, "D-245")
 def __checkEricNBlankAfterLastParagraph(self, docstringContext, _context):
 """
 Private method to check, that the last paragraph of docstrings is
 not followed by a blank line.
 if len(docstrings) <= 3:
 # correct/invalid one-liner
 return
 if not docstrings[-2].strip():
-self.__error(docstringContext.end(), 0, "D-247")
+self.addError(docstringContext.end(), 0, "D-247")
 def __checkEricSummary(self, docstringContext, context):
 """
 Private method to check, that method docstring summaries start with
 specific words.
 context.source()[0].lstrip().split()[1].split("(", 1)
 )
 firstWord = summary.strip().split(None, 1)[0].lower()
 if functionName == "__init__":
 if firstWord != "constructor":
-self.__error(
+self.addError(
 docstringContext.start() + lineNumber, 0, "D-232", "constructor"
 )
 elif functionName.startswith("__") and functionName.endswith("__"):
 if firstWord != "special":
-self.__error(
+self.addError(
 docstringContext.start() + lineNumber, 0, "D-232", "special"
 )
 elif context.special() == "staticmethod":
 secondWord = summary.strip().split(None, 2)[1].lower()
 if firstWord != "static" and secondWord != "static":
-self.__error(
+self.addError(
 docstringContext.start() + lineNumber, 0, "D-232", "static"
 )
 elif secondWord == "static":
 if functionName.startswith(("__", "on_")):
 if firstWord != "private":
-self.__error(
+self.addError(
 docstringContext.start() + lineNumber,
 0,
 "D-232",
 "private static",
 )
 elif functionName.startswith("_") or functionName.endswith("Event"):
 if firstWord != "protected":
-self.__error(
+self.addError(
 docstringContext.start() + lineNumber,
 0,
 "D-232",
 "protected static",
 )
 else:
 if firstWord != "public":
-self.__error(
+self.addError(
 docstringContext.start() + lineNumber,
 0,
 "D-232",
 "public static",
 )
 arguments.startswith(("cls,", "cls)"))
 or context.special() == "classmethod"
 ):
 secondWord = summary.strip().split(None, 2)[1].lower()
 if firstWord != "class" and secondWord != "class":
-self.__error(
+self.addError(
 docstringContext.start() + lineNumber, 0, "D-232", "class"
 )
 elif secondWord == "class":
 if functionName.startswith(("__", "on_")):
 if firstWord != "private":
-self.__error(
+self.addError(
 docstringContext.start() + lineNumber,
 0,
 "D-232",
 "private class",
 )
 elif functionName.startswith("_") or functionName.endswith("Event"):
 if firstWord != "protected":
-self.__error(
+self.addError(
 docstringContext.start() + lineNumber,
 0,
 "D-232",
 "protected class",
 )
 else:
 if firstWord != "public":
-self.__error(
+self.addError(
 docstringContext.start() + lineNumber,
 0,
 "D-232",
 "public class",
 )
 elif functionName.startswith(("__", "on_")):
 if firstWord != "private":
-self.__error(
+self.addError(
 docstringContext.start() + lineNumber, 0, "D-232", "private"
 )
 elif functionName.startswith("_") or functionName.endswith("Event"):
 if firstWord != "protected":
-self.__error(
+self.addError(
 docstringContext.start() + lineNumber, 0, "D-232", "protected"
 )
 else:
 if firstWord != "public":
-self.__error(
+self.addError(
 docstringContext.start() + lineNumber, 0, "D-232", "public"
 )
 def __checkEricDocumentationSequence(
 self,
 if (
 docToken in ("@type", "@rtype", "@ytype")
 and lineno > 0
 and lines[lineno - 1].strip() == ""
 ):
-self.__error(
+self.addError(
 docstringContext.start() + lineno, 0, "D-271", docToken
 )
 # check the correct sequence of @param/@return/@yield and their accompanying
 # type tag
 docToken2, _ = docTokens[index + 1]
 except IndexError:
 docToken2 = ""
 if docToken in ("@param", "@keyparam") and docToken2 != "@type":
-self.__error(
+self.addError(
 docstringContext.start() + lineno, 0, "D-270", docToken, "@type"
 )
 elif docToken == "@return" and docToken2 != "@rtype":
-self.__error(
+self.addError(
 docstringContext.start() + lineno, 0, "D-270", docToken, "@rtype"
 )
 elif docToken == "@yield" and docToken2 != "@ytype":
-self.__error(
+self.addError(
 docstringContext.start() + lineno, 0, "D-270", docToken, "@ytype"
 )
 def __checkEricDocumentationDeprecatedTags(
 self,
 strippedLine = line.lstrip()
 if strippedLine.startswith("@"):
 # it is a tag line
 tag = strippedLine.split(None, 1)[0]
 with contextlib.suppress(KeyError):
-self.__error(
+self.addError(
 docstringContext.start() + lineno,
 0,
 "D-272",
 tag,
 deprecationsList[tag],
 strippedLine = line.lstrip()
 if strippedLine.startswith("@"):
 tag = strippedLine.split(None, 1)[0]
 currentIndentation = len(line) - len(strippedLine)
 if currentIndentation != indentationLength:
-self.__error(docstringContext.start() + lineno, 0, "D-273", tag)
+self.addError(docstringContext.start() + lineno, 0, "D-273", tag)

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Plugins/CheckerPlugins/CodeStyleChecker/DocStyle/DocStyleChecker.py

src/eric7/Plugins/CheckerPlugins/CodeStyleChecker/DocStyle/DocStyleChecker.py