eric: comparison Plugins/CheckerPlugins/Pep8/Pep257Checker.py

-:9da653363d07
+:a8628dfdfe04
 Codes = [
 "D101", "D102", "D103", "D104", "D105",
 "D111", "D112", "D113",
 "D121", "D122",
 "D131", "D132", "D133", "D134",
-"D141"
+"D141", "D142", "D143", "D144", "D145",
 ]
 Messages = {
 "D101": QT_TRANSLATE_NOOP(
 "Pep257Checker", "module is missing a docstring"),
 "docstring summary looks like a function's/method's signature"),
 "D134": QT_TRANSLATE_NOOP(
 "Pep257Checker",
 "docstring does not mention the return value type"),
 "D141": QT_TRANSLATE_NOOP(
-"Pep257Checker", "docstring is separated by a blank line"),
+"Pep257Checker",
+"function/method docstring is separated by a blank line"),
+"D142": QT_TRANSLATE_NOOP(
+"Pep257Checker",
+"class docstring is not preceded by a blank line"),
+"D143": QT_TRANSLATE_NOOP(
+"Pep257Checker",
+"class docstring is not followed by a blank line"),
+"D144": QT_TRANSLATE_NOOP(
+"Pep257Checker",
+"docstring summary is not followed by a blank line"),
+"D145": QT_TRANSLATE_NOOP(
+"Pep257Checker",
+"last paragraph of docstring is not followed by a blank line"),
 }
-def __init__(self, source, filename, select, ignore, expected, repeat):
+def __init__(self, source, filename, select, ignore, expected, repeat,
+maxLineLength=79):
 """
 Constructor (according to 'extended' pep8.py API)
 @param source source code to be checked (list of string)
 @param filename name of the source file (string)
 @param select list of selected codes (list of string)
 @param ignore list of codes to be ignored (list of string)
 @param expected list of expected codes (list of string)
 @param repeat flag indicating to report each occurrence of a code
 (boolean)
+@param maxLineLength allowed line length (integer)
 """
 self.__select = tuple(select)
 self.__ignore = tuple(ignore)
 self.__expected = expected[:]
 self.__repeat = repeat
+self.__maxLineLength = maxLineLength
 self.__filename = filename
 self.__source = source[:]
 self.__isScript = self.__source[0].startswith('#!')
 # statistics counters
 ],
 "functionDocstring": [
 ],
 "classDocstring": [
 (self.__checkClassDocstring, ("D104", "D105")),
+(self.__checkBlankBeforeAndAfterClass, ("D142", "D143")),
 ],
 "methodDocstring": [
 ],
 "defDocstring": [
 (self.__checkFunctionDocstring, ("D102", "D103")),
 (self.__checkBackslashes, ("D112",)),
 (self.__checkUnicode, ("D113",)),
 (self.__checkOneLiner, ("D121",)),
 (self.__checkIndent, ("D122",)),
 (self.__checkEndsWithPeriod, ("D131",)),
+(self.__checkBlankAfterSummary, ("D144",)),
+(self.__checkBlankAfterLastParagraph, ("D145",)),
 ],
 }
 self.__checkers = {}
 for key, checkers in self.__checkersWithCodes.items():
 line = (lines[0]
 .replace('r"""', "", 1)
 .replace('u"""', "", 1)
 .replace('"""', "")
+.replace("r'''", "", 1)
+.replace("u'''", "", 1)
+.replace("'''", "")
 .strip())
 if len(lines) == 1 or len(line) > 0:
 return line, 0
-return lines[1].strip(), 1
-first_line = lines[0].strip()
-if len(lines) == 1 or len(first_line) > 0:
-return first_line, 0
 return lines[1].strip(), 1
 ##################################################################
 ## Parsing functionality below
 ##################################################################
 @param context context data to get the docstring from (Pep257Context)
 @return context of extracted docstring (Pep257Context)
 """
 moduleDocstring = self.__parseModuleDocstring(context.source())
-if what.startswith('module'):
+if what.startswith('module') or context.contextType() == "module":
 return moduleDocstring
 if moduleDocstring:
 return moduleDocstring
 tokenGenerator = tokenize.generate_tokens(
 lines = docstringContext.source()
 if len(lines) > 1:
 nonEmptyLines = [l for l in lines if l.strip().strip('\'"')]
 if len(nonEmptyLines) == 1:
-self.__error(docstringContext.start(), 0, "D121")
+modLen = len(context.indent() + '"""' +
+nonEmptyLines[0].strip() + '"""')
+if context.contextType() != "module":
+modLen += 4
+if modLen <= self.__maxLineLength:
+self.__error(docstringContext.start(), 0, "D121")
 def __checkIndent(self, docstringContext, context):
 """
 Private method to check, that docstrings are properly indented.
 if "return" not in docstringContext.ssource().lower():
 tokens = list(
 tokenize.generate_tokens(StringIO(context.ssource()).readline))
 return_ = [tokens[i + 1][0] for i,  token in enumerate(tokens)
 if token[1] == "return"]
 if (set(return_) -
 set([tokenize.COMMENT, tokenize.NL, tokenize.NEWLINE]) !=
 set([])):
 self.__error(docstringContext.end(), 0, "D134")
 def __checkNoBlankLineBefore(self, docstringContext, context):
 preceded by a blank line.
 @param docstringContext docstring context (Pep257Context)
 @param context context of the docstring (Pep257Context)
 """
