eric: comparison src/eric7/Utilities/ModuleParser.py

-:2fe91fe443dd
+:328f3ec4b77a
 def getTypeFromTypeName(name):
 """
 Module function to determine the module type given the module type name.
-@param name module type name (string)
+@param name module type name
-@return module type or -1 for failure (integer)
+@type str
+@return module type or -1 for failure
+@rtype int
 """
 if name in TYPE_MAPPING:
 return TYPE_MAPPING[name]
 else:
 return -1
 def isPrivate(self):
 """
 Public method to check, if the visibility is Private.
-@return flag indicating Private visibility (boolean)
+@return flag indicating Private visibility
+@rtype bool
 """
 return self.visibility == 0
 def isProtected(self):
 """
 Public method to check, if the visibility is Protected.
-@return flag indicating Protected visibility (boolean)
+@return flag indicating Protected visibility
+@rtype bool
 """
 return self.visibility == 1
 def isPublic(self):
 """
 Public method to check, if the visibility is Public.
-@return flag indicating Public visibility (boolean)
+@return flag indicating Public visibility
+@rtype bool
 """
 return self.visibility == 2
 def setPrivate(self):
 """
 def __init__(self, name, file=None, moduleType=None):
 """
 Constructor
-@param name name of this module (string)
+@param name name of this module
-@param file filename of file containing this module (string)
+@type str
+@param file filename of file containing this module
+@type str
 @param moduleType type of this module
+@type int
 """
 self.name = name
 self.file = file
 self.modules = {}
 self.modules_counts = {}
 def addClass(self, name, _class):
 """
 Public method to add information about a class.
-@param name name of class to be added (string)
+@param name name of class to be added
+@type str
 @param _class Class object to be added
+@type Class
 """
 if name in self.classes:
 self.classes_counts[name] += 1
 name = "{0}_{1:d}".format(name, self.classes_counts[name])
 else:
 def addModule(self, name, module):
 """
 Public method to add information about a Ruby module.
-@param name name of module to be added (string)
+@param name name of module to be added
+@type str
 @param module Module object to be added
+@type Module
 """
 if name in self.modules:
 self.modules_counts[name] += 1
 name = "{0}_{1:d}".format(name, self.modules_counts[name])
 else:
 def addFunction(self, name, function):
 """
 Public method to add information about a function.
-@param name name of function to be added (string)
+@param name name of function to be added
+@type str
 @param function Function object to be added
+@type Function
 """
 if name in self.functions:
 self.functions_counts[name] += 1
 name = "{0}_{1:d}".format(name, self.functions_counts[name])
 else:
 def addGlobal(self, name, attr):
 """
 Public method to add information about global variables.
-@param name name of the global to add (string)
+@param name name of the global to add
+@type str
 @param attr Attribute object to be added
+@type Attribute
 """
 if name not in self.globals:
 self.globals[name] = attr
 else:
 self.globals[name].addAssignment(attr.lineno)
 def addDescription(self, description):
 """
 Public method to store the modules docstring.
-@param description the docstring to be stored (string)
+@param description the docstring to be stored
+@type str
 """
 self.description = description
 def scan(self, src):
 """
 Public method to scan the source text and retrieve the relevant
 information.
-@param src the source text to be scanned (string)
+@param src the source text to be scanned
+@type str
 """
 # convert eol markers the Python style
 src = src.replace("\r\n", "\n").replace("\r", "\n")
 if self.type in [PY_SOURCE, PTL_SOURCE]:
 self.__py_scan(src)
 def __py_setVisibility(self, objectRef):
 """
 Private method to set the visibility of an object.
-@param objectRef reference to the object (Attribute, Class or Function)
+@param objectRef reference to the object
+@type Attribute, Class or Function
 """
 if objectRef.name.startswith("__"):
 objectRef.setPrivate()
 elif objectRef.name.startswith("_"):
 objectRef.setProtected()
 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)
+@param src the source text to be scanned
+@type str
 """  # __IGNORE_WARNING_D234__
 def calculateEndline(lineno, lines, indent):
 """
 Function to calculate the end line of a class or method/function.
 """
 Public method to build the inheritance hierarchy for all classes of
 this module.
 @return A dictionary with inheritance hierarchies.
