def test_new_documenter():
    class MyDocumenter(ModuleLevelDocumenter):
        objtype = "integer"
        directivetype = "data"
        priority = 100

        @classmethod
        def can_document_member(cls, member, membername, isattr, parent):
            return isinstance(member, int)

        def document_members(self, all_members=False):
            return

    add_documenter(MyDocumenter)

    def assert_result_contains(item, objtype, name, **kw):
        inst = AutoDirective._registry[objtype](directive, name)
        inst.generate(**kw)
        # print '\n'.join(directive.result)
        assert len(_warnings) == 0, _warnings
        assert item in directive.result
        del directive.result[:]

    options.members = ["integer"]
    assert_result_contains(".. py:data:: integer", "module", "test_autodoc")

def test_new_documenter():
    logging.setup(app, app._status, app._warning)

    class MyDocumenter(ModuleLevelDocumenter):
        objtype = 'integer'
        directivetype = 'data'
        priority = 100

        @classmethod
        def can_document_member(cls, member, membername, isattr, parent):
            return isinstance(member, int)

        def document_members(self, all_members=False):
            return

    add_documenter(MyDocumenter)

    def assert_result_contains(item, objtype, name, **kw):
        app._warning.truncate(0)
        inst = app.registry.documenters[objtype](directive, name)
        inst.generate(**kw)
        # print '\n'.join(directive.result)
        assert app._warning.getvalue() == ''
        assert item in directive.result
        del directive.result[:]

    options.members = ['integer']
    assert_result_contains('.. py:data:: integer', 'module', 'target')

def setup(app):
    app.add_config_value('autoc_base_path', False, True)

    autodoc.add_documenter(CFileDocumenter)
    # add_directive_to_domain was added in Sphinx 1.0, use add_directive instead.
    #app.add_directive_to_domain('c', 'autofile', autodoc.AutoDirective)
    app.add_directive('autocfile', autodoc.AutoDirective)

def add_autodocumenter(app, cls):
    logger.debug('[app] adding autodocumenter: %r', cls)
    try:
        from sphinx.ext.autodoc.directive import AutodocDirective
        app.registry.add_documenter(cls.objtype, cls)
    except AttributeError:
        from sphinx.ext import autodoc
        autodoc.add_documenter(cls)

    app.add_directive('auto' + cls.objtype, DispatcherDirective)

def setup(app):
    # NOTE: the "correct", forward compatible call to make here is
    # app.add_autodocumenter() - because as of Sphinx 1.7, the inner API we are
    # manipulating here got changed around a bunch (but the outer
    # API of add_autodocumenter() remained the same, on purpose).
    # Unfortunately, in both cases add_autodocumenter() both registers the
    # documenter AND adds an `auto<type>` directive - meaning it's not possible
    # to register a "acts kinda like another" Documenter or you double-define
    # e.g. autofunction, which Sphinx warns about and also presumably kills
    # real function documenting.
    # NOTE: sooo for now, since a bunch of our other shit breaks on Sphinx 1.7,
    # we are just explicitly calling autodoc's add_documenter. Sadface.
    autodoc.add_documenter(TaskDocumenter)

def setup(app):
    global sphinxapp
    sphinxapp = app
    autodoc.setup(app)
    autodoc.add_documenter(FieldDocumenter)
    autodoc.add_documenter(SettingsDocumenter)
    autodoc.add_documenter(SignalDocumenter)
    autodoc.add_documenter(EnumDocumenter)
    app.connect('autodoc-skip-member', skip_member_predicate)

from jinja2 import FileSystemLoader, TemplateNotFound
from jinja2.sandbox import SandboxedEnvironment

from sphinx import package_dir
from sphinx.ext.autosummary import import_by_name, get_documenter
from sphinx.jinja2glue import BuiltinTemplateLoader
from sphinx.util.osutil import ensuredir
from sphinx.util.inspect import safe_getattr
from sphinx.util.rst import escape as rst_escape

# Add documenters to AutoDirective registry
from sphinx.ext.autodoc import add_documenter, \
    ModuleDocumenter, ClassDocumenter, ExceptionDocumenter, DataDocumenter, \
    FunctionDocumenter, MethodDocumenter, AttributeDocumenter, \
    InstanceAttributeDocumenter
add_documenter(ModuleDocumenter)
add_documenter(ClassDocumenter)
add_documenter(ExceptionDocumenter)
add_documenter(DataDocumenter)
add_documenter(FunctionDocumenter)
add_documenter(MethodDocumenter)
add_documenter(AttributeDocumenter)
add_documenter(InstanceAttributeDocumenter)

