# $Id: frontend.py 4913 2007-02-12 04:05:20Z goodger $

# Author: David Goodger <goodger@python.org>

# Copyright: This module has been placed in the public domain.

"""

Command-line and common processing for Docutils front-end tools.

Exports the following classes:

* `OptionParser`: Standard Docutils command-line processing.

* `Option`: Customized version of `optparse.Option`; validation support.

* `Values`: Runtime settings; objects are simple structs

  (``object.attribute``).  Supports cumulative list settings (attributes).

* `ConfigParser`: Standard Docutils config file processing.

Also exports the following functions:

* Option callbacks: `store_multiple`, `read_config_file`.

* Setting validators: `validate_encoding`,

  `validate_encoding_error_handler`,

  `validate_encoding_and_error_handler`, `validate_boolean`,

  `validate_threshold`, `validate_colon_separated_string_list`,

  `validate_dependency_file`.

* `make_paths_absolute`.

"""

__docformat__ = 'reStructuredText'

import os

import os.path

import sys

import types

import warnings

import ConfigParser as CP

import codecs

import docutils

import docutils.utils

import docutils.nodes

try:

    import optparse

    from optparse import SUPPRESS_HELP

except ImportError:

    import optik as optparse

    from optik import SUPPRESS_HELP

def store_multiple(option, opt, value, parser, *args, **kwargs):

    """

    Store multiple values in `parser.values`.  (Option callback.)

    Store `None` for each attribute named in `args`, and store the value for

    each key (attribute name) in `kwargs`.

    """

    for attribute in args:

        setattr(parser.values, attribute, None)

    for key, value in kwargs.items():

        setattr(parser.values, key, value)

def read_config_file(option, opt, value, parser):

    """

    Read a configuration file during option processing.  (Option callback.)

    """

    try:

        new_settings = parser.get_config_file_settings(value)

    except ValueError, error:

        parser.error(error)

    parser.values.update(new_settings, parser)

def validate_encoding(setting, value, option_parser,

                      config_parser=None, config_section=None):

    try:

        codecs.lookup(value)

    except LookupError:

        raise (LookupError('setting "%s": unknown encoding: "%s"'

                           % (setting, value)),

               None, sys.exc_info()[2])

    return value

def validate_encoding_error_handler(setting, value, option_parser,

                                    config_parser=None, config_section=None):

    try:

        codecs.lookup_error(value)

    except AttributeError:              # prior to Python 2.3

        if value not in ('strict', 'ignore', 'replace', 'xmlcharrefreplace'):

            raise (LookupError(

                'unknown encoding error handler: "%s" (choices: '

                '"strict", "ignore", "replace", or "xmlcharrefreplace")' % value),

                   None, sys.exc_info()[2])

    except LookupError:

        raise (LookupError(

            'unknown encoding error handler: "%s" (choices: '

            '"strict", "ignore", "replace", "backslashreplace", '

            '"xmlcharrefreplace", and possibly others; see documentation for '

            'the Python ``codecs`` module)' % value),

               None, sys.exc_info()[2])

    return value

def validate_encoding_and_error_handler(

    setting, value, option_parser, config_parser=None, config_section=None):

    """

    Side-effect: if an error handler is included in the value, it is inserted

    into the appropriate place as if it was a separate setting/option.

    """

    if ':' in value:

        encoding, handler = value.split(':')

        validate_encoding_error_handler(

            setting + '_error_handler', handler, option_parser,

            config_parser, config_section)

        if config_parser:

            config_parser.set(config_section, setting + '_error_handler',

                              handler)

        else:

            setattr(option_parser.values, setting + '_error_handler', handler)

    else:

        encoding = value

    validate_encoding(setting, encoding, option_parser,

                      config_parser, config_section)

    return encoding

def validate_boolean(setting, value, option_parser,

                     config_parser=None, config_section=None):

    if isinstance(value, types.UnicodeType):

        try:

            return option_parser.booleans[value.strip().lower()]

        except KeyError:

            raise (LookupError('unknown boolean value: "%s"' % value),

                   None, sys.exc_info()[2])

    return value

