eric: comparison eric7/DocumentationTools/ModuleDocumentor.py

-:57cdd880326b
+:0460087da31b
 """
 def __init__(self, module):
 """
 Constructor
-@param outputDir The output directory for the files
+@param module information of the parsed Python file
 @type str
 """
 self.module = module
 self.empty = True
-# TODO: replace these assignments
-self.headerTemplate = TemplatesListsStyleCSS.headerTemplate
-self.footerTemplate = TemplatesListsStyleCSS.footerTemplate
-self.moduleTemplate = TemplatesListsStyleCSS.moduleTemplate
-self.rbFileTemplate = TemplatesListsStyleCSS.rbFileTemplate
-self.classTemplate = TemplatesListsStyleCSS.classTemplate
-self.methodTemplate = TemplatesListsStyleCSS.methodTemplate
-self.constructorTemplate = (
-TemplatesListsStyleCSS.constructorTemplate)
-self.rbModuleTemplate = TemplatesListsStyleCSS.rbModuleTemplate
-self.rbModulesClassTemplate = (
-TemplatesListsStyleCSS.rbModulesClassTemplate)
-self.functionTemplate = TemplatesListsStyleCSS.functionTemplate
-self.listTemplate = TemplatesListsStyleCSS.listTemplate
-self.listEntryTemplate = TemplatesListsStyleCSS.listEntryTemplate
-self.listEntryNoneTemplate = (
-TemplatesListsStyleCSS.listEntryNoneTemplate)
-self.listEntryDeprecatedTemplate = (
-TemplatesListsStyleCSS.listEntryDeprecatedTemplate)
-self.listEntrySimpleTemplate = (
-TemplatesListsStyleCSS.listEntrySimpleTemplate)
-self.paragraphTemplate = TemplatesListsStyleCSS.paragraphTemplate
-self.parametersListTemplate = (
-TemplatesListsStyleCSS.parametersListTemplate)
-self.parameterTypesListEntryTemplate = (
-TemplatesListsStyleCSS.parameterTypesListEntryTemplate)
-self.parametersListEntryTemplate = (
-TemplatesListsStyleCSS.parametersListEntryTemplate)
-self.returnsTemplate = TemplatesListsStyleCSS.returnsTemplate
-self.returnTypesTemplate = (
-TemplatesListsStyleCSS.returnTypesTemplate)
-self.yieldsTemplate = TemplatesListsStyleCSS.yieldsTemplate
-self.yieldTypesTemplate = (
-TemplatesListsStyleCSS.yieldTypesTemplate)
-self.exceptionsListTemplate = (
-TemplatesListsStyleCSS.exceptionsListTemplate)
-self.exceptionsListEntryTemplate = (
-TemplatesListsStyleCSS.exceptionsListEntryTemplate)
-self.signalsListTemplate = (
-TemplatesListsStyleCSS.signalsListTemplate)
-self.signalsListEntryTemplate = (
-TemplatesListsStyleCSS.signalsListEntryTemplate)
-self.eventsListTemplate = TemplatesListsStyleCSS.eventsListTemplate
-self.eventsListEntryTemplate = (
-TemplatesListsStyleCSS.eventsListEntryTemplate)
-self.deprecatedTemplate = TemplatesListsStyleCSS.deprecatedTemplate
-self.authorInfoTemplate = TemplatesListsStyleCSS.authorInfoTemplate
-self.seeListTemplate = TemplatesListsStyleCSS.seeListTemplate
-self.seeListEntryTemplate = (
-TemplatesListsStyleCSS.seeListEntryTemplate)
-self.seeLinkTemplate = TemplatesListsStyleCSS.seeLinkTemplate
-self.sinceInfoTemplate = TemplatesListsStyleCSS.sinceInfoTemplate
 self.keywords = []
 # list of tuples containing the name (string) and
 # the ref (string). The ref is without the filename part.
 self.generated = False
 Public method to generate the source code documentation.
 @return The source code documentation. (string)
 """
 doc = (
-self.headerTemplate.format(
+TemplatesListsStyleCSS.headerTemplate.format(
 **{'Title': self.module.name}
 ) +
 self.__genModuleSection() +
-self.footerTemplate
+TemplatesListsStyleCSS.footerTemplate
 )
 self.generated = True
 return doc
 def __genModuleSection(self):
 classList = self.__genClassListSection()
 functionList = self.__genFunctionListSection()
 try:
 if self.module.type == RB_SOURCE:
 rbModulesList = self.__genRbModulesListSection()
-modBody = self.rbFileTemplate.format(
+modBody = TemplatesListsStyleCSS.rbFileTemplate.format(
 **{'Module': self.module.name,
 'ModuleDescription':
 self.__formatDescription(self.module.description),
 'GlobalsList': globalsList,
 'ClassList': classList,
 'RbModulesList': rbModulesList,
 'FunctionList': functionList,
 })
 else:
-modBody = self.moduleTemplate.format(
+modBody = TemplatesListsStyleCSS.moduleTemplate.format(
 **{'Module': self.module.name,
 'ModuleDescription':
 self.__formatDescription(self.module.description),
 'GlobalsList': globalsList,
 'ClassList': classList,
 @param kwSuffix suffix to be used for the QtHelp keywords (string)
 @return list section (string)
 """
 lst = []
 for name in names:
-lst.append(self.listEntryTemplate.format(
+lst.append(TemplatesListsStyleCSS.listEntryTemplate.format(
 **{'Link': "{0}".format(name),
 'Name': sectionDict[name].name,
 'Description':
 self.__getShortDescription(sectionDict[name].description),
 'Deprecated':
 self.__checkDeprecated(sectionDict[name].description) and
-self.listEntryDeprecatedTemplate or "",
+TemplatesListsStyleCSS.listEntryDeprecatedTemplate or "",
 }))
 n = ("{0} ({1})".format(name, kwSuffix) if kwSuffix
 else "{0}".format(name))
 self.keywords.append((n, "#{0}".format(name)))
 return ''.join(lst)
 scope = class_ if class_ is not None else self.module
 attrNames = sorted(attr for attr in scope.globals.keys()
 if not scope.globals[attr].isSignal)
 s = (
 ''.join(
-[self.listEntrySimpleTemplate.format(**{'Name': name})
+[TemplatesListsStyleCSS.listEntrySimpleTemplate
-for name in attrNames])
+.format(**{'Name': name}) for name in attrNames])
 if attrNames else
-self.listEntryNoneTemplate
+TemplatesListsStyleCSS.listEntryNoneTemplate
 )
-return self.listTemplate.format(**{'Entries': s})
+return TemplatesListsStyleCSS.listTemplate.format(**{'Entries': s})
 def __genClassListSection(self):
 """
 Private method to generate the section listing all classes of the
 module.
 names = sorted(list(self.module.classes.keys()))
 if names:
 self.empty = False
 s = self.__genListSection(names, self.module.classes)
 else:
-s = self.listEntryNoneTemplate
+s = TemplatesListsStyleCSS.listEntryNoneTemplate
-return self.listTemplate.format(**{'Entries': s})
+return TemplatesListsStyleCSS.listTemplate.format(**{'Entries': s})
 def __genRbModulesListSection(self):
 """
 Private method to generate the section listing all modules of the file
 (Ruby only).
 names = sorted(list(self.module.modules.keys()))
 if names:
 self.empty = False
 s = self.__genListSection(names, self.module.modules)
 else:
-s = self.listEntryNoneTemplate
+s = TemplatesListsStyleCSS.listEntryNoneTemplate
-return self.listTemplate.format(**{'Entries': s})
+return TemplatesListsStyleCSS.listTemplate.format(**{'Entries': s})
 def __genFunctionListSection(self):
 """
 Private method to generate the section listing all functions of the
 module.
 names = sorted(list(self.module.functions.keys()))
 if names:
 self.empty = False
 s = self.__genListSection(names, self.module.functions)
 else:
-s = self.listEntryNoneTemplate
+s = TemplatesListsStyleCSS.listEntryNoneTemplate
-return self.listTemplate.format(**{'Entries': s})
+return TemplatesListsStyleCSS.listTemplate.format(**{'Entries': s})
 def __genClassesSection(self):
 """
 Private method to generate the document section with details about
 classes.
 _class, className, Function.General)
 staticMethList, staticMethBodies = self.__genMethodSection(
 _class, className, Function.Static)
 try:
-clsBody = self.classTemplate.format(
+clsBody = TemplatesListsStyleCSS.classTemplate.format(
 **{'Anchor': className,
 'Class': _class.name,
 'ClassSuper': supers,
 'ClassDescription':
 self.__formatDescription(_class.description),
 @return methods list section (string)
 """
 lst = []
 if includeInit:
 with contextlib.suppress(KeyError):
-lst.append(self.listEntryTemplate.format(
+lst.append(TemplatesListsStyleCSS.listEntryTemplate.format(
 **{'Link': "{0}.{1}".format(className, '__init__'),
 'Name': clsName,
 'Description': self.__getShortDescription(
 sectionDict['__init__'].description),
 'Deprecated': self.__checkDeprecated(
 sectionDict['__init__'].description) and
-self.listEntryDeprecatedTemplate or "",
+TemplatesListsStyleCSS.listEntryDeprecatedTemplate or
+"",
 }))
 self.keywords.append(
 ("{0} (Constructor)".format(className),
 "#{0}.{1}".format(className, '__init__')))
 for name in names:
-lst.append(self.listEntryTemplate.format(
+lst.append(TemplatesListsStyleCSS.listEntryTemplate.format(
 **{'Link': "{0}.{1}".format(className, name),
 'Name': sectionDict[name].name,
 'Description':
 self.__getShortDescription(sectionDict[name].description),
 'Deprecated':
 self.__checkDeprecated(sectionDict[name].description) and
-self.listEntryDeprecatedTemplate or "",
+TemplatesListsStyleCSS.listEntryDeprecatedTemplate or "",
 }))
 self.keywords.append(("{0}.{1}".format(className, name),
 "#{0}.{1}".format(className, name)))
 return ''.join(lst)
 methods = sorted(k for k in obj.methods.keys()
 if obj.methods[k].modifier == modifierFilter)
 if '__init__' in methods:
 methods.remove('__init__')
 try:
-methBody = self.constructorTemplate.format(
+methBody = TemplatesListsStyleCSS.constructorTemplate.format(
 **{'Anchor': className,
 'Class': obj.name,
 'Method': '__init__',
 'MethodDescription':
 self.__formatDescription(
 methodClassifier = " (static)"
 else:
 methodClassifier = ""
 for method in methods:
 try:
-methBody = self.methodTemplate.format(
+methBody = TemplatesListsStyleCSS.methodTemplate.format(
 **{'Anchor': className,
 'Class': obj.name,
 'Method': obj.methods[method].name,
 'MethodClassifier': methodClassifier,
 'MethodDescription':
 methList = self.__genMethodsListSection(
 methods, obj.methods, className, obj.name,
 includeInit=modifierFilter == Function.General)
 if not methList:
-methList = self.listEntryNoneTemplate
+methList = TemplatesListsStyleCSS.listEntryNoneTemplate
-return (self.listTemplate.format(**{'Entries': methList}),
+return (TemplatesListsStyleCSS.listTemplate
-''.join(methBodies))
+.format(**{'Entries': methList}), ''.join(methBodies))
 def __genRbModulesSection(self):
 """
 Private method to generate the document section with details about
 Ruby modules.
 rbModule, rbModuleName, Function.General)
 classList, classBodies = self.__genRbModulesClassesSection(
 rbModule, rbModuleName)
 try:
-rbmBody = self.rbModuleTemplate.format(
+rbmBody = TemplatesListsStyleCSS.rbModuleTemplate.format(
 **{'Anchor': rbModuleName,
 'Module': rbModule.name,
 'ModuleDescription':
 self.__formatDescription(rbModule.description),
 'GlobalsList': globalsList,
 methList, methBodies = self.__genMethodSection(
 _class, className, Function.General)
 try:
-clsBody = self.rbModulesClassTemplate.format(
+clsBody = TemplatesListsStyleCSS.rbModulesClassTemplate.format(
 **{'Anchor': className,
 'Class': _class.name,
 'ClassSuper': supers,
 'ClassDescription':
 self.__formatDescription(_class.description),
 classesList = self.__genRbModulesClassesListSection(
 classNames, obj.classes, modName)
 if not classesList:
-classesList = self.listEntryNoneTemplate
+classesList = TemplatesListsStyleCSS.listEntryNoneTemplate
-return (self.listTemplate.format(**{'Entries': classesList}),
+return (TemplatesListsStyleCSS.listTemplate
-''.join(classes))
+.format(**{'Entries': classesList}), ''.join(classes))
 def __genRbModulesClassesListSection(self, names, sectionDict, moduleName):
 """
 Private method to generate the classes list section of a Ruby module.
 (string)
 @return The list section. (string)
 """
 lst = []
 for name in names:
-lst.append(self.listEntryTemplate.format(
+lst.append(TemplatesListsStyleCSS.listEntryTemplate.format(
 **{'Link': "{0}.{1}".format(moduleName, name),
 'Name': sectionDict[name].name,
 'Description':
 self.__getShortDescription(sectionDict[name].description),
 'Deprecated':
 self.__checkDeprecated(sectionDict[name].description) and
-self.listEntryDeprecatedTemplate or "",
+TemplatesListsStyleCSS.listEntryDeprecatedTemplate or "",
 }))
 self.keywords.append(("{0}.{1}".format(moduleName, name),
 "#{0}.{1}".format(moduleName, name)))
 return ''.join(lst)
 """
 funcBodies = []
 funcNames = sorted(list(self.module.functions.keys()))
 for funcName in funcNames:
 try:
-funcBody = self.functionTemplate.format(
+funcBody = TemplatesListsStyleCSS.functionTemplate.format(
 **{'Anchor': funcName,
 'Function': self.module.functions[funcName].name,
 'FunctionDescription': self.__formatDescription(
 self.module.functions[funcName].description),
 'Params':
 if line == '.':
 linelist.append("")
 else:
 linelist.append(html_uencode(line))
 else:
-lst.append(self.paragraphTemplate.format(
+lst.append(TemplatesListsStyleCSS.paragraphTemplate.format(
 **{'Lines': '\n'.join(linelist)}))
 linelist = []
 if linelist:
-lst.append(self.paragraphTemplate.format(
+lst.append(TemplatesListsStyleCSS.paragraphTemplate.format(
 **{'Lines': '\n'.join(linelist)}))
 return ''.join(lst)
 def __genDescriptionListSection(self, dictionary, template):
 """
 @return formatted list section (string)
 """
 lst = []
 for name, type_, lines in _list:
 if type_:
-lst.append(self.parameterTypesListEntryTemplate.format(
+lst.append(
-**{'Name': name,
+TemplatesListsStyleCSS.parameterTypesListEntryTemplate
-'Type': type_,
+.format(
-'Description': html_uencode('\n'.join(lines)),
+**{'Name': name,
-}))
+'Type': type_,
+'Description': html_uencode('\n'.join(lines)),
+}
+)
+)
 else:
-lst.append(self.parametersListEntryTemplate.format(
+lst.append(
-**{'Name': name,
+TemplatesListsStyleCSS.parametersListEntryTemplate.format(
-'Description': html_uencode('\n'.join(lines)),
+**{'Name': name,
-}))
+'Description': html_uencode('\n'.join(lines)),
+}
+)
+)
 return ''.join(lst)
 def __formatCrossReferenceEntry(self, entry):
 """
 Private method to format a cross reference entry.
 reference = path and "{0}.html".format(path) or ''
 if anchor:
 reference = "{0}#{1}".format(reference, anchor)
 entry = 'href="{0}">{1}</a>'.format(reference, label)
-return self.seeLinkTemplate.format(**{'Link': entry})
+return TemplatesListsStyleCSS.seeLinkTemplate.format(**{'Link': entry})
 def __genSeeListSection(self, _list, template):
 """
 Private method to generate the "see also" list section of a
 description.
 lastItem.append(ditem)
 description = self.__genParagraphs(paragraphs) if paragraphs else ""
 parameterSect = (
-self.parametersListTemplate.format(
+TemplatesListsStyleCSS.parametersListTemplate.format(
 **{'Parameters': self.__genParamDescriptionListSection(
 paramList)})
 if paramList else
 ""
 )
 returnSect = (
-self.returnsTemplate.format(
+TemplatesListsStyleCSS.returnsTemplate.format(
 html_uencode('\n'.join(returns)))
 if returns else
 ""
 )
 returnTypesSect = (
-self.returnTypesTemplate.format(
+TemplatesListsStyleCSS.returnTypesTemplate.format(
 html_uencode('\n'.join(returnTypes)))
 if returnTypes else
 ""
 )
 yieldSect = (
-self.yieldsTemplate.format(
+TemplatesListsStyleCSS.yieldsTemplate.format(
 html_uencode('\n'.join(yields)))
 if yields else
 ""
 )
 yieldTypesSect = (
-self.yieldTypesTemplate.format(
+TemplatesListsStyleCSS.yieldTypesTemplate.format(
 html_uencode('\n'.join(yieldTypes)))
 if yieldTypes else
 ""
 )
 exceptionSect = (
-self.exceptionsListTemplate.format(
+TemplatesListsStyleCSS.exceptionsListTemplate.format(
 **{'Exceptions': self.__genDescriptionListSection(
-exceptionDict, self.exceptionsListEntryTemplate)})
+exceptionDict,
+TemplatesListsStyleCSS.exceptionsListEntryTemplate)}
+)
 if exceptionDict else
 ""
 )
 signalSect = (
-self.signalsListTemplate.format(
+TemplatesListsStyleCSS.signalsListTemplate.format(
 **{'Signals': self.__genDescriptionListSection(
-signalDict, self.signalsListEntryTemplate)})
+signalDict,
+TemplatesListsStyleCSS.signalsListEntryTemplate)}
+)
 if signalDict else
 ""
 )
 eventSect = (
-self.eventsListTemplate.format(
+TemplatesListsStyleCSS.eventsListTemplate.format(
 **{'Events': self.__genDescriptionListSection(
-eventDict, self.eventsListEntryTemplate)})
+eventDict,
+TemplatesListsStyleCSS.eventsListEntryTemplate)}
+)
 if eventDict else
 ""
 )
 deprecatedSect = (
-self.deprecatedTemplate.format(
+TemplatesListsStyleCSS.deprecatedTemplate.format(
 **{'Lines': html_uencode('\n'.join(deprecated))})
 if deprecated else
 ""
 )
 authorInfoSect = (
-self.authorInfoTemplate.format(
+TemplatesListsStyleCSS.authorInfoTemplate.format(
 **{'Authors': html_uencode('\n'.join(authorInfo))})
 if authorInfo else
 ""
 )
 sinceInfoSect = (
-self.sinceInfoTemplate.format(
+TemplatesListsStyleCSS.sinceInfoTemplate.format(
 **{'Info': html_uencode(sinceInfo[0])})
 if sinceInfo else
 ""
 )
 seeSect = (
-self.seeListTemplate.format(
+TemplatesListsStyleCSS.seeListTemplate.format(
 **{'Links': self.__genSeeListSection(
-seeList, self.seeListEntryTemplate)})
+seeList, TemplatesListsStyleCSS.seeListEntryTemplate)})
 if seeList else
 ''
 )
 return "".join([

Mercurial Repositories > eric / file comparison

comparison: eric7/DocumentationTools/ModuleDocumentor.py

eric7/DocumentationTools/ModuleDocumentor.py