eric: comparison Utilities/ModuleParser.py

-:b0996e4a289e
+:1d8dd9706f46
 import os
 import imp
 import re
 import Utilities
+from functools import reduce
 __all__ = ["Module", "Class", "Function", "RbModule", "readModule"]
 TABWIDTH = 4
 Public method to add information about a class.
 @param name name of class to be added (string)
 @param _class Class object to be added
 """
-if self.classes.has_key(name):
+if name in self.classes:
 self.classes_counts[name] += 1
 name = "%s_%d" % (name, self.classes_counts[name])
 else:
 self.classes_counts[name] = 0
 self.classes[name] = _class
 Public method to add information about a Ruby module.
 @param name name of module to be added (string)
 @param module Module object to be added
 """
-if self.modules.has_key(name):
+if name in self.modules:
 self.modules_counts[name] += 1
 name = "%s_%d" % (name, self.modules_counts[name])
 else:
 self.modules_counts[name] = 0
 self.modules[name] = module
 Public method to add information about a function.
 @param name name of function to be added (string)
 @param function Function object to be added
 """
-if self.functions.has_key(name):
+if name in self.functions:
 self.functions_counts[name] += 1
 name = "%s_%d" % (name, self.functions_counts[name])
 else:
 self.functions_counts[name] = 0
 self.functions[name] = function
 inherit = _commentsub('', inherit)
 names = []
 for n in inherit.split(','):
 n = n.strip()
 if n:
-if self.classes.has_key(n):
+if n in self.classes:
 # we know this super class
 n = self.classes[n].name
 else:
 c = n.split('.')
 if len(c) > 1:
 # super class is of the
 # form module.class:
 # look in module for class
 m = c[-2]
 c = c[-1]
-if _modules.has_key(m):
+if m in _modules:
 m = _modules[m]
 n = m.name
 names.append(n)
 inherit = names
 # remember this class
 elif m.start("ImportFrom") >= 0:
 # from module import stuff
 mod = m.group("ImportFromPath")
 names = m.group("ImportFromList").split(',')
-if not self.from_imports.has_key(mod):
+if mod not in self.from_imports:
 self.from_imports[mod] = []
 for n in names:
 n = n.strip()
 self.from_imports[mod].append(n)
 # add nested classes to the file
 if classstack and isinstance(classstack[-1][0], RbModule):
 parent_obj = classstack[-1][0]
 else:
 parent_obj = self
-if parent_obj.classes.has_key(class_name):
+if class_name in parent_obj.classes:
 cur_class = parent_obj.classes[class_name]
 elif classstack and \
 isinstance(classstack[-1][0], Class) and \
 class_name == "self":
 cur_class = classstack[-1][0]
 module_name = m.group("ModuleName")
 # remember this class
 cur_class = RbModule(self.name, module_name,
 self.file, lineno)
 # add nested Ruby modules to the file
-if self.modules.has_key(module_name):
+if module_name in self.modules:
 cur_class = self.modules[module_name]
 else:
 self.addModule(module_name, cur_class)
 cur_obj = cur_class
 classstack.append((cur_class, thisindent))
 Public method to build the inheritance hierarchy for all classes of this module.
 @return A dictionary with inheritance hierarchies.
 """
 hierarchy =  {}
-for cls in self.classes.keys():
+for cls in list(list(self.classes.keys())):
 self.assembleHierarchy(cls, self.classes, [cls], hierarchy)
-for mod in self.modules.keys():
+for mod in list(list(self.modules.keys())):
 self.assembleHierarchy(mod, self.modules, [mod], hierarchy)
 return hierarchy
 def assembleHierarchy(self, name, classes, path, result):
 """
 @param classes A dictionary of classes to look in.
 @param path
 @param result The resultant hierarchy
 """
 rv = {}
-if classes.has_key(name):
+if name in classes:
 for cls in classes[name].super:
-if not classes.has_key(cls):
+if cls not in classes:
 rv[cls] = {}
 exhausted = path + [cls]
 exhausted.reverse()
 self.addPathToHierarchy(exhausted, result, self.addPathToHierarchy)
 else:
 @param path the exhausted path of classes
 @param result the result dictionary
 @param fn function to call for classe that are already part of the
 result dictionary
 """
-if path[0] in result.keys():
+if path[0] in list(list(result.keys())):
 if len(path) > 1:
 fn(path[1:], result[path[0]], fn)
 else:
 for part in path:
 result[part] = {}
 if modname.lower().endswith(ext):
 modname = modname[:-len(ext)]
 break
 module = os.path.basename(module)
-if caching and _modules.has_key(modname):
+if caching and modname in _modules:
 # we've seen this module before...
 return _modules[modname]
 if module in sys.builtin_module_names:
 # this is a built-in module
 _modules[modname] = Module(modname, None, None)
 return _modules[modname]
 mod = Module(modname, file, type)
 try:
-src = Utilities.decode(f.read())[0]
+src = f.read()
 mod.scan(src)
 finally:
 f.close()
 if caching:
 _modules[modname] = mod
 raise ImportError
 # standard Python module file
 if name.lower().endswith('.py'):
 name = name[:-3]
-if type(name) == type(u""):
+##    if isinstance(name, type("")):
-name = name.encode('utf-8')
+##        name = name.encode('utf-8')
 return imp.find_module(name, path)
 def resetParsedModules():
 """
 modname = modname[:-4]
 elif modname.lower().endswith(".rb"):
 modname = modname[:-3]
 module = os.path.basename(module)
-if _modules.has_key(modname):
+if modname in _modules:
 del _modules[modname]
 if __name__ == "__main__":
 # Main program for testing.
 mod = sys.argv[1]
 module = readModule(mod)
-for cls in module.classes.values():
+for cls in list(module.classes.values()):
-print "--------------"
+print("--------------")
-print cls.name
+print(cls.name)
-for meth in cls.methods.values():
+for meth in list(cls.methods.values()):
-print meth.name, meth.pyqtSignature
+print(meth.name, meth.pyqtSignature)

Mercurial Repositories > eric / file comparison

comparison: Utilities/ModuleParser.py

Utilities/ModuleParser.py