eric: comparison Utilities/ModuleParser.py

-:1b59c4ba121e
+:8cd4d08fa9f6
 |
 (?P<MethodName> [a-zA-Z_] [a-zA-Z0-9_?!=]* )
 |
 (?P<MethodName3> [^( \t]{1,3} )
 )
 [ \t]*
 (?:
 \( (?P<MethodSignature> (?: [^)] | \)[ \t]*,? )*? ) \)
 )?
 [ \t]*
 )
 [ \t]+
 (?P<ClassName> [A-Z] [a-zA-Z0-9_]* )
 [ \t]*
 (?P<ClassSupers> < [ \t]* [A-Z] [a-zA-Z0-9_]* )?
 |
 [ \t]* << [ \t]*
 (?P<ClassName2> [a-zA-Z_] [a-zA-Z0-9_]* )
 )
 [ \t]*
 )
 )
 |   (?P<Attr>
 ^
 (?P<AttrIndent> [ \t]* )
 attr
 (?P<AttrType> (?: _accessor | _reader | _writer ) )?
 \(?
 [ \t]*
 (?P<AttrList> (?: : [a-zA-Z0-9_]+ , \s* )* (?: : [a-zA-Z0-9_]+ | true | false )+ )
 [ \t]*
 _commentsub = re.compile(r"""#[^\n]*\n|#[^\n]*$""").sub
 _modules = {}                           # cache of modules we've seen
 class VisibilityBase(object):
 """
 Class implementing the visibility aspect of all objects.
 """
 def isPrivate(self):
 def setPublic(self):
 """
 Public method to set the visibility to Public.
 """
 self.visibility = 2
 class Module(object):
 '''
 Class to represent a Python module.
 '''
 else:
 object.setPublic()
 def __py_scan(self, src):
 """
 Private method to scan the source text of a Python module and retrieve the
 relevant information.
 @param src the source text to be scanned (string)
 """
 lineno, last_lineno_pos = 1, 0
-classstack = [] # stack of (class, indent) pairs
+classstack = []  # stack of (class, indent) pairs
-conditionalsstack = [] # stack of indents of conditional defines
+conditionalsstack = []  # stack of indents of conditional defines
 deltastack = []
 deltaindent = 0
 deltaindentcalculated = 0
 i = 0
 modulelevel = 1
 # modify indentation level for conditional defines
 if conditionalsstack:
 if thisindent > conditionalsstack[-1]:
 if not deltaindentcalculated:
 deltastack.append(thisindent - conditionalsstack[-1])
-deltaindent = reduce(lambda x,y: x+y, deltastack)
+deltaindent = reduce(lambda x, y:  x + y, deltastack)
 deltaindentcalculated = 1
 thisindent -= deltaindent
 else:
 while conditionalsstack and \
 conditionalsstack[-1] >= thisindent:
 if cur_class is None:
 continue
 if isinstance(cur_class, Class):
 # it's a class method
 f = Function(None, meth_name, None, lineno,
 meth_sig, meth_pyqtSig)
 self.__py_setVisibility(f)
 cur_class.addMethod(meth_name, f)
 break
 else:
 # it's a nested function of a module function
 f = Function(self.name, meth_name, self.file, lineno,
 meth_sig, meth_pyqtSig)
 self.__py_setVisibility(f)
 self.addFunction(meth_name, f)
 else:
 # it's a module function
 f = Function(self.name, meth_name, self.file, lineno,
 meth_sig, meth_pyqtSig)
 self.__py_setVisibility(f)
 self.addFunction(meth_name, f)
 cur_obj = f
-classstack.append((None, thisindent)) # Marker for nested fns
+classstack.append((None, thisindent))  # Marker for nested fns
 elif m.start("Docstring") >= 0:
 contents = m.group("DocstringContents3")
 if contents is not None:
 contents = _hashsub(r"\1", contents)
 if cur_obj:
 cur_obj.addDescription(contents)
 elif m.start("String") >= 0:
 if modulelevel and \
-(src[start-len('\r\n'):start] == '\r\n' or \
+(src[start - len('\r\n'):start] == '\r\n' or \
-src[start-len('\n'):start] == '\n' or \
+src[start - len('\n'):start] == '\n' or \
-src[start-len('\r'):start] == '\r'):
+src[start - len('\r'):start] == '\r'):
 contents = m.group("StringContents3")
 if contents is not None:
 contents = _hashsub(r"\1", contents)
 else:
 if self.file.lower().endswith('.ptl'):
 isSignal = m.group("VariableSignal") != ""
 lineno = lineno + src.count('\n', last_lineno_pos, start)
 last_lineno_pos = start
 if thisindent == 0:
 # global variable
 attr = Attribute(self.name, variable_name, self.file, lineno,
-isSignal = isSignal)
+isSignal=isSignal)
 self.__py_setVisibility(attr)
 self.addGlobal(variable_name, attr)
 else:
 index = -1
 while index >= -len(classstack):
 if classstack[index][1] >= thisindent:
 index -= 1
 else:
 if classstack[index][0] is not None and \
 isinstance(classstack[index][0], Class):
 attr = Attribute(self.name, variable_name, self.file,
-lineno, isSignal = isSignal)
+lineno, isSignal=isSignal)
 self.__py_setVisibility(attr)
 classstack[index][0].addGlobal(variable_name, attr)
 break
 elif m.start("Import") >= 0:
 modulelevel = 0
 def __rb_scan(self, src):
 """
 Private method to scan the source text of a Python module and retrieve the
 relevant information.
 @param src the source text to be scanned (string)
 """
 lineno, last_lineno_pos = 1, 0