+@rtype dict
 """
 hierarchy = {}
 for class_ in self.classes:
 self.assembleHierarchy(class_, self.classes, [class_], hierarchy)
 for module in self.modules:
 and build up a nested dictionary of super-classes. The result is
 intended to be inverted, i.e. the highest level are the super classes.
 This code is borrowed from Boa Constructor.
-@param name name of class to assemble hierarchy (string)
+@param name name of class to assemble hierarchy
+@type str
 @param classes A dictionary of classes to look in.
-@param path
+@type dict
+@param path path of classes
+@type list of str
 @param result The resultant hierarchy
+@type dict
 """
 rv = {}
 if name in classes:
 for class_ in classes[name].super:
 if class_ not in classes:
 def addPathToHierarchy(self, path, result, fn):
 """
 Public method to put the exhausted path into the result dictionary.
 @param path the exhausted path of classes
+@type list of str
 @param result the result dictionary
+@type dict
 @param fn function to call for classe that are already part of the
 result dictionary
+@type function
 """
 if path[0] in result:
 if len(path) > 1:
 fn(path[1:], result[path[0]], fn)
 else:
 def getName(self):
 """
 Public method to retrieve the modules name.
-@return module name (string)
+@return module name
+@rtype str
 """
 return self.name
 def getFileName(self):
 """
 Public method to retrieve the modules filename.
-@return module filename (string)
+@return module filename
+@rtype str
 """
 return self.file
 def getType(self):
 """
 Public method to get the type of the module's source.
-@return type of the modules's source (string)
+@return type of the modules's source
+@rtype str
 """
 if self.type in [PY_SOURCE, PTL_SOURCE]:
 moduleType = "Python3"
 elif self.type == RB_SOURCE:
 moduleType = "Ruby"
 def __init__(self, module, name, superClasses, file, lineno):
 """
 Constructor
-@param module name of module containing this class (string)
+@param module name of module containing this class
-@param name name of the class (string)
+@type str
+@param name name of the class
+@type str
 @param superClasses list of classnames this class is inherited from
-(list of strings)
+@type list of str
-@param file name of file containing this class (string)
+@param file name of file containing this class
-@param lineno linenumber of the class definition (integer)
+@type str
+@param lineno linenumber of the class definition
+@type int
 """
 self.module = module
 self.name = name
 if superClasses is None:
 superClasses = []
 def addMethod(self, name, function):
 """
 Public method to add information about a method.
-@param name name of method to be added (string)
+@param name name of method to be added
+@type str
 @param function Function object to be added
+@type Function
 """
 self.methods[name] = function
 def getMethod(self, name):
 """
 Public method to retrieve a method by name.
-@param name name of the method (string)
+@param name name of the method
+@type str
 @return the named method or None
+@rtype Function
 """
 try:
 return self.methods[name]
 except KeyError:
 return None
 def addAttribute(self, name, attr):
 """
 Public method to add information about attributes.
-@param name name of the attribute to add (string)
+@param name name of the attribute to add
+@type str
 @param attr Attribute object to be added
+@type Attribute
 """
 if name not in self.attributes:
 self.attributes[name] = attr
 else:
 self.attributes[name].addAssignment(attr.lineno)
 def getAttribute(self, name):
 """
 Public method to retrieve an attribute by name.
-@param name name of the attribute (string)
+@param name name of the attribute
+@type str
 @return the named attribute or None
+@rtype Attribute
 """
 try:
 return self.attributes[name]
 except KeyError:
 return None
 def addGlobal(self, name, attr):
 """
 Public method to add information about global (class) variables.
-@param name name of the global to add (string)
+@param name name of the global to add
+@type str
 @param attr Attribute object to be added
+@type Attribute
 """
 if name not in self.globals:
 self.globals[name] = attr
 else:
 self.globals[name].addAssignment(attr.lineno)
 def addDescription(self, description):
 """
 Public method to store the class docstring.
-@param description the docstring to be stored (string)
+@param description the docstring to be stored
+@type str
 """
 self.description = description
 def setEndLine(self, endLineNo):
 """
 Public method to record the number of the last line of a class.
-@param endLineNo number of the last line (integer)
+@param endLineNo number of the last line
+@type int
 """
 self.endlineno = endLineNo
 class RbModule(Class):
 def __init__(self, module, name, file, lineno):
 """
 Constructor
-@param module name of module containing this class (string)
+@param module name of module containing this class
-@param name name of the class (string)
+@type str
-@param file name of file containing this class (string)
+@param name name of the class
-@param lineno linenumber of the class definition (integer)
+@type str
+@param file name of file containing this class
+@type str
+@param lineno linenumber of the class definition
+@type int
 """
 Class.__init__(self, module, name, None, file, lineno)
 self.classes = {}
 def addClass(self, name, _class):
 """
 Public method to add information about a class.
-@param name name of class to be added (string)
+@param name name of class to be added
+@type str
 @param _class Class object to be added
+@type Class
 """
 self.classes[name] = _class
 class Function(VisibilityBase):
 annotation="",
 ):
 """
 Constructor
-@param module name of module containing this function (string)
+@param module name of module containing this function
-@param name name of the function (string)
+@type str
-@param file name of file containing this function (string)
+@param name name of the function
-@param lineno linenumber of the function definition (integer)
+@type str
-@param signature the functions call signature (string)
+@param file name of file containing this function
-@param pyqtSignature the functions PyQt signature (string)
+@type str
+@param lineno linenumber of the function definition
+@type int
+@param signature the functions call signature
+@type str
+@param pyqtSignature the functions PyQt signature
+@type str
 @param modifierType type of the function
+@type int
 @param annotation return annotation
+@type str
 """
 self.module = module
 self.name = name
 self.file = file
 self.lineno = lineno
 def addDescription(self, description):
 """
 Public method to store the functions docstring.
-@param description the docstring to be stored (string)
+@param description the docstring to be stored
+@type str
 """
 self.description = description
 def setEndLine(self, endLineNo):
 """
 Public method to record the number of the last line of a class.
-@param endLineNo number of the last line (integer)
+@param endLineNo number of the last line
+@type int
 """
 self.endlineno = endLineNo
 class Attribute(VisibilityBase):
 def __init__(self, module, name, file, lineno, isSignal=False):
 """
 Constructor
-@param module name of module containing this function (string)
+@param module name of module containing this function
-@param name name of the function (string)
+@type str
-@param file name of file containing this function (string)
+@param name name of the function
-@param lineno linenumber of the first attribute assignment (integer)
+@type str
-@param isSignal flag indicating a signal definition (boolean)
+@param file name of file containing this function
+@type str
+@param lineno linenumber of the first attribute assignment
+@type int
+@param isSignal flag indicating a signal definition
+@type bool
 """
 self.module = module
 self.name = name
 self.file = file
 self.lineno = lineno
 def addAssignment(self, lineno):
 """
 Public method to add another assignment line number.
 @param lineno linenumber of the additional attribute assignment
-(integer)
+@type int
 """
 if lineno not in self.linenos:
 self.linenos.append(lineno)
 The module is searched in path and sys.path, read and parsed.
 If the module was parsed before, the information is taken
 from a cache in order to speed up processing.
