eric: comparison src/eric7/Plugins/CheckerPlugins/CodeStyleChecker/Naming/NamingStyleChecker.py

-:2f60384fe01f
+:f655c20ff500
 """
 Module implementing a checker for naming conventions.
 """
+import ast
 import collections
-import ast
+import functools
-import re
 import os
 try:
 ast.AsyncFunctionDef  # __IGNORE_EXCEPTION__
 except AttributeError:
 class NamingStyleChecker:
 """
 Class implementing a checker for naming conventions.
 """
-LowercaseRegex = re.compile(r"[_a-z][_a-z0-9]*$")
-UppercaseRegexp = re.compile(r"[_A-Z][_A-Z0-9]*$")
-CamelcaseRegexp = re.compile(r"_?[A-Z][a-zA-Z0-9]*$")
-MixedcaseRegexp = re.compile(r"_?[a-z][a-zA-Z0-9]*$")
 Codes = [
 "N801",
 "N802",
 "N803",
 "N804",
 "N805",
 "N806",
 "N807",
 "N808",
+"N809",
 "N811",
 "N812",
 "N813",
 "N814",
+"N815",
+"N818",
 "N821",
+"N822",
+"N823",
 "N831",
 ]
 def __init__(self, tree, filename, options):
 """
 self.__tree = tree
 self.__filename = filename
 self.__checkersWithCodes = {
 "classdef": [
-(self.__checkClassName, ("N801",)),
+(self.__checkClassName, ("N801", "N818")),
 (self.__checkNameToBeAvoided, ("N831",)),
-],
-"functiondef": [
-(self.__checkFunctionName, ("N802",)),
-(self.__checkFunctionArgumentNames, ("N803", "N804", "N805", "N806")),
-(self.__checkNameToBeAvoided, ("N831",)),
-],
-"assign": [
-(self.__checkVariablesInFunction, ("N821",)),
-(self.__checkNameToBeAvoided, ("N831",)),
-],
-"importfrom": [
-(self.__checkImportAs, ("N811", "N812", "N813", "N814")),
 ],
 "module": [
 (self.__checkModule, ("N807", "N808")),
 ],
 }
+for name in ("functiondef", "asyncfunctiondef"):
+self.__checkersWithCodes[name] = [
+(self.__checkFunctionName, ("N802", "N809")),
+(self.__checkFunctionArgumentNames, ("N803", "N804", "N805", "N806")),
+(self.__checkNameToBeAvoided, ("N831",)),
+]
+for name in ("assign", "namedexpr", "annassign"):
+self.__checkersWithCodes[name] = [
+(self.__checkVariableNames, ("N821",)),
+(self.__checkNameToBeAvoided, ("N831",)),
+]
+for name in (
+"with",
+"asyncwith",
+"for",
+"asyncfor",
+"excepthandler",
+"generatorexp",
+"listcomp",
+"dictcomp",
+"setcomp",
+):
+self.__checkersWithCodes[name] = [
+(self.__checkVariableNames, ("N821",)),
+]
+for name in ("import", "importfrom"):
+self.__checkersWithCodes[name] = [
+(self.__checkImportAs, ("N811", "N812", "N813", "N814", "N815")),
+]
 self.__checkers = {}
 for key, checkers in self.__checkersWithCodes.items():
 for checker, codes in checkers:
 if any(not (code and options.ignore_code(code)) for code in codes):
 """
 if isinstance(node, (ast.ClassDef, ast.FunctionDef, ast.AsyncFunctionDef)):
 name = node.name
 if self.__isNameToBeAvoided(name):
 yield self.__error(node, "N831")
-return
+elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
 argNames = self.__getArgNames(node)
 for arg in argNames:
 if self.__isNameToBeAvoided(arg):
 yield self.__error(node, "N831")
-return
+elif isinstance(node, (ast.Assign, ast.NamedExpr, ast.AnnAssign)):
 if isinstance(node, ast.Assign):
-for target in node.targets:
+targets = node.targets
+else:
+targets = [node.target]
+for target in targets:
 if isinstance(target, ast.Name):
 name = target.id
