コード例 #1
0
    def run(self):
        # type: () -> List[nodes.Node]
        """
        """
        self.env = self.state.document.settings.env  # type: BuildEnvironment

        node = addnodes.desc()
        node.document = self.state.document
        # 'desctype' is a backwards compatible attribute
        node['objtype'] = node['desctype'] = self.objtype

        targetid = self.compute_target_id()
        caption = self.arguments[0]
        signode = addnodes.desc_signature(targetid, '')
        signode['names'].append(caption)
        signode['ids'].append(targetid)
        signode['first'] = 1
        targetnode = nodes.target('', '', ids=[targetid], names=[caption])
        signode += targetnode 
        signode += addnodes.desc_name(caption, caption)
        node.append(signode)        
        contentnode = addnodes.desc_content()
        node.append(contentnode)
        self.add_label(targetid, caption)
        if not 'setting_group' in self.env.temp_data:
            self.env.temp_data['setting_group'] = []
        self.env.temp_data['setting_group'].append(targetid)
        self.state.nested_parse(self.content, self.content_offset, contentnode)
        self.env.temp_data['setting_group'].pop()
        return [node]        
コード例 #2
0
ファイル: marxmarkup.py プロジェクト: Chandra-MARX/doc
    def handle_signature(self, sig, signode):
        match = re.search('(\w+)', sig)
        name = match.groups()[0]
        # At this point, we make no attempt to break up the arglist into
        # reqired parameters, keywords, optional arguments etc.
        # This would be very hard, since we would have to cover the syntax
        # of shell, IDL, S-Lang, ...
        # For our output all we want is to attach it to the name in
        # reasonable formatting.
        arglist = sig[len(name):]

        anno = self.options.get('annotation')
        lang = self.options.get('language')

        signode += addnodes.desc_name(name, name)
        # addname has a good formatting, even if it is meant for a
        # different use in sphinx for python.
        # Sphinx expects name + parameterlist, but unfortunately,
        # the parameterlist is automatically wrapped in (), so we avoid that
        # here.
        signode += addnodes.desc_addname(arglist, arglist)

        if lang:
            signode += addnodes.desc(' ' + lang, ' ' + lang)
        if anno:
            signode += addnodes.desc_annotation(' ' + anno, ' ' + anno)
        return name
コード例 #3
0
    def run(self):
        """Same as :meth:`sphinx.directives.ObjectDescription`
        but using :class:`FortranDocFieldTransformer`"""
        if ':' in self.name:
            self.domain, self.objtype = self.name.split(':', 1)
        else:
            self.domain, self.objtype = '', self.name
        if not hasattr(self, 'env'):
            self.env = self.state.document.settings.env
        self.indexnode = addnodes.index(entries=[])

        node = addnodes.desc()
        node.document = self.state.document
        node['domain'] = self.domain
        # 'desctype' is a backwards compatible attribute
        node['objtype'] = node['desctype'] = self.objtype
        node['noindex'] = noindex = ('noindex' in self.options)

        self.names = []
        signatures = self.get_signatures()
        for i, sig in enumerate(signatures):
            # add a signature node for each signature in the current unit
            # and add a reference target for it
            signode = addnodes.desc_signature(sig, '')
            signode['first'] = False
            node.append(signode)
            try:
                # name can also be a tuple, e.g. (classname, objname);
                # this is strictly domain-specific (i.e. no assumptions may
                # be made in this base class)
                name = self.handle_signature(sig, signode)
            except ValueError:
                # signature parsing failed
                signode.clear()
                signode += addnodes.desc_name(sig, sig)
                continue  # we don't want an index entry here
            if not isinstance(name[0], six.string_types):
                name = (str(name), name[1])
            if not noindex and name not in self.names:
                # only add target and index entry if this is the first
                # description of the object with this name in this desc block
                self.names.append(name)
                self.add_target_and_index(name, sig, signode)

        modname = signode.get('module')
        typename = signode.get('type')
        contentnode = addnodes.desc_content()
        node.append(contentnode)
        if self.names:
            # needed for association of version{added,changed} directives
            self.env.temp_data['object'] = self.names[0]
        self.before_content()
        self.state.nested_parse(self.content, self.content_offset, contentnode)
        FortranDocFieldTransformer(
            self,
            modname=modname,
            typename=typename).transform_all(contentnode)
        self.env.temp_data['object'] = None
        self.after_content()
        return [self.indexnode, node]
コード例 #4
0
    def handle_signature(self, sig, signode):
        match = re.search('(\w+)', sig)
        name = match.groups()[0]
        # At this point, we make no attempt to break up the arglist into
        # reqired parameters, keywords, optional arguments etc.
        # This would be very hard, since we would have to cover the syntax
        # of shell, IDL, S-Lang, ...
        # For our output all we want is to attach it to the name in
        # reasonable formatting.
        arglist = sig[len(name):]

        anno = self.options.get('annotation')
        lang = self.options.get('language')

        signode += addnodes.desc_name(name, name)
        # addname has a good formatting, even if it is meant for a
        # different use in sphinx for python.
        # Sphinx expects name + parameterlist, but unfortunately,
        # the parameterlist is automatically wrapped in (), so we avoid that
        # here.
        signode += addnodes.desc_addname(arglist, arglist)

        if lang:
            signode += addnodes.desc(' ' + lang, ' ' + lang)
        if anno:
            signode += addnodes.desc_annotation(' ' + anno, ' ' + anno)
        return name
コード例 #5
0
    def run_definition(self, definition, base_ids):
        r"""
        Writes down the definition of a field of a message and parses its
        description.

        In general it can be seen as a function that converts `MessageField` in
        parsed document, with a description section containing both signature and
        informative content text.

        The signature are set as `attribute` object type.
        
        :param definition: a definition that should be parsed
        :param base_ids: the base id for indexing, local scope will be added to that 
                         id, based on the name of the field.
        :return: a full `desc` node, to be added to the main document
        """
        ids = f"{base_ids}.{definition.name}"
        desc_type = addnodes.desc_type(text=definition.type_text)
        desc_name = addnodes.desc_name(text=definition.name)
        desc_annotation = addnodes.desc_annotation(
            text=definition.default_text)
        desc_signature = addnodes.desc_signature(ids=[ids],
                                                 fullname=[definition.name])
        desc_signature += desc_type
        desc_signature += desc_name
        desc_signature += desc_annotation

        section = self.run_section(definition.text, ids)
        desc_content = addnodes.desc_content()
        desc_content += section
        desc = addnodes.desc(objtype="attribute")
        desc += desc_signature
        desc += desc_content
        return desc
コード例 #6
0
ファイル: directives.py プロジェクト: maxrothman/sphinx-test
  def run(self):
    #no good
    # node = nodes.paragraph('', 'Hi there!',
    #   ids=['foo'],
    #   names = ['foobar']
    # )

    #works
    # node = nodes.section(names=['foobar'])
    # self.state.document.note_explicit_target(node)
    # node.append(nodes.paragraph('', "foo foo"))
    
    #no good
    # node = nodes.admonition(names=['foobar'])
    # self.state.document.note_explicit_target(node)
    # node.append(nodes.paragraph('', "foo foo"))

    # node = nodes.paragraph('', 'foo foo', names=['foobar'])
    # self.state.document.note_explicit_target(node)

    #This doesn't properly render
    desc = addnodes.desc('',
      addnodes.desc_signature('',
        addnodes.desc_name('', 'namename'),
        addnodes.desc_parameterlist('',
          addnodes.desc_parameter('', 'def')
        ),
      names=['namename'], fullname="namename", ids=['namename'], module=None, first=False),
    desctype="function", domain="py", objtype='objtype')
    
    #no link (because didn't properly render?)
    self.state.document.note_explicit_target(desc)
    return [desc]
コード例 #7
0
    def run(self):
        self.desctype = self.name
        self.env = self.state.document.settings.env
        self.indexnode = addnodes.index(entries=[])

        node = addnodes.desc()
        node.document = self.state.document
        node['desctype'] = self.desctype
        node['noindex'] = noindex = ('noindex' in self.options)

        self.names = []
        signatures = self.get_signatures()
        for i, sig in enumerate(signatures):
            # add a signature node for each signature in the current unit
            # and add a reference target for it
            signode = addnodes.desc_signature(sig, '')
            signode['first'] = False
            node.append(signode)
            try:
                # name can also be a tuple, e.g. (classname, objname)
                name = self.parse_signature(sig, signode)
            except ValueError, err:
                # signature parsing failed
                signode.clear()
                signode += addnodes.desc_name(sig, sig)
                continue  # we don't want an index entry here
            if not noindex and name not in self.names:
                # only add target and index entry if this is the first
                # description of the object with this name in this desc block
                self.names.append(name)
                self.add_target_and_index(name, sig, signode)