-@param module name of the module to be parsed (string)
+@param module name of the module to be parsed
-@param path search path for the module (list of strings)
+@type str
+@param path search path for the module
+@type list of str
 @param inpackage flag indicating that module is inside a
-package (boolean)
+package
+@type bool
 @param basename a path basename that is deleted from the filename of
-the module file to be read (string)
+the module file to be read
+@type str
 @param extensions list of extensions, which should be considered valid
-source file extensions (list of strings)
+source file extensions
+@type list of str
 @param caching flag indicating that the parsed module should be
-cached (boolean)
+cached
+@type bool
 @param ignoreBuiltinModules flag indicating to ignore the builtin modules
-(boolean)
+@type bool
 @return reference to a Module object containing the parsed
-module information (Module)
+module information
+@rtype Module
 """
 global _modules
 _extensions = (
 [".py", ".pyw", ".pyi", ".ptl", ".rb"] if extensions is None else extensions[:]
 def _indent(ws):
 """
 Protected function to determine the indent width of a whitespace string.
-@param ws The whitespace string to be cheked. (string)
+@param ws The whitespace string to be cheked.
-@return Length of the whitespace string after tab expansion.
+@type str
+@return length of the whitespace string after tab expansion
+@rtype int
 """
 return len(ws.expandtabs(TABWIDTH))
 def find_module(name, path, extensions):
 This function searches for files in the given path. If the filename
 doesn't have an extension or an extension of .py, the normal search
 implemented in the imp module is used. For all other supported files
 only path is searched.
-@param name filename or modulename to search for (string)
+@param name filename or modulename to search for
-@param path search path (list of strings)
+@type str
+@param path search path
+@type list of str
 @param extensions list of extensions, which should be considered valid
-source file extensions (list of strings)
+source file extensions
+@type list of str
 @return tuple of the open file, pathname and description. Description
 is a tuple of file suffix, file mode and file type)
+@rtype tuple
 @exception ImportError The file or module wasn't found.
 """
 for ext in extensions:
 if name.lower().endswith(ext):
 for p in path:  # only search in path
 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 module Name of the module to be parsed
+@type str
 @param basename a path basename. This basename is deleted from
-the filename of the module file to be cleared. (string)
+the filename of the module file to be cleared.
+@type str
 """
 modname = module
 if os.path.exists(module):
 modulePath = [os.path.dirname(module)]

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Utilities/ModuleParser.py

src/eric7/Utilities/ModuleParser.py