-if not name:
+if bool(name) and self.__isNameToBeAvoided(name):
-return
-if self.__isNameToBeAvoided(name):
 yield self.__error(node, "N831")
-return
 elif isinstance(target, (ast.Tuple, ast.List)):
 for element in target.elts:
 if isinstance(element, ast.Name):
 name = element.id
-if not name:
+if bool(name) and self.__isNameToBeAvoided(name):
-return
-if self.__isNameToBeAvoided(name):
 yield self.__error(node, "N831")
-return
+def __getClassdef(self, name, parents):
+"""
+Private method to extract the class definition.
+@param name name of the class
+@type str
+@param parents list of parent nodes
+@type ast.AST
+@return node containing the class definition
+@rtype ast.ClassDef
+"""
+for parent in parents:
+for node in parent.body:
+if isinstance(node, ast.ClassDef) and node.name == name:
+return node
+return None
+def __superClassNames(self, name, parents, names=None):
+"""
+Private method to extract the names of all super classes.
+@param name name of the class
+@type str
+@param parents list of parent nodes
+@type ast.AST
+@param names set of collected class names (defaults to None)
+@type set of str (optional)
+@return set of class names
+@rtype set of str
+"""
+if names is None:
+# initialize recursive search with empty set
+names = set()
+classdef = self.__getClassdef(name, parents)
+if not classdef:
+return names
+for base in classdef.bases:
+if isinstance(base, ast.Name) and base.id not in names:
+names.add(base.id)
+names.update(self.__superClassNames(base.id, parents, names))
+return names
 def __checkClassName(self, node, parents):
 """
 Private class to check the given node for class name
-conventions (N801).
+conventions (N801, N818).
 Almost without exception, class names use the CapWords convention.
 Classes for internal use have a leading underscore in addition.
 @param node AST note to check
 @param parents list of parent nodes
 @yield tuple giving line number, offset within line and error code
 @ytype tuple of (int, int, str)
 """
-if not self.CamelcaseRegexp.match(node.name):
+name = node.name
+strippedName = name.strip("_")
+if not strippedName[:1].isupper() or "_" in strippedName:
 yield self.__error(node, "N801")
+superClasses = self.__superClassNames(name, parents)
+if "Exception" in superClasses and not name.endswith("Error"):
+yield self.__error(node, "N818")
 def __checkFunctionName(self, node, parents):
 """
 Private class to check the given node for function name
-conventions (N802).
+conventions (N802, N809).
 Function names should be lowercase, with words separated by underscores
 as necessary to improve readability. Functions <b>not</b> being
 methods '__' in front and back are not allowed. Mixed case is allowed
 only in contexts where that's already the prevailing style
 @yield tuple giving line number, offset within line and error code
 @ytype tuple of (int, int, str)
 """
 functionType = getattr(node, "function_type", "function")
 name = node.name
-if (
-functionType == "function" and "__" in (name[:2], name[-2:])
+if name in ("__dir__", "__getattr__"):
-) or not self.LowercaseRegex.match(name):
+return
+if name.lower() != name:
 yield self.__error(node, "N802")
+if functionType == "function" and name[:2] == "__" and name[-2:] == "__":
+yield self.__error(node, "N809")
 def __checkFunctionArgumentNames(self, node, parents):
 """
 Private class to check the argument names of functions
 (N803, N804, N805, N806).
 @yield tuple giving line number, offset within line and error code
 @ytype tuple of (int, int, str)
 """
 if node.args.kwarg is not None:
 kwarg = node.args.kwarg.arg
-if not self.LowercaseRegex.match(kwarg):
+if kwarg.lower() != kwarg:
 yield self.__error(node, "N803")