コード例 #8
0
ファイル: desc.py プロジェクト: 89sos98/main
    def run(self):
        self.desctype = self.name
        self.env = self.state.document.settings.env
        self.indexnode = addnodes.index(entries=[])

        node = addnodes.desc()
        node.document = self.state.document
        node['desctype'] = self.desctype
        node['noindex'] = noindex = ('noindex' in self.options)

        self.names = []
        signatures = self.get_signatures()
        for i, sig in enumerate(signatures):
            # add a signature node for each signature in the current unit
            # and add a reference target for it
            signode = addnodes.desc_signature(sig, '')
            signode['first'] = False
            node.append(signode)
            try:
                # name can also be a tuple, e.g. (classname, objname)
                name = self.parse_signature(sig, signode)
            except ValueError, err:
                # signature parsing failed
                signode.clear()
                signode += addnodes.desc_name(sig, sig)
                continue  # we don't want an index entry here
            if not noindex and name not in self.names:
                # only add target and index entry if this is the first
                # description of the object with this name in this desc block
                self.names.append(name)
                self.add_target_and_index(name, sig, signode)
コード例 #9
0
ファイル: sphinxdomain.py プロジェクト: klauer/blark
def declarations_to_block(
    declarations: Iterable[summary.DeclarationSummary],
    *,
    env: Optional[sphinx.environment.BuildEnvironment] = None,
) -> Generator[addnodes.desc, None, None]:
    # These nodes translate into the following in html:
    # desc -> dl
    # desc_signature -> dt
    # desc_content -> dd
    # So:
    #  desc
    #  -> desc_signature
    #      -> desc_sig_name, desc_sig_punctuation, etc.
    #  -> desc_content
    #      -> paragraph, etc.
    for decl in declarations:
        desc = addnodes.desc(classes=["declaration"])
        signode = addnodes.desc_signature()
        signode += declaration_to_signature(signode, decl, env=env)

        decl_info = addnodes.desc_content()
        decl_info += declaration_to_content(decl)

        desc += signode
        desc += decl_info

        yield desc
コード例 #10
0
ファイル: workchain.py プロジェクト: greschd/sphinx-aiida
 def build_node_tree(self):
     """Returns the docutils node tree."""
     workchain_node = addnodes.desc(
         desctype='class', domain='py', noindex=False, objtype='class'
     )
     workchain_node += self.build_signature()
     workchain_node += self.build_content()
     return [workchain_node]
コード例 #11
0
ファイル: __init__.py プロジェクト: aldebaran/doc-tools
 def run(self):
     populated = CPPAutoDocObject._populate(self)
     indexnode = addnodes.index(entries=[])
     main_node = addnodes.desc()
     main_node['objtype'] = 'type'
     if populated:
         obj = self._get_obj()
         main_node += self._make_typedef_documentation(obj)
     return [indexnode, main_node]
コード例 #12
0
def getGroupTree(Group, prefix):
  return [
    nodes.target('', '', ids=[prefix]),
    desc(prefix,
      getSignature(Group.Config),
      getMemberContent(Group, *getChildren(Group, prefix)),
      id=prefix, objtype='Group'
    )
  ]
コード例 #13
0
def getGroupTree(Group, prefix):
  return [
    nodes.target('', '', ids=[prefix]),
    desc(prefix,
      getSignature(Group.Config),
      getMemberContent(Group, *getChildren(Group, prefix)),
      id=prefix, objtype='Group'
    )
  ]
コード例 #14
0
ファイル: ext.py プロジェクト: Cray/buildbot
    def run(self):
        self.env = env = self.state.document.settings.env
        # normalize whitespace in fullname like XRefRole does
        fullname = ws_re.sub(' ', self.arguments[0].strip())
        targetname = '%s-%s' % (self.ref_type, fullname)

        # keep the target; this may be used to generate a BBIndex later
        targets = env.domaindata['bb']['targets'].setdefault(self.ref_type, {})
        targets[fullname] = env.docname, targetname

        # make up the descriptor: a target and potentially an index descriptor
        node = nodes.target('', '', ids=[targetname])
        ret = [node]

        # add the target to the document
        self.state.document.note_explicit_target(node)

        # append the index node if necessary
        entries = []
        for tpl in self.indextemplates:
            colon = tpl.find(':')
            if colon != -1:
                indextype = tpl[:colon].strip()
                indexentry = tpl[colon + 1:].strip() % (fullname,)
            else:
                indextype = 'single'
                indexentry = tpl % (fullname,)
            entries.append(
                (indextype, indexentry, targetname, targetname, None))

        if entries:
            inode = addnodes.index(entries=entries)
            ret.insert(0, inode)

        # if the node has content, set up a signature and parse the content
        if self.has_content:
            descnode = addnodes.desc()
            descnode['domain'] = 'bb'
            descnode['objtype'] = self.ref_type
            descnode['noindex'] = True
            signode = addnodes.desc_signature(fullname, '')

            if self.name_annotation:
                annotation = "%s " % self.name_annotation
                signode += addnodes.desc_annotation(annotation, annotation)
            signode += addnodes.desc_name(fullname, fullname)
            descnode += signode

            contentnode = addnodes.desc_content()
            self.state.nested_parse(self.content, 0, contentnode)
            DocFieldTransformer(self).transform_all(contentnode)
            descnode += contentnode

            ret.append(descnode)

        return ret
コード例 #15
0
ファイル: fortran_domain.py プロジェクト: leloulight/magic
    def run(self):
        """Same as :meth:`sphinx.directives.ObjectDescription`
        but using :class:`FortranDocFieldTransformer`"""
        if ':' in self.name:
            self.domain, self.objtype = self.name.split(':', 1)
        else:
            self.domain, self.objtype = '', self.name
        self.env = self.state.document.settings.env
        self.indexnode = addnodes.index(entries=[])

        node = addnodes.desc()
        node.document = self.state.document
        node['domain'] = self.domain
        # 'desctype' is a backwards compatible attribute
        node['objtype'] = node['desctype'] = self.objtype
        node['noindex'] = noindex = ('noindex' in self.options)

        self.names = []
        signatures = self.get_signatures()
        for i, sig in enumerate(signatures):
            # add a signature node for each signature in the current unit
            # and add a reference target for it
            signode = addnodes.desc_signature(sig, '')
            signode['first'] = False
            node.append(signode)
            try:
                # name can also be a tuple, e.g. (classname, objname);
                # this is strictly domain-specific (i.e. no assumptions may
                # be made in this base class)
                name = self.handle_signature(sig, signode)
            except ValueError:
                # signature parsing failed
                signode.clear()
                signode += addnodes.desc_name(sig, sig)
                continue  # we don't want an index entry here
            if not isinstance(name[0], unicode):
                name = (unicode(name), name[1])
            if not noindex and name not in self.names:
                # only add target and index entry if this is the first
                # description of the object with this name in this desc block
                self.names.append(name)
                self.add_target_and_index(name, sig, signode)

        modname = signode.get('module')
        typename = signode.get('type')
        contentnode = addnodes.desc_content()
        node.append(contentnode)
        if self.names:
            # needed for association of version{added,changed} directives
            self.env.temp_data['object'] = self.names[0]
        self.before_content()
        self.state.nested_parse(self.content, self.content_offset, contentnode)
        FortranDocFieldTransformer(self, modname=modname, typename=typename).transform_all(contentnode)
        self.env.temp_data['object'] = None
        self.after_content()
        return [self.indexnode, node]
