eric: comparison Plugins/CheckerPlugins/CodeStyleChecker/MiscellaneousChecker.py

-:43437fc9f4c9
+:b5e4e7efa904
 from __future__ import unicode_literals
 import sys
 import ast
 import re
+import itertools
+from string import Formatter
 class MiscellaneousChecker(object):
 """
 Class implementing a checker for miscellaneous checks.
 """
 Codes = [
 "M101", "M102",
 "M111", "M112",
 "M121",
-"M131",
+"M601",
+"M611", "M612", "M613",
+"M621", "M622", "M623", "M624", "M625",
+"M631", "M632",
 "M701", "M702",
 "M801",
 "M811",
 "M901",
 ]
+Formatter = Formatter()
+FormatFieldRegex = re.compile(r'^((?:\s|.)*?)(\..*|\[.*\])?$')
 def __init__(self, source, filename, select, ignore, expected, repeat,
 args):
 """
 Constructor
 # collection of detected errors
 self.errors = []
 checkersWithCodes = [
-# TODO: fill this
 (self.__checkCoding, ("M101", "M102")),
 (self.__checkCopyright, ("M111", "M112")),
 (self.__checkBlindExcept, ("M121",)),
-(self.__checkPep3101, ("M131",)),
+(self.__checkPep3101, ("M601",)),
+(self.__checkFormatString, ("M611", "M612", "M613",
+"M621", "M622", "M623", "M624", "M625",
+"M631", "M632")),
+(self.__checkFuture, ("M701", "M702")),
 (self.__checkPrintStatements, ("M801",)),
 (self.__checkTuple, ("M811", )),
-(self.__checkFuture, ("M701", "M702")),
 ]
 self.__defaultArgs = {
 "CodingChecker": 'latin-1, utf-8',
 "CopyrightChecker": {
 """
 for lineno, line in enumerate(self.__source):
 match = self.__blindExceptRegex.search(line)
 if match:
 self.__error(lineno, match.start(), "M121")
+def __checkPrintStatements(self):
+"""
+Private method to check for print statements.
+"""
+for node in ast.walk(self.__tree):
+if (isinstance(node, ast.Call) and
+getattr(node.func, 'id', None) == 'print') or \
+(hasattr(ast, 'Print') and isinstance(node, ast.Print)):
+self.__error(node.lineno - 1, node.col_offset, "M801")
+def __checkTuple(self):
+"""
+Private method to check for one element tuples.
+"""
+for node in ast.walk(self.__tree):
+if isinstance(node, ast.Tuple) and \
+len(node.elts) == 1:
+self.__error(node.lineno - 1, node.col_offset, "M811")
+def __checkFuture(self):
+"""
+Private method to check the __future__ imports.
+"""
+expectedImports = set(
+[i.strip()
+for i in self.__args.get("FutureChecker", "").split(",")
+if bool(i.strip())])
+if len(expectedImports) == 0:
+# nothing to check for; disabling the check
+return
+imports = set()
+node = None
+for node in ast.walk(self.__tree):
+if (isinstance(node, ast.ImportFrom) and
+node.module == '__future__'):
+imports |= set(name.name for name in node.names)
+elif isinstance(node, ast.Expr):
+if not isinstance(node.value, ast.Str):
+break
+elif not isinstance(node, ast.Module):
+break
+if isinstance(node, ast.Module):
+return
+if not (imports >= expectedImports):
+if imports:
+self.__error(node.lineno - 1, node.col_offset, "M701",
+", ".join(expectedImports), ", ".join(imports))
+else:
+self.__error(node.lineno - 1, node.col_offset, "M702",
+", ".join(expectedImports))
 def __checkPep3101(self):
 """
 Private method to check for old style string formatting.
 """
 if pos >= lineLen:
 break
 c = line[pos]
 if c in "diouxXeEfFgGcrs":
 formatter += c
-self.__error(lineno, formatPos, "M131", formatter)
+self.__error(lineno, formatPos, "M601", formatter)
-def __checkPrintStatements(self):
+def __checkFormatString(self):
 """
-Private method to check for print statements.
+Private method to check string format strings.
 """