-classstack = [] # stack of (class, indent) pairs
+classstack = []  # stack of (class, indent) pairs
 acstack = []    # stack of (access control, indent) pairs
 indent = 0
 i = 0
 cur_obj = self
 while True:
 else:
 # it's a function
 f = Function(self.name, meth_name, self.file, lineno, meth_sig)
 self.addFunction(meth_name, f)
 cur_obj = f
-classstack.append((None, thisindent)) # Marker for nested fns
+classstack.append((None, thisindent))  # Marker for nested fns
 elif m.start("Docstring") >= 0:
 contents = m.group("DocstringContents")
 if contents is not None:
 contents = _hashsub(r"\1", contents)
 if m.group("AttrType") is None:
 nv = m.group("AttrList").split(",")
 if not nv:
 break
 name = nv[0].strip()[1:]    # get rid of leading ':'
-attr = parent.getAttribute("@"+name) or \
+attr = parent.getAttribute("@" + name) or \
-parent.getAttribute("@@"+name) or \
+parent.getAttribute("@@" + name) or \
-Attribute(self.name, "@"+name, self.file, lineno)
+Attribute(self.name, "@" + name, self.file, lineno)
 if len(nv) == 1 or nv[1].strip() == "false":
 attr.setProtected()
 elif nv[1].strip() == "true":
 attr.setPublic()
 parent.addAttribute(attr.name, attr)
 else:
 access = m.group("AttrType")
 for name in m.group("AttrList").split(","):
 name = name.strip()[1:]     # get rid of leading ':'
-attr = parent.getAttribute("@"+name) or \
+attr = parent.getAttribute("@" + name) or \
-parent.getAttribute("@@"+name) or \
+parent.getAttribute("@@" + name) or \
-Attribute(self.name, "@"+name, self.file, lineno)
+Attribute(self.name, "@" + name, self.file, lineno)
 if access == "_accessor":
 attr.setPublic()
 elif access == "_reader" or access == "_writer":
 if attr.isPrivate():
 attr.setProtected()
 """
 Public method to build the inheritance hierarchy for all classes of this module.
 @return A dictionary with inheritance hierarchies.
 """
-hierarchy =  {}
+hierarchy = {}
 for cls in list(list(self.classes.keys())):
 self.assembleHierarchy(cls, self.classes, [cls], hierarchy)
 for mod in list(list(self.modules.keys())):
 self.assembleHierarchy(mod, self.modules, [mod], hierarchy)
 return hierarchy
 This code is borrowed from Boa Constructor.
 @param name name of class to assemble hierarchy (string)
 @param classes A dictionary of classes to look in.
 @param path
 @param result The resultant hierarchy
 """
 rv = {}
 if name in classes:
 for cls in classes[name].super:
 elif self.type == RB_SOURCE:
 type = "Ruby"
 else:
 type = ""
 return type
 class Class(VisibilityBase):
 '''
 Class to represent a Python class.
 '''
 @param endLineNo number of the last line (integer)
 """
 self.endlineno = endLineNo
 class RbModule(Class):
 '''
 Class to represent a Ruby module.
 '''
 def __init__(self, module, name, file, lineno):
 @param name name of class to be added (string)
 @param _class Class object to be added
 """
 self.classes[name] = _class
 class Function(VisibilityBase):
 '''
 Class to represent a Python function or method.
 '''
-def __init__(self, module, name, file, lineno, signature = '', pyqtSignature = None):
+def __init__(self, module, name, file, lineno, signature='', pyqtSignature=None):
 """
 Constructor
 @param module name of module containing this function (string)
 @param name name of the function (string)
 @param description the docstring to be stored (string)
 """
 self.description = description
 class Attribute(VisibilityBase):
 '''
 Class to represent a Python function or method.
 '''
-def __init__(self, module, name, file, lineno, isSignal = False):
+def __init__(self, module, name, file, lineno, isSignal=False):
 """
 Constructor
 @param module name of module containing this function (string)
 @param name name of the function (string)
 self.file = file
 self.lineno = lineno
 self.isSignal = isSignal
 self.setPublic()
-def readModule(module, path = [], inpackage = False, basename = "",
-extensions = None, caching = True):
+def readModule(module, path=[], inpackage=False, basename="",
+extensions=None, caching=True):
 '''
 Function to read a module file and parse it.
 The module is searched in path and sys.path, read and parsed.
 If the module was parsed before, the information is taken
 package (boolean)
 @param basename a path basename. This basename is deleted from
 the filename of the module file to be read. (string)
 @param extensions list of extensions, which should be considered valid
 source file extensions (list of strings)
 @param caching flag indicating that the parsed module should be
 cached (boolean)
 @return reference to a Module object containing the parsed
 module information (Module)
 '''
 global _modules
 pass
 if caching:
 _modules[modname] = mod
 return mod
 def _indent(ws):
 """
 Protected function to determine the indent width of a whitespace string.
 @param ws The whitespace string to be cheked. (string)
 @return Length of the whitespace string after tab expansion.
 """
 return len(ws.expandtabs(TABWIDTH))
 def find_module(name, path, extensions):
 """
 Module function to extend the Python module finding mechanism.
 if name.lower().endswith('.py'):
 name = name[:-3]
 return imp.find_module(name, path)
 def resetParsedModules():
 """
 Module function to reset the list of modules already parsed.
 """
 _modules.clear()
-def resetParsedModule(module, basename = ""):
+def resetParsedModule(module, basename=""):
 """
 Module function to clear one module from the list of parsed modules.
 @param module Name of the module to be parsed (string)
 @param basename a path basename. This basename is deleted from

Mercurial Repositories > eric / file comparison

comparison: Utilities/ModuleParser.py

Utilities/ModuleParser.py