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

-:61566f35ab22
+:c878e8255972
 self.__args = args
 self.__pep3101FormatRegex = re.compile(
 r'^(?:[^\'"]*[\'"][^\'"]*[\'"])*\s*%|^\s*%')
-if sys.version_info >= (3, 0):
+import builtins
-import builtins
+self.__builtins = [b for b in dir(builtins)
-self.__builtins = [b for b in dir(builtins)
+if b not in self.BuiltinsWhiteList]
-if b not in self.BuiltinsWhiteList]
-else:
-import __builtin__
-self.__builtins = [b for b in dir(__builtin__)
-if b not in self.BuiltinsWhiteList]
 # statistics counters
 self.counters = {}
 # collection of detected errors
 @return generated AST
 @rtype ast.AST
 """
 source = "".join(self.__source)
-# Check type for py2: if not str it's unicode
-if sys.version_info[0] == 2:
-try:
-source = source.encode('utf-8')
-except UnicodeError:
-pass
 return compile(source, self.__filename, 'exec', ast.PyCF_ONLY_AST)
 def run(self):
 """
 Public method to check the given source against miscellaneous
 visitor = TextVisitor()
 visitor.visit(self.__tree)
 for node in visitor.nodes:
 text = node.s
-if sys.version_info[0] > 2 and isinstance(text, bytes):
+if isinstance(text, bytes):
 try:
 text = text.decode(coding)
 except UnicodeDecodeError:
 continue
 fields, implicit, explicit = self.__getFields(text)
 element.col_offset,
 "M131", element.id)
 elif any(isinstance(node, functionDef)
 for functionDef in functionDefs):
 # (asynchronous) function definition
-if sys.version_info >= (3, 0):
+for arg in node.args.args:
-for arg in node.args.args:
+if (
-if (
+isinstance(arg, ast.arg) and
-isinstance(arg, ast.arg) and
+arg.arg in self.__builtins
-arg.arg in self.__builtins
+):
-):
+self.__error(arg.lineno - 1, arg.col_offset,
-self.__error(arg.lineno - 1, arg.col_offset,
+"M132", arg.arg)
-"M132", arg.arg)
-else:
-for arg in node.args.args:
-if (
-isinstance(arg, ast.Name) and
-arg.id in self.__builtins
-):
-self.__error(arg.lineno - 1, arg.col_offset,
-"M132", arg.id)
 def __checkComprehensions(self):
 """
 Private method to check some comprehension related things.
 """
 def __checkDateTime(self):
 """
 Private method to check use of naive datetime functions.
 """
-if sys.version_info[0] >= 3:
+# step 1: generate an augmented node tree containing parent info
-# this check is only performed for Python 3
+#         for each child node
+tree = self.__generateTree()
-# step 1: generate an augmented node tree containing parent info
+for node in ast.walk(tree):
-#         for each child node
+for childNode in ast.iter_child_nodes(node):
-tree = self.__generateTree()
+childNode._dtCheckerParent = node
-for node in ast.walk(tree):
-for childNode in ast.iter_child_nodes(node):
+# step 2: perform checks and report issues
-childNode._dtCheckerParent = node
+visitor = DateTimeVisitor()
+visitor.visit(tree)
-# step 2: perform checks and report issues
+for violation in visitor.violations:
-visitor = DateTimeVisitor()
+node = violation[0]
-visitor.visit(tree)
+reason = violation[1]
-for violation in visitor.violations:
+self.__error(node.lineno - 1, node.col_offset, reason)
-node = violation[0]
-reason = violation[1]
-self.__error(node.lineno - 1, node.col_offset, reason)
 def __checkSysVersion(self):
 """
 Private method to check the use of sys.version and sys.version_info.
 """
 Public method to handle a function call.
 @param node reference to the node to be processed
 @type ast.Call
 """
-if sys.version_info >= (3, 0):
+validPaths = ("six", "future.utils", "builtins")
-validPaths = ("six", "future.utils", "builtins")
+methodsDict = {
-methodsDict = {
+"M521": ("iterkeys", "itervalues", "iteritems", "iterlists"),
-"M521": ("iterkeys", "itervalues", "iteritems", "iterlists"),
+"M522": ("viewkeys", "viewvalues", "viewitems", "viewlists"),
-"M522": ("viewkeys", "viewvalues", "viewitems", "viewlists"),
+"M523": ("next",),
-"M523": ("next",),
+}
-}
-else:
-validPaths = ()
-methodsDict = {}
 if isinstance(node.func, ast.Attribute):
 for code, methods in methodsDict.items():
 if node.func.attr in methods:
 callPath = ".".join(composeCallPath(node.func.value))
 @param node reference to the node to be processed
 @type ast.Attribute
 """
 callPath = list(composeCallPath(node))
-if '.'.join(callPath) == 'sys.maxint' and sys.version_info >= (3, 0):
+if '.'.join(callPath) == 'sys.maxint':
 self.violations.append((node, "M504"))
 elif (
 len(callPath) == 2 and
-callPath[1] == 'message' and
+callPath[1] == 'message'
-sys.version_info >= (2, 6)
 ):
 name = callPath[0]
 for elem in reversed(self.__nodeStack[:-1]):
 if isinstance(elem, ast.ExceptHandler) and elem.name == name:
 self.violations.append((node, "M505"))
 """
 if isinstance(self.__nodeStack[-2], ast.ClassDef):
 # By using 'hasattr' below we're ignoring starred arguments, slices
 # and tuples for simplicity.
 assignTargets = {t.id for t in node.targets if hasattr(t, 'id')}
-if '__metaclass__' in assignTargets and sys.version_info >= (3, 0):
+if '__metaclass__' in assignTargets:
 self.violations.append((node, "M524"))
 elif len(node.targets) == 1:
 target = node.targets[0]
 if (
 @param node reference to the node to check
 @type ast.AST
 @return flag indicating the node contains a None value
 """
-if sys.version_info[0] > 2:
+return (
-return (
+AstUtilities.isNameConstant(node) and
-AstUtilities.isNameConstant(node) and
+AstUtilities.getValue(node) is None
-AstUtilities.getValue(node) is None
+)
-)
-else:
-return isinstance(node, ast.Name) and node.id == "None"
 def __resultExists(self):
 """
 Private method to check the existance of a return result.
 return
 try:
 okNodes = (ast.Return, ast.Raise, ast.While, ast.Try)
 except AttributeError:
-# Py2
 okNodes = (ast.Return, ast.Raise, ast.While)
 if not isinstance(node, okNodes):
 self.violations.append((node, "M833"))
 def __checkUnnecessaryAssign(self, node):

Mercurial Repositories > eric / file comparison

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

eric6/Plugins/CheckerPlugins/CodeStyleChecker/MiscellaneousChecker.py