-if docstringContext is None or self.__isScript:
+if docstringContext is None:
 return
 contextLines = context.source()
 cti = 0
-while not contextLines[cti].strip().startswith(
+while cti < len(contextLines) and \
-('"""', 'r"""', 'u"""')):
+not contextLines[cti].strip().startswith(
+('"""', 'r"""', 'u"""', "'''", "r'''", "u'''")):
 cti += 1
+if cti == len(contextLines):
+return
 if not contextLines[cti - 1].strip():
 self.__error(docstringContext.start(), 0, "D141")
-# D142: check_blank_before_after_class
+def __checkBlankBeforeAndAfterClass(self, docstringContext, context):
-##def check_blank_before_after_class(class_docstring, context, is_script):
+"""
-##    """Class docstring should have 1 blank line around them.
+Private method to check, that class docstrings have one
-##
+blank line around them.
-##    Insert a blank line before and after all docstrings (one-line or
-##    multi-line) that document a class -- generally speaking, the class's
+@param docstringContext docstring context (Pep257Context)
-##    methods are separated from each other by a single blank line, and the
+@param context context of the docstring (Pep257Context)
-##    docstring needs to be offset from the first method by a blank line;
+"""
-##    for symmetry, put a blank line between the class header and the
+if docstringContext is None:
-##    docstring.
+return
-##
-##    """
+contextLines = context.source()
-##    if not class_docstring:
+cti = 0
-##        return
+while cti < len(contextLines) and \
-##    before, after = context.split(class_docstring)[:2]
+not contextLines[cti].strip().startswith(
-##    before_blanks = [not line.strip() for line in before.split('\n')]
+('"""', 'r"""', 'u"""', "'''", "r'''", "u'''")):
-##    after_blanks = [not line.strip() for line in after.split('\n')]
+cti += 1
-##    if before_blanks[-3:] != [False, True, True]:
-##        return True
+if cti == len(contextLines):
-##    if not all(after_blanks) and after_blanks[:3] != [True, True, False]:
+return
-##        return True
+start = cti
-# D143: check_blank_after_summary
+if contextLines[cti].strip() in (
-##def check_blank_after_summary(docstring, context, is_script):
+'"""', 'r"""', 'u"""', "'''", "r'''", "u'''"):
-##    """Blank line missing after one-line summary.
+# it is a multi line docstring
-##
+cti += 1
-##    Multi-line docstrings consist of a summary line just like a one-line
-##    docstring, followed by a blank line, followed by a more elaborate
+while cti < len(contextLines) and \
-##    description. The summary line may be used by automatic indexing tools;
+not contextLines[cti].strip().endswith(('"""', "'''")):
-##    it is important that it fits on one line and is separated from the
+cti += 1
-##    rest of the docstring by a blank line.
+end = cti
-##
-##    """
+if contextLines[start - 1].strip():
-##    if not docstring:
+self.__error(docstringContext.start(), 0, "D142")
-##        return
+if contextLines[end + 1].strip():
-##    lines = eval(docstring).split('\n')
+self.__error(docstringContext.end(), 0, "D143")
-##    if len(lines) > 1:
-##        (summary_line, line_number) = get_summary_line_info(docstring)
+def __checkBlankAfterSummary(self, docstringContext, context):
-##        if len(lines) <= (line_number+1) or lines[line_number+1].strip() != '':
+"""
-##            return True
+Private method to check, that docstring summaries are followed
+by a blank line.
-# D144: check_blank_after_last_paragraph
-##def check_blank_after_last_paragraph(docstring, context, is_script):
+@param docstringContext docstring context (Pep257Context)
-##    """Multiline docstring should end with 1 blank line.
+@param context context of the docstring (Pep257Context)
-##
+"""
-##    The BDFL recommends inserting a blank line between the last
+if docstringContext is None:
-##    paragraph in a multi-line docstring and its closing quotes,
+return
-##    placing the closing quotes on a line by themselves.
-##
+docstrings = docstringContext.source()
-##    """
+if len(docstrings) in [1, 3]:
-##    if (not docstring) or len(eval(docstring).split('\n')) == 1:
+# correct/invalid one-liner
-##        return
+return
-##    blanks = [not line.strip() for line in eval(docstring).split('\n')]
-##    if blanks[-3:] != [False, True, True]:
+summary, lineNumber = self.__getSummaryLine(docstringContext)
-##        return True
+if docstrings[lineNumber + 1].strip():
+self.__error(docstringContext.start() + lineNumber, 0, "D144")
+def __checkBlankAfterLastParagraph(self, docstringContext, context):
+"""
+Private method to check, that docstring summaries are followed
+by a blank line.
+@param docstringContext docstring context (Pep257Context)
+@param context context of the docstring (Pep257Context)
+"""
+if docstringContext is None:
+return
+docstrings = docstringContext.source()
+if len(docstrings) in [1, 3]:
+# correct/invalid one-liner
+return
+if docstrings[-2].strip():
+self.__error(docstringContext.end(), 0, "D145")

Mercurial Repositories > eric / file comparison

comparison: Plugins/CheckerPlugins/Pep8/Pep257Checker.py

Plugins/CheckerPlugins/Pep8/Pep257Checker.py