+elif node.args.vararg is not None:
+vararg = node.args.vararg.arg
+if vararg.lower() != vararg:
+yield self.__error(node, "N803")
+else:
+argNames = self.__getArgNames(node)
+functionType = getattr(node, "function_type", "function")
+if not argNames:
+if functionType == "method":
+yield self.__error(node, "N805")
+elif functionType == "classmethod":
+yield self.__error(node, "N804")
+elif functionType == "method" and argNames[0] != "self":
+yield self.__error(node, "N805")
+elif functionType == "classmethod" and argNames[0] != "cls":
+yield self.__error(node, "N804")
+elif functionType == "staticmethod" and argNames[0] in ("cls", "self"):
+yield self.__error(node, "N806")
+for arg in argNames:
+if arg.lower() != arg:
+yield self.__error(node, "N803")
+break
+def __checkVariableNames(self, node, parents):
+"""
+Private method to check variable names in function, class and global scope
+(N821, N822, N823).
+Local variables in functions should be lowercase.
+@param node AST note to check
+@param parents list of parent nodes
+@yield tuple giving line number, offset within line and error code
+@ytype tuple of (int, int, str)
+"""
+nodeType = type(node)
+if nodeType is ast.Assign:
+if self.__isNamedTupel(node.value):
 return
+for target in node.targets:
-if node.args.vararg is not None:
+yield from self.__findVariableNameErrors(target, parents)
-vararg = node.args.vararg.arg
-if not self.LowercaseRegex.match(vararg):
+elif nodeType in (ast.NamedExpr, ast.AnnAssign):
-yield self.__error(node, "N803")
+if self.__isNamedTupel(node.value):
 return