コード例 #16
0
    def run(self):
        self.env = env = self.state.document.settings.env
        # normalize whitespace in fullname like XRefRole does
        fullname = ws_re.sub(' ', self.arguments[0].strip())
        targetname = '%s-%s' % (self.ref_type, fullname)

        # keep the target; this may be used to generate a BBIndex later
        targets = env.domaindata['bb']['targets'].setdefault(self.ref_type, {})
        targets[fullname] = env.docname, targetname

        # make up the descriptor: a target and potentially an index descriptor
        node = nodes.target('', '', ids=[targetname])
        ret = [node]

        # add the target to the document
        self.state.document.note_explicit_target(node)

        # append the index node if necessary
        entries = []
        for tpl in self.indextemplates:
            colon = tpl.find(':')
            if colon != -1:
                indextype = tpl[:colon].strip()
                indexentry = tpl[colon + 1:].strip() % (fullname, )
            else:
                indextype = 'single'
                indexentry = tpl % (fullname, )
            entries.append(
                (indextype, indexentry, targetname, targetname, None))

        if entries:
            inode = addnodes.index(entries=entries)
            ret.insert(0, inode)

        # if the node has content, set up a signature and parse the content
        if self.has_content:
            descnode = addnodes.desc()
            descnode['domain'] = 'bb'
            descnode['objtype'] = self.ref_type
            descnode['noindex'] = True
            signode = addnodes.desc_signature(fullname, '')

            if self.name_annotation:
                annotation = "%s " % self.name_annotation
                signode += addnodes.desc_annotation(annotation, annotation)
            signode += addnodes.desc_name(fullname, fullname)
            descnode += signode

            contentnode = addnodes.desc_content()
            self.state.nested_parse(self.content, 0, contentnode)
            DocFieldTransformer(self).transform_all(contentnode)
            descnode += contentnode

            ret.append(descnode)

        return ret
コード例 #17
0
def getArgsContent(Args):
  Container = desc('', desc_signature(text='Args'), objtype="Args")

  for name, Arg in Args.items():
    Content = desc_content()
    Content.append(desc_name(text='%s: ' % name))
    Content.append(compact_paragraph(text=getArgDesc(Arg)))
    Container.append(Content)

  return Container
コード例 #18
0
def getArgsContent(Args):
  Container = desc('', desc_signature(text='Args'), objtype="Args")

  for name, Arg in Args.items():
    Content = desc_content()
    Content.append(desc_name(text='%s: ' % name))
    Content.append(compact_paragraph(text=getArgDesc(Arg)))
    Container.append(Content)

  return Container
コード例 #19
0
ファイル: __init__.py プロジェクト: aldebaran/doc-tools
 def run(self):
     populated = CPPAutoDocObject._populate(self)
     if populated:
       (desc, content) = CPPAutoDocObject._make_enum_documentation(self, self._obj)
       lst = addnodes.desc()
       lst += desc
       lst += content
       lst['objtype'] = 'type'
       return [lst]
     return []
コード例 #20
0
ファイル: envy.py プロジェクト: xlee/envytools
    def run(self):
        if ':' in self.name:
            self.domain, self.objtype = self.name.split(':', 1)
        else:
            self.domain, self.objtype = '', self.name
        self.env = self.state.document.settings.env
        self.indexnode = addnodes.index(entries=[])

        obj = self.make_obj()
        node = addnodes.desc()
        node.document = self.state.document
        node['domain'] = self.domain
        # 'desctype' is a backwards compatible attribute
        node['objtype'] = node['desctype'] = self.objtype
        node['noindex'] = noindex = ('noindex' in self.options)
        node.name = obj.name
        obj.docname = self.env.docname

        objects = self.env.domaindata['envy']['objects']

        signode = addnodes.desc_signature('', '')
        signode['first'] = True
        node.append(signode)
        self.make_signature(obj, signode)
        if not noindex and self.name not in objects:
            # only add target and index entry if this is the first
            # description of the object with this name in this desc block
            #self.add_target_and_index(self.name, sig, signode)
            nid = obj.iname + '-' + self.name
            signode['names'].append(nid)
            signode['ids'].append(nid)
            self.state.document.note_explicit_target(signode)

        for loc in self.locs:
            signode = addnodes.desc_signature('', '')
            signode['first'] = False
            node.append(signode)
            signode += addnodes.desc_name(loc, loc)

        node.append(uplink_placeholder(self.name))

        if self.name in objects:
            other = objects[self.name]
            self.state_machine.reporter.warning(
                'duplicate object {}, other instance in {}'.format(
                    self.name, self.env.doc2path(other.docname)))
        objects[self.name] = obj

        contentnode = addnodes.desc_content()
        node.append(contentnode)
        self.env.temp_data['object'] = self.name
        self.state.nested_parse(self.content, self.content_offset, contentnode)
        self.env.temp_data['object'] = None
        contentnode += self.after_content()
        return [self.indexnode, node]
コード例 #21
0
ファイル: envy.py プロジェクト: AlexAltea/envytools
    def run(self):
        if ':' in self.name:
            self.domain, self.objtype = self.name.split(':', 1)
        else:
            self.domain, self.objtype = '', self.name
        self.env = self.state.document.settings.env
        self.indexnode = addnodes.index(entries=[])

        obj = self.make_obj()
        node = addnodes.desc()
        node.document = self.state.document
        node['domain'] = self.domain
        # 'desctype' is a backwards compatible attribute
        node['objtype'] = node['desctype'] = self.objtype
        node['noindex'] = noindex = ('noindex' in self.options)
        node.name = obj.name
        obj.docname = self.env.docname

        objects = self.env.domaindata['envy']['objects']

        signode = addnodes.desc_signature('', '')
        signode['first'] = True
        node.append(signode)
        self.make_signature(obj, signode)
        if not noindex and self.name not in objects:
            # only add target and index entry if this is the first
            # description of the object with this name in this desc block
            #self.add_target_and_index(self.name, sig, signode)
            nid = obj.iname + '-' + self.name
            signode['names'].append(nid)
            signode['ids'].append(nid)
            self.state.document.note_explicit_target(signode)

        for loc in self.locs:
            signode = addnodes.desc_signature('', '')
            signode['first'] = False
            node.append(signode)
            signode += addnodes.desc_name(loc, loc)

        node.append(uplink_placeholder(self.name))

        if self.name in objects:
            other = objects[self.name]
            self.state_machine.reporter.warning('duplicate object {}, other instance in {}'.format(self.name, self.env.doc2path(other.docname)))
        objects[self.name] = obj

        contentnode = addnodes.desc_content()
        node.append(contentnode)
        self.env.temp_data['object'] = self.name
        self.state.nested_parse(self.content, self.content_offset, contentnode)
        self.env.temp_data['object'] = None
        contentnode += self.after_content()
        return [self.indexnode, node]
コード例 #22
0
    def make_process_header(self, slug, typ, version, source_uri, description,
                            inputs):
        """Generate a process definition header.

        :param str slug: process' slug
        :param str typ: process' type
        :param str version:  process' version
        :param str source_uri: url to the process definition
        :param str description: process' description
        :param dict inputs: process' inputs

        """
        node = addnodes.desc()
        signode = addnodes.desc_signature(slug, "")
        node.append(signode)

        node["objtype"] = node["desctype"] = typ

        signode += addnodes.desc_annotation(typ, typ, classes=["process-type"])
        signode += addnodes.desc_addname("", "")
        signode += addnodes.desc_name(slug + " ", slug + " ")

        paramlist = addnodes.desc_parameterlist()

        for field_schema, _, _ in iterate_schema({}, inputs, ""):
            field_type = field_schema["type"]
            field_name = field_schema["name"]

            field_default = field_schema.get("default", None)
            field_default = "" if field_default is None else "={}".format(
                field_default)

            param = addnodes.desc_parameter("", "", noemph=True)
            param += nodes.emphasis(field_type,
                                    field_type,
                                    classes=["process-type"])
            # separate by non-breaking space in the output
            param += nodes.strong(text="\xa0\xa0" + field_name)

            paramlist += param

        signode += paramlist
        signode += nodes.reference(
            "",
            nodes.Text("[Source: v{}]".format(version)),
            refuri=source_uri,
            classes=["viewcode-link"],
        )

        desc = nodes.paragraph()
        desc += nodes.Text(description, description)

        return [node, desc]
コード例 #23
0
    def run(self):
        if ':' in self.name:
            self.domain, self.objtype = self.name.split(':', 1)
        else:
            self.domain, self.objtype = '', self.name
        self.indexnode = addnodes.index(entries=[])

        node = addnodes.desc()
        node.document = self.state.document
        node['domain'] = self.domain

        node['classes'].append('csharp')

        node['objtype'] = node['desctype'] = self.objtype
        node['noindex'] = noindex = ('noindex' in self.options)

        self.names = []
        signatures = self.get_signatures()
        for i, sig in enumerate(signatures):
            beforesignode = CSNodes.EmptyNode()
            node.append(beforesignode)

            signode = addnodes.desc_signature(sig, '')
            signode['first'] = False
            node.append(signode)
            self.before_sig(beforesignode)
            try:
                name = self.handle_signature(sig, signode)
            except ValueError:
                signode.clear()
                signode += addnodes.desc_name(sig, sig)
                continue
            if name not in self.names:
                self.names.append(name)
                if not noindex:
                    self.add_target_and_index(name, sig, signode)

            aftersignode = CSNodes.EmptyNode()
            node.append(aftersignode)
            self.after_sig(aftersignode)

        contentnode = addnodes.desc_content()
        node.append(contentnode)
        self.before_content_node(contentnode)
        if self.names:
            self.env.temp_data['object'] = self.names[0]
        self.before_content()
        self.state.nested_parse(self.content, self.content_offset, contentnode)
        self.after_content_node(contentnode)
        DocFieldTransformer(self).transform_all(contentnode)
        self.env.temp_data['object'] = None
        self.after_content()
        return [self.indexnode, node]
