Added to project; batch-generates .html from all the .txt files in directories and subdirectories.

git-svn-id: http://svn.code.sf.net/p/docutils/code/trunk/docutils@426 929543f6-e4f2-0310-98a6-ba3bd3dd1d04

1 files changed, 163 insertions, 0 deletions

diff --git a/tools/buildhtml.py b/tools/buildhtml.py
new file mode 100755
index 000000000..310790899
--- /dev/null
+++ b/tools/buildhtml.py
@@ -0,0 +1,163 @@
+#!/usr/bin/env python
+
+"""
+Generates .html from all the .txt files in a directory.
+
+Ordinary .txt files are understood to be standalone reStructuredText.
+Files named ``pep-*.txt`` are interpreted as PEPs (either old-style or
+new reStructuredText PEPs).
+"""
+# Once PySource is here, build .html from .py as well.
+
+__docformat__ = 'reStructuredText'
+
+
+import sys
+import os
+import os.path
+import copy
+from docutils import core, frontend, io
+from docutils.parsers import rst
+from docutils.readers import pep
+from docutils.writers import pep_html
+import pep2html
+
+
+usage = '%prog [options] [<directory> ...]'
+description = ('Generates .html from all the .txt files (including PEPs) '
+               'in each <directory> (default is the current directory).')
+
+
+class OptionSpec:
+
+    """
+    Command-line options for the ``buildhtml.py`` front end.
+    """
+
+    # Can't be included in OptionParser below because we don't want to
+    # override the base class.
+    cmdline_options = (
+        'Build-HTML Options',
+        None,
+        (('Recursively scan subdirectories for files to process.  This is '
+          'the default.',
+          ['--recurse'], {'action': 'store_true', 'default': 1}),
+         ('Do not scan subdirectories for files to process.',
+          ['--local'], {'dest': 'recurse', 'action': 'store_false'}),))
+
+    
+class OptionParser(frontend.OptionParser):
+
+    """
+    Command-line option processing for the ``buildhtml.py`` front end.
+    """
+
+    def check_values(self, values, args):
+        frontend.OptionParser.check_values(self, values, args)
+        values._source = None
+        return values
+
+    def check_args(self, args):
+        source = destination = None
+        if args:
+            self.values._directories = args
+        else:
+            self.values._directories = [os.getcwd()]
+        return source, destination
+
+
+class Builder:
+
+    def run(self, directory=None, recurse=1):
+        self.process_command_line()
+        initial_options = self.get_options()
+        recurse = recurse and initial_options.recurse
+        self.setup_html_publisher()
+        if directory:
+            self.directories = [directory]
+        elif self.cmdline_options._directories:
+            self.directories = self.cmdline_options._directories
+        else:
+            self.directories = [os.getcwd()]
+        for directory in self.directories:
+            os.path.walk(directory, self.visit, recurse)
+
+    def visit(self, recurse, directory, names):
+        print >>sys.stderr, '/// Processing directory:', directory
+        sys.stderr.flush()
+        options = self.get_options(directory)
+        peps_found = 0
+        for name in names:
+            if name.endswith('.txt'):
+                if name.startswith('pep-'):
+                    peps_found = 1
+                else:
+                    self.process_txt(directory, name, options)
+        if peps_found:
+            self.process_peps(options, directory)
+        if not recurse:
+            del names[:]
+
+    def process_txt(self, directory, name, options):
+        options._source = os.path.normpath(os.path.join(directory, name))
+        options._destination = options._source[:-4]+'.html'
+        self.pub.options = options
+        print >>sys.stderr, '    ::: Processing .txt:', name
+        sys.stderr.flush()
+        self.pub.source = io.FileIO(options, source_path=options._source)
+        self.pub.destination = io.FileIO(
+            options, destination_path=options._destination)
+        self.pub.publish()
+
+    def process_peps(self, options, directory):
+        old_directory = os.getcwd()
+        os.chdir(directory)
+        print >>sys.stderr, '    ::: Processing PEPs:'
+        sys.stderr.flush()
+        pep2html.docutils_options = options
+        pep2html.main()
+        os.chdir(old_directory)
+
+    def process_command_line(self):
+        option_parser = OptionParser(
+            components=(OptionSpec, pep.Reader, rst.Parser, pep_html.Writer),
+            usage=usage, description=description)
+        self.option_defaults = option_parser.get_default_values()
+        config_parser = frontend.ConfigParser()
+        config_parser.read_standard_files()
+        self.config_settings = config_parser.get_section('options')
+        frontend.make_paths_absolute(self.config_settings)
+        self.cmdline_options = option_parser.parse_args(
+            values=frontend.Values())   # no defaults
+        # Clear out the command-line options so pep2html doesn't see them:
+        del sys.argv[1:]
+
+    def get_options(self, directory=None):
+        """
+        Return an option values object, from multiple sources.
+
+        Copy the option defaults, overlay the startup config file settings,
+        then the local config file settings, then the command-line options.
+        Assumes the current directory has been set.
+        """
+        options = copy.deepcopy(self.option_defaults)
+        options.__dict__.update(self.config_settings)
+        if directory:
+            config_parser = frontend.ConfigParser()
+            config_parser.read(os.path.join(directory, 'docutils.conf'))
+            local_config = config_parser.get_section('options')
+            frontend.make_paths_absolute(local_config, directory)
+            options.__dict__.update(local_config)
+        options.__dict__.update(self.cmdline_options.__dict__)
+        return options
+
+    def setup_html_publisher(self):
+        pub = core.Publisher()
+        pub.set_reader(reader_name='standalone',
+                       parser_name='restructuredtext', parser=None)
+        pub.set_writer(writer_name='html')
+        self.pub = pub
+
+
+if __name__ == "__main__":
+    Builder().run()