if False:
    # For type annotation
    from typing import Any, Callable, Dict, Tuple, List  # NOQA
    from jinja2 import BaseLoader  # NOQA
    from sphinx import addnodes  # NOQA
    from sphinx.builders import Builder  # NOQA
    from sphinx.environment import BuildEnvironment  # NOQA

 def add_autodocumenter(self, cls):
     self.debug('[app] adding autodocumenter: %r', cls)
     from sphinx.ext import autodoc
     autodoc.add_documenter(cls)
     self.add_directive('auto' + cls.objtype, autodoc.AutoDirective)

#print os.path.abspath('canvas')
sys.path.append(os.path.abspath('canvas'))
import redREnviron
directoryNames = redREnviron.__getDirectoryNames(os.path.abspath(''))
redREnviron.directoryNames = directoryNames
redREnviron.addOrangeDirectoriesToPath(directoryNames)
# import orngDlgs
# from orngDlgs import SignalDialog

from sphinx.ext import autodoc

class DocsonlyMethodDocumenter(autodoc.MethodDocumenter):
  def format_args(self):
    return None

autodoc.add_documenter(DocsonlyMethodDocumenter)

# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#sys.path.insert(0, os.path.abspath('.'))

# -- General configuration -----------------------------------------------------

# If your documentation needs a minimal Sphinx version, state it here.
#needs_sphinx = '1.0'

# Add any Sphinx extension module names here, as strings. They can be extensions
# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
extensions = ['sphinx.ext.autodoc', 'sphinx.ext.doctest', 'sphinx.ext.coverage', 'sphinx.ext.pngmath', 'sphinx.ext.ifconfig', 'sphinx.ext.viewcode', 'sphinx.ext.graphviz', 'sphinx.ext.inheritance_diagram']

#!/usr/bin/env python
import sys

import auto

sys.path.append("..")

from jinja2 import FileSystemLoader
from jinja2.sandbox import SandboxedEnvironment

from sphinx.ext.autodoc import (ModuleDocumenter,ClassDocumenter,ExceptionDocumenter,DataDocumenter,FunctionDocumenter,MethodDocumenter,AttributeDocumenter,InstanceAttributeDocumenter)

from sphinx.ext.autodoc import AutoDirective, add_documenter

for typ in (ModuleDocumenter,ClassDocumenter,ExceptionDocumenter,DataDocumenter,FunctionDocumenter,MethodDocumenter,AttributeDocumenter,InstanceAttributeDocumenter):
    add_documenter(typ)

from sphinx.ext.autosummary import get_documenter

def main ():
    loader = FileSystemLoader([".templates"])
    env = SandboxedEnvironment(loader=loader)

    done_files = []

    for orig_module in auto.modules:
        output = orig_module + ".rst"

        f = open(output, "w")

        try:

class TaskDocumenter(autodoc.FunctionDocumenter):
    objtype = "task"
    directivetype = "function"
    
    @classmethod
    def can_document_member(cls, member, membername, isattr, parent):
        from paver.tasks import Task
        return isinstance(member, Task)
        
    def import_object(self):
        super(TaskDocumenter, self).import_object()
        obj = self.object
        self.object = obj.func
        return True
    
autodoc.add_documenter(TaskDocumenter)

# General configuration
# ---------------------

# Add any Sphinx extension module names here, as strings. They can be extensions
# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
extensions = ['sphinx.ext.autodoc']

# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']

# The suffix of source filenames.
source_suffix = '.rst'

# The master toctree document.