コード例 #24
0
    def make_process_header(self, slug, typ, version, source_uri, description,
                            inputs):
        """Generate a process definition header.

        :param str slug: process' slug
        :param str typ: process' type
        :param str version:  process' version
        :param str source_uri: url to the process definition
        :param str description: process' description
        :param dict inputs: process' inputs

        """
        node = addnodes.desc()
        signode = addnodes.desc_signature(slug, '')
        node.append(signode)

        node['objtype'] = node['desctype'] = typ

        signode += addnodes.desc_annotation(typ, typ, classes=['process-type'])
        signode += addnodes.desc_addname('', '')
        signode += addnodes.desc_name(slug + ' ', slug + ' ')

        paramlist = addnodes.desc_parameterlist()

        for field_schema, _, _ in iterate_schema({}, inputs, ''):
            field_type = field_schema['type']
            field_name = field_schema['name']

            field_default = field_schema.get('default', None)
            field_default = '' if field_default is None else '={}'.format(
                field_default)

            param = addnodes.desc_parameter('', '', noemph=True)
            param += nodes.emphasis(field_type,
                                    field_type,
                                    classes=['process-type'])
            # separate by non-breaking space in the output
            param += nodes.strong(text='\xa0\xa0' + field_name)

            paramlist += param

        signode += paramlist
        signode += nodes.reference('',
                                   nodes.Text('[Source: v{}]'.format(version)),
                                   refuri=source_uri,
                                   classes=['viewcode-link'])

        desc = nodes.paragraph()
        desc += nodes.Text(description, description)

        return [node, desc]
コード例 #25
0
ファイル: directives.py プロジェクト: yemanadep/Flectra
    def generate(self, all_members=False):
        """
        :rtype: List[nodes.Node]
        """
        objname = self.item.name
        prefixed = (self.item['sourcemodule'].name + '.' +
                    objname) if self.item['sourcemodule'] else None
        objtype = self.objtype
        assert objtype, '%s has no objtype' % type(self)
        root = addnodes.desc(domain='js', desctype=objtype, objtype=objtype)
        with addto(
                root,
                addnodes.desc_signature(
                    module=self.modname or '',
                    fullname=objname,
                )) as s:
            s['class'] = self.classname

            s['ids'] = []
            if objname:
                s['ids'].append(objname)
            if prefixed:
                s['ids'].append(prefixed)

            if objtype:
                s += addnodes.desc_annotation(
                    objtype,
                    objtype,
                    nodes.Text(' '),
                )

                env = self.env
                if objname:
                    env.domaindata['js']['objects'][objname] = (env.docname,
                                                                objtype)
                if prefixed:
                    env.domaindata['js']['objects'][prefixed] = (env.docname,
                                                                 objtype)

            # TODO: linkcode_resolve
            s += self.make_signature()
        with addto(root, addnodes.desc_content()) as c:
            # must be here otherwise nested_parse(self.content) will not have
            # the prefix set
            self.env.temp_data.setdefault('autojs:prefix',
                                          []).append(self.item.name)
            c += self.make_content(all_members=all_members)
            self.env.temp_data['autojs:prefix'].pop()
        return [root]
コード例 #26
0
ファイル: __init__.py プロジェクト: aldebaran/doc-tools
 def _make_index_section(self, obj, title, id):
     section = self._make_section(title)
     subobjs = obj.filter_by_id(id)
     kwargs = {
         'refdomain': 'cpp',
         'refexplicit': False,
     }
     if subobjs:
         lst = addnodes.desc()
         lst['objtype'] = 'function function-index'
         for obj in subobjs:
             desc = addnodes.desc_signature()
             span = nodes.inline()
             try:
                 kwargs['reftype'] = 'func'
                 if obj.rv is not None:
                     span += addnodes.desc_type(text=str(obj.rv))
             except AttributeError:
                 kwargs['reftype'] = 'member'
                 span += addnodes.desc_type(text=str(obj.typename))
             desc += span
             desc += nodes.Text(u' ')
             name = unicode(obj.name)
             kwargs['reftarget'] = unicode(obj.get_name())
             name = name.split('::')[-1]
             desc_name = addnodes.desc_name()
             refnode = addnodes.pending_xref('', **kwargs)
             innernode = nodes.literal(text=name)
             innernode.attributes['classes'].extend(['xref', 'cpp', 'cpp-func'])
             refnode += innernode
             desc_name += refnode
             desc += desc_name
             try:
                 paramlist = addnodes.desc_parameterlist()
                 for param_obj in obj.signature:
                     param = addnodes.desc_parameter('', '', noemph=True)
                     if param_obj.type is not None:
                         param += nodes.Text(str(param_obj.type) + ' ')
                     param += nodes.emphasis(text=str(param_obj.name))
                     paramlist += param
                 desc += paramlist
                 if obj.const:
                     desc += nodes.Text(u' const')
             except AttributeError:
                 pass
             lst += desc
         section += lst
         return section
     return None
コード例 #27
0
ファイル: sphinx_ext_wire.py プロジェクト: vmagamedov/harness
    def run(self):
        missing_options = set(self.option_spec).difference(self.options)
        if missing_options:
            raise ValueError(f"Missing options: {missing_options!r};"
                             f" content: {list(self.content)!r}")
        try:
            wires = getattr(self.env.app, KEY)
        except AttributeError:
            wires = []
            setattr(self.env.app, KEY, wires)
        wires.append(
            WireInfo(
                value=self.content[0],
                type=self.options["type"],
                runtime=self.options["runtime"],
                config=self.options["config"],
                requirements=self.options["requirements"].split(),
            ))

        node = addnodes.desc()
        node["objtype"] = "wire"
        signode = addnodes.desc_signature("", "")
        signode += addnodes.desc_annotation("type", "type:")
        signode += addnodes.desc_name(self.options["type"],
                                      self.options["type"])
        signode += addnodes.desc_annotation("config", "config:")
        signode += addnodes.pending_xref(
            "",
            addnodes.desc_addname(self.options["config"],
                                  self.options["config"]),
            refdomain="proto",
            reftype="message",
            reftarget=self.options["config"],
        )
        node.append(signode)

        contentnode = addnodes.desc_content()
        if self.options["requirements"]:
            contentnode += nodes.paragraph("", "Requirements:")
            bullet_list = nodes.bullet_list("")
            for requirement in self.options["requirements"].split():
                bullet_list += nodes.list_item("",
                                               nodes.literal("", requirement))
            contentnode += bullet_list
        else:
            contentnode += nodes.paragraph("", "No requirements")
        node.append(contentnode)

        return [node]
コード例 #28
0
def getTaskTree(Task, id):
  Config = Task.Config

  Elms = [nodes.target('', '', ids=[id])]

  content = getMemberContent(Task)
  signature = getSignature(Config)
  signature.append(getArgList(Task.Args))

  if Task.Args:
    content.append(getArgsContent(Task.Args))

  Elms.append(desc(id, signature, content, id=id, objtype='Task'))

  return Elms
コード例 #29
0
ファイル: __init__.py プロジェクト: aldebaran/doc-tools
 def _make_enums_documentation(self, obj):
     first = True
     if obj.enums:
         section = self._make_section('Enumerations')
         lst = addnodes.desc()
         section += lst
         lst['objtype'] = 'type'
         for obj_ in obj.enums:
             obj_.docname = obj.docname
             (desc, content) = _make_enum_documentation(self, obj_)
             desc.attributes['first'] = first
             lst += desc
             lst += content
         return section
     return None
コード例 #30
0
def getTaskTree(Task, id):
  Config = Task.Config

  Elms = [nodes.target('', '', ids=[id])]

  content = getMemberContent(Task)
  signature = getSignature(Config)
  signature.append(getArgList(Task.Args))

  if Task.Args:
    content.append(getArgsContent(Task.Args))

  Elms.append(desc(id, signature, content, id=id, objtype='Task'))

  return Elms
