eric: comparison DocumentationTools/ModuleDocumentor.py

-:0a02c433f52d
+:5883ce99ee12
 ^@signal [ \t]+
 (?P<SignalName2>
 [a-zA-Z_] \w*
 )
 [ \t]+ (?P<SignalDescription2> .*)
 """, re.VERBOSE | re.DOTALL | re.MULTILINE).search
 _event = re.compile(
 r"""
 ^@event [ \t]+
 (?P<EventName1>
 ^@event [ \t]+
 (?P<EventName2>
 [a-zA-Z_] \w*
 )
 [ \t]+ (?P<EventDescription2> .*)
 """, re.VERBOSE | re.DOTALL | re.MULTILINE).search
 class TagError(Exception):
 """
 Exception class raised, if an invalid documentation tag was found.
 """
 Public method to generate the source code documentation.
 @return The source code documentation. (string)
 """
-doc = self.headerTemplate.format(**{ \
+doc = self.headerTemplate.format(
-'Title': self.module.name,
+**{'Title': self.module.name,
 'Style': self.stylesheet}) + \
 self.__genModuleSection() + \
 self.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 = self.rbFileTemplate.format(
-'Module': self.module.name,
+**{'Module': self.module.name,
-'ModuleDescription': \
+'ModuleDescription':
 self.__formatDescription(self.module.description),
 'GlobalsList': globalsList,
 'ClassList': classList,
 'RbModulesList': rbModulesList,
 'FunctionList': functionList,
 })
 else:
-modBody = self.moduleTemplate.format(**{ \
+modBody = self.moduleTemplate.format(
-'Module': self.module.name,
+**{'Module': self.module.name,
-'ModuleDescription': \
+'ModuleDescription':
 self.__formatDescription(self.module.description),
 'GlobalsList': globalsList,
 'ClassList': classList,
 'FunctionList': functionList,
 })
 except TagError as e:
 sys.stderr.write(
 "Error in tags of description of module {0}.\n".format(
 self.module.name))
 sys.stderr.write("{0}\n".format(e))
 return ""
 classesSection = self.__genClassesSection()
 functionsSection = self.__genFunctionsSection()
 @param kwSuffix suffix to be used for the QtHelp keywords (string)
 @return The list section. (string)
 """
 lst = []
 for name in names:
-lst.append(self.listEntryTemplate.format(**{ \
+lst.append(self.listEntryTemplate.format(
-'Link': "{0}".format(name),
+**{'Link': "{0}".format(name),
 'Name': dict[name].name,
 'Description':
 self.__getShortDescription(dict[name].description),
 'Deprecated':
-self.__checkDeprecated(dict[name].description) and \
+self.__checkDeprecated(dict[name].description) and
 self.listEntryDeprecatedTemplate or "",
 }))
 if kwSuffix:
 n = "{0} ({1})".format(name, kwSuffix)
 else:
 n = "{0}".format(name)
 self.keywords.append((n, "#{0}".format(name)))
 if class_ is not None:
 scope = class_
 else:
 scope = self.module
 attrNames = sorted([attr for attr in scope.globals.keys()
 if not scope.globals[attr].isSignal])
 if attrNames:
 s = ''.join(
-[self.listEntrySimpleTemplate.format(**{'Name': name}) \
+[self.listEntrySimpleTemplate.format(**{'Name': name})
 for name in attrNames])
 else:
 s = self.listEntryNoneTemplate
-return self.listTemplate.format(**{ \
+return self.listTemplate.format(**{'Entries': s})
-'Entries': s,
-})
 def __genClassListSection(self):
 """
 Private method to generate the section listing all classes of the
 module.
 if names:
 self.empty = False
 s = self.__genListSection(names, self.module.classes)
 else:
 s = self.listEntryNoneTemplate
-return self.listTemplate.format(**{ \
+return self.listTemplate.format(**{'Entries': s})
-'Entries': s,
-})
 def __genRbModulesListSection(self):
 """
 Private method to generate the section listing all modules of the file
 (Ruby only).
 if names:
 self.empty = False
 s = self.__genListSection(names, self.module.modules)
 else:
 s = self.listEntryNoneTemplate
-return self.listTemplate.format(**{ \
+return self.listTemplate.format(**{'Entries': s})
-'Entries': s,
-})
 def __genFunctionListSection(self):
 """
 Private method to generate the section listing all functions of the
 module.
 if names:
 self.empty = False
 s = self.__genListSection(names, self.module.functions)
 else:
 s = self.listEntryNoneTemplate
-return self.listTemplate.format(**{ \
+return self.listTemplate.format(**{'Entries': s})
-'Entries': s,
-})
 def __genClassesSection(self):
 """
 Private method to generate the document section with details about
 classes.
 self.__genMethodSection(_class, className, Function.General)
 staticMethList, staticMethBodies = \
 self.__genMethodSection(_class, className, Function.Static)
 try:
-clsBody = self.classTemplate.format(**{ \
+clsBody = self.classTemplate.format(
-'Anchor': className,
+**{'Anchor': className,
 'Class': _class.name,
 'ClassSuper': supers,
 'ClassDescription':
 self.__formatDescription(_class.description),
 'GlobalsList': globalsList,
 'ClassMethodList': classMethList,
 'MethodList': methList,
 '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))
 clsBody = ""
 classes.append(clsBody)
 @return methods list section (string)
 """
 lst = []
 if includeInit:
 try:
-lst.append(self.listEntryTemplate.format(**{ \
+lst.append(self.listEntryTemplate.format(
-'Link': "{0}.{1}".format(className, '__init__'),
+**{'Link': "{0}.{1}".format(className, '__init__'),
 'Name': clsName,
 'Description': self.__getShortDescription(
 dict['__init__'].description),
 'Deprecated': self.__checkDeprecated(
-dict['__init__'].description) and \
+dict['__init__'].description) and
 self.listEntryDeprecatedTemplate or "",
 }))
 self.keywords.append(
 ("{0} (Constructor)".format(className),
 "#{0}.{1}".format(className, '__init__')))
 except KeyError:
 pass
 for name in names:
-lst.append(self.listEntryTemplate.format(**{ \
+lst.append(self.listEntryTemplate.format(
-'Link': "{0}.{1}".format(className, name),
+**{'Link': "{0}.{1}".format(className, name),
 'Name': dict[name].name,
 'Description':
 self.__getShortDescription(dict[name].description),
 'Deprecated':
-self.__checkDeprecated(dict[name].description) and \
+self.__checkDeprecated(dict[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):
 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(**{ \
+methBody = self.constructorTemplate.format(
-'Anchor': className,
+**{'Anchor': className,
 'Class': obj.name,
 'Method': '__init__',
-'MethodDescription': \
+'MethodDescription':
 self.__formatDescription(
 obj.methods['__init__'].description),
 'Params':
 ', '.join(obj.methods['__init__'].parameters[1:]),
 })
 except TagError as e:
 sys.stderr.write(
 "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 = " (static)"
 else:
 methodClassifier = ""
 for method in methods:
 try:
-methBody = self.methodTemplate.format(**{ \
+methBody = self.methodTemplate.format(
-'Anchor': className,
+**{'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:
 sys.stderr.write(
 "Error in tags of description of method {0}.{1}.\n".format(
 className, method))
 sys.stderr.write("{0}\n".format(e))
 methBody = ""
 methBodies.append(methBody)
 methList = self.__genMethodsListSection(
 methods, obj.methods, className, obj.name,
 includeInit=filter == Function.General)
 if not methList:
 methList = self.listEntryNoneTemplate
-return self.listTemplate.format(**{ \
+return (self.listTemplate.format(**{'Entries': methList}),
-'Entries': methList,
+''.join(methBodies))
-}), ''.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 = self.rbModuleTemplate.format(
-'Anchor': rbModuleName,
+**{'Anchor': rbModuleName,
 'Module': rbModule.name,
 'ModuleDescription':
 self.__formatDescription(rbModule.description),
 'GlobalsList': globalsList,
 'ClassesList': classList,
 'ClassesDetails': classBodies,
 'FunctionsList': methList,
 'FunctionsDetails': methBodies,
 })
 except TagError as e:
 sys.stderr.write(
 "Error in tags of description of Ruby module {0}.\n"
 .format(rbModuleName))
 sys.stderr.write("{0}\n".format(e))
 methList, methBodies = \
 self.__genMethodSection(_class, className, Function.General)
 try:
-clsBody = self.rbModulesClassTemplate.format(**{ \
+clsBody = self.rbModulesClassTemplate.format(
-'Anchor': className,
+**{'Anchor': className,
 'Class': _class.name,
 'ClassSuper': supers,
 'ClassDescription':
 self.__formatDescription(_class.description),
 'MethodList': methList,
 'MethodDetails': methBodies,
 })
 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))
 clsBody = ""
 classes.append(clsBody)
 classesList = self.__genRbModulesClassesListSection(
 classNames, obj.classes, modName)
 if not classesList:
 classesList = self.listEntryNoneTemplate
-return self.listTemplate.format(**{ \
+return (self.listTemplate.format(**{'Entries': classesList}),
-'Entries': classesList,
+''.join(classes))
-}), ''.join(classes)
 def __genRbModulesClassesListSection(self, names, dict, 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(self.listEntryTemplate.format(
-'Link': "{0}.{1}".format(moduleName, name),
+**{'Link': "{0}.{1}".format(moduleName, name),
 'Name': dict[name].name,
 'Description':
 self.__getShortDescription(dict[name].description),
 'Deprecated':
-self.__checkDeprecated(dict[name].description) and \
+self.__checkDeprecated(dict[name].description) and
 self.listEntryDeprecatedTemplate or "",
 }))
 self.keywords.append(("{0}.{1}".format(moduleName, name),
 "#{0}.{1}".format(moduleName, name)))
 return ''.join(lst)
 def __genFunctionsSection(self):
 """
 funcBodies = []
 funcNames = sorted(list(self.module.functions.keys()))
 for funcName in funcNames:
 try:
-funcBody = self.functionTemplate.format(**{ \
+funcBody = self.functionTemplate.format(
-'Anchor': funcName,
+**{'Anchor': funcName,
 'Function': self.module.functions[funcName].name,
 'FunctionDescription': self.__formatDescription(
 self.module.functions[funcName].description),
 'Params':
 ', '.join(self.module.functions[funcName].parameters),
 })
 except TagError as e:
 sys.stderr.write(
 "Error in tags of description of function {0}.\n".format(
 funcName))
 sys.stderr.write("{0}\n".format(e))
 funcBody = ""
 funcBodies.append(funcBody)
 if line == '.':
 linelist.append("")
 else:
 linelist.append(html_uencode(line))
 else:
-lst.append(self.paragraphTemplate.format(**{ \
+lst.append(self.paragraphTemplate.format(
-'Lines': '\n'.join(linelist)
+**{'Lines': '\n'.join(linelist)}))
-}))
 linelist = []
 if linelist:
-lst.append(self.paragraphTemplate.format(**{ \
+lst.append(self.paragraphTemplate.format(
-'Lines': '\n'.join(linelist)
+**{'Lines': '\n'.join(linelist)}))
-}))
 return ''.join(lst)
 def __genDescriptionListSection(self, dictionary, template):
 """
 Private method to generate the list section of a description.
 @return The list section. (string)
 """
 lst = []
 keys = sorted(list(dictionary.keys()))
 for key in keys:
-lst.append(template.format(**{ \
+lst.append(template.format(
-'Name': key,
+**{'Name': key,
 'Description': html_uencode('\n'.join(dictionary[key])),
 }))
 return ''.join(lst)
 def __genParamDescriptionListSection(self, _list, template):
 """
 Private method to generate the list section of a description.
 @param template The template to be used for the list. (string)
 @return The list section. (string)
 """
 lst = []
 for name, lines in _list:
-lst.append(template.format(**{ \
+lst.append(template.format(
-'Name': name,
+**{'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(**{ \
+return self.seeLinkTemplate.format(**{'Link': entry})
-'Link': entry,
-})
 def __genSeeListSection(self, _list, template):
 """
 Private method to generate the "see also" list section of a
 description.
 @return The list section. (string)
 """
 lst = []
 for seeEntry in _list:
 seeEntryString = ''.join(seeEntry)
-lst.append(template.format(**{ \
+lst.append(template.format(
-'Link': html_uencode(self.__formatCrossReferenceEntry(
+**{'Link': html_uencode(self.__formatCrossReferenceEntry(
 seeEntryString)),
 }))
 return '\n'.join(lst)
 def __processInlineTags(self, desc):
 """
 Private method to process inline tags.
 inTagSection = True
 m = _signal(desc, 0)
 if m is None:
 raise TagError("Wrong format in @signal line.\n")
 signalName = 1 and m.group("SignalName1") \
 or m.group("SignalName2")
 signalDesc = 1 and m.group("SignalDescription1") \
 or m.group("SignalDescription2")
 signalDict[signalName] = []
 if signalDesc is not None:
 signalDict[signalName].append(signalDesc)
 lastItem = signalDict[signalName]
 elif desc.startswith("@event"):
 m = _event(desc, 0)
 if m is None:
 raise TagError(
 "Wrong format in {0} line.\n".format(parts[0]))
 eventName = 1 and m.group("EventName1") \
 or m.group("EventName2")
 eventDesc = 1 and m.group("EventDescription1") \
 or m.group("EventDescription2")
 eventDict[eventName] = []
 if eventDesc is not None:
 eventDict[eventName].append(eventDesc)
 lastItem = eventDict[eventName]
 elif desc.startswith("@deprecated"):
 description = self.__genParagraphs(paragraphs)
 else:
 description = ""
 if paramList:
-parameterSect = self.parametersListTemplate.format(**{ \
+parameterSect = self.parametersListTemplate.format(
-'Parameters': self.__genParamDescriptionListSection(
+**{'Parameters': self.__genParamDescriptionListSection(
-paramList, self.parametersListEntryTemplate)
+paramList, self.parametersListEntryTemplate)})
-})
 else:
 parameterSect = ""
 if returns:
 returnSect = self.returnsTemplate.format(
 html_uencode('\n'.join(returns)))
 else:
 returnSect = ""
 if exceptionDict:
-exceptionSect = self.exceptionsListTemplate.format(**{ \
+exceptionSect = self.exceptionsListTemplate.format(
-'Exceptions': self.__genDescriptionListSection(
+**{'Exceptions': self.__genDescriptionListSection(
-exceptionDict, self.exceptionsListEntryTemplate)
+exceptionDict, self.exceptionsListEntryTemplate)})
-})
 else:
 exceptionSect = ""
 if signalDict:
-signalSect = self.signalsListTemplate.format(**{ \
+signalSect = self.signalsListTemplate.format(
-'Signals': self.__genDescriptionListSection(
+**{'Signals': self.__genDescriptionListSection(
-signalDict, self.signalsListEntryTemplate)
+signalDict, self.signalsListEntryTemplate)})
-})
 else:
 signalSect = ""
 if eventDict:
-eventSect = self.eventsListTemplate.format(**{ \
+eventSect = self.eventsListTemplate.format(
-'Events': self.__genDescriptionListSection(
+**{'Events': self.__genDescriptionListSection(
-eventDict, self.eventsListEntryTemplate)
+eventDict, self.eventsListEntryTemplate)})
-})
 else:
 eventSect = ""
 if deprecated:
-deprecatedSect = self.deprecatedTemplate.format(**{ \
+deprecatedSect = self.deprecatedTemplate.format(
-'Lines': html_uencode('\n'.join(deprecated)),
+**{'Lines': html_uencode('\n'.join(deprecated))})
-})
 else:
 deprecatedSect = ""
 if authorInfo:
-authorInfoSect = self.authorInfoTemplate.format(**{ \
+authorInfoSect = self.authorInfoTemplate.format(
-'Authors': html_uencode('\n'.join(authorInfo)),
+**{'Authors': html_uencode('\n'.join(authorInfo))})
-})
 else:
 authorInfoSect = ""
 if sinceInfo:
-sinceInfoSect = self.sinceInfoTemplate.format(**{ \
+sinceInfoSect = self.sinceInfoTemplate.format(
-'Info': html_uencode(sinceInfo[0]),
+**{'Info': html_uencode(sinceInfo[0])})
-})
 else:
 sinceInfoSect = ""
 if seeList:
-seeSect = self.seeListTemplate.format(**{ \
+seeSect = self.seeListTemplate.format(
-'Links': self.__genSeeListSection(
+**{'Links': self.__genSeeListSection(
-seeList, self.seeListEntryTemplate),
+seeList, self.seeListEntryTemplate)})
-})
 else:
 seeSect = ''
 return "{0}{1}{2}{3}{4}{5}{6}{7}{8}{9}".format(
 deprecatedSect, description, parameterSect, returnSect,

Mercurial Repositories > eric / file comparison

comparison: DocumentationTools/ModuleDocumentor.py

DocumentationTools/ModuleDocumentor.py