docset_MultiHTMLFile.py :  » Development » HappyDoc » HappyDoc3-r3_1 » happydoclib » docset » Python Open Source

Home
Python Open Source
1.3.1.2 Python
2.Ajax
3.Aspect Oriented
4.Blog
5.Build
6.Business Application
7.Chart Report
8.Content Management Systems
9.Cryptographic
10.Database
11.Development
12.Editor
13.Email
14.ERP
15.Game 2D 3D
16.GIS
17.GUI
18.IDE
19.Installer
20.IRC
21.Issue Tracker
22.Language Interface
23.Log
24.Math
25.Media Sound Audio
26.Mobile
27.Network
28.Parser
29.PDF
30.Project Management
31.RSS
32.Search
33.Security
34.Template Engines
35.Test
36.UML
37.USB Serial
38.Web Frameworks
39.Web Server
40.Web Services
41.Web Unit
42.Wiki
43.Windows
44.XML
Python Open Source » Development » HappyDoc 
HappyDoc » HappyDoc3 r3_1 » happydoclib » docset » docset_MultiHTMLFile.py
#!/usr/bin/env python
#
# $Id: docset_MultiHTMLFile.py,v 1.18 2006/12/05 13:10:45 doughellmann Exp $
#
# Copyright 2002 Doug Hellmann.
#
#
#                         All Rights Reserved
#
# Permission to use, copy, modify, and distribute this software and
# its documentation for any purpose and without fee is hereby
# granted, provided that the above copyright notice appear in all
# copies and that both that copyright notice and this permission
# notice appear in supporting documentation, and that the name of Doug
# Hellmann not be used in advertising or publicity pertaining to
# distribution of the software without specific, written prior
# permission.
#
# DOUG HELLMANN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
# INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
# NO EVENT SHALL DOUG HELLMANN BE LIABLE FOR ANY SPECIAL, INDIRECT OR
# CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
# OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
# NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#

"""Documentation set which writes output to multiple files.

"""

__rcs_info__ = {
    #
    #  Creation Information
    #
    'module_name'  : '$RCSfile: docset_MultiHTMLFile.py,v $',
    'rcs_id'       : '$Id: docset_MultiHTMLFile.py,v 1.18 2006/12/05 13:10:45 doughellmann Exp $',
    'creator'      : 'Doug Hellmann',
    'project'      : 'HappyDoc',
    'created'      : 'Sun, 17-Nov-2002 13:32:00 EST',

    #
    #  Current Information
    #
    'author'       : '$Author: doughellmann $',
    'version'      : '$Revision: 1.18 $',
    'date'         : '$Date: 2006/12/05 13:10:45 $',
}
try:
    __version__ = __rcs_info__['version'].split(' ')[1]
except:
    __version__ = '0.0'

#
# Import system modules
#
import os
import pprint
try:
    from cStringIO import StringIO
except:
    from StringIO import StringIO
import time
import token

#
# Import Local modules
#
import happydoclib
from happydoclib.docset import base
from happydoclib.sysmodules import getPythonSystemModuleURL
from happydoclib.trace import trace

#
# Module
#

TRACE_LEVEL=2

def entryPoint():
    "Return info about this module to the dynamic loader."
    return { 'name':'MultiHTMLFile',
             'factory':MultiHTMLFileDocSet,
             }