コード例 #31
0
ファイル: envy.py プロジェクト: zhusl/envytools
    def run(self):
        if ':' in self.name:
            self.domain, self.objtype = self.name.split(':', 1)
        else:
            self.domain, self.objtype = '', self.name
        self.env = self.state.document.settings.env

        obj_name, = self.arguments
        for obj in self.gen_type.instances:
            if obj.name == obj_name:
                break
        else:
            raise ValueError('unknown instance {}'.format(obj_name))

        node = addnodes.desc()
        node.document = self.state.document
        node['domain'] = self.domain
        node['objtype'] = node['desctype'] = self.objtype
        node['noindex'] = False
        node.name = obj.slug
        pobj = GenObjPlaceholder(self.env.docname, obj.brief)

        genobjs = self.env.domaindata['envy']['genobjs']

        signode = addnodes.desc_signature('', '')
        signode['first'] = True
        node.append(signode)
        self.make_signature(obj, signode)
        signode['names'].append(obj.name)
        signode['ids'].append(obj.slug)
        self.state.document.note_explicit_target(signode)

        if obj.slug in genobjs:
            other = genobjs[obj.slug]
            self.state_machine.reporter.warning('duplicate object {}, other instance in {}'.format(obj.slug, self.env.doc2path(other.docname)))
        genobjs[obj.slug] = pobj

        contentnode = addnodes.desc_content()
        node.append(contentnode)
        vl = ViewList()
        doc = prepare_docstring(obj.doc or '')
        for line in doc:
            vl.append(line, obj_name)
        self.state.nested_parse(vl, 0, contentnode)

        return [
            node
        ]
コード例 #32
0
ファイル: eldomain.py プロジェクト: immerrr/sphinx-eldomain
    def run(self):
        env = self.state.document.settings.env
        package = env.temp_data.get('el:package')
        keymap_list = DATA.get(package, {}).get('keymap', [])
        keymap_name = self.arguments[0]
        for keymap in keymap_list:
            if keymap['name'] == keymap_name:
                break
        else:
            return [
                self.state.reporter.warning(
                    "Keymap {0} not found".format(keymap_name))
            ]
        nodelist = []

        mapdoc = keymap['doc']
        if mapdoc:
            nd = nodes.paragraph()
            lines = string2lines(doc_to_rst(mapdoc))
            if lines and lines[-1].startswith('(fn '):
                lines = lines[:-1]
            self.state.nested_parse(StringList(lines), 0, nd)
            nodelist.append(nd)

        exclude = self.options.get('exclude', [])
        replace = self.options.get('replace', [])
        for keybind in filter_by_exclude_regexp_list(keymap['data'], exclude,
                                                     lambda x: x['func']):
            desc = addnodes.desc()
            desc['domain'] = 'el'
            desc['objtype'] = 'keybind'
            desc['noindex'] = False
            signode = addnodes.desc_signature()
            # signode += addnodes.desc_annotation("", 'keybind ')
            key = simple_sed(replace, keybind['key'])
            signode += addnodes.desc_name("", key)
            signode += addnodes.desc_addname("", " " + keybind['func'])
            desc += signode
            if keybind['doc']:
                nd = addnodes.desc_content()
                lines = string2lines(doc_to_rst(keybind['doc']))
                if lines and lines[-1].startswith('(fn '):
                    lines = lines[:-1]
                self.state.nested_parse(StringList(lines), 0, nd)
                desc += nodes.definition("", nd)
            nodelist.append(desc)

        return nodelist
コード例 #33
0
def check(name, input, idDict, output=None):
    # first a simple check of the AST
    if output is None:
        output = input
    ast = parse(name, input)
    res = str(ast)
    if res != output:
        print("")
        print("Input:    ", input)
        print("Result:   ", res)
        print("Expected: ", output)
        raise DefinitionError("")
    rootSymbol = Symbol(None, None, None, None, None, None)
    symbol = rootSymbol.add_declaration(ast, docname="TestDoc")
    parentNode = addnodes.desc()
    signode = addnodes.desc_signature(input, '')
    parentNode += signode
    ast.describe_signature(signode, 'lastIsName', symbol, options={})

    idExpected = [None]
    for i in range(1, _max_id + 1):
        if i in idDict:
            idExpected.append(idDict[i])
        else:
            idExpected.append(idExpected[i - 1])
    idActual = [None]
    for i in range(1, _max_id + 1):
        try:
            id = ast.get_id(version=i)
            assert id is not None
            idActual.append(id[len(_id_prefix[i]):])
        except NoOldIdError:
            idActual.append(None)

    res = [True]
    for i in range(1, _max_id + 1):
        res.append(idExpected[i] == idActual[i])

    if not all(res):
        print("input:    %s" % input.rjust(20))
        for i in range(1, _max_id + 1):
            if res[i]:
                continue
            print("Error in id version %d." % i)
            print("result:   %s" % idActual[i])
            print("expected: %s" % idExpected[i])
        print(rootSymbol.dump(0))
        raise DefinitionError("")
コード例 #34
0
ファイル: test_domain_cpp.py プロジェクト: mgeier/sphinx
def check(name, input, idDict, output=None):
    # first a simple check of the AST
    if output is None:
        output = input
    ast = parse(name, input)
    res = text_type(ast)
    if res != output:
        print("")
        print("Input:    ", text_type(input))
        print("Result:   ", res)
        print("Expected: ", output)
        raise DefinitionError("")
    rootSymbol = Symbol(None, None, None, None, None, None)
    symbol = rootSymbol.add_declaration(ast, docname="TestDoc")
    parentNode = addnodes.desc()
    signode = addnodes.desc_signature(input, '')
    parentNode += signode
    ast.describe_signature(signode, 'lastIsName', symbol, options={})

    idExpected = [None]
    for i in range(1, _max_id + 1):
        if i in idDict:
            idExpected.append(idDict[i])
        else:
            idExpected.append(idExpected[i - 1])
    idActual = [None]
    for i in range(1, _max_id + 1):
        try:
            id = ast.get_id(version=i)
            assert id is not None
            idActual.append(id[len(_id_prefix[i]):])
        except NoOldIdError:
            idActual.append(None)

    res = [True]
    for i in range(1, _max_id + 1):
        res.append(idExpected[i] == idActual[i])

    if not all(res):
        print("input:    %s" % text_type(input).rjust(20))
        for i in range(1, _max_id + 1):
            if res[i]:
                continue
            print("Error in id version %d." % i)
            print("result:   %s" % str(idActual[i]))
            print("expected: %s" % str(idExpected[i]))
        print(rootSymbol.dump(0))
        raise DefinitionError("")
コード例 #35
0
ファイル: __init__.py プロジェクト: aldebaran/doc-tools
 def _make_all_typedefs_documentation(self, obj):
     section = None
     if obj.typedefs:
         first = True
         section = self._make_section('Types')
         lst = addnodes.desc()
         section += lst
         lst['objtype'] = 'type'
         for tpd in obj.typedefs:
             tpd.docname = obj.docname
             (node, desc) = self._make_typedef_documentation(self._get_obj(tpd.name))
             node.attributes['first'] = first
             first = False
             lst += node
             lst += desc
     return section
コード例 #36
0
ファイル: __init__.py プロジェクト: aldebaran/doc-tools
 def _make_enums_documentation(self, obj):
     if obj.enums:
         first = True
         section = self._make_section('Enumerations')
         lst = addnodes.desc()
         section += lst
         lst['objtype'] = 'type'
         for elem in obj.enums:
             elem.docname = obj.docname
             (desc, content) = self._make_enum_documentation(elem)
             desc.attributes['first'] = first
             first = False
             lst += desc
             lst += content
         return section
     return None
コード例 #37
0
ファイル: vars.py プロジェクト: timgates42/pex
        def make_nodes(var_name):
            var_obj = Variables.__dict__[var_name]
            if isinstance(var_obj, DefaultedProperty):
                desc_str = var_obj._func.__doc__
            else:
                desc_str = var_obj.__doc__
            desc_str = desc_str or "NO DESC"

            sig = addnodes.desc()
            sig.append(nodes.target("", "", ids=[var_name]))
            sig.append(addnodes.desc_signature(var_name, var_name))
            desc = nodes.paragraph()
            for line in desc_str.split("\n"):
                desc += nodes.line(line, line)
            sig["objtype"] = sig["desctype"] = "var"
            return sig, desc
