eric: comparison DocumentationTools/ModuleDocumentor.py

-:0e5421d679e7
+:ea526b78ee6c
 else:
 rbModulesSection = ""
 return "{0}{1}{2}{3}".format(
 modBody, classesSection, rbModulesSection, functionsSection)
-def __genListSection(self, names, dict, kwSuffix=""):
+def __genListSection(self, names, sectionDict, kwSuffix=""):
 """
 Private method to generate a list section of the document.
 @param names The names to appear in the list. (list of strings)
-@param dict A dictionary containing all relevant information.
+@param sectionDict dictionary containing all relevant information
+(dict)
 @param kwSuffix suffix to be used for the QtHelp keywords (string)
-@return The list section. (string)
+@return list section (string)
 """
 lst = []
 for name in names:
 lst.append(self.listEntryTemplate.format(
 **{'Link': "{0}".format(name),
-'Name': dict[name].name,
+'Name': sectionDict[name].name,
 'Description':
-self.__getShortDescription(dict[name].description),
+self.__getShortDescription(sectionDict[name].description),
 'Deprecated':
-self.__checkDeprecated(dict[name].description) and
+self.__checkDeprecated(sectionDict[name].description) and
 self.listEntryDeprecatedTemplate or "",
 }))
 if kwSuffix:
 n = "{0} ({1})".format(name, kwSuffix)
 else:
 attrNames = []
 if class_ is not None:
 scope = class_
 else:
 scope = self.module
-attrNames = sorted([attr for attr in scope.globals.keys()
+attrNames = sorted(attr for attr in scope.globals.keys()
-if not scope.globals[attr].isSignal])
+if not scope.globals[attr].isSignal)
 if attrNames:
 s = ''.join(
 [self.listEntrySimpleTemplate.format(**{'Name': name})
 for name in attrNames])
 else:
 classes.append(clsBody)
 return ''.join(classes)
-def __genMethodsListSection(self, names, dict, className, clsName,
+def __genMethodsListSection(self, names, sectionDict, className, clsName,
 includeInit=True):
 """
 Private method to generate the methods list section of a class.
 @param names names to appear in the list (list of strings)
-@param dict dictionary containing all relevant information
+@param sectionDict dictionary containing all relevant information
+(dict)
 @param className class name containing the names
 @param clsName visible class name containing the names
 @param includeInit flag indicating to include the __init__ method
 (boolean)
 @return methods list section (string)
 try:
 lst.append(self.listEntryTemplate.format(
 **{'Link': "{0}.{1}".format(className, '__init__'),
 'Name': clsName,
 'Description': self.__getShortDescription(
-dict['__init__'].description),
+sectionDict['__init__'].description),
 'Deprecated': self.__checkDeprecated(
-dict['__init__'].description) and
+sectionDict['__init__'].description) and
 self.listEntryDeprecatedTemplate or "",
 }))
 self.keywords.append(
 ("{0} (Constructor)".format(className),
 "#{0}.{1}".format(className, '__init__')))
 pass
 for name in names:
 lst.append(self.listEntryTemplate.format(
 **{'Link': "{0}.{1}".format(className, name),
-'Name': dict[name].name,
+'Name': sectionDict[name].name,
 'Description':
-self.__getShortDescription(dict[name].description),
+self.__getShortDescription(sectionDict[name].description),
 'Deprecated':
-self.__checkDeprecated(dict[name].description) and
+self.__checkDeprecated(sectionDict[name].description) and
 self.listEntryDeprecatedTemplate or "",
 }))
 self.keywords.append(("{0}.{1}".format(className, name),
 "#{0}.{1}".format(className, name)))
 return ''.join(lst)
-def __genMethodSection(self, obj, className, filter):
+def __genMethodSection(self, obj, className, modifierFilter):
 """
 Private method to generate the method details section.
 @param obj reference to the object being formatted
 @param className name of the class containing the method (string)
-@param filter filter value designating the method types
+@param modifierFilter filter value designating the method types
 @return method list and method details section (tuple of two string)
 """
 methList = []
 methBodies = []
-methods = sorted([k for k in obj.methods.keys()
+methods = sorted(k for k in obj.methods.keys()
-if obj.methods[k].modifier == filter])
+if obj.methods[k].modifier == modifierFilter)
 if '__init__' in methods:
 methods.remove('__init__')
 try:
 methBody = self.constructorTemplate.format(
 **{'Anchor': className,
 className, '__init__'))
 sys.stderr.write("{0}\n".format(e))
 methBody = ""
 methBodies.append(methBody)
-if filter == Function.Class:
+if modifierFilter == Function.Class:
 methodClassifier = " (class method)"
-elif filter == Function.Static:
+elif modifierFilter == Function.Static:
 methodClassifier = " (static)"
 else:
 methodClassifier = ""
 for method in methods:
 try:
 methBody = ""
 methBodies.append(methBody)
 methList = self.__genMethodsListSection(
 methods, obj.methods, className, obj.name,
-includeInit=filter == Function.General)
+includeInit=modifierFilter == Function.General)
 if not methList:
 methList = self.listEntryNoneTemplate
 return (self.listTemplate.format(**{'Entries': methList}),
 ''.join(methBodies))
 if not classesList:
 classesList = self.listEntryNoneTemplate
 return (self.listTemplate.format(**{'Entries': classesList}),
 ''.join(classes))
-def __genRbModulesClassesListSection(self, names, dict, moduleName):
+def __genRbModulesClassesListSection(self, names, sectionDict, moduleName):
 """
 Private method to generate the classes list section of a Ruby module.
 @param names The names to appear in the list. (list of strings)
-@param dict A dictionary containing all relevant information.
+@param sectionDict dictionary containing all relevant information
-@param moduleName Name of the Ruby module containing the classes.
+(dict)
+@param moduleName name of the Ruby module containing the classes
 (string)
 @return The list section. (string)
 """
 lst = []
 for name in names:
 lst.append(self.listEntryTemplate.format(
 **{'Link': "{0}.{1}".format(moduleName, name),
-'Name': dict[name].name,
+'Name': sectionDict[name].name,
 'Description':
-self.__getShortDescription(dict[name].description),
+self.__getShortDescription(sectionDict[name].description),
 'Deprecated':
-self.__checkDeprecated(dict[name].description) and
+self.__checkDeprecated(sectionDict[name].description) and
 self.listEntryDeprecatedTemplate or "",
 }))
 self.keywords.append(("{0}.{1}".format(moduleName, name),
 "#{0}.{1}".format(moduleName, name)))
 return ''.join(lst)

Mercurial Repositories > eric / file comparison

comparison: DocumentationTools/ModuleDocumentor.py

DocumentationTools/ModuleDocumentor.py