class MultiHTMLFileDocSet(base.MultiFileDocSet):
    """Documentation set written to multiple HTML files.
    """

    pageBackgroundColor='#ffffff'
    levelOneHeadingBackgroundColor='#88bbee'
    levelOneHeadingForegroundColor='#000000'
    levelTwoHeadingBackgroundColor='#99ccff'
    levelTwoHeadingForegroundColor='#000000'
    codeForegroundColor='#000088'

    def getOutputFilenameForPackageTreeNode(self, packageTreeNode, includePath=1):
        """Returns a filename where documentation for packageTreeNode should be written.

        The filename will be in the output directory, possibly in a
        subdirectory based on the path from the input root to the
        input file.

        For example::

          input_directory  : /foo/input
          containing       : /foo/input/bar.py
          output_directory : /foo/output

          results in       : /foo/output/input/bar.py
        """
        trace.into('MultiHTMLFileDocSet', 'getOutputFilenameForPackageTreeNode',
                   outputLevel=TRACE_LEVEL)
        filename = base.MultiFileDocSet.getOutputFilenameForPackageTreeNode(
            self,
            packageTreeNode,
            includePath=includePath,
            )
        
        if packageTreeNode.getMimeType() == ('application/x-directory', None):
            #
            # This is a directory.
            #
            filename_with_extension = os.path.join(filename, 'index.html')
        else:
            #
            # This is not a directory (file, module, class, etc.).
            #
            filename_with_extension = '%s.html' % filename

        trace.outof(filename_with_extension, outputLevel=TRACE_LEVEL)
        return filename_with_extension

    def getOutputFilenameForSymbol(self, packageTreeNode, symbolName, includePath=1):
        """Returns a filename where documentation for symbolName should be written.

        The filename will be in the output directory, possibly in a
        subdirectory based on the path from the input root to the
        input file.
        """
        package_output_name = self.getOutputFilenameForPackageTreeNode(
            packageTreeNode,
            includePath=includePath,
            )
        name, ext = os.path.splitext(package_output_name)
        output_name = '%s_%s.html' % (name, symbolName)
        return output_name

    def _writeBreadcrumbs(self, output, sourceNode, breadcrumbNode):
        """Write breadcrumb links from the root down to packageTreeNode.

        This method actually handles the recursion.
        """
        trace.into('MultiHTMLFile', '_writeBreadcrumbs',
                   sourceNode=sourceNode.getName(),
                   breadcrumbNode=(breadcrumbNode and breadcrumbNode.getName()),
                   outputLevel=TRACE_LEVEL,
                   )
        if not breadcrumbNode:
            trace.outof(outputLevel=TRACE_LEVEL)
            return
        
        #
        # Write the preceding part of the breadcrumbs
        #
        self._writeBreadcrumbs(output, sourceNode, breadcrumbNode.getParent())
        
        #
        # Write our breadcrumb
        #
        if breadcrumbNode.getName() != '__init__.py':
            if sourceNode == breadcrumbNode:
                ref = breadcrumbNode.getName()
            else:
                ref = self._getAnchorTagForPackageTreeNode(sourceNode,
                                                           breadcrumbNode,
                                                           )
            output.write('/ %s '% ref)
            trace.write('/ %s '% ref,
                        outputLevel=TRACE_LEVEL)
            #output.write('\n')
        else:
            trace.write('Skipping __init__.py', outputLevel=TRACE_LEVEL)

        trace.outof(outputLevel=TRACE_LEVEL)
        return

    def writeBreadcrumbs(self, output, packageTreeNode):
        """Write breadcrumb links from the root down to packageTreeNode.
        """
        #
        # Begin breadcrumbs.
        #
        output.write('<!-- breadcrumbs -->\n')
        output.write('<p><small>\n')

        self._writeBreadcrumbs(output, packageTreeNode, packageTreeNode)

        output.write('</small></p>\n')
        output.write('\n<!-- /breadcrumbs -->\n')
        return

    def writeFileHeader(self, output, packageTreeNode, title='', subtitle=''):
        """Given an open output stream, write a header using the title and subtitle.
        """
        title_bg = self.levelOneHeadingBackgroundColor
        title_fg = self.levelOneHeadingForegroundColor
        bgcolor = self.pageBackgroundColor
        root = 'need root URL'

        #
        # HTML header and Body tag.
        #
        output.write('''<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
          "http://www.w3.org/TR/html40/loose.dtd">

<html>
         
  <head>
    <title>%(title)s</title>
  </head>

  <body bgcolor="%(bgcolor)s">
        ''' % locals())

        #
        # Outline table
        #
        output.write('''
        
        <table border="0" cellpadding="5" cellspacing="0" width="100%%">
        <tr>
            <th rowspan="2"
                valign="top"
                align="left"
                width="10%%"
                bgcolor="%(title_bg)s"><font color="%(title_fg)s">%(title)s</font>
            </th>
            <th bgcolor="%(title_bg)s"
                width="90%%"
                align="right"><font color="%(title_fg)s">%(subtitle)s</font>
            </th>
        </tr>
        <tr>
        <td>
        ''' % locals())

        #
        # Breadcrumbs
        #
        if packageTreeNode.getParent() is not None:
            self.writeBreadcrumbs(output, packageTreeNode)
        return

    def writeFileFooter(self, output):
        """Given an open output stream, write a footer using the title and subtitle.
        """
        date_str = time.ctime(time.time())
        app_version = happydoclib.cvsProductVersion()
        
        output.write('''
        </td>
        </tr>
        </table>

    <hr>

    <font size="-2"><i>This document was automatically generated
    %(date_str)s by <a
    href="http://happydoc.sourceforge.net">HappyDoc</a> version
    %(app_version)s</i></font>
        
  </body>
</html>
        ''' % locals())
        return

    def writeDescriptiveList(self, output, descriptiveList):
        """Write a list including descriptions.

        Arguments

            output -- Open output stream.

            descriptiveList -- Sequence of (name, description,
            description_format) values to be included in the output
            list.

        """
        output.write('<!-- writeDescriptiveList -->\n')
        output.write('<table border="0" cellpadding="3" cellspacing="0">\n')
        
        for name, text, text_format in descriptiveList:

            output.write('''
            <tr>
              <td valign="top"><p>%(name)s</p></td>
              <td valign="top">''' % locals())

            self.writeText(output, text, text_format)
            
            output.write('''</td>
            </tr>
            ''')

        output.write('</table>')
        return

    def writeList(self, output, listElements):
        """Write a formatted list of values to the output.
        """
        output.write('<p>\n')
        for list_element in listElements:
            output.write('%s<br>\n' % list_element)
        output.write('</p>\n')
        return

    def _getAnchorTagForPackageTreeNode(self,
                                        source,
                                        destination,
                                        title=None,
                                        internalTarget=None):
        """Return a anchor tag to be included in the documentation of
        source that points to the destination.
        """
        if title is None:
            title = destination.getName()
        href = self._computeRelativeHREF(source, destination)
        if internalTarget:
            href='%s#%s' % (href, internalTarget)
        return '<a href="%s">%s</a>' % (href, title)

    def writeSectionTitle(self, output, title, subtitle, anchor=None):
        """Generate the text and styles to begin a new section.
        """
        bgcolor = self.levelTwoHeadingBackgroundColor
        fgcolor = self.levelTwoHeadingForegroundColor
        output.write('''
        <tr>
            <th bgcolor="%(bgcolor)s"
                rowspan="2"
                valign="top"
                align="left"
                width="20%%"
                >
                <font color="%(fgcolor)s">
                  <a name="%(anchor)s">%(title)s</a>&nbsp;
                </font>
            </th>
            <th bgcolor="%(bgcolor)s"
                valign="top"
                align="left"
                width="80%%"
                >
                <font color="%(fgcolor)s">%(subtitle)s&nbsp;</font>
            </th>
        </tr>
        <tr>
        <td>
        ''' % locals())
        #output.write('<h%s>%s</h%s>\n' % (level, title, level))
        return

    def pushSectionLevel(self, output, title, subtitle='', anchor=''):
        """Increase the section level.

        Generate the text and styles to begin a new section one
        deeper than the previous level.
        """
        output.write(
            '<table border="0" cellpadding="5" cellspacing="0" width="100%">\n'
            )
        self.writeSectionTitle(output,
                               title=title,
                               subtitle=subtitle,
                               anchor=anchor,
                               )
        return

    def writeSectionFooter(self, output):
        """Generate the text and styles to close the current section.
        """
        output.write('</td></tr>\n')
        return
    
    def popSectionLevel(self, output):
        """Decrease the section level.

        Generate the text and styles to close the current section
        and change the section level to the next higher level.
        """
        self.writeSectionFooter(output)
        output.write('</table>')
        return

    def writeTOCReferencesSection(self,
                                   output,
                                   packageTreeNode,
                                   title,
                                   moduleList,
                                   ):
        """Write a list of references in the table of contents.

        Arguments

            output -- Open output stream on which to write.

            packageTreeNode -- The node for which the section is being
            written.

            title -- Title of the reference section.

            moduleList -- A list of nodes to be included in the
            reference section.

        """
        descriptive_list = [(self._getAnchorTagForPackageTreeNode(packageTreeNode, node), ) + node.getSummaryAndFormat()
                             for node in moduleList
                            ]
        if descriptive_list:
            self.pushSectionLevel(output, title)
            
        descriptive_list.sort()
        self.writeDescriptiveList(output, descriptive_list)
        
        if descriptive_list:
            self.popSectionLevel(output)
        return

    def writeTOCFile(self, packageTreeNode):
        """Write the table of contents for a directory.

        The packageTreeNode is a directory, and the table of contents
        for that directory should be written as appropriate.
        """
        trace.into('MultiHTMLFile', 'writeTOCFile',
                   packageTreeNode=packageTreeNode,
                   outputLevel=TRACE_LEVEL,
                   )
        
        output_filename = self.getOutputFilenameForPackageTreeNode(packageTreeNode)

        output = self.openOutput(output_filename,
                                 packageTreeNode,
                                 title=self.title,
                                 subtitle=packageTreeNode.getRelativeFilename(),
                                 )

        #
        # Description
        #
        readme_text, text_format = packageTreeNode.getDocStringAndFormat()
        self.writeText(output, readme_text, text_format)

        #
        # Content from __init__.py
        #
        try:
            init_node = packageTreeNode['__init__.py']
        except KeyError:
            pass
        else:
            self.writePythonFileInfoToOutput(output, init_node)

        #
        # Write out references to text files we would have
        # converted.
        #
        text_files = packageTreeNode.getSubNodes(['text/plain',
                                                  'text/x-structured',
                                                  'text/html',
                                                  ])
        self.writeTOCReferencesSection(
            output,
            packageTreeNode,
            'Other documentation',
            text_files,
            )
        
        #
        # Write out references to Python files we parsed.
        #
        self.writeTOCReferencesSection(
            output,
            packageTreeNode,
            'Python files',
            [ node for node in packageTreeNode.getSubNodes(['text/x-python'])
              if node.getName() != '__init__.py'
              ],
            )
        
        #
        # Write out references to subdirectories
        #
        directories = packageTreeNode.getSubNodes(['application/x-directory'])
        #directories = [ d for d in directories
        #                if d[1].items()
        #                ]
        self.writeTOCReferencesSection(
            output,
            packageTreeNode,
            'Subdirectories',
            directories,
            )

        self.closeOutput(output)

        trace.outof(outputLevel=TRACE_LEVEL)
        return

    def writeImportWithFrom(self, output, pacakgeTreeNode, moduleReference, symbolReferences):
        """Write an import statement: 'from X import Y'
        """
        output.write('from %s import %s<br>' % (moduleReference,
                                            ', '.join(symbolReferences),
                                            )
                     )
        return

    def writeImport(self, output, packageTreeNode, moduleReference):
        """Write an import statement: 'import X'
        """
        output.write('import %s<br>' % moduleReference)
        return
    
    def writeImportForPythonSystemModule(self,
                                          output,
                                          packageTreeNode,
                                          name,
                                          symbols,
                                          url,
                                          ):
        """Write an import statement for a Python system module.

        Handles either 'from X import Y' or 'import X'.  The module
        name is a link to the Python documentation on
        http://www.python.org.
        """
        ref = '<a href="%s">%s</a>' % (url, name)
        if symbols:
            self.writeImportWithFrom(output,
                                      packageTreeNode,
                                      ref,
                                      symbols,
                                      )
        else:
            self.writeImport(output,
                              packageTreeNode,
                              ref,
                              )
        return

    
    def writeImportForKnownModule(self,
                                   output,
                                   packageTreeNode,
                                   name,
                                   referencedModule,
                                   symbols,
                                   ):
        """Write an import statement for a module known to HappyDoc.

        Handles either 'from X import Y' or 'import X'.  The module
        name is a link to the documentation for that module within the
        HappyDoc-generated output.
        """        
        #
        # Compute the href from here to there.
        #
        ref = self._getAnchorTagForPackageTreeNode(
            packageTreeNode,
            referencedModule,
            title=name,
            )

        if symbols:
            symbol_refs = []

            for symbol in symbols:
                symbol_module = referencedModule.findNodeFromDottedName(symbol)
                if symbol_module is not None:
                    symbol_ref = self._getAnchorTagForPackageTreeNode(
                        packageTreeNode,
                        symbol_module,
                        title=symbol,
                        )
                else:
                    symbol_ref = symbol

                symbol_refs.append( symbol_ref )
            
            self.writeImportWithFrom(output,
                                      packageTreeNode,
                                      ref,
                                      symbol_refs,
                                      )
        else:
            self.writeImport(output,
                              packageTreeNode,
                              ref,
                              )
        return
        

    def writePythonFileImportsToOutput(self, output, packageTreeNode):
        """Writes the list of imported modules for the packageTreeNode.
        """
        import_data = packageTreeNode.module_info.getImportData()
        if import_data:
            self.pushSectionLevel(output, 'Imported Modules')
            
            output.write('<p>\n')
            
            for name, symbols in import_data:
                ref = None
                
                #
                # Check if the name is a Python system module.
                #
                url = getPythonSystemModuleURL(name)
                if url:
                    self.writeImportForPythonSystemModule(output,
                                                           packageTreeNode,
                                                           name,
                                                           symbols,
                                                           url,
                                                           )
                    continue

                #
                # Check to see if the name is another module we know about.
                #
                referenced_module = packageTreeNode.findNodeFromDottedName(name)
                if referenced_module is not None:
                    self.writeImportForKnownModule(output,
                                                    packageTreeNode,
                                                    name,
                                                    referenced_module,
                                                    symbols,
                                                    )
                    continue

                #
                # Default to the module name for the reference.
                #
                if symbols:
                    self.writeImportWithFrom(output,
                                              packageTreeNode,
                                              name,
                                              symbols,
                                              )
                else:
                    self.writeImport(output,
                                      packageTreeNode,
                                      name,
                                      )

            output.write('</p>\n')

            self.popSectionLevel(output)
            
        return

    def writePreformatted(self, output, text):
        """Write text as a preformatted section.
        """
        output.write('<pre>\n')
        output.write(text)
        if text and text[-1] != '\n':
            output.write('\n')
        output.write('</pre>\n')
        return

    def writeFunctionParameter(self, output, name, info):
        '''Write a function parameter to the output.
         
        No indenting or formatting is performed.  The output
        looks like::

            name

        or
        
            name=default
 
        Parameters:
 
            name -- name of the parameter
 
            info -- tuple of (default_specified, default_value,
                    default_value_type)
                    concerning the default value of the parameter
 
            output -- destination for written output
             
        '''
        output.write(name)
        default_specified, default_value, default_value_type = info
        if default_specified:
            output.write('=')
            if default_value_type == token.STRING:
                output.write(`default_value`)
            elif default_value_type == token.NUMBER:
                output.write(str(default_value))
            else:
                #print 'FUNCTION DEFAULT VALUE (%s, %s): "%s"' % (
                #    type(default_value),
                #    default_value_type or 'Unknown',
                #    default_value)
                output.write(str(default_value))
        return

    def writeFunctionSignature(self,
                                output,
                                packageTreeNode,
                                function,
                                ):
        """Write the function signature for 'function' to 'output'.

        Parameters

          output -- Where to write.

          pacakgeTreeNode -- The part of the input we are processing.

          function -- Instance of FunctionInfo from parseinfo module.
          
        """
        function_name = function.getName()
        signature_buffer = StringIO()
        signature_buffer.write('%s (' % function_name)
        parameter_names = function.getParameterNames()
        if parameter_names:
            if len(parameter_names) <= 2:
                for param in parameter_names:
                    param_info = function.getParameterInfo(param)
                    signature_buffer.write(' ')
                    self.writeFunctionParameter(signature_buffer,
                                                 param,
                                                 param_info,
                                                 )
                    if param != parameter_names[-1]:
                        signature_buffer.write(',')
                    signature_buffer.write(' ')
            else:
                signature_buffer.write('\n')
                indent = 8 #len(name) + 3
                for param in parameter_names:
                    signature_buffer.write(' ' * indent)
                    param_info = function.getParameterInfo(param)
                    self.writeFunctionParameter(signature_buffer,
                                                 param,
                                                 param_info,
                                                 )
                    signature_buffer.write(',\n')
                signature_buffer.write('%s' % (' ' * indent))
        signature_buffer.write(')\n')

        self.writePreformatted(output, signature_buffer.getvalue())
        return
    
    def writeExceptionListForFunction(self, output, function):
        """Write the list of exceptions raised by a function.

        Parameters

          output -- Where to write.

          function -- FunctionInfo from parseinfo module.

          listHeader -- Header for list being generated.

        """
        exception_names = function.getExceptionNames()
        if not exception_names:
            return
        
        if self.sort_names:
            exception_names.sort()

        exception_list = []
        
        for name in exception_names:
            #exception_class = self.getClassInfo(name)
            exception_class = None
            
            if exception_class:
                # FIXME - Need a way to get a reference to a class in the
                # scanned input!
                ref = formatter.getReference( exception_class,
                                              #output_reduced_name,
                                              output.name,
                                              )
            else:
                #ref = formatter.getPythonReference( name )
                ref = name

            exception_list.append(ref)

        self.pushSectionLevel(output, 'Exceptions')
        self.writeList(output, exception_list)
        self.popSectionLevel(output)
        
        return

    def writeOneFunctionToOutput(self,
                                  output,
                                  packageTreeNode,
                                  functionInfo,
                                  ):
        """Write all of the information for one function to the output stream.
        """
        self.pushSectionLevel(output,
                              title='',
                              subtitle=functionInfo.getName(),
                              anchor=functionInfo.getName(),
                              )
        #
        # Signature
        #
        self.writeFunctionSignature(output, packageTreeNode, functionInfo)

        #
        # Description
        #
        docstring_text = functionInfo.getDocString()
        docstring_format = functionInfo.getDocStringFormat()
        self.writeText(output, docstring_text, docstring_format)

        #
        # Exceptions
        #
        self.writeExceptionListForFunction(output, functionInfo)

        self.popSectionLevel(output)
        return

    def writeFunctionsToOutput(self, output, packageTreeNode):
        """Writes information about functions in this module to the output stream.
        """
        function_names = self._filterNames(packageTreeNode.module_info.getFunctionNames())
        if not function_names:
            return

        if self.sort_names:
            function_names.sort()

        #
        # Section header
        #
        self.pushSectionLevel(output, 'Functions')

        #
        # Functions
        #

        for function_name in function_names:
            self.writeOneFunctionToOutput(
                output,
                packageTreeNode,
                packageTreeNode.module_info.getFunctionInfo(function_name),
                )

        self.popSectionLevel(output)
        return

    def _getBaseClassTree(self, linkSource, moduleTreeNode, classTreeNode, className):
        trace.into('MultiHTMLFile', '_getBaseClassTree',
                   linkSource=linkSource.getName(),
                   moduleTreeNode=moduleTreeNode.getName(),
                   classTreeNode=(classTreeNode and classTreeNode.getName()),
                   the_className=className,
                   outputLevel=TRACE_LEVEL,
                   )

        #
        # Find the list of base classes of the current class
        #
        if classTreeNode is None:
            base_class_names = []
        else:
            try:
                class_info = classTreeNode.code_info
            except AttributeError:
                base_class_names = []
            else:
                base_class_names = self._filterNames(class_info.getBaseClassNames())

        #
        # Build the subtrees from our base classes
        #
        base_class_trees = []
        for base_class_name in base_class_names:
            base_class_node = moduleTreeNode.findNodeFromDottedName(
                base_class_name,
                )
            base_class_tree = self._getBaseClassTree(
                linkSource,
                moduleTreeNode,
                base_class_node,
                base_class_name,
                )
            base_class_trees.append( base_class_tree )

        #
        # Set up the reference for this node
        #
        if classTreeNode:
            ref = self._getAnchorTagForPackageTreeNode(
                source=linkSource,
                destination=classTreeNode,
                title=className,
                )
        else:
            ref = className
            
        trace.outof(outputLevel=TRACE_LEVEL)
        return (ref, base_class_trees)

    def writeTree(self, output, treeRoot, indent=0):
        output.write('%s%s<br>' % ('&nbsp;&nbsp;' * indent, treeRoot[0]))
        for subtree in treeRoot[1]:
            self.writeTree(output, subtree, indent+1)
        return
    
    def writeBaseClassNames(self, output, packageTreeNode, classInfo):
        base_class_tree = self._getBaseClassTree(
            linkSource=packageTreeNode,
            moduleTreeNode=packageTreeNode.getParent(),
            classTreeNode=packageTreeNode,
            className=classInfo.getName(),
            )
        #self.writeList(output, base_class_names)
        output.write('<p>\n')
        self.writeTree(output, base_class_tree)
        output.write('</p>\n')
        return

    def writeOneClassToOutput(self, output, packageTreeNode):
        """Writes information about one class to the output stream.
        """
        class_info = packageTreeNode.code_info

        #
        # Description
        #
        docstring_text = class_info.getDocString()
        docstring_format = class_info.getDocStringFormat()
        self.writeText(output, docstring_text, docstring_format)

        #
        # Base classes
        #
        base_class_names = self._filterNames(class_info.getBaseClassNames())
        if base_class_names:
            self.pushSectionLevel(output, 'Base Classes')
            self.writeBaseClassNames(output, packageTreeNode, class_info)
            self.popSectionLevel(output)

        #
        # Methods
        #
        method_names = self._filterNames(class_info.getMethodNames())
        if method_names:
            if self.sort_names:
                method_names.sort()
            self.pushSectionLevel(output, 'Methods')

            for method_name in method_names:
                method_info = class_info.getMethodInfo(method_name)
                self.writeOneFunctionToOutput(
                    output,
                    packageTreeNode,
                    method_info,
                    )
            
            self.popSectionLevel(output)
        
        return

    def writeClassListForModule(self, output, packageTreeNode):
        """Write descriptions of all of the classes to the output stream.
        """
        #class_names = self._filterNames(packageTreeNode.module_info.getClassNames())
        classes = packageTreeNode.getSubNodes(['application/x-class'])
        class_map = {}
        for c in classes:
            class_map[c.getName()] = c
        class_names = self._filterNames(class_map.keys())

        if self.sort_names:
            class_names.sort()

        descriptive_list = []

        for class_name in class_names:
            #symbol_output_name = self.getOutputFilenameForSymbol(
            #    packageTreeNode,
            #    class_name,
            #    includePath=0,
            #    )
            class_node = class_map[class_name]
            #symbol_output_name = self.getOutputFilenameForPackageTreeNode(
            #    class_node,
            #    )
            #ref = '<a href="%s">%s</a>' % (symbol_output_name, class_name)
            ref = self._getAnchorTagForPackageTreeNode(
                source=packageTreeNode,
                destination=class_node,
                title=class_name,
                )
            class_info = packageTreeNode.module_info.getClassInfo(class_name)
            class_info_summary, class_info_format = class_info.getSummaryAndFormat()
            descriptive_list.append( (ref, class_info_summary, class_info_format) )

        self.pushSectionLevel(output, 'Classes')
        self.writeDescriptiveList(output, descriptive_list)
        self.popSectionLevel(output)
        return

    def writePythonFileInfoToOutput(self, output, packageTreeNode):
        """Writes parts of the Python file information to the output stream.
        """
        self.writePythonFileImportsToOutput(output, packageTreeNode)
        self.writeFunctionsToOutput(output, packageTreeNode)
        #self.writeClassesToOutput(output, packageTreeNode)

        #
        # Write a list of the classes to the current output file
        #
        self.writeClassListForModule(output, packageTreeNode)

        return
        

    def processPythonFile(self, packageTreeNode):
        """Handler for text/x-python nodes.
        """
        trace.into('MultiHTMLFileDocSet', 'processPythonFile',
                   packageTreeNode=packageTreeNode,
                   outputLevel=TRACE_LEVEL,
                   )

        node_name = packageTreeNode.getName()
        if node_name == '__init__.py':

            #
            # Skip the __init__.py file, since it will
            # be handled as part of the package.
            #
            trace.write('skipping __init__.py', outputLevel=TRACE_LEVEL)
            trace.outof(outputLevel=TRACE_LEVEL)
            return
        
        canonical_path = packageTreeNode.getPath(1)
        canonical_filename = apply(os.path.join, canonical_path)
        output_filename = self.getOutputFilenameForPackageTreeNode(packageTreeNode)
        
        self.statusMessage('Documenting: "%s"\n         to: "%s"' % (
            canonical_filename,
            output_filename,
            ))

        output = self.openOutput(output_filename,
                                 packageTreeNode,
                                 title=self.title,
                                 subtitle=packageTreeNode.getRelativeFilename(),
                                 )

        #
        # Summary/module docstring
        #
        readme_text = packageTreeNode.module_info.getDocString()
        readme_text = self._unquoteString(readme_text)
        text_format = packageTreeNode.module_info.getDocStringFormat()
        self.writeText(output, readme_text, text_format)

        self.writePythonFileInfoToOutput(output, packageTreeNode)
        
        self.closeOutput(output)
        
        trace.outof(outputLevel=TRACE_LEVEL)
        return

    def processPythonClass(self, packageTreeNode):
        """Writes information about classes in this module to the output stream.
        """
        #print 'Processing class: %s' % packageTreeNode.getName()
        #
        # Open a new output stream for the class.
        #
        #class_output_name = self.getOutputFilenameForSymbol(
        #    packageTreeNode,
        #    class_name,
        #    includePath=1,
        #    )
        class_output_name = self.getOutputFilenameForPackageTreeNode(
            packageTreeNode,
            )
        #print '  output file:', class_output_name
        
        class_output = self.openOutput(
            class_output_name,
            packageTreeNode,
            title=self.title,
            subtitle='Class: %s' % packageTreeNode.getName(),
            )
        
        #
        # Write class documentation
        #
        self.writeOneClassToOutput(
            class_output,
            packageTreeNode,
            )
        
        #
        # Close the class' output stream
        #
        self.closeOutput(class_output)
        return
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.