def make_rst(rootpath, excludes, destdir, header=None, suffix="rst",
             full=False, author="Author", version="", release="", maxdepth=4,
             dryrun=False, followlinks=False, includeprivate=False,
             separatemodules=True, noheadings=False, force=False, notoc=False):
    """ Make a set of RST files for the modules starting at rootpath
    """

    add_documenter(ModuleDocumenter)
    add_documenter(ClassDocumenter)
    add_documenter(ExceptionDocumenter)
    add_documenter(DataDocumenter)
    add_documenter(FunctionDocumenter)
    add_documenter(MethodDocumenter)
    add_documenter(AttributeDocumenter)
    add_documenter(InstanceAttributeDocumenter)

    if header is None:
        header = path.normpath(rootpath).split(path.sep)[-1]
    if suffix.startswith('.'):
        suffix = suffix[1:]
    if not path.isdir(rootpath):
        print >>sys.stderr, '%s is not a directory.' % rootpath
        sys.exit(1)
    if not path.isdir(destdir):
        if not dryrun:
            os.makedirs(destdir)
    rootpath = path.normpath(path.abspath(rootpath))
    excludes = normalize_excludes(rootpath, excludes)
    modules = recurse_tree(rootpath, excludes, followlinks, includeprivate,
                           separatemodules, noheadings, destdir, dryrun, force,
                           suffix)
    if full:
        from sphinx import quickstart as qs
        modules.sort()
        prev_module = ''
        text = ''
        for module in modules:
            if module.startswith(prev_module + '.'):
                continue
            prev_module = module
            text += '   %s\n' % module
        d = dict(
            path=destdir,
            sep=False,
            dot='_',
            project=header,
            author=author,
            version=version,
            release=release,
            suffix='.' + suffix,
            master='index',
            epub=True,
            ext_autodoc=True,
            ext_viewcode=True,
            makefile=True,
            batchfile=True,
            mastertocmaxdepth=maxdepth,
            mastertoctree=text,
        )
        if not dryrun:
            qs.generate(d, silent=True, overwrite=force)
    elif not notoc:
        create_modules_toc_file(modules, header, maxdepth, destdir, dryrun,
                                force, suffix)

 def add_autodocumenter(self, cls):
     from sphinx.ext import autodoc
     autodoc.add_documenter(cls)
     self.add_directive('auto' + cls.objtype, autodoc.AutoDirective)

def setup(app):
    from docutils import nodes
    from sphinx.ext.autodoc import MethodDocumenter, add_documenter
    from sphinx.domains.python import PyXrefMixin, PyObject
    from sphinx.locale import _
    from sphinx.util.docfields import GroupedField
    from sphinx.writers.html import SmartyPantsHTMLTranslator

    class PyXrefGroupedField(PyXrefMixin, GroupedField):
        pass
    #-class

    class MethodDocumenterNoDecoratedPrivateMembers(MethodDocumenter):
        """Converts names like '_Class__private' to '__private'.
        """

        def format_name(self):
            objpath = self.objpath[:]
            if len(objpath) >= 2:
                class_name = objpath[-2]
                method_name = objpath[-1]
                if method_name.startswith("_%s" % class_name):
                    objpath[-1] = method_name[1 + len(class_name):] \
                                  or method_name
            return '.'.join(objpath) or self.modname
        #-def
    #-class

    add_documenter(MethodDocumenterNoDecoratedPrivateMembers)

    # Patch PyObject.doc_field_types:
    item = 0
    for field in PyObject.doc_field_types:
        if field.name == 'exceptions':
            break
        item += 1
    if item < len(PyObject.doc_field_types):
        PyObject.doc_field_types[item] = PyXrefGroupedField(
            field.name,
            label = field.label,
            rolename = field.rolename,
            names = field.names,
            can_collapse = field.can_collapse
        )

    # Patch Sphinx bug #1788:
    class CorrectedHTMLTranslator(SmartyPantsHTMLTranslator):

        def __init__(self, *args, **kwargs):
            SmartyPantsHTMLTranslator.__init__(self, *args, **kwargs)
        #-def

        def depart_caption(self, node):
            self.body.append('</span>')

            # append permalink if available
            if isinstance(node.parent, nodes.container) \
            and node.parent.get('literal_block'):
                self.add_permalink_ref(
                    node.parent, _('Permalink to this code')
                )
            elif isinstance(node.parent, nodes.figure):
                image_nodes = node.parent.traverse(nodes.image)
                target_node = image_nodes and image_nodes[0] or node.parent
                self.add_permalink_ref(
                    target_node, _('Permalink to this image')
                )
            elif node.parent.get('toctree'):
                self.add_permalink_ref(
                    node.parent.parent, _('Permalink to this toctree')
                )

            if isinstance(node.parent, nodes.container) \
            and node.parent.get('literal_block'):
                self.body.append('</div>\n')
            else:
                SmartyPantsHTMLTranslator.__bases__[0].__bases__[0] \
                    .depart_caption(self, node)
        #-def
    #-class

    def process_signature(
        app, what, name, obj, options, signature, return_annotation
    ):
        if what != 'function':
            return signature, return_annotation
        params = []
        # We suppose that we have not something like this:
        #
        #     def fnc(x, y, z = "Hello, World!", g = "== Problem? =="):
        #         ...
        #
        for p in [p.strip() for p in signature[1:-1].split(',')]:
            if '=' not in p:
                params.append(p)
                continue
            key, value = p.split('=')
            s, e = "<class '", "'>"
            if not value.startswith(s) or not value.endswith(e):
                params.append(p)
#.........这里部分代码省略.........

def setup(app):
    autodoc.add_documenter(FunctionDocumenter)
    autodoc.add_documenter(MethodDocumenter)