eric: comparison DocumentationTools/ModuleDocumentor.py

-:254ec677c775
+:c5db073a124f
 from . import TemplatesListsStyle
 from . import TemplatesListsStyleCSS
 from Utilities import html_uencode
-from Utilities.ModuleParser import RB_SOURCE
+from Utilities.ModuleParser import RB_SOURCE, Function
 _signal = re.compile(r"""
 ^@signal [ \t]+
 (?P<SignalName1>
 [a-zA-Z_] \w* [ \t]* \( [^)]* \)
 supers = ', '.join(supers)
 else:
 supers = 'None'
 globalsList = self.__genGlobalsListSection(_class)
-methList, methBodies = self.__genMethodSection(_class, className)
+classMethList, classMethBodies = \
+self.__genMethodSection(_class, className, Function.Class)
+methList, methBodies = \
+self.__genMethodSection(_class, className, Function.General)
+staticMethList, staticMethBodies = \
+self.__genMethodSection(_class, className, Function.Static)
 try:
 clsBody = self.classTemplate.format(**{ \
 'Anchor': className,
 'Class': _class.name,
 'ClassSuper': supers,
 'ClassDescription': self.__formatDescription(_class.description),
 'GlobalsList': globalsList,
+'ClassMethodList': classMethList,
 'MethodList': methList,
-'MethodDetails': methBodies,
+'StaticMethodList': staticMethList,
+'MethodDetails': classMethBodies + methBodies + staticMethBodies,
 })
 except TagError as e:
 sys.stderr.write("Error in tags of description of class {0}.\n".format(
 className))
 sys.stderr.write("{0}\n".format(e))
 classes.append(clsBody)
 return ''.join(classes)
-def __genMethodsListSection(self, names, dict, className, clsName):
+def __genMethodsListSection(self, names, dict, className, clsName,
+includeInit=True):
 """
 Private method to generate the methods list section of a class.
-@param names The names to appear in the list. (list of strings)
+@param names names to appear in the list (list of strings)
-@param dict A dictionary containing all relevant information.
+@param dict dictionary containing all relevant information
-@param className The class name containing the names.
+@param className class name containing the names
-@param clsName The visible class name containing the names.
+@param clsName visible class name containing the names
-@return The list section. (string)
+@param includeInit flag indicating to include the __init__ method (boolean)
+@return methods list section (string)
 """
 lst = []
-try:
+if includeInit:
-lst.append(self.listEntryTemplate.format(**{ \
+try:
-'Link': "{0}.{1}".format(className, '__init__'),
+lst.append(self.listEntryTemplate.format(**{ \
-'Name': clsName,
+'Link': "{0}.{1}".format(className, '__init__'),
-'Description': self.__getShortDescription(dict['__init__'].description),
+'Name': clsName,
-'Deprecated': self.__checkDeprecated(dict['__init__'].description) and \
+'Description': self.__getShortDescription(dict['__init__'].description),
-self.listEntryDeprecatedTemplate or "",
+'Deprecated': self.__checkDeprecated(dict['__init__'].description) and \
-}))
+self.listEntryDeprecatedTemplate or "",
-self.keywords.append(("{0} (Constructor)".format(className),
+}))
-"#{0}.{1}".format(className, '__init__')))
+self.keywords.append(("{0} (Constructor)".format(className),
-except KeyError:
+"#{0}.{1}".format(className, '__init__')))
-pass
+except KeyError:
+pass
 for name in names:
 lst.append(self.listEntryTemplate.format(**{ \
 'Link': "{0}.{1}".format(className, name),
 'Name': dict[name].name,
 'Description': self.__getShortDescription(dict[name].description),
 }))
 self.keywords.append(("{0}.{1}".format(className, name),
 "#{0}.{1}".format(className, name)))
 return ''.join(lst)
-def __genMethodSection(self, obj, className):
+def __genMethodSection(self, obj, className, filter):
 """
 Private method to generate the method details section.
-@param obj Reference to the object being formatted.
+@param obj reference to the object being formatted
-@param className Name of the class containing the method. (string)
+@param className name of the class containing the method (string)
-@return The method list and method details section. (tuple of two string)
+@param filter filter value designating the method types
+@return method list and method details section (tuple of two string)
 """
 methList = []
 methBodies = []
-methods = sorted(list(obj.methods.keys()))
+methods = sorted([k for k in obj.methods.keys()
+if obj.methods[k].modifier == filter])
 if '__init__' in methods:
 methods.remove('__init__')
 try:
 methBody = self.constructorTemplate.format(**{ \
 'Anchor': className,
 "Error in tags of description of method {0}.{1}.\n".format(
 className, '__init__'))
 sys.stderr.write("{0}\n".format(e))
 methBody = ""
 methBodies.append(methBody)
+if filter == Function.Class:
+methodClassifier = " (class method)"
+elif filter == Function.Static:
+methodClassifier = " (static)"
+else:
+methodClassifier = ""
 for method in methods:
 try:
 methBody = self.methodTemplate.format(**{ \
 'Anchor': className,
 'Class': obj.name,
 'Method': obj.methods[method].name,
+'MethodClassifier': methodClassifier,
 'MethodDescription': \
 self.__formatDescription(obj.methods[method].description),
 'Params': ', '.join(obj.methods[method].parameters[1:]),
 })
 except TagError as e:
 className, method))
 sys.stderr.write("{0}\n".format(e))
 methBody = ""
 methBodies.append(methBody)
-methList = self.__genMethodsListSection(methods, obj.methods, className, obj.name)
+methList = self.__genMethodsListSection(methods, obj.methods, className,
+obj.name, includeInit='__init__' in methods)
 if not methList:
 methList = self.listEntryNoneTemplate
 return self.listTemplate.format(**{ \
 'Entries': methList,
 rbModulesNames = sorted(list(self.module.modules.keys()))
 rbModules = []
 for rbModuleName in rbModulesNames:
 rbModule = self.module.modules[rbModuleName]
 globalsList = self.__genGlobalsListSection(rbModule)
-methList, methBodies = self.__genMethodSection(rbModule, rbModuleName)
+methList, methBodies = \
+self.__genMethodSection(rbModule, rbModuleName, Function.General)
 classList, classBodies = \
 self.__genRbModulesClassesSection(rbModule, rbModuleName)
 try:
 rbmBody = self.rbModuleTemplate.format(**{ \
 if len(supers) > 0:
 supers = ', '.join(supers)
 else:
 supers = 'None'
-methList, methBodies = self.__genMethodSection(_class, className)
+methList, methBodies = \
+self.__genMethodSection(_class, className, Function.General)
 try:
 clsBody = self.rbModulesClassTemplate.format(**{ \
 'Anchor': className,
 'Class': _class.name,

Mercurial Repositories > eric / file comparison

comparison: DocumentationTools/ModuleDocumentor.py

DocumentationTools/ModuleDocumentor.py