def validate_nonnegative_int(setting, value, option_parser,

                             config_parser=None, config_section=None):

    value = int(value)

    if value < 0:

        raise ValueError('negative value; must be positive or zero')

    return value

def validate_threshold(setting, value, option_parser,

                       config_parser=None, config_section=None):

    try:

        return int(value)

    except ValueError:

        try:

            return option_parser.thresholds[value.lower()]

        except (KeyError, AttributeError):

            raise (LookupError('unknown threshold: %r.' % value),

                   None, sys.exc_info[2])

def validate_colon_separated_string_list(

    setting, value, option_parser, config_parser=None, config_section=None):

    if isinstance(value, types.UnicodeType):

        value = value.split(':')

    else:

        last = value.pop()

        value.extend(last.split(':'))

    return value

def validate_url_trailing_slash(

    setting, value, option_parser, config_parser=None, config_section=None):

    if not value:

        return './'

    elif value.endswith('/'):

        return value

    else:

        return value + '/'

def validate_dependency_file(setting, value, option_parser,

                             config_parser=None, config_section=None):

    try:

        return docutils.utils.DependencyList(value)

    except IOError:

        return docutils.utils.DependencyList(None)

def validate_strip_class(setting, value, option_parser,

                         config_parser=None, config_section=None):

    if config_parser:                   # validate all values

        class_values = value

    else:                               # just validate the latest value

        class_values = [value[-1]]

    for class_value in class_values:

        normalized = docutils.nodes.make_id(class_value)

        if class_value != normalized:

            raise ValueError('invalid class value %r (perhaps %r?)'

                             % (class_value, normalized))

    return value

def make_paths_absolute(pathdict, keys, base_path=None):

    """

    Interpret filesystem path settings relative to the `base_path` given.

    Paths are values in `pathdict` whose keys are in `keys`.  Get `keys` from

    `OptionParser.relative_path_settings`.

    """

    if base_path is None:

        base_path = os.getcwd()

    for key in keys:

        if pathdict.has_key(key):

            value = pathdict[key]

            if isinstance(value, types.ListType):

                value = [make_one_path_absolute(base_path, path)

                         for path in value]

            elif value:

                value = make_one_path_absolute(base_path, value)

            pathdict[key] = value

def make_one_path_absolute(base_path, path):

    return os.path.abspath(os.path.join(base_path, path))

class Values(optparse.Values):

    """

    Updates list attributes by extension rather than by replacement.

    Works in conjunction with the `OptionParser.lists` instance attribute.

    """

    def __init__(self, *args, **kwargs):

        optparse.Values.__init__(self, *args, **kwargs)

        if (not hasattr(self, 'record_dependencies')

            or self.record_dependencies is None):

            # Set up dependency list, in case it is needed.

            self.record_dependencies = docutils.utils.DependencyList()

    def update(self, other_dict, option_parser):

        if isinstance(other_dict, Values):

            other_dict = other_dict.__dict__

        other_dict = other_dict.copy()

        for setting in option_parser.lists.keys():

            if (hasattr(self, setting) and other_dict.has_key(setting)):

                value = getattr(self, setting)

                if value:

                    value += other_dict[setting]

                    del other_dict[setting]

        self._update_loose(other_dict)

    def copy(self):

        """Return a shallow copy of `self`."""

        return self.__class__(defaults=self.__dict__)

class Option(optparse.Option):

    ATTRS = optparse.Option.ATTRS + ['validator', 'overrides']

    def process(self, opt, value, values, parser):

        """

        Call the validator function on applicable settings and

        evaluate the 'overrides' option.

        Extends `optparse.Option.process`.

        """

        result = optparse.Option.process(self, opt, value, values, parser)

        setting = self.dest

        if setting:

            if self.validator:

                value = getattr(values, setting)

                try:

                    new_value = self.validator(setting, value, parser)

                except Exception, error:

                    raise (optparse.OptionValueError(

                        'Error in option "%s":\n    %s: %s'

                        % (opt, error.__class__.__name__, error)),

                           None, sys.exc_info()[2])

                setattr(values, setting, new_value)

            if self.overrides:

                setattr(values, self.overrides, None)

        return result

