class ROSAPI(ROSObjectDescription):
option_spec = {
'noindex': directives.flag,
'base': directives.path,
}
doc_field_types = [
TypedField('pub',
label=l_('Published Topics'),
names=('pub', ),
typerolename='msg',
typenames=('pub-type', )),
TypedField('sub',
label=l_('Subscribed Topics'),
names=('sub', ),
typerolename='msg',
typenames=('sub-type', )),
TypedField('srv',
label=l_('Services'),
names=('srv', ),
typerolename='srv',
typenames=('srv-type', )),
TypedField('srv_called',
label=l_('Services Called'),
names=('srv_called', ),
typerolename='srv',
typenames=('srv_called-type', )),
TypedField('action',
label=l_('Actions'),
names=('action', ),
typerolename='action',
typenames=('action-type', )),
TypedField('action_called',
label=l_('Actions Called'),
names=('action_called', ),
typerolename='action',
typenames=('action_called-type', )),
TypedField('param',
label=l_('Parameters'),
names=('param', ),
typenames=('param-type', )),
TypedField('param_set',
label=l_('Parameters Set'),
names=('param_set', ),
typenames=('param_set-type', )),
GroupedField('param-default',
label=l_('Parameters Default Value'),
names=('param-default', )),
GroupedField('param_set-default',
label=l_('Parameters Set Default Value'),
names=('param_set-default', )),
]
doc_merge_fields = {
'param-default': 'param',
'param_set-default': 'param_set'
}
def merge_field(self, src_node, dest_node):
dest_node.insert(4, nodes.Text(' (default: '))
dest_node.insert(5, nodes.literal('', src_node[2].astext()))
dest_node.insert(6, nodes.Text(')'))
class RemoteCallable(RemoteObject):
"""Description of a Kurento ROM function, method or constructor."""
has_arguments = True
doc_field_types = [
TypedField('arguments',
label=l_('Arguments'),
names=('argument', 'arg', 'parameter', 'param'),
typerolename='func',
typenames=('paramtype', 'type')),
GroupedField('errors',
label=l_('Throws'),
rolename='err',
names=('throws', ),
can_collapse=True),
GroupedField('events',
label=l_('Events'),
rolename='evt',
names=('events', ),
can_collapse=True),
Field('returnvalue',
label=l_('Returns'),
has_arg=False,
names=('returns', 'return')),
Field('returntype',
label=l_('Return type'),
has_arg=False,
names=('rtype', )),
Field('isabstract',
label=l_('Abstract'),
has_arg=False,
names=('abstract', )),
]
class ODataFeedDirective(ObjectDescription):
option_spec = {
'mle': directives.flag,
}
doc_field_types = [
GroupedField('httpmethod',
label='Methods Supported',
names=('method', )),
GroupedField('filter', label='Filters supported', names=('filter', )),
GroupedField('expand',
label='Expansions supported',
names=('expand', )),
]
def before_content(self):
self.env.temp_data['od:feed'] = self.names[0]
def after_content(self):
self.env.temp_data['od:feed'] = None
def handle_signature(self, sig, signode):
"""Format: <name> <entity-type>"""
svc = self.env.temp_data.get('od:service', None)
sig = sig.strip().split()
fname = sig[0]
ftype = sig[1]
obj = ODataFeed(parent=svc,
docname=self.env.docname,
name=fname,
title=fname)
tobj = ODataType(parent=svc,
docname=self.env.docname,
name=ftype,
title=ftype)
signode += addnodes.desc_name(fname, fname)
signode += nodes.Text(" ")
signode += addnodes.pending_xref(ftype,
nodes.Text(ftype),
refdomain="od",
reftype="type",
reftarget=tobj._get_untyped_id())
if 'mle' in self.options:
signode += nodes.Text(" (Media Link Entry)")
return obj
def add_target_and_index(self, name, sig, signode):
targetname = name.get_target_id()
signode['ids'].append(targetname)
self.state.document.note_explicit_target(signode)
objects = self.env.domaindata['od']['objects']
if targetname in objects:
self.warning("duplicate object description: %s" % targetname)
objects[targetname] = name
self.indexnode['entries'].append(
('single', '%s (OData feed)' % name.title, targetname, '', None))
class PlanguageDesignIdea(PlanguageObject):
display_prefix = 'Design Idea '
doc_field_types = [
GroupedField('impacts', label='Impacts', names=('impact', 'impacts')),
GroupedField('impact_est',
label='Impact Estimation',
names=('ie', 'impact_est', 'impactest')),
]
class HTTPResource(ObjectDescription):
doc_field_types = [
TypedField('parameter',
label='Parameters',
names=('param', 'parameter', 'arg', 'argument'),
typerolename='obj',
typenames=('paramtype', 'type')),
GroupedField('queryparameter',
label='Query Parameters',
names=('queryparameter', 'queryparam', 'qparam',
'query')),
GroupedField('formparameter',
label='Form Parameters',
names=('formparameter', 'formparam', 'fparam', 'form')),
GroupedField('statuscode',
label='Status Codes',
rolename='statuscode',
names=('statuscode', 'status', 'code'))
]
method = NotImplemented
def handle_signature(self, sig, signode):
method = self.method.upper() + ' '
signode += addnodes.desc_name(method, method)
offset = 0
for match in http_sig_param_re.finditer(sig):
path = sig[offset:match.start()]
signode += addnodes.desc_name(path, path)
params = addnodes.desc_parameterlist()
typ = match.group('type')
if typ:
typ = typ + ': '
params += addnodes.desc_annotation(typ, typ)
name = match.group('name')
params += addnodes.desc_parameter(name, name)
signode += params
offset = match.end()
if offset < len(sig):
path = sig[offset:len(sig)]
signode += addnodes.desc_name(path, path)
fullname = self.method.upper() + ' ' + path
signode['method'] = self.method
signode['path'] = sig
signode['fullname'] = fullname
return (fullname, self.method, sig)
def needs_arglist(self):
return False
def add_target_and_index(self, name_cls, sig, signode):
signode['ids'].append(http_resource_anchor(*name_cls[1:]))
self.env.domaindata['http'][self.method][sig] = (self.env.docname, '')
def get_index_text(self, modname, name):
return ''
class CtonInst(CtonObject):
"""A Cretonne IR instruction."""
doc_field_types = [
TypedField('argument',
label=l_('Arguments'),
names=('in', 'arg'),
typerolename='type',
typenames=('type', )),
TypedField('result',
label=l_('Results'),
names=('out', 'result'),
typerolename='type',
typenames=('type', )),
GroupedField('typevar',
names=('typevar', ),
label=l_('Type Variables')),
GroupedField('flag', names=('flag', ), label=l_('Flags')),
Field('resulttype',
label=l_('Result type'),
has_arg=False,
names=('rtype', )),
]
def handle_signature(self, sig, signode):
# Look for signatures like
#
# v0, v1 = foo op0, op1
# v0 = foo
# foo op0
parts = re.split(sep_equal, sig, 1)
if len(parts) == 2:
# Outgoing parameters.
parse_params(parts[0], signode)
signode += nodes.Text(' = ')
name = parts[1]
else:
name = parts[0]
# Parse 'name arg, arg'
parts = name.split(None, 1)
name = parts[0]
signode += addnodes.desc_name(name, name)
if len(parts) == 2:
# Incoming parameters.
signode += nodes.Text(' ')
parse_params(parts[1], signode)
return name
def get_index_text(self, name):
return name
class DoctorHTTPResource(HTTPResource):
doc_field_types = [
TypedField('parameter',
label='Parameters',
names=('param', 'parameter', 'arg', 'argument'),
typerolename='obj',
typenames=('paramtype', 'type')),
TypedField('jsonparameter',
label='JSON Parameters',
names=('jsonparameter', 'jsonparam', 'json'),
typerolename='obj',
typenames=('jsonparamtype', 'jsontype')),
ObjectTypedField('requestjsonobject',
label='Request JSON Object',
names=('reqjsonobj', 'reqjson', '<jsonobj', '<json'),
typerolename='obj',
typenames=('reqjsonobj', '<jsonobj')),
ObjectTypedField('requestjsonarray',
label='Request JSON Array of Objects',
names=('reqjsonarr', '<jsonarr'),
typerolename='obj',
typenames=('reqjsonarrtype', '<jsonarrtype')),
ObjectTypedField('responsejsonobject',
label='Response JSON Object',
names=('resjsonobj', 'resjson', '>jsonobj', '>json'),
typerolename='obj',
typenames=('resjsonobj', '>jsonobj')),
ObjectTypedField('responsejsonarray',
label='Response JSON Array of Objects',
names=('resjsonarr', '>jsonarr'),
typerolename='obj',
typenames=('resjsonarrtype', '>jsonarrtype')),
TypedField('queryparameter',
label='Query Parameters',
names=('queryparameter', 'queryparam', 'qparam', 'query'),
typerolename='obj',
typenames=('queryparamtype', 'querytype', 'qtype')),
GroupedField('formparameter',
label='Form Parameters',
names=('formparameter', 'formparam', 'fparam', 'form')),
GroupedField('requestheader',
label='Request Headers',
rolename='header',
names=('<header', 'reqheader', 'requestheader')),
GroupedField('responseheader',
label='Response Headers',
rolename='header',
names=('>header', 'resheader', 'responseheader')),
GroupedField('statuscode',
label='Status Codes',
rolename='statuscode',
names=('statuscode', 'status', 'code'))
]
class TeXMacro(TeXObject):
"""Description of a TeX macro or environment."""
has_arguments = True
# Field types: GroupedField, TypedField, Field
doc_field_types = [
GroupedField('arguments',
label=l_('Arguments'),
names=('argument', 'arg', 'parameter', 'param'),
can_collapse=True),
GroupedField('keywordarguments',
label=l_('Keyword Arguments'),
names=('karg', 'kwarg', 'kparam', 'kwparam'),
can_collapse=True),
]
def setup(app):
from sphinx.ext.autodoc import cut_lines
from sphinx.util.docfields import GroupedField
app.connect('autodoc-process-docstring', cut_lines(4, what=['module']))
app.connect('source-read', linkify_issues_in_changelog)
app.add_object_type('confval', 'confval',
objname='configuration value',
indextemplate='pair: %s; configuration value')
app.add_object_type('setuptools-confval', 'setuptools-confval',
objname='setuptools configuration value',
indextemplate='pair: %s; setuptools configuration value')
fdesc = GroupedField('parameter', label='Parameters',
names=['param'], can_collapse=True)
app.add_object_type('event', 'event', 'pair: %s; event', parse_event,
doc_field_types=[fdesc])
# Load jQuery and patches to make readthedocs-doc-embed.js available (refs: #10574)
app.add_js_file('https://ajax.googleapis.com/ajax/libs/jquery/3.6.0/jquery.min.js',
priority=100)
app.add_js_file('https://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.13.1/underscore-min.js', # NoQA
priority=100)
app.add_js_file('_sphinx_javascript_frameworks_compat.js', priority=105)
# workaround for RTD
from sphinx.util import logging
logger = logging.getLogger(__name__)
app.info = lambda *args, **kwargs: logger.info(*args, **kwargs)
app.warn = lambda *args, **kwargs: logger.warning(*args, **kwargs)
app.debug = lambda *args, **kwargs: logger.debug(*args, **kwargs)
class AIMMSCallable(AIMMSObject):
"""Description of a AIMMS function, method or constructor."""
has_arguments = True
doc_field_types = [
TypedField('arguments',
label=_('Attributes'),
names=('argument', 'arg', 'parameter', 'param', 'attribute',
'attr'),
typerolename='function',
typenames=('paramtype', 'type')),
GroupedField('errors',
label=_('Throws'),
rolename='err',
names=('throws', ),
can_collapse=True),
Field('returnvalue',
label=_('Returns'),
has_arg=False,
names=('returns', 'return')),
Field('returntype',
label=_('Return type'),
has_arg=False,
names=('rtype', )),
]
class OptionDirective(ObjectDescription):
doc_field_types = [
Field('default', label='Default'),
Field('required', label='Required'),
Field('static-check', label='Static Check'),
Field('runtime-check', label='Runtime Check'),
GroupedField('type', label='Types'),
]
def add_target_and_index(self, name, sig, signode):
targetname = self.objtype + name
if targetname not in self.state.document.ids:
signode['names'].append(targetname)
signode['ids'].append(targetname)
signode['first'] = (not self.names)
self.state.document.note_explicit_target(signode)
inv = self.env.domaindata[self.domain]['objects']
if name in inv:
self.state_machine.reporter.warning(
'duplicate option description of {}, other instance in {}'.
format(name, self.env.doc2path(inv[name][0])),
line=self.lineno)
inv[name] = self.env.docname
self.indexnode['entries'].append(
('pair: option; ' + name, name, targetname, '', None))
def setup(app):
from sphinx.util.docfields import GroupedField
app.add_node(
node=desc_cmake_argumentlist,
html=(html_argumentlist_visit, html_argumentlist_depart),
latex=(argumentlist_visit, argumentlist_depart),
)
app.add_node(
node=desc_cmake_argument,
html=(html_argument_visit, html_argument_depart),
latex=(argument_visit, argument_depart),
)
app.add_domain(
custom_domain(
'CMakeDomain',
name='cmake',
label="CMake",
elements=dict(
macro=dict(
# role = 'xxx' if differs from macro
# objtype = 'xxx' if differs from macro
objname="CMake Macro",
indextemplate="pair: %s; CMake macro",
parse=parse_macro,
fields=[
GroupedField('parameter',
label="Parameters",
names=['param'])
]),
var=dict(objname="CMake Variable",
indextemplate="pair: %s; CMake variable"),
)))
class DylanMacroDesc(DylanBindingDesc):
"""A Dylan macro."""
final_argument_whitespace = True
display_name = "macro"
annotations = ['statement', 'function', 'defining', 'macro-type'
] + DylanBindingDesc.annotations
option_spec = dict(DylanBindingDesc.option_spec.items())
option_spec.update(
dict({
'statement': DIRECTIVES.flag,
'function': DIRECTIVES.flag,
'defining': DIRECTIVES.flag,
'macro-type': DIRECTIVES.unchanged,
}.items()))
doc_field_types = [
TypedField(
'parameters', label="Parameters", names=('param', 'parameter')),
GroupedField('values',
label="Values",
names=('value', 'val', 'retval', 'return')),
Field('call',
label="Macro Call",
has_arg=False,
names=('call', 'macrocall', 'syntax'))
] + DylanBindingDesc.doc_field_types
class JoernNode(JoernObj):
doc_field_types = [
GroupedField('prop', label='Properties', names=('prop',), can_collapse = False),
]
desc_annotation = 'node'
class CoffeeObj(ObjectDescription):
doc_field_types = [
GroupedField('parameter',
label='Parameters',
names=('param', 'parameter', 'arg', 'argument')),
]
def handle_signature(self, sig, signode):
if self.display_prefix:
signode += addnodes.desc_annotation(self.display_prefix,
self.display_prefix)
fullname, paren, args = sig.partition('(')
modname, name = fullname.split(MOD_SEP)
classname = self.env.temp_data.get('autodoc:class')
if classname and name.startswith(classname):
name = name[len(classname):]
args = args[:-1]
signode += addnodes.desc_name(name, name)
if isinstance(self, CoffeeFunction):
_pseudo_parse_arglist(signode, args)
return fullname
def add_target_and_index(self, fqn, sig, signode):
#doc = self.state.document
if fqn not in self.state.document.ids:
signode['names'].append(fqn)
signode['ids'].append(fqn)
self.state.document.note_explicit_target(signode)
objects = self.env.domaindata['coffee']['objects']
objects[fqn] = (self.env.docname, self.objtype)
indextext = "%s (%s)" % (fqn, self.display_prefix.strip())
self.indexnode['entries'].append(('single', _(indextext), fqn, ''))
class TempoIQMethod(TempoIQObject):
has_arguments = True
doc_field_types = [
TypedField('arguments',
label=l_('Arguments'),
names=('argument', 'arg', 'parameter', 'param'),
typerolename='class',
typenames=('type', 'paramtype'),
can_collapse=True),
Field('endpoint',
label=l_('HTTP Endpoint'),
has_arg=False,
names=('endpoint', )),
GroupedField('errors',
label=l_('Errors'),
rolename='err',
names=('throws', 'errors'),
can_collapse=True),
Field('returns',
label=l_('Returns'),
has_arg=False,
names=('returns', 'return')),
Field('cursored',
label=l_("Cursored"),
names=('cursored', 'cursor'),
has_arg=False)
]
class JSCustomCallable(JSCallable):
doc_field_types = [
StyledTypedField(
'arguments', label=l_('Arguments'),
names=('argument', 'arg', 'parameter', 'param'), typerolename='func',
typenames=('paramtype', 'type')
),
GroupedField('errors', label=l_('Throws'), rolename='err',
names=('throws', ),
can_collapse=True),
Field('returnvalue', label=l_('Returns'), has_arg=False,
names=('returns', 'return')),
Field('returntype', label=l_('Return type'), has_arg=False,
names=('rtype', 'returntype'), bodyrolename='class'),
Field('default', label=l_('Default'), names=('default',), has_arg=False),
BoolField('required', label=l_('Required'), names=('require', 'required'),
has_arg=False),
BoolField('static', label=l_('Static'), names=('static',), has_arg=False),
AnnotateField('overrides', label=l_('Overrides'), names=('override', 'overrides'),
annotate_type=ANNOTATE_OVERRIDES, bodyrolename='class', has_arg=False),
AnnotateField('extends', label=l_('Extends'), names=('extend', 'extends'),
annotate_type=ANNOTATE_EXTENDS, has_arg=False),
AnnotateField('inheritedFrom', label=l_('inheritedFrom'), names=('inheritedFrom', 'inheritedFrom'),
annotate_type=ANNOTATE_INHERITEDFROM, has_arg=False),
]
class Function(JuliaDirective):
doc_field_types = [
TypedField('parameter',
label=l_('Parameters'),
names=('param', 'parameter', 'arg', 'argument'),
typerolename='obj',
typenames=('paramtype', 'type'),
can_collapse=True),
TypedField('kwparam',
label=l_('Keyword Parameters'),
names=('kwparam', 'kwparameter', 'kwarg', 'kwargument'),
typerolename='obj',
typenames=('kwparamtype', 'kwtype'),
can_collapse=True),
GroupedField('exceptions',
label=l_('Exceptions'),
rolename='exc',
names=('raises', 'raise', 'exception', 'except'),
can_collapse=True),
Field('returnvalue',
label=l_('Returns'),
has_arg=False,
names=('returns', 'return')),
Field('returntype',
label=l_('Return type'),
has_arg=False,
names=('rtype', ),
bodyrolename='obj'),
]
def setup(app):
from sphinx.ext.autodoc import cut_lines
from sphinx.util.docfields import GroupedField
app.connect('autodoc-process-docstring', cut_lines(4, what=['module']))
app.add_object_type('confval',
'confval',
objname='configuration value',
indextemplate='pair: %s; configuration value')
app.add_object_type(
'setuptools-confval',
'setuptools-confval',
objname='setuptools configuration value',
indextemplate='pair: %s; setuptools configuration value')
fdesc = GroupedField('parameter',
label='Parameters',
names=['param'],
can_collapse=True)
app.add_object_type('event',
'event',
'pair: %s; event',
parse_event,
doc_field_types=[fdesc])
# workaround for RTD
from sphinx.util import logging
logger = logging.getLogger(__name__)
app.info = lambda *args, **kwargs: logger.info(*args, **kwargs)
app.warn = lambda *args, **kwargs: logger.warning(*args, **kwargs)
app.debug = lambda *args, **kwargs: logger.debug(*args, **kwargs)
class RustStruct(RustObject):
"""
Description of a rust struct
"""
doc_field_types = [
GroupedField('parameter', names=('param', ), label=l_('Parameters'))
]
def get_index_text(self, crate, module, impl, name):
"""
Get the text for this object that goes in the index
"""
return _('%s (Rust struct)') % name
def handle_signature(self, sig, signode):
"""
handle the signature of the directive
"""
print("handling struct signature: ", sig)
sig_match = rust_struct_sig_re.match(sig)
name = sig_match.group("name")
mods = sig_match.group("mods")
formatted_mods = formatter.output_modifiers(mods).build()
signode += nodes.Text(mods + ' ', mods + ' ')
signode += nodes.Text('struct ', 'struct ')
signode += addnodes.desc_name(name, name)
return name
class DylanClassDesc (DylanBindingDesc):
"""A Dylan class."""
display_name = "class"
annotations = [
'open', 'primary', 'free', 'abstract', 'concrete', 'instantiable',
'uninstantiable', 'sealed'
] + DylanBindingDesc.annotations
option_spec = dict(DylanBindingDesc.option_spec.items())
option_spec.update(dict({
'open': DIRECTIVES.flag,
'primary': DIRECTIVES.flag,
'free': DIRECTIVES.flag,
'abstract': DIRECTIVES.flag,
'sealed': DIRECTIVES.flag,
'concrete': DIRECTIVES.flag,
'instantiable': DIRECTIVES.flag,
'uninstantiable': DIRECTIVES.flag,
}.items()))
doc_field_types = [
Field('superclasses', label="Superclasses", has_arg=False,
names=('supers', 'superclasses', 'super', 'superclass')),
TypedField('keyword', label="Init-Keywords",
names=('keyword', 'init-keyword')),
GroupedField('slots', label="Slots",
names=('slot', 'getter')),
Field('conditions', label="Conditions", has_arg=False,
names=('conditions', 'exceptions', 'condition', 'exception',
'signals', 'throws')),
Field('operations', label="Operations", has_arg=False,
names=('operations', 'methods', 'functions')),
] + DylanBindingDesc.doc_field_types
class PlanguagePerformanceRequirement(PlanguageObject):
display_prefix = 'Performance Requirement '
doc_field_types = [
Field('scale', label='Scale', names=('scale')),
GroupedField('level', label='Levels', names=('level', 'levels')),
Field('meter', label='Meter', names=('meter')),
]
class SublimeWindowCommand(SublimeObject):
doc_field_types = [
GroupedField('shortcut',
label='Keyboard Shortcut',
names=('shortcut', )),
GroupedField('setting', label='Settings', names=('setting', )),
]
def handle_signature(self, sig, signode):
signode += addnodes.desc_name(sig, sig)
signode['command'] = sig
return sig
def needs_arglist(self):
return False
def add_target_and_index(self, name, sig, signode):
slug = re.sub(r'\W+', '-', name).lower()
if slug not in self.state.document.ids:
signode['names'].append(slug)
signode['ids'].append(slug)
signode['first'] = (not self.names)
self.state.document.note_explicit_target(signode)
inv = self.env.domaindata['sublime']['objects']
# if name in inv:
# self.state_machine.reporter.warning(
# 'duplicate C object description of %s, ' % name +
# 'other instance in ' + self.env.doc2path(inv[name][0]),
# line=self.lineno)
inv[name] = (self.env.docname, self.objtype)
#print inv[name]
indextext = self.get_index_text(name)
if indextext:
self.indexnode['entries'].append(('single', indextext, slug, ''))
# signode['ids'].append(clean_name)
# self.env.domaindata['sublime'][sig] = (self.env.docname, '')
# self.indexnode['entries'].append(('single', u'name', u'fullname', ''))
def get_index_text(self, name):
name = name.replace('Git: ', '')
return u"%s (command)" % name
class JoernLookup(JoernObj):
doc_field_types = [
GroupedField('param', label='Parameter', names=('param',), can_collapse = False),
Field('out*', label='Outgoing nodes', names=('out*',), has_arg = False),
NodeField('out', label='Outgoing nodes', names=('out',), rolename = 'ref'),
]
desc_annotation = 'lookup'
class DotNetStruct(DotNetObject):
display_prefix = 'struct '
doc_field_types = [
GroupedField('typeparameters',
label=l_('Type Parameters'),
rolename='typeparam',
names=('typeparam', 'typeparameter')),
]
def setup(app):
from sphinx.util.docfields import GroupedField
app.add_object_type('confval', 'confval',
objname='configuration value',
indextemplate='pair: %s; configuration value')
fdesc = GroupedField('parameter', label='Parameters',
names=['param'], can_collapse=True)
app.add_object_type('event', 'event', 'pair: %s; event', parse_event,
doc_field_types=[fdesc])
class QCSEnum(ObjectDescription):
doc_field_types = [
Field('description',
label=_('Description'),
names=('description'),
has_arg=False),
GroupedField('item',
label=_('Enum Items'),
names=('item', 'item'),
can_collapse=False),
]
allow_nesting = False
def handle_signature(self, sig: str,
sig_node: addnodes.desc_signature) -> str:
sig_node += addnodes.desc_name(sig, sig)
self.obj_name = sig
return sig
def after_content(self):
enum_doc = {"type": "enum", "name": self.obj_name, "items": []}
linesList = build_lines_list(self.content)
for line in linesList:
if line.startswith(":description:"):
enum_doc["description"] = preprocess_doc(
line[len(":description:"):])
elif line.startswith(":item "):
item_start = len(":item ")
item_end = line.find(":", item_start)
item_name = line[item_start:item_end]
item = {
"name": item_name,
"description": preprocess_doc(line[(item_end + 1):])
}
enum_doc["items"].append(item)
qcs_domain = self.env.get_domain('qcs')
qcs_domain.data["api_doc"]["enums"][self.obj_name] = enum_doc
def add_target_and_index(self, name_cls: str, sig: str,
sig_node: addnodes.desc_signature) -> None:
qcs_domain = self.env.get_domain('qcs')
qcs_domain.add_enum(sig)
target_name = "qcs.enum.{}".format(sig)
sig_node['names'].append(target_name)
sig_node['ids'].append(target_name)
sig_node['first'] = (not self.names)
self.state.document.note_explicit_target(sig_node)
def setup(app: Sphinx):
fdesc = GroupedField("parameter",
label="Parameters",
names=["param"],
can_collapse=True)
app.add_object_type("event",
"event",
"pair: %s; event",
parse_event,
doc_field_types=[fdesc])
def setup(app):
from sphinx.ext.autodoc import cut_lines
from sphinx.util.docfields import GroupedField
app.connect('autodoc-process-docstring', cut_lines(4, what=['module']))
app.add_object_type('confval', 'confval',
objname='configuration value',
indextemplate='pair: %s; configuration value')
fdesc = GroupedField('parameter', label='Parameters',
names=['param'], can_collapse=True)
app.add_object_type('event', 'event', 'pair: %s; event', parse_event,
doc_field_types=[fdesc])
class AvroRPCMessage(AvroObject):
doc_field_types = [
TypedField('arguments',
label=l_('Arguments'),
names=('argument', 'arg', 'param'),
typerolename='rpc'),
GroupedField('errors',
label=l_('Throws'),
names=('throws', 'throw'),
can_collapse=True),
Field('returntype', label=l_('Returns'), names=('returns', 'return'))
]