+yield from self.__findVariableNameErrors(node.target, parents)
-argNames = self.__getArgNames(node)
-functionType = getattr(node, "function_type", "function")
+elif nodeType in (ast.With, ast.AsyncWith):
+for item in node.items:
-if not argNames:
+yield from self.__findVariableNameErrors(item.optional_vars, parents)
-if functionType == "method":
-yield self.__error(node, "N805")
+elif nodeType in (ast.For, ast.AsyncFor):
-elif functionType == "classmethod":
+yield from self.__findVariableNameErrors(node.target, parents)
-yield self.__error(node, "N804")
-return
+elif nodeType is ast.ExceptHandler:
+if node.name:
-if functionType == "method" and argNames[0] != "self":
+yield from self.__findVariableNameErrors(node, parents)
-yield self.__error(node, "N805")
-elif functionType == "classmethod" and argNames[0] != "cls":
+elif nodeType in (ast.GeneratorExp, ast.ListComp, ast.DictComp, ast.SetComp):
-yield self.__error(node, "N804")
+for gen in node.generators:
-elif functionType == "staticmethod" and argNames[0] in ("cls", "self"):
+yield from self.__findVariableNameErrors(gen.target, parents)
-yield self.__error(node, "N806")
-for arg in argNames:
+def __findVariableNameErrors(self, assignmentTarget, parents):
-if not self.LowercaseRegex.match(arg):
+"""
-yield self.__error(node, "N803")
+Private method to check, if there is a variable name error.
-return
+@param assignmentTarget target node of the assignment
-def __checkVariablesInFunction(self, node, parents):
+@type ast.Name, ast.Tuple, ast.List or ast.ExceptHandler
-"""
+@param parents list of parent nodes
-Private method to check local variables in functions (N821).
+@type ast.AST
-Local variables in functions should be lowercase.
-@param node AST note to check
-@param parents list of parent nodes
 @yield tuple giving line number, offset within line and error code
 @ytype tuple of (int, int, str)
 """
 for parentFunc in reversed(parents):
 if isinstance(parentFunc, ast.ClassDef):
-return
+checker = self.__classVariableCheck
+break
 if isinstance(parentFunc, (ast.FunctionDef, ast.AsyncFunctionDef)):
+checker = functools.partial(self.__functionVariableCheck, parentFunc)
 break
 else:
-return
+checker = self.__globalVariableCheck
-for target in node.targets:
+for name in self.__extractNames(assignmentTarget):
-name = isinstance(target, ast.Name) and target.id
+errorCode = checker(name)
-if not name or name in parentFunc.global_names:
+if errorCode:
-return
+yield self.__error(assignmentTarget, errorCode)
-if not self.LowercaseRegex.match(name) and name[:1] != "_":
+def __extractNames(self, assignmentTarget):
-yield self.__error(target, "N821")
+"""
+Private method to extract the names from the target node.
+@param assignmentTarget target node of the assignment
+@type ast.Name, ast.Tuple, ast.List or ast.ExceptHandler
+@yield name of the variable
+@ytype str
+"""
+targetType = type(assignmentTarget)
+if targetType is ast.Name:
+yield assignmentTarget.id
+elif targetType in (ast.Tuple, ast.List):
+for element in assignmentTarget.elts:
+elementType = type(element)
+if elementType is ast.Name:
+yield element.id
+elif elementType in (ast.Tuple, ast.List):
+yield from self.__extractNames(element)
+elif elementType is ast.Starred:  # PEP 3132
+yield from self.__extractNames(element.value)
+elif isinstance(assignmentTarget, ast.ExceptHandler):
+yield assignmentTarget.name
+def __isMixedCase(self, name):
+"""
+Private method to check, if the given name is mixed case.
+@param name variable name to be checked
+@type str
+@return flag indicating mixed case
+@rtype bool
+"""
+return name.lower() != name and name.lstrip("_")[:1].islower()
+def __globalVariableCheck(self, name):
+"""
+Private method to determine the error code for a variable in global scope.
+@param name variable name to be checked
+@type str
+@return error code or None
+@rtype str or None
+"""
+if self.__isMixedCase(name):
+return "N823"
+return None
+def __classVariableCheck(self, name):
+"""
+Private method to determine the error code for a variable in class scope.
+@param name variable name to be checked
+@type str
+@return error code or None
+@rtype str or None
+"""
+if self.__isMixedCase(name):
+return "N822"
+return None
+def __functionVariableCheck(self, func, varName):
+"""
+Private method to determine the error code for a variable in class scope.
+@param func reference to the function definition node
+@type ast.FunctionDef or ast.AsyncFunctionDef
+@param varName variable name to be checked
+@type str
+@return error code or None
+@rtype str or None
+"""
+if varName not in func.global_names and varName.lower() != varName:
+return "N821"
+return None
+def __isNamedTupel(self, nodeValue):
+"""
+Private method to check, if a node is a named tuple.
+@param nodeValue node to be checked
+@type ast.AST
+@return flag indicating a nemd tuple
+@rtype bool
+"""
+return isinstance(nodeValue, ast.Call) and (
+(
+isinstance(nodeValue.func, ast.Attribute)
+and nodeValue.func.attr == "namedtuple"
+)
+or (
+isinstance(nodeValue.func, ast.Name)
+and nodeValue.func.id == "namedtuple"
+)
+)
 def __checkModule(self, node, parents):
 """
 Private method to check module naming conventions (N807, N808).
 yield self.__error(node, "N808")
 def __checkImportAs(self, node, parents):
 """
 Private method to check that imports don't change the
-naming convention (N811, N812, N813, N814).
+naming convention (N811, N812, N813, N814, N815).
 @param node AST note to check
 @param parents list of parent nodes
 @yield tuple giving line number, offset within line and error code
 @ytype tuple of (int, int, str)
 """
 for name in node.names:
-if not name.asname:
+asname = name.asname
+if not asname:
 continue
-if self.UppercaseRegexp.match(name.name):
+originalName = name.name
-if not self.UppercaseRegexp.match(name.asname):
+if originalName.isupper():
+if not asname.isupper():
 yield self.__error(node, "N811")
-elif self.LowercaseRegex.match(name.name):
+elif originalName.islower():
-if not self.LowercaseRegex.match(name.asname):
+if asname.lower() != asname:
 yield self.__error(node, "N812")
-elif self.LowercaseRegex.match(name.asname):
+elif asname.islower():
 yield self.__error(node, "N813")
-elif self.UppercaseRegexp.match(name.asname):
+elif asname.isupper():
-yield self.__error(node, "N814")
+if "".join(filter(str.isupper, originalName)) == asname:
+yield self.__error(node, "N815")
+else:
+yield self.__error(node, "N814")

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Plugins/CheckerPlugins/CodeStyleChecker/Naming/NamingStyleChecker.py

src/eric7/Plugins/CheckerPlugins/CodeStyleChecker/Naming/NamingStyleChecker.py