-for node in ast.walk(self.__tree):
+visitor = TextVisitor()
-if (isinstance(node, ast.Call) and
+visitor.visit(self.__tree)
-getattr(node.func, 'id', None) == 'print') or \
+for node in visitor.nodes:
-(hasattr(ast, 'Print') and isinstance(node, ast.Print)):
+text = node.s
-self.__error(node.lineno - 1, node.col_offset, "M801")
+if sys.version_info[0] > 2 and isinstance(text, bytes):
+try:
-def __checkTuple(self):
+# TODO: Maybe decode using file encoding?
-"""
+text = text.decode('utf-8')
-Private method to check for one element tuples.
+except UnicodeDecodeError:
-"""
+continue
-for node in ast.walk(self.__tree):
+fields, implicit, explicit = self.__getFields(text)
-if isinstance(node, ast.Tuple) and \
+if implicit:
-len(node.elts) == 1:
+if node in visitor.calls:
-self.__error(node.lineno - 1, node.col_offset, "M811")
+self.__error(node.lineno - 1, node.col_offset, "M611")
+else:
-def __checkFuture(self):
+if node.is_docstring:
-"""
+self.__error(node.lineno - 1, node.col_offset, "M612")
-Private method to check the __future__ imports.
+else:
-"""
+self.__error(node.lineno - 1, node.col_offset, "M613")
-expectedImports = set(
-[i.strip()
+if node in visitor.calls:
-for i in self.__args.get("FutureChecker", "").split(",")
+call, strArgs = visitor.calls[node]
-if bool(i.strip())])
-if len(expectedImports) == 0:
+numbers = set()
-# nothing to check for; disabling the check
+names = set()
-return
+# Determine which fields require a keyword and which an arg
+for name in fields:
-imports = set()
+fieldMatch = self.FormatFieldRegex.match(name)
-node = None
+try:
+number = int(fieldMatch.group(1))
-for node in ast.walk(self.__tree):
+except ValueError:
-if (isinstance(node, ast.ImportFrom) and
+number = -1
-node.module == '__future__'):
+# negative numbers are considered keywords
-imports |= set(name.name for name in node.names)
+if number >= 0:
-elif isinstance(node, ast.Expr):
+numbers.add(number)
-if not isinstance(node.value, ast.Str):
+else:
-break
+names.add(fieldMatch.group(1))
-elif not isinstance(node, ast.Module):
-break
+keywords = set(keyword.arg for keyword in call.keywords)
+numArgs = len(call.args)
-if isinstance(node, ast.Module):
+if strArgs:
-return
+numArgs -= 1
+if sys.version_info < (3, 5):
-if not (imports >= expectedImports):
+hasKwArgs = bool(call.kwargs)
-if imports:
+hasStarArgs = bool(call.starargs)
-self.__error(node.lineno - 1, node.col_offset, "M701",
+else:
-", ".join(expectedImports), ", ".join(imports))
+hasKwArgs = any(kw.arg is None for kw in call.keywords)
-else:
+hasStarArgs = sum(1 for arg in call.args
-self.__error(node.lineno - 1, node.col_offset, "M702",
+if isinstance(arg, ast.Starred))
-", ".join(expectedImports))
+if hasKwArgs:
+keywords.discard(None)
+if hasStarArgs:
+numArgs -= 1
+# if starargs or kwargs is not None, it can't count the
+# parameters but at least check if the args are used
+if hasKwArgs:
+if not names:
+# No names but kwargs
+self.__error(call.lineno - 1, call.col_offset, "M623")
+if hasStarArgs:
+if not numbers:
+# No numbers but args
+self.__error(call.lineno - 1, call.col_offset, "M624")
+if not hasKwArgs and not hasStarArgs:
+# can actually verify numbers and names
+for number in sorted(numbers):
+if number >= numArgs:
+self.__error(call.lineno - 1, call.col_offset,
+"M621", number)
+for name in sorted(names):
+if name not in keywords:
+self.__error(call.lineno - 1, call.col_offset,
+"M622", name)
+for arg in range(numArgs):
+if arg not in numbers:
+self.__error(call.lineno - 1, call.col_offset, "M631",
+arg)
+for keyword in keywords:
+if keyword not in names:
+self.__error(call.lineno - 1, call.col_offset, "M632",
+keyword)
+if implicit and explicit:
+self.__error(call.lineno - 1, call.col_offset, "M625")
+def __getFields(self, string):
+"""
+Private method to extract the format field information.
+@param string format string to be parsed
+@type str
+@return format field information as a tuple with fields, implicit
+field definitions present and explicit field definitions present
+@rtype tuple of set of str, bool, bool
+"""
+fields = set()
+cnt = itertools.count()
+implicit = False
+explicit = False
+try:
+for literal, field, spec, conv in self.Formatter.parse(string):
+if field is not None and (conv is None or conv in 'rsa'):
+if not field:
+field = str(next(cnt))
+implicit = True
+else:
+explicit = True
+fields.add(field)
+fields.update(parsedSpec[1]
+for parsedSpec in self.Formatter.parse(spec)
+if parsedSpec[1] is not None)
+except ValueError:
+return set(), False, False
+else:
+return fields, implicit, explicit
+class TextVisitor(ast.NodeVisitor):
+"""
+Class implementing a node visitor for bytes and str instances.
+It tries to detect docstrings as string of the first expression of each
+module, class or function.
+"""
+# modelled after the string format flake8 extension
+def __init__(self):
+"""
+Constructor
+"""
+super(TextVisitor, self).__init__()
+self.nodes = []
+self.calls = {}
+def __addNode(self, node):
+"""
+Private method to add a node to our list of nodes.
+@param node reference to the node to add
+@type ast.AST
+"""
+if not hasattr(node, 'is_docstring'):
+node.is_docstring = False
+self.nodes.append(node)
+def __isBaseString(self, node):
+"""
+Private method to determine, if a node is a base string node.
+@param node reference to the node to check
+@type ast.AST
+@return flag indicating a base string
+@rtype bool
+"""
+typ = (ast.Str,)
+if sys.version_info[0] > 2:
+typ += (ast.Bytes,)
+return isinstance(node, typ)
+def visit_Str(self, node):
+"""
+Public method to record a string node.
+@param node reference to the string node
+@type ast.Str
+"""
+self.__addNode(node)
+def visit_Bytes(self, node):
+"""
+Public method to record a bytes node.
+@param node reference to the bytes node
+@type ast.Bytes
+"""
+self.__addNode(node)
+def __visitDefinition(self, node):
+"""
+Private method handling class and function definitions.
+@param node reference to the node to handle
+@type ast.FunctionDef or ast.ClassDef
+"""
+# Manually traverse class or function definition
+# * Handle decorators normally
+# * Use special check for body content
+# * Don't handle the rest (e.g. bases)
+for decorator in node.decorator_list:
+self.visit(decorator)
+self.__visitBody(node)
+def __visitBody(self, node):
+"""
+Private method to traverse the body of the node manually.
+If the first node is an expression which contains a string or bytes it
+marks that as a docstring.
+@param node reference to the node to traverse
+@type ast.AST
+"""
+if (node.body and isinstance(node.body[0], ast.Expr) and
+self.__isBaseString(node.body[0].value)):
+node.body[0].value.is_docstring = True
+for subnode in node.body:
+self.visit(subnode)
+def visit_Module(self, node):
+"""
+Public method to handle a module.
+@param node reference to the node to handle
+@type ast.Module
+"""
+self.__visitBody(node)
+def visit_ClassDef(self, node):
+"""
+Public method to handle a class definition.
+@param node reference to the node to handle
+@type ast.ClassDef
+"""
+# Skipped nodes: ('name', 'bases', 'keywords', 'starargs', 'kwargs')
+self.__visitDefinition(node)
+def visit_FunctionDef(self, node):
+"""
+Public method to handle a function definition.
+@param node reference to the node to handle
+@type ast.FunctionDef
+"""
+# Skipped nodes: ('name', 'args', 'returns')
+self.__visitDefinition(node)
+def visit_Call(self, node):
+"""
+Public method to handle a function call.
+@param node reference to the node to handle
+@type ast.Call
+"""
+if (isinstance(node.func, ast.Attribute) and
+node.func.attr == 'format'):
+if self.__isBaseString(node.func.value):
+self.calls[node.func.value] = (node, False)
+elif (isinstance(node.func.value, ast.Name) and
+node.func.value.id == 'str' and node.args and
+self.__isBaseString(node.args[0])):
+self.calls[node.args[0]] = (node, True)
+super(TextVisitor, self).generic_visit(node)

Mercurial Repositories > eric / file comparison

comparison: Plugins/CheckerPlugins/CodeStyleChecker/MiscellaneousChecker.py

Plugins/CheckerPlugins/CodeStyleChecker/MiscellaneousChecker.py