コード例 #38
0
    def document(self):
        eid = (self.tag, self.fqname)
        if eid in self.documented:
            return [build_paragraph(get_xref(self.tag, eid[1]))]
        else:
            self.documented.append(eid)

        rv = [self.target_node(self.tag, self.ns_name, self.name)]

        data = addnodes.desc(objtype=self.tag)
        targetid = get_target_id(self.tag, self.ns_name, self.name)
        header = addnodes.desc_signature('', '',
                                         first=True,
                                         ids=[targetid])

        if self.include['doc']:
            header.extend([nodes.emphasis(self.tag, self.tag),
                          text(" "), self.tname])
            data.append(header)
        contents = nodes.definition()
        if self.include['doc']:
            contents.append(self.get_doc(self.entity))
        contents.extend(getattr(self, "document_%s" % self.tag)())
        data.append(contents)
        rv.append(data)

        if self.parent is None:
            # avoid adding duplicate dependencies
            added = [(self.type, self.name)]
            for typ, name, entity in self.dependencies:
                if not name:
                    name = entity.get('name')
                if (typ, name) in added:
                    continue
                ns_name, name = self.split_ns(name)
                ns_uri = self.namespaces[ns_name]
                if not entity:
                    try:
                        entity = self.entities[ns_uri][typ][name]
                    except KeyError:
                        self.app.warn("Dependency %s not found in schemas" %
                                      get_target_id(typ, ns_name, name))
                        continue
                doc = self.get_documentor(entity, name=name, ns_uri=ns_uri)
                rv.extend(doc.document())
                added.append((typ, name))
        return rv
コード例 #39
0
ファイル: xmlschema.py プロジェクト: zenazn/bcfg2
    def document(self):
        eid = (self.tag, self.fqname)
        if eid in self.documented:
            return [build_paragraph(get_xref(self.tag, eid[1]))]
        else:
            self.documented.append(eid)

        rv = [self.target_node(self.tag, self.ns_name, self.name)]

        data = addnodes.desc(objtype=self.tag)
        targetid = get_target_id(self.tag, self.ns_name, self.name)
        header = addnodes.desc_signature('', '',
                                         first=True,
                                         ids=[targetid])

        if self.include['doc']:
            header.extend([nodes.emphasis(self.tag, self.tag),
                          text(" "), self.tname])
            data.append(header)
        contents = nodes.definition()
        if self.include['doc']:
            contents.append(self.get_doc(self.entity))
        contents.extend(getattr(self, "document_%s" % self.tag)())
        data.append(contents)
        rv.append(data)

        if self.parent is None:
            # avoid adding duplicate dependencies
            added = [(self.type, self.name)]
            for typ, name, entity in self.dependencies:
                if not name:
                    name = entity.get('name')
                if (typ, name) in added:
                    continue
                ns_name, name = self.split_ns(name)
                ns_uri = self.namespaces[ns_name]
                if not entity:
                    try:
                        entity = self.entities[ns_uri][typ][name]
                    except KeyError:
                        self.app.warn("Dependency %s not found in schemas" %
                                      get_target_id(typ, ns_name, name))
                        continue
                doc = self.get_documentor(entity, name=name, ns_uri=ns_uri)
                rv.extend(doc.document())
                added.append((typ, name))
        return rv
コード例 #40
0
ファイル: eldomain.py プロジェクト: hyphenlee/emacs.d
    def run(self):
        env = self.state.document.settings.env
        package = env.temp_data.get('el:package')
        keymap_list = DATA.get(package, {}).get('keymap', [])
        keymap_name = self.arguments[0]
        for keymap in keymap_list:
            if keymap['name'] == keymap_name:
                break
        else:
            return [self.state.reporter.warning(
                "Keymap {0} not found".format(keymap_name))]
        nodelist = []

        mapdoc = keymap['doc']
        if mapdoc:
            nd = nodes.paragraph()
            lines = string2lines(doc_to_rst(mapdoc))
            if lines and lines[-1].startswith('(fn '):
                lines = lines[:-1]
            self.state.nested_parse(StringList(lines), 0, nd)
            nodelist.append(nd)

        exclude = self.options.get('exclude', [])
        replace = self.options.get('replace', [])
        for keybind in filter_by_exclude_regexp_list(
                keymap['data'], exclude, lambda x: x['func']):
            desc = addnodes.desc()
            desc['domain'] = 'el'
            desc['objtype'] = 'keybind'
            desc['noindex'] = False
            signode = addnodes.desc_signature()
            # signode += addnodes.desc_annotation("", 'keybind ')
            key = simple_sed(replace, keybind['key'])
            signode += addnodes.desc_name("", key)
            signode += addnodes.desc_addname("", " " + keybind['func'])
            desc += signode
            if keybind['doc']:
                nd = addnodes.desc_content()
                lines = string2lines(doc_to_rst(keybind['doc']))
                if lines and lines[-1].startswith('(fn '):
                    lines = lines[:-1]
                self.state.nested_parse(StringList(lines), 0, nd)
                desc += nodes.definition("", nd)
            nodelist.append(desc)

        return nodelist
コード例 #41
0
    def run(self):
        """
        Main directive entry function, called by docutils upon encountering the
        directive.

        This directive is meant to be quite easily subclassable, so it delegates
        to several additional methods.  What it does:

        * find out if called as a domain-specific directive, set self.domain
        * create a `desc` node to fit all description inside
        * parse standard options, currently `noindex`
        * create an index node if needed as self.indexnode
        * parse all given signatures (as returned by self.get_signatures())
          using self.handle_signature(), which should either return a name
          or raise ValueError
        * add index entries using self.add_target_and_index()
        * parse the content and handle doc fields in it
        """


        # set info for sphinx_directive
        self.sphinx_directive.objtype = self.objtype
        self.sphinx_directive.domain = self.domain
        self.sphinx_directive.env = self.sphinx_directive.state.document.settings.env
        self.sphinx_directive.indexnode = addnodes.index(entries=[])

        # setup this node
        self.node = addnodes.desc()
        self.node.document = self.sphinx_directive.state.document
        self.node['domain'] = self.domain

        # 'desctype' is a backwards compatible attribute
        self.node['objtype'] = self.node['desctype'] = self.sphinx_directive.objtype
        self.node['noindex'] = noindex = ('noindex' in self.sphinx_directive.options)
        self.noindex = noindex 

        self.sphinx_directive.names = []

        # get renderer
        self.data_object_renderer = self.get_data_object_renderer()

        #self.data_object_renderer.handle()
        self.node.extend(self.data_object_renderer.render())


        return [self.sphinx_directive.indexnode, self.node]
コード例 #42
0
ファイル: autoprocess.py プロジェクト: hadalin/resolwe
    def make_process_header(self, slug, typ, version, source_uri, description, inputs):
        """Generate a process definition header.

        :param str slug: process' slug
        :param str typ: process' type
        :param str version:  process' version
        :param str source_uri: url to the process definition
        :param str description: process' description
        :param dict inputs: process' inputs

        """
        node = addnodes.desc()
        signode = addnodes.desc_signature(slug, '')
        node.append(signode)

        node['objtype'] = node['desctype'] = typ

        signode += addnodes.desc_annotation(typ, typ, classes=['process-type'])
        signode += addnodes.desc_addname('', '')
        signode += addnodes.desc_name(slug + ' ', slug + ' ')

        paramlist = addnodes.desc_parameterlist()

        for field_schema, _, _ in iterate_schema({}, inputs, ''):
            field_type = field_schema['type']
            field_name = field_schema['name']

            field_default = field_schema.get('default', None)
            field_default = '' if field_default is None else '={}'.format(field_default)

            param = addnodes.desc_parameter('', '', noemph=True)
            param += nodes.emphasis(field_type, field_type, classes=['process-type'])
            # separate by non-breaking space in the output
            param += nodes.strong(text=u'\xa0\xa0' + field_name)

            paramlist += param

        signode += paramlist
        signode += nodes.reference('', nodes.Text('[Source: v{}]'.format(version)),
                                   refuri=source_uri, classes=['viewcode-link'])

        desc = nodes.paragraph()
        desc += nodes.Text(description, description)

        return [node, desc]
コード例 #43
0
ファイル: swag.py プロジェクト: doismellburning/cla_backend
    def format_operation(self, operations):
        c = n.container()
        for op in operations:

            p = addnodes.desc(objtype='endpoint')
            p += addnodes.desc_signature('nickname', op['nickname'])
            p += addnodes.desc_addname('method', op['httpMethod'])
            p += addnodes.desc_content(text=op['summary'])
            if 'parameters' in op.keys():
                p += addnodes.desc_annotation(text='Parameters: ')
                params = self.format_parameters(op['parameters'])
                p += params
            if op.get('responseClass'):
                response = self.format_response_class(op['responseClass'])
                p += response
            c += p

        return c