class OptionParser(optparse.OptionParser, docutils.SettingsSpec):

    """

    Parser for command-line and library use.  The `settings_spec`

    specification here and in other Docutils components are merged to build

    the set of command-line options and runtime settings for this process.

    Common settings (defined below) and component-specific settings must not

    conflict.  Short options are reserved for common settings, and components

    are restrict to using long options.

    """

    standard_config_files = [

        '/etc/docutils.conf',           # system-wide

        './docutils.conf',              # project-specific

        '~/.docutils']                  # user-specific

    """Docutils configuration files, using ConfigParser syntax.  Filenames

    will be tilde-expanded later.  Later files override earlier ones."""

    threshold_choices = 'info 1 warning 2 error 3 severe 4 none 5'.split()

    """Possible inputs for for --report and --halt threshold values."""

    thresholds = {'info': 1, 'warning': 2, 'error': 3, 'severe': 4, 'none': 5}

    """Lookup table for --report and --halt threshold values."""

    booleans={'1': 1, 'on': 1, 'yes': 1, 'true': 1,

              '0': 0, 'off': 0, 'no': 0, 'false': 0, '': 0}

    """Lookup table for boolean configuration file settings."""

    if hasattr(codecs, 'backslashreplace_errors'):

        default_error_encoding_error_handler = 'backslashreplace'

    else:

        default_error_encoding_error_handler = 'replace'

    settings_spec = (

        'General Docutils Options',

        None,

        (('Specify the document title as metadata.',

          ['--title'], {}),

         ('Include a "Generated by Docutils" credit and link.',

          ['--generator', '-g'], {'action': 'store_true',

                                  'validator': validate_boolean}),

         ('Do not include a generator credit.',

          ['--no-generator'], {'action': 'store_false', 'dest': 'generator'}),

         ('Include the date at the end of the document (UTC).',

          ['--date', '-d'], {'action': 'store_const', 'const': '%Y-%m-%d',

                             'dest': 'datestamp'}),

         ('Include the time & date (UTC).',

          ['--time', '-t'], {'action': 'store_const',

                             'const': '%Y-%m-%d %H:%M UTC',

                             'dest': 'datestamp'}),

         ('Do not include a datestamp of any kind.',

          ['--no-datestamp'], {'action': 'store_const', 'const': None,

                               'dest': 'datestamp'}),

         ('Include a "View document source" link.',

          ['--source-link', '-s'], {'action': 'store_true',

                                    'validator': validate_boolean}),

         ('Use <URL> for a source link; implies --source-link.',

          ['--source-url'], {'metavar': '<URL>'}),

         ('Do not include a "View document source" link.',

          ['--no-source-link'],

          {'action': 'callback', 'callback': store_multiple,

           'callback_args': ('source_link', 'source_url')}),

         ('Link from section headers to TOC entries.  (default)',

          ['--toc-entry-backlinks'],

          {'dest': 'toc_backlinks', 'action': 'store_const', 'const': 'entry',

           'default': 'entry'}),

         ('Link from section headers to the top of the TOC.',

          ['--toc-top-backlinks'],

          {'dest': 'toc_backlinks', 'action': 'store_const', 'const': 'top'}),

         ('Disable backlinks to the table of contents.',

          ['--no-toc-backlinks'],

          {'dest': 'toc_backlinks', 'action': 'store_false'}),

         ('Link from footnotes/citations to references. (default)',

          ['--footnote-backlinks'],

          {'action': 'store_true', 'default': 1,

           'validator': validate_boolean}),

         ('Disable backlinks from footnotes and citations.',

          ['--no-footnote-backlinks'],

          {'dest': 'footnote_backlinks', 'action': 'store_false'}),

         ('Enable section numbering.  (default)',

          ['--section-numbering'],

          {'action': 'store_true', 'dest': 'sectnum_xform',

           'default': 1, 'validator': validate_boolean}),

         ('Disable section numbering.',

          ['--no-section-numbering'],

          {'action': 'store_false', 'dest': 'sectnum_xform'}),

         ('Remove comment elements from the document tree.',

          ['--strip-comments'],

          {'action': 'store_true', 'validator': validate_boolean}),

         ('Leave comment elements in the document tree. (default)',

          ['--leave-comments'],

          {'action': 'store_false', 'dest': 'strip_comments'}),

         ('Remove all elements with classes="<class>" from the document tree. '

          '(Multiple-use option.)',

          ['--strip-elements-with-class'],

          {'action': 'append', 'dest': 'strip_elements_with_classes',

           'metavar': '<class>', 'validator': validate_strip_class}),

         ('Remove all classes="<class>" attributes from elements in the '

          'document tree. (Multiple-use option.)',

          ['--strip-class'],

          {'action': 'append', 'dest': 'strip_classes',

           'metavar': '<class>', 'validator': validate_strip_class}),

         ('Report system messages at or higher than <level>: "info" or "1", '

          '"warning"/"2" (default), "error"/"3", "severe"/"4", "none"/"5"',

          ['--report', '-r'], {'choices': threshold_choices, 'default': 2,

                               'dest': 'report_level', 'metavar': '<level>',

                               'validator': validate_threshold}),

         ('Report all system messages.  (Same as "--report=1".)',

          ['--verbose', '-v'], {'action': 'store_const', 'const': 1,

                                'dest': 'report_level'}),

         ('Report no system messages.  (Same as "--report=5".)',

          ['--quiet', '-q'], {'action': 'store_const', 'const': 5,

                              'dest': 'report_level'}),

         ('Halt execution at system messages at or above <level>.  '

          'Levels as in --report.  Default: 4 (severe).',

          ['--halt'], {'choices': threshold_choices, 'dest': 'halt_level',

                       'default': 4, 'metavar': '<level>',

                       'validator': validate_threshold}),

         ('Halt at the slightest problem.  Same as "--halt=info".',

          ['--strict'], {'action': 'store_const', 'const': 'info',

                         'dest': 'halt_level'}),

         ('Enable a non-zero exit status for non-halting system messages at '

          'or above <level>.  Default: 5 (disabled).',

          ['--exit-status'], {'choices': threshold_choices,

                              'dest': 'exit_status_level',

                              'default': 5, 'metavar': '<level>',

                              'validator': validate_threshold}),

         ('Enable debug-level system messages and diagnostics.',

          ['--debug'], {'action': 'store_true', 'validator': validate_boolean}),

         ('Disable debug output.  (default)',

          ['--no-debug'], {'action': 'store_false', 'dest': 'debug'}),

         ('Send the output of system messages to <file>.',

          ['--warnings'], {'dest': 'warning_stream', 'metavar': '<file>'}),

         ('Enable Python tracebacks when Docutils is halted.',

          ['--traceback'], {'action': 'store_true', 'default': None,

                            'validator': validate_boolean}),

         ('Disable Python tracebacks.  (default)',

          ['--no-traceback'], {'dest': 'traceback', 'action': 'store_false'}),

         ('Specify the encoding and optionally the '

          'error handler of input text.  Default: <locale-dependent>:strict.',

          ['--input-encoding', '-i'],

          {'metavar': '<name[:handler]>',

           'validator': validate_encoding_and_error_handler}),

         ('Specify the error handler for undecodable characters.  '

          'Choices: "strict" (default), "ignore", and "replace".',

          ['--input-encoding-error-handler'],

          {'default': 'strict', 'validator': validate_encoding_error_handler}),

         ('Specify the text encoding and optionally the error handler for '

          'output.  Default: UTF-8:strict.',

          ['--output-encoding', '-o'],

          {'metavar': '<name[:handler]>', 'default': 'utf-8',

           'validator': validate_encoding_and_error_handler}),

         ('Specify error handler for unencodable output characters; '

          '"strict" (default), "ignore", "replace", '

          '"xmlcharrefreplace", "backslashreplace" (Python 2.3+).',

          ['--output-encoding-error-handler'],

          {'default': 'strict', 'validator': validate_encoding_error_handler}),

         ('Specify text encoding and error handler for error output.  '

          'Default: ASCII:%s.'

          % default_error_encoding_error_handler,

          ['--error-encoding', '-e'],

          {'metavar': '<name[:handler]>', 'default': 'ascii',

           'validator': validate_encoding_and_error_handler}),

         ('Specify the error handler for unencodable characters in '

          'error output.  Default: %s.'

          % default_error_encoding_error_handler,

          ['--error-encoding-error-handler'],

          {'default': default_error_encoding_error_handler,

           'validator': validate_encoding_error_handler}),

         ('Specify the language (as 2-letter code).  Default: en.',

          ['--language', '-l'], {'dest': 'language_code', 'default': 'en',

                                 'metavar': '<name>'}),

         ('Write output file dependencies to <file>.',

          ['--record-dependencies'],

          {'metavar': '<file>', 'validator': validate_dependency_file,

           'default': None}),           # default set in Values class

         ('Read configuration settings from <file>, if it exists.',

          ['--config'], {'metavar': '<file>', 'type': 'string',

                         'action': 'callback', 'callback': read_config_file}),

         ("Show this program's version number and exit.",

          ['--version', '-V'], {'action': 'version'}),

         ('Show this help message and exit.',

          ['--help', '-h'], {'action': 'help'}),

         # Typically not useful for non-programmatical use:

         (SUPPRESS_HELP, ['--id-prefix'], {'default': ''}),

         (SUPPRESS_HELP, ['--auto-id-prefix'], {'default': 'id'}),

         # Hidden options, for development use only:

         (SUPPRESS_HELP, ['--dump-settings'], {'action': 'store_true'}),

         (SUPPRESS_HELP, ['--dump-internals'], {'action': 'store_true'}),

         (SUPPRESS_HELP, ['--dump-transforms'], {'action': 'store_true'}),

         (SUPPRESS_HELP, ['--dump-pseudo-xml'], {'action': 'store_true'}),

         (SUPPRESS_HELP, ['--expose-internal-attribute'],

          {'action': 'append', 'dest': 'expose_internals',

           'validator': validate_colon_separated_string_list}),

         (SUPPRESS_HELP, ['--strict-visitor'], {'action': 'store_true'}),

         ))

    """Runtime settings and command-line options common to all Docutils front

    ends.  Setting specs specific to individual Docutils components are also

    used (see `populate_from_components()`)."""

    settings_defaults = {'_disable_config': None,

                         '_source': None,

                         '_destination': None,

                         '_config_files': None}

    """Defaults for settings that don't have command-line option equivalents."""

    relative_path_settings = ('warning_stream',)

    config_section = 'general'

    version_template = ('%%prog (Docutils %s [%s])'

                        % (docutils.__version__, docutils.__version_details__))

    """Default version message."""

    def __init__(self, components=(), defaults=None, read_config_files=None,

                 *args, **kwargs):

        """

        `components` is a list of Docutils components each containing a

        ``.settings_spec`` attribute.  `defaults` is a mapping of setting

        default overrides.

        """

        self.lists = {}

        """Set of list-type settings."""

        self.config_files = []

        """List of paths of applied configuration files."""

        optparse.OptionParser.__init__(

            self, option_class=Option, add_help_option=None,

            formatter=optparse.TitledHelpFormatter(width=78),

            *args, **kwargs)

        if not self.version:

            self.version = self.version_template

        # Make an instance copy (it will be modified):

        self.relative_path_settings = list(self.relative_path_settings)

        self.components = (self,) + tuple(components)

        self.populate_from_components(self.components)

        self.set_defaults_from_dict(defaults or {})

        if read_config_files and not self.defaults['_disable_config']:

            try:

                config_settings = self.get_standard_config_settings()

            except ValueError, error:

                self.error(error)

            self.set_defaults_from_dict(config_settings.__dict__)

    def populate_from_components(self, components):

        """

        For each component, first populate from the `SettingsSpec.settings_spec`

        structure, then from the `SettingsSpec.settings_defaults` dictionary.

        After all components have been processed, check for and populate from

        each component's `SettingsSpec.settings_default_overrides` dictionary.

        """

        for component in components:

            if component is None:

                continue

            settings_spec = component.settings_spec

            self.relative_path_settings.extend(

                component.relative_path_settings)

            for i in range(0, len(settings_spec), 3):

                title, description, option_spec = settings_spec[i:i+3]