コード例 #44
0
ファイル: swag.py プロジェクト: doismellburning/cla_backend
    def format_operation(self, operations):
        c = n.container()
        for op in operations:

            p = addnodes.desc(objtype='endpoint')
            p += addnodes.desc_signature('nickname', op['nickname'])
            p += addnodes.desc_addname('method', op['httpMethod'])
            p += addnodes.desc_content(text=op['summary'])
            if 'parameters' in op.keys():
                p += addnodes.desc_annotation(text='Parameters: ')
                params = self.format_parameters(op['parameters'])
                p += params
            if op.get('responseClass'):
                response = self.format_response_class(op['responseClass'])
                p += response
            c += p

        return c
コード例 #45
0
ファイル: boilerplate.py プロジェクト: Anugrahaa/anagrammatic
def transform_module_section(section_node, title_node, env):
    fullmodname = section_node['names'][0]
    where = section_node.first_child_matching_class(section_prelude_end_class)
    content_children = list(ipop_child(section_node, where + 1))
    if title_node is None:
        signature_children = [literal('', fullmodname)]
    else:
        signature_children = list(ipop_child(title_node))
    signature_node = desc_signature('', '', *signature_children,
                                    classes=['title', 'module'],
                                    names=[fullmodname])
    content_node = desc_content('', *content_children)
    desc_node = desc('', signature_node, content_node,
                     desctype='module',
                     objtype='module',
                     classes=['definition'])
    section_node.append(desc_node)
    add_toc(desc_node, env, section_node)
コード例 #46
0
    def format_operation(self, operations):
        c = n.container()
        for op in operations:

            p = addnodes.desc(objtype="endpoint")
            p += addnodes.desc_signature("nickname", op["nickname"])
            p += addnodes.desc_addname("method", op["httpMethod"])
            p += addnodes.desc_content(text=op["summary"])
            if "parameters" in op.keys():
                p += addnodes.desc_annotation(text="Parameters: ")
                params = self.format_parameters(op["parameters"])
                p += params
            if op.get("responseClass"):
                response = self.format_response_class(op["responseClass"])
                p += response
            c += p

        return c
コード例 #47
0
ファイル: directives.py プロジェクト: PieterPaulussen/odoo
    def generate(self, all_members=False):
        """
        :rtype: List[nodes.Node]
        """
        objname = self.item.name
        prefixed = (self.item['sourcemodule'].name + '.' + objname) if self.item['sourcemodule'] else None
        objtype = self.objtype
        assert objtype, '%s has no objtype' % type(self)
        root = addnodes.desc(domain='js', desctype=objtype, objtype=objtype)
        with addto(root, addnodes.desc_signature(
            module=self.modname or '',
            fullname=objname,
        )) as s:
            s['class'] = self.classname

            s['ids'] = []
            if objname:
                s['ids'].append(objname)
            if prefixed:
                s['ids'].append(prefixed)

            if objtype:
                s += addnodes.desc_annotation(
                    objtype, objtype,
                    nodes.Text(' '),
                )

                env = self.env
                if objname:
                    env.domaindata['js']['objects'][objname] = (env.docname, objtype)
                if prefixed:
                    env.domaindata['js']['objects'][prefixed] = (env.docname, objtype)

            # TODO: linkcode_resolve
            s += self.make_signature()
        with addto(root, addnodes.desc_content()) as c:
            # must be here otherwise nested_parse(self.content) will not have
            # the prefix set
            self.env.temp_data.setdefault('autojs:prefix', []).append(self.item.name)
            c += self.make_content(all_members=all_members)
            self.env.temp_data['autojs:prefix'].pop()
        return [root]
コード例 #48
0
    def run(self):
        name = self.arguments[0]
        dname = addnodes.desc_name(name, name)

        dcontent = addnodes.desc_content()
        self.state.nested_parse(self.content, self.content_offset, dcontent)

        dcontent, fields = _split_content(dcontent)
        dcontent.append(_group_fields(fields))

        signature = addnodes.desc_signature(name, "")
        signature.append(dname)
        signature.append(dcontent)

        if ":" in self.name:
            domain, objtype = self.name.split(":", 1)
        else:
            domain, objtype = "", self.name

        description = addnodes.desc()
        description["domain"] = domain
        description["objtype"] = objtype
        description.append(signature)

        if name not in self.state.document.ids:
            signature["names"].append(name)
            signature["ids"].append(name)
            signature["first"] = True
            self.state.document.note_explicit_target(signature)

            env = self.state.document.settings.env
            objects = env.domaindata["tosca"]["objects"]
            if name in objects:
                msg = "duplicate TOSCA type {}, other in {}"
                self.state_machine.reporter.warning(msg.format(
                    name, env.doc2path(objects[name].doc)
                ), line=self.lineno)
            objects[name] = ToscaObject(env.docname, objtype)

        indexnode = addnodes.index(entries=[("single", name, name, "", None)])

        return [indexnode, description]
コード例 #49
0
    def handle_ada_decl(self, decl):
        # type: (lal.BasicDecl) -> Tuple[List[nodes.Node], N.desc_content]

        # Get the documentation content
        doc, annotations = self.get_documentation(decl)

        # Create sphinx nodes
        self.indexnode = N.index(entries=[])
        node = N.desc()
        node.document = self.state.document
        signode = N.desc_signature('', '')
        signode['first'] = False
        node.append(signode)

        # Do decl-type specific stuff in specialized methods
        handlers = [
            (lal.BasicSubpDecl, lal.ExprFunction, self.handle_subprogram_decl),
            (lal.BaseTypeDecl, self.handle_type_decl),
            (lal.ObjectDecl, self.handle_object_decl),
            (lal.PackageRenamingDecl, self.handle_package_renaming_decl),
            (lal.GenericPackageInstantiation, self.handle_package_inst),
            (lal.GenericSubpInstantiation, self.handle_subp_inst),
            (lal.ExceptionDecl, self.handle_exception_decl),
        ]
        for h in handlers:
            types, handler = h[:-1], h[-1]
            if isinstance(decl, types):
                handler(decl, node, signode, annotations)
                break
        else:
            self.handle_decl_generic(decl, node, signode, annotations)

        # Create the documentation's content
        content_node = N.desc_content()
        node.append(content_node)

        rst = ViewList()
        for i, l in enumerate(doc, 1):
            rst.append(l, 'no_file.rst', i)

        nested_parse_with_titles(self.state, rst, content_node)
        return [self.indexnode, node], content_node
コード例 #50
0
    def run(self):
        self.env = self.state.document.settings.env

        contents_node = desc_content()
        if self.contents_separator is not None:
            self.env.domaindata[OCamlDomain.name]["module_stack"].append(
                self.current_module_prefix() + self.arguments[0] +
                self.contents_separator)
        self.state.nested_parse(self.content, self.content_offset,
                                contents_node)
        if self.contents_separator is not None:
            self.env.domaindata[OCamlDomain.name]["module_stack"].pop()
        # @todo Maybe labels and constructors should be directives instead of docfields?
        sphinx.util.docfields.DocFieldTransformer(self).transform_all(
            contents_node)

        main_node = desc()
        main_node["objtype"] = self.object_type
        for node in self.make_nodes(contents_node):
            main_node += node

        header_node = main_node[0]
        assert isinstance(header_node,
                          sphinx.addnodes.desc_signature), header_node

        index_node = sphinx.addnodes.index(entries=[])
        ident = self.get_id()
        if ident is not None:
            if ident in self.state.document.ids:
                logger.warning('Duplicate: %s' % ident, subtype='ocaml')
            header_node["first"] = False
            header_node["ids"].append(ident)

            if "noindex" not in self.options:
                index_entry = self.get_index_entry()
                if index_entry is not None:
                    self.env.domaindata[OCamlDomain.name][self.role][
                        ident.split()[-1]] = self.env.docname
                    index_node["entries"].append(
                        ("single", index_entry, ident, "", None))

        return [index_node, main_node]
コード例 #51
0
ファイル: rx.py プロジェクト: segfault87/sphinx-rx
    def run(self):
        if ':' in self.name:
            self.domain, self.objtype = self.name.split(':', 1)
        else:
            self.domain, self.objtype = '', self.name
        self.env = self.state.document.settings.env
        self.indexnode = addnodes.index(entries=[])

        node = addnodes.desc()
        node.document = self.state.document
        node['domain'] = self.domain
        node['objtype'] = node['desctype'] = self.objtype
        node['noindex'] = False

        try:
            signature = self.arguments[0]
            if self.objtype == 'schema':
                signode = addnodes.desc_signature(signature)
                signode['first'] = False
                node += signode
        except:
            signature = None

        headernode = addnodes.desc_name()
        headernode += nodes.inline('', _(self.objtype) + ' ')
        if signature is not None:
            headernode += nodes.emphasis('', signature)
        if _is_compositional(self.options['type']):
            if signature is not None:
                headernode += nodes.inline('', ' -- ')
            _describe_type(self.options['type'], headernode,
                           contains=self.options['contains'])
        node.append(headernode)

        contentnode = addnodes.desc_content()
        node.append(contentnode)
        self.state.nested_parse(self.content, self.content_offset, contentnode)
        type = self.options['type']
        if type in __transformers__:
            __transformers__[type](self).transform_all(contentnode)

        return [addnodes.index(entries=[]), node]
コード例 #52
0
ファイル: test_domain_cpp.py プロジェクト: nwf/sphinx
def check(name, input, idv1output=None, idv2output=None, output=None):
    # first a simple check of the AST
    if output is None:
        output = input
    ast = parse(name, input)
    res = text_type(ast)
    if res != output:
        print("")
        print("Input:    ", text_type(input))
        print("Result:   ", res)
        print("Expected: ", output)
        raise DefinitionError("")
    rootSymbol = Symbol(None, None, None, None, None, None)
    symbol = rootSymbol.add_declaration(ast, docname="TestDoc")
    parentNode = addnodes.desc()
    signode = addnodes.desc_signature(input, '')
    parentNode += signode
    ast.describe_signature(signode, 'lastIsName', symbol, options={})

    if idv2output:
        idv2output = "_CPPv2" + idv2output
    try:
        idv1 = ast.get_id_v1()
        assert idv1 is not None
    except NoOldIdError:
        idv1 = None
    try:
        idv2 = ast.get_id_v2()
        assert idv2 is not None
    except NoOldIdError:
        idv2 = None
    if idv1 != idv1output or idv2 != idv2output:
        print("input:    %s" % text_type(input).rjust(20))
        print("          %s    %s" % ("Id v1".rjust(20), "Id v2".rjust(20)))
        print("result:   %s    %s" %
              (str(idv1).rjust(20), str(idv2).rjust(20)))
        print("expected: %s    %s" %
              (str(idv1output).rjust(20), str(idv2output).rjust(20)))
        print(rootSymbol.dump(0))
        raise DefinitionError("")
    ids.append(ast.get_id_v2())
コード例 #53
0
ファイル: sphinxdomain.py プロジェクト: klauer/blark
    def _get_basic_variable_blocks(
            self) -> Generator[addnodes.desc, None, None]:
        """Get the usual input/output variable blocks as sphinx nodes."""
        blocks = ("VAR_INPUT", "VAR_IN_OUT", "VAR_OUTPUT", "VAR_GLOBAL")
        if isinstance(self.obj, summary.ProgramSummary):
            blocks += ("VAR", )

        for block in blocks:
            decls = self.obj.declarations_by_block.get(block, {})
            if not decls:
                continue

            block_desc = addnodes.desc()
            block_desc += addnodes.desc_name(text=block,
                                             classes=["variable_block", block])
            block_contents = addnodes.desc_content()
            block_contents += declarations_to_block(decls.values(),
                                                    env=self.env)

            block_desc += block_contents
            yield block_desc
コード例 #54
0
    def parse_section(self, node):
        matched = re.search("^(.*?)\s*\((.*)\)\s*$", node[0].astext())
        if not matched:
            return

        objname = matched.group(1).strip()
        typename = matched.group(2).strip()

        desc = sphinxnodes.desc(domain="js", desctype="data", objtype="data")
        sig = sphinxnodes.desc_signature(object="", fullname=objname, first=False)
        sig["names"].append(objname)
        sig["ids"].append(objname.replace("$", "_S_"))
        sig += sphinxnodes.desc_name(text="%s (%s)" % (objname, typename))

        content = sphinxnodes.desc_content()
        node.pop(0)
        transpose_subnodes(node, content)

        node.replace_self(desc)
        desc.append(sig)
        desc.append(content)
コード例 #55
0
ファイル: test_domain_cpp.py プロジェクト: mdavezac/sphinx
def check(name, input, idv1output=None, idv2output=None, output=None):
    # first a simple check of the AST
    if output is None:
        output = input
    ast = parse(name, input)
    res = text_type(ast)
    if res != output:
        print("")
        print("Input:    ", text_type(input))
        print("Result:   ", res)
        print("Expected: ", output)
        raise DefinitionError("")
    rootSymbol = Symbol(None, None, None, None, None, None)
    symbol = rootSymbol.add_declaration(ast, docname="Test")
    parentNode = addnodes.desc()
    signode = addnodes.desc_signature(input, '')
    parentNode += signode
    ast.describe_signature(signode, 'lastIsName', symbol)

    if idv2output:
        idv2output = "_CPPv2" + idv2output
    try:
        idv1 = ast.get_id_v1()
        assert idv1 is not None
    except NoOldIdError:
        idv1 = None
    try:
        idv2 = ast.get_id_v2()
        assert idv2 is not None
    except NoOldIdError:
        idv2 = None
    if idv1 != idv1output or idv2 != idv2output:
        print("input:    %s" % text_type(input).rjust(20))
        print("          %s    %s" % ("Id v1".rjust(20), "Id v2".rjust(20)))
        print("result:   %s    %s" % (str(idv1).rjust(20), str(idv2).rjust(20)))
        print("expected: %s    %s" % (str(idv1output).rjust(20),
                                      str(idv2output).rjust(20)))
        print(rootSymbol.dump(0))
        raise DefinitionError("")
    ids.append(ast.get_id_v2())
コード例 #56
0
ファイル: eldomain.py プロジェクト: srirampc/emacs-live
    def run(self):
        env = self.state.document.settings.env
        package = env.temp_data.get("el:package")
        keymap_list = DATA.get(package, {}).get("keymap", [])
        keymap_name = self.arguments[0]
        for keymap in keymap_list:
            if keymap["name"] == keymap_name:
                break
        else:
            return [self.state.reporter.warning("Keymap {0} not found".format(keymap_name))]
        nodelist = []

        mapdoc = keymap["doc"]
        if mapdoc:
            nd = nodes.paragraph()
            lines = string2lines(doc_to_rst(mapdoc))
            self.state.nested_parse(StringList(lines), 0, nd)
            nodelist.append(nd)

        exclude = self.options.get("exclude", [])
        for keybind in filter_by_exclude_regexp_list(keymap["data"], exclude, lambda x: x["func"]):
            desc = addnodes.desc()
            desc["domain"] = "el"
            desc["objtype"] = "keybind"
            desc["noindex"] = False
            signode = addnodes.desc_signature()
            # signode += addnodes.desc_annotation("", 'keybind ')
            signode += addnodes.desc_name("", keybind["key"])
            signode += addnodes.desc_addname("", " " + keybind["func"])
            desc += signode
            if keybind["doc"]:
                nd = addnodes.desc_content()
                lines = string2lines(doc_to_rst(keybind["doc"]))
                self.state.nested_parse(StringList(lines), 0, nd)
                desc += nodes.definition("", nd)
            nodelist.append(desc)

        return nodelist
コード例 #57
0
    def depart_Action(self, node):
        http_method = node['http_method']
        uri = node['uri']

        self.env.domaindata['http'][http_method.lower()][uri] = (self.env.docname, node['identifier'], False)
        desc = addnodes.desc(domain='http',
                             desctype=http_method.lower(),
                             objtype=http_method.lower())

        sig = addnodes.desc_signature(method=http_method.lower(), path=uri, first=False,
                                      fullname="%s %s" % (http_method, uri))
        sig['ids'].append(http_resource_anchor(http_method, uri))
        if node['identifier']:
            sig += addnodes.desc_name(text="%s %s (%s)" % (http_method, uri, node['identifier']))
        else:
            sig += addnodes.desc_name(text="%s %s" % (http_method, uri))

        content = addnodes.desc_content()
        transpose_subnodes(node, content)

        node.replace_self(desc)
        desc.append(sig)
        desc.append(content)