def run(self):
env = self.state.document.settings.env
modname = self.arguments[0].strip()
noindex = "noindex" in self.options
env.temp_data["py:module"] = modname
env.domaindata["py"]["modules"][modname] = (
env.docname,
self.options.get("synopsis", ""),
self.options.get("platform", ""),
"deprecated" in self.options,
)
# make a duplicate entry in 'objects' to facilitate searching for the
# module in PythonDomain.find_obj()
env.domaindata["py"]["objects"][modname] = (env.docname, "module")
targetnode = nodes.target("", "", ids=["module-" + modname], ismod=True)
self.state.document.note_explicit_target(targetnode)
ret = [targetnode]
# XXX this behavior of the module directive is a mess...
if "platform" in self.options:
platform = self.options["platform"]
node = nodes.paragraph()
node += nodes.emphasis("", _("Platforms: "))
node += nodes.Text(platform, platform)
ret.append(node)
# the synopsis isn't printed; in fact, it is only used in the
# modindex currently
if not noindex:
indextext = _("%s (module)") % modname
inode = addnodes.index(entries=[("single", indextext, "module-" + modname, modname)])
ret.append(inode)
return ret
def run(self):
pkgname = self.arguments[0].strip()
env = self.state.document.settings.env
env.ref_context['qbs:package'] = pkgname
if 'noindex' in self.options:
return []
sdkname = self.options.get('sdk', env.ref_context.get('qbs:sdk', None))
if sdkname:
pkgname = sdkname + '.' + pkgname
env.domaindata['qbs']['packages'][pkgname] = (env.docname, self.options.get('synopsis', ''))
env.domaindata['qbs']['objects'][pkgname] = (env.docname, 'package')
# target
targetname = 'package-' + pkgname
targetnode = nodes.target('', '', ids=[targetname], ismod=True)
self.state.document.note_explicit_target(targetnode)
# index
if sdkname:
itext = _('%s (Qbs Package in %s)') % (pkgname[len(sdkname) + 1:], sdkname)
else:
itext = _('%s (Qbs Package') % (pkgname[len(sdkname) + 1:])
inode = addnodes.index(entries=[('single', itext, targetname, '', None)])
return [targetnode, inode]
def index_role(typ, rawtext, text, lineno, inliner, options={}, content=[]):
# create new reference target
env = inliner.document.settings.env
targetid = 'index-%s' % env.new_serialno('index')
targetnode = nodes.target('', '', ids=[targetid])
# split text and target in role content
has_explicit_title, title, target = split_explicit_title(text)
title = utils.unescape(title)
target = utils.unescape(target)
# if an explicit target is given, we can process it as a full entry
if has_explicit_title:
entries = process_index_entry(target, targetid)
# otherwise we just create a "single" entry
else:
# but allow giving main entry
main = ''
if target.startswith('!'):
target = target[1:]
title = title[1:]
main = 'main'
entries = [('single', target, targetid, main)]
indexnode = addnodes.index()
indexnode['entries'] = entries
set_role_source_info(inliner, lineno, indexnode)
textnode = nodes.Text(title, title)
return [indexnode, targetnode, textnode], []
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)
def make_glossary_term(env, textnodes, index_key, source, lineno, new_id=None):
# get a text-only representation of the term and register it
# as a cross-reference target
term = nodes.term('', '', *textnodes)
term.source = source
term.line = lineno
gloss_entries = env.temp_data.setdefault('gloss_entries', set())
objects = env.domaindata['std']['objects']
termtext = term.astext()
if new_id is None:
new_id = nodes.make_id('term-' + termtext)
if new_id in gloss_entries:
new_id = 'term-' + str(len(gloss_entries))
gloss_entries.add(new_id)
objects['term', termtext.lower()] = env.docname, new_id
# add an index entry too
indexnode = addnodes.index()
indexnode['entries'] = [('single', termtext, new_id, 'main', index_key)]
indexnode.source, indexnode.line = term.source, term.line
term.append(indexnode)
term['ids'].append(new_id)
term['names'].append(new_id)
return term
def module_directive(name, arguments, options, content, lineno,
content_offset, block_text, state, state_machine):
env = state.document.settings.env
modname = arguments[0].strip()
noindex = 'noindex' in options
env.currmodule = modname
env.note_module(modname, options.get('synopsis', ''),
options.get('platform', ''),
'deprecated' in options)
modulenode = addnodes.module()
modulenode['modname'] = modname
modulenode['synopsis'] = options.get('synopsis', '')
targetnode = nodes.target('', '', ids=['module-' + modname])
state.document.note_explicit_target(targetnode)
ret = [modulenode, targetnode]
if 'platform' in options:
modulenode['platform'] = options['platform']
node = nodes.paragraph()
node += nodes.emphasis('', _('Platforms: '))
node += nodes.Text(options['platform'], options['platform'])
ret.append(node)
# the synopsis isn't printed; in fact, it is only used in the modindex currently
if not noindex:
indextext = _('%s (module)') % modname
inode = addnodes.index(entries=[('single', indextext,
'module-' + modname, modname)])
ret.insert(0, inode)
return ret
def run(self):
# type: () -> List[nodes.Node]
modname = self.arguments[0].strip()
noindex = 'noindex' in self.options
self.env.ref_context['py:module'] = modname
ret = []
if not noindex:
self.env.domaindata['py']['modules'][modname] = (self.env.docname,
self.options.get('synopsis', ''),
self.options.get('platform', ''),
'deprecated' in self.options)
# make a duplicate entry in 'objects' to facilitate searching for
# the module in PythonDomain.find_obj()
self.env.domaindata['py']['objects'][modname] = (self.env.docname, 'module')
targetnode = nodes.target('', '', ids=['module-' + modname],
ismod=True)
self.state.document.note_explicit_target(targetnode)
# the platform and synopsis aren't printed; in fact, they are only
# used in the modindex currently
ret.append(targetnode)
indextext = _('%s (module)') % modname
inode = addnodes.index(entries=[('single', indextext,
'module-' + modname, '', None)])
ret.append(inode)
return ret
def glossary_directive(name, arguments, options, content, lineno,
content_offset, block_text, state, state_machine):
"""Glossary with cross-reference targets for :term: roles."""
env = state.document.settings.env
node = addnodes.glossary()
state.nested_parse(content, content_offset, node)
# the content should be definition lists
dls = [child for child in node if isinstance(child, nodes.definition_list)]
# now, extract definition terms to enable cross-reference creation
for dl in dls:
dl['classes'].append('glossary')
for li in dl.children:
if not li.children or not isinstance(li[0], nodes.term):
continue
termtext = li.children[0].astext()
new_id = 'term-' + nodes.make_id(termtext)
if new_id in env.gloss_entries:
new_id = 'term-' + str(len(env.gloss_entries))
env.gloss_entries.add(new_id)
li[0]['names'].append(new_id)
li[0]['ids'].append(new_id)
state.document.settings.env.note_reftarget('term', termtext.lower(),
new_id)
# add an index entry too
indexnode = addnodes.index()
indexnode['entries'] = [('single', termtext, new_id, termtext)]
li.insert(0, indexnode)
return [node]
def run(self):
arguments = self.arguments[0].split('\n')
env = self.state.document.settings.env
targetid = 'index-%s' % env.new_serialno('index')
targetnode = nodes.target('', '', ids=[targetid])
self.state.document.note_explicit_target(targetnode)
indexnode = addnodes.index()
indexnode['entries'] = ne = []
for entry in arguments:
entry = entry.strip()
for type in pairindextypes:
if entry.startswith(type+':'):
value = entry[len(type)+1:].strip()
value = pairindextypes[type] + '; ' + value
ne.append(('pair', value, targetid, value))
break
else:
for type in self.indextypes:
if entry.startswith(type+':'):
value = entry[len(type)+1:].strip()
if type == 'double':
type = 'pair'
ne.append((type, value, targetid, value))
break
# shorthand notation for single entries
else:
for value in entry.split(','):
value = value.strip()
if not value:
continue
ne.append(('single', value, targetid, value))
return [indexnode, targetnode]
def run(self):
env = self.state.document.settings.env
name = self.content[0].strip()
expr = '\n'.join(self.content[1:]).strip()
targetid = "syntax-%s" % name
targetnode = nodes.target('', '', ids=[targetid])
label = nodes.paragraph('', '', nodes.strong(text=name))
ix = addnodes.index(entries=[
("single", "syntax; " + name, targetid, False)])
try:
it = eval(expr,
railroad_diagrams.__dict__)
except Exception as ex:
print >>stderr, "@@eek!", self.content
print >>stderr, "@@", ex
raise
diag = RailroadDiagram(railroad_diagrams.Diagram(it))
if env.config.syntax_fp:
out = env.config.syntax_fp
dump({'name': name, 'expr': expr}, out)
out.write(",\n\n")
return [targetnode, ix, label, diag]
def role(name, rawtext, text, lineno, inliner, options={}, content=[]):
env = inliner.document.settings.env
try:
command, parameter = text.split(' ', 1)
except ValueError:
command = text
parameter = ''
indexstring = 'Console; Command; {}'.format(command)
targetid = 'bcommand-{}-{}'.format(command, env.new_serialno('bcommand'))
# Generic index entries
indexnode = addnodes.index()
indexnode['entries'] = []
indexnode['entries'].append([
'single',
indexstring,
targetid, '', None
])
targetnode = nodes.target('', '', ids=[targetid])
text_node = nodes.strong(text='{}'.format(text))
return [targetnode, text_node, indexnode], []
def run(self):
self.index_entries = []
#~ index_entries is a list of 4-tuples of
#~ ``(entrytype, entryname, target, ignored)``
content = super(ActorDirective, self).run()
indexnode = addnodes.index(entries=self.index_entries)
return [indexnode] + content
def run(self):
modname = self.arguments[0].strip()
env = self.state.document.settings.env
env.temp_data['cf3:namespace'] = modname
ret = []
if 'noindex' in self.options:
return ret
env.domaindata['cf3']['namespaces'][modname] = (
env.docname, self.options.get('synopsis', ''),
'deprecated' in self.options,
)
targetnode = nodes.target(
'', '', ids=['namespace-' + modname], ismod=True
)
self.state.document.note_explicit_target(targetnode)
ret.append(targetnode)
indextext = _('%s (namespace)') % modname
ret.append(
addnodes.index(entries=[
('single', indextext, 'namespace-' + modname, modname)
])
)
return ret
def run(self):
env = self.state.document.settings.env
modname = self.arguments[0].strip()
noindex = 'noindex' in self.options
env.temp_data['tcpip:module'] = modname
env.domaindata['tcpip']['modules'][modname] = \
(env.docname, self.options.get('synopsis', ''),
self.options.get('platform', ''), 'deprecated' in self.options)
targetnode = nodes.target('', '', ids=['module-' + modname], ismod=True)
self.state.document.note_explicit_target(targetnode)
ret = [targetnode]
# XXX this behavior of the module directive is a mess...
if 'platform' in self.options:
platform = self.options['platform']
node = nodes.paragraph()
node += nodes.emphasis('', _('Platforms: '))
node += nodes.Text(platform, platform)
ret.append(node)
# the synopsis isn't printed; in fact, it is only used in the
# modindex currently
if not noindex:
indextext = _('%s (module)') % modname
inode = addnodes.index(entries=[('single', indextext,
'module-' + modname, modname)])
ret.append(inode)
return ret
def run(self):
language = self.arguments[0]
indexed_languages = self.options.get('index_as') or language
index_specs = ['pair: {}; language'.format(l)
for l in indexed_languages.splitlines()]
name = nodes.fully_normalize_name(language)
target = 'language-{}'.format(name)
targetnode = nodes.target('', '', ids=[target])
self.state.document.note_explicit_target(targetnode)
indexnode = addnodes.index()
indexnode['entries'] = []
indexnode['inline'] = False
set_source_info(self, indexnode)
for spec in index_specs:
indexnode['entries'].extend(process_index_entry(spec, target))
sectionnode = nodes.section()
sectionnode['names'].append(name)
title, messages = self.state.inline_text(language, self.lineno)
titlenode = nodes.title(language, '', *title)
sectionnode += titlenode
sectionnode += messages
self.state.document.note_implicit_target(sectionnode, sectionnode)
self.state.nested_parse(self.content, self.content_offset, sectionnode)
return [indexnode, targetnode, sectionnode]
def run(self):
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))
if entries:
inode = addnodes.index(entries=entries)
ret.insert(0, inode)
return ret
def make_glossary_term(env, textnodes, index_key, source, lineno, new_id=None):
# type: (BuildEnvironment, Iterable[nodes.Node], str, str, int, str) -> nodes.term
# get a text-only representation of the term and register it
# as a cross-reference target
term = nodes.term('', '', *textnodes)
term.source = source
term.line = lineno
gloss_entries = env.temp_data.setdefault('gloss_entries', set())
termtext = term.astext()
if new_id is None:
new_id = nodes.make_id('term-' + termtext)
if new_id in gloss_entries:
new_id = 'term-' + str(len(gloss_entries))
gloss_entries.add(new_id)
std = cast(StandardDomain, env.get_domain('std'))
std.add_object('term', termtext.lower(), env.docname, new_id)
# add an index entry too
indexnode = addnodes.index()
indexnode['entries'] = [('single', termtext, new_id, 'main', index_key)]
indexnode.source, indexnode.line = term.source, term.line
term.append(indexnode)
term['ids'].append(new_id)
term['names'].append(new_id)
return term
def run(self):
# type: () -> List[nodes.Node]
# normalize whitespace in fullname like XRefRole does
fullname = ws_re.sub(' ', self.arguments[0].strip())
targetname = '%s-%s' % (self.name, fullname)
node = nodes.target('', '', ids=[targetname])
self.state.document.note_explicit_target(node)
ret = [node] # type: List[nodes.Node]
if self.indextemplate:
indexentry = self.indextemplate % (fullname,)
indextype = 'single'
colon = indexentry.find(':')
if colon != -1:
indextype = indexentry[:colon].strip()
indexentry = indexentry[colon + 1:].strip()
inode = addnodes.index(entries=[(indextype, indexentry,
targetname, '', None)])
ret.insert(0, inode)
name = self.name
if ':' in self.name:
_, name = self.name.split(':', 1)
std = cast(StandardDomain, self.env.get_domain('std'))
std.add_object(name, fullname, self.env.docname, targetname)
return ret
def indexmarkup_role(typ, rawtext, text, lineno, inliner,
options={}, content=[]):
"""Role for PEP/RFC references that generate an index entry."""
env = inliner.document.settings.env
if not typ:
typ = env.config.default_role
else:
typ = typ.lower()
has_explicit_title, title, target = split_explicit_title(text) # type: bool, unicode, unicode # NOQA
title = utils.unescape(title)
target = utils.unescape(target)
targetid = 'index-%s' % env.new_serialno('index')
indexnode = addnodes.index()
targetnode = nodes.target('', '', ids=[targetid])
inliner.document.note_explicit_target(targetnode)
if typ == 'pep':
indexnode['entries'] = [
('single', _('Python Enhancement Proposals; PEP %s') % target,
targetid, '', None)]
anchor = '' # type: unicode
anchorindex = target.find('#')
if anchorindex > 0:
target, anchor = target[:anchorindex], target[anchorindex:]
if not has_explicit_title:
title = "PEP " + utils.unescape(title)
try:
pepnum = int(target)
except ValueError:
msg = inliner.reporter.error('invalid PEP number %s' % target,
line=lineno)
prb = inliner.problematic(rawtext, rawtext, msg)
return [prb], [msg]
ref = inliner.document.settings.pep_base_url + 'pep-%04d' % pepnum
sn = nodes.strong(title, title)
rn = nodes.reference('', '', internal=False, refuri=ref+anchor,
classes=[typ])
rn += sn
return [indexnode, targetnode, rn], []
elif typ == 'rfc':
indexnode['entries'] = [
('single', 'RFC; RFC %s' % target, targetid, '', None)]
anchor = ''
anchorindex = target.find('#')
if anchorindex > 0:
target, anchor = target[:anchorindex], target[anchorindex:]
if not has_explicit_title:
title = "RFC " + utils.unescape(title)
try:
rfcnum = int(target)
except ValueError:
msg = inliner.reporter.error('invalid RFC number %s' % target,
line=lineno)
prb = inliner.problematic(rawtext, rawtext, msg)
return [prb], [msg]
ref = inliner.document.settings.rfc_base_url + inliner.rfc_url % rfcnum
sn = nodes.strong(title, title)
rn = nodes.reference('', '', internal=False, refuri=ref+anchor,
classes=[typ])
rn += sn
return [indexnode, targetnode, rn], []
def run(self):
env = self.state.document.settings.env
modname = self.arguments[0].strip()
noindex = 'noindex' in self.options
env.temp_data['lua:module'] = modname
ret = []
if not noindex:
env.domaindata['lua']['modules'][modname] = \
(env.docname, self.options.get('synopsis', ''),
self.options.get('platform', ''), 'deprecated' in self.options)
ids = "lua-module.%s" % (modname)
# make a duplicate entry in 'objects' to facilitate searching for
# the module in LuaDomain.find_obj()
env.domaindata['lua']['objects'][modname] = (env.docname, 'module', ids)
targetnode = nodes.target('', '', ids=[ids],
ismod=True)
self.state.document.note_explicit_target(targetnode)
# the platform and synopsis aren't printed; in fact, they are only
# used in the modindex currently
ret.append(targetnode)
indextext = _('%s (module)') % modname
inode = addnodes.index(entries=[('single', indextext,
ids, '')])
ret.append(inode)
return ret
def run(self):
env = self.state.document.settings.env
node = addnodes.glossary()
node.document = self.state.document
self.state.nested_parse(self.content, self.content_offset, node)
# the content should be definition lists
dls = [child for child in node
if isinstance(child, nodes.definition_list)]
# now, extract definition terms to enable cross-reference creation
new_dl = nodes.definition_list()
new_dl['classes'].append('glossary')
items = []
for dl in dls:
for li in dl.children:
if not li.children or not isinstance(li[0], nodes.term):
continue
termtext = li.children[0].astext()
new_id = 'term-' + nodes.make_id(termtext)
if new_id in env.gloss_entries:
new_id = 'term-' + str(len(env.gloss_entries))
env.gloss_entries.add(new_id)
li[0]['names'].append(new_id)
li[0]['ids'].append(new_id)
env.note_reftarget('term', termtext.lower(), new_id)
# add an index entry too
indexnode = addnodes.index()
indexnode['entries'] = [('single', termtext, new_id, termtext)]
li.insert(0, indexnode)
items.append((termtext, li))
if 'sorted' in self.options:
items.sort(key=lambda x: x[0].lower())
new_dl.extend(item[1] for item in items)
node.children = [new_dl]
return [node]
def run(self):
env = self.state.document.settings.env
modname = self.arguments[0].strip()
noindex = 'noindex' in self.options
env.currmodule = modname
env.note_module(modname, self.options.get('synopsis', ''),
self.options.get('platform', ''),
'deprecated' in self.options)
modulenode = addnodes.module()
modulenode['modname'] = modname
modulenode['synopsis'] = self.options.get('synopsis', '')
targetnode = nodes.target('', '', ids=['module-' + modname], ismod=True)
self.state.document.note_explicit_target(targetnode)
ret = [modulenode, targetnode]
if 'platform' in self.options:
platform = self.options['platform']
modulenode['platform'] = platform
node = nodes.paragraph()
node += nodes.emphasis('', _('Platforms: '))
node += nodes.Text(platform, platform)
ret.append(node)
# the synopsis isn't printed; in fact, it is only used in the
# modindex currently
if not noindex:
indextext = _('%s (module)') % modname
inode = addnodes.index(entries=[('single', indextext,
'module-' + modname, modname)])
ret.insert(0, inode)
return ret
def index_directive(name, arguments, options, content, lineno,
content_offset, block_text, state, state_machine):
arguments = arguments[0].split('\n')
env = state.document.settings.env
targetid = 'index-%s' % env.index_num
env.index_num += 1
targetnode = nodes.target('', '', ids=[targetid])
state.document.note_explicit_target(targetnode)
indexnode = addnodes.index()
indexnode['entries'] = ne = []
for entry in arguments:
entry = entry.strip()
for type in pairindextypes:
if entry.startswith(type+':'):
value = entry[len(type)+1:].strip()
value = pairindextypes[type] + '; ' + value
ne.append(('pair', value, targetid, value))
break
else:
for type in indextypes:
if entry.startswith(type+':'):
value = entry[len(type)+1:].strip()
ne.append((type, value, targetid, value))
break
# shorthand notation for single entries
else:
for value in entry.split(','):
value = value.strip()
if not value:
continue
ne.append(('single', value, targetid, value))
return [indexnode, targetnode]
def role(name, rawtext, text, lineno, inliner, options={}, content=[]):
env = inliner.document.settings.env
# Generic index entries
indexnode = addnodes.index()
indexnode['entries'] = []
try:
platform, version = text.split(' ', 1)
targetid = 'os-{}-{}-{}'.format(platform, version, env.new_serialno('os'))
indexnode['entries'].append([
'single',
'Platform; {}; {}'.format(platform, version),
targetid, '', None
])
except ValueError:
platform = text
version = ''
targetid = 'os-{}-{}-{}'.format(platform, version, env.new_serialno('os'))
indexnode['entries'].append([
'single',
'Platform; {}'.format(platform),
targetid, '', None
])
targetnode = nodes.target('', '', ids=[targetid])
text_node = nodes.strong(text='{}'.format(text))
return [targetnode, text_node, indexnode], []
def role(name, rawtext, text, lineno, inliner, options={}, content=[]):
#version = self.arguments[0]
#summary = self.arguments[1]
version, summary = text.split(':', 1)
summary = summary.strip()
indexstring = 'bareos-{}; {}'.format(version, summary)
idstring = 'bareos-{}-{}'.format(version, summary)
_id = nodes.make_id(idstring)
# Generic index entries
indexnode = addnodes.index()
indexnode['entries'] = []
indexnode['entries'].append([
'pair',
indexstring,
_id, '', None
])
targetnode = nodes.target('', '', ids=[_id])
#text_node = nodes.Text(text='Version >= {}'.format(version))
#text_node = nodes.strong(text='Version >= {}'.format(version))
text_node = nodes.emphasis(text='Version >= {}'.format(version))
# target does not work with generated.
#text_node = nodes.generated(text='Version >= {}'.format(version))
return [targetnode, text_node, indexnode], []
def run(self):
populated = CPPAutoDocObject._populate(self)
indexnode = addnodes.index(entries=[])
title = '{name} Namespace Reference'.format(name = self._get_name())
main_section = self._make_main_section(title)
if populated:
obj = self._get_obj()
section = self._make_section('Introduction')
section += self._make_brief(obj)
main_section += section
section = self._make_section('Inner Definitions')
main_section += section
section += self._make_innernamespaces(obj)
section += self._make_innermacros(obj)
section += self._make_innertypes(obj)
section += self._make_innerclasses(obj)
section += self._make_innerfunctions(obj)
section = self._make_section('Detailed Description')
section += self._make_details(obj)
main_section += section
main_section += self._make_methods_documentation(obj)
main_section += self._make_enums_documentation(obj)
else:
main_section += nodes.paragraph(text='Unknown Namespace.')
return [indexnode, main_section]
def run(self):
env = self.state.document.settings.env
modname = self.arguments[0].strip()
noindex = "noindex" in self.options
env.ref_context["py:module"] = modname
ret = []
if not noindex:
env.domaindata["py"]["modules"][modname] = (
env.docname,
self.options.get("synopsis", ""),
self.options.get("platform", ""),
"deprecated" in self.options,
)
# make a duplicate entry in 'objects' to facilitate searching for
# the module in PythonDomain.find_obj()
env.domaindata["py"]["objects"][modname] = (env.docname, "module")
targetnode = nodes.target("", "", ids=["module-" + modname], ismod=True)
self.state.document.note_explicit_target(targetnode)
# the platform and synopsis aren't printed; in fact, they are only
# used in the modindex currently
ret.append(targetnode)
indextext = _("%s (module)") % modname
inode = addnodes.index(entries=[("single", indextext, "module-" + modname, "", None)])
ret.append(inode)
return ret
def create_index_node(self, env, tag, attributes):
if sphinx.version_info[:2] < (1, 4): # Sphinx earlier than v1.4
entries = [("single", tag, tag, "")]
else: # Sphinx v1.4 and later
entries = [("single", tag, tag, "", None)]
index_node = addnodes.index()
index_node["entries"] = entries
return index_node
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]
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]
def run(self):
# type: () -> List[nodes.Node]
arguments = self.arguments[0].split('\n')
targetid = 'index-%s' % self.env.new_serialno('index')
targetnode = nodes.target('', '', ids=[targetid])
self.state.document.note_explicit_target(targetnode)
indexnode = addnodes.index()
indexnode['entries'] = []
indexnode['inline'] = False
set_source_info(self, indexnode)
for entry in arguments:
indexnode['entries'].extend(process_index_entry(entry, targetid))
return [indexnode, targetnode]
def result_nodes(self, document, env, node, is_ref):
if not is_ref:
return [node], []
varname = node['reftarget']
tgtid = 'index-%s' % env.new_serialno('index')
indexnode = addnodes.index()
indexnode['entries'] = [
('single', varname, tgtid, ''),
('single', _('environment variable; %s') % varname, tgtid, '')
]
targetnode = nodes.target('', '', ids=[tgtid])
document.note_explicit_target(targetnode)
return [indexnode, targetnode, node], []
def result_nodes(self, document, env, node, is_ref):
if not is_ref:
return [node], []
varname = node["reftarget"]
tgtid = "index-%s" % env.new_serialno("index")
indexnode = addnodes.index()
indexnode["entries"] = [
("single", varname, tgtid, varname, None),
("single", "configuration section; %s" % varname, tgtid, varname, None),
]
targetnode = nodes.target("", "", ids=[tgtid])
document.note_explicit_target(targetnode)
return [indexnode, targetnode, node], []
def result_nodes(self, document: nodes.document, env: "BuildEnvironment", node: Element,
is_ref: bool) -> Tuple[List[Node], List[system_message]]:
if not is_ref:
return [node], []
varname = node['reftarget']
tgtid = 'index-%s' % env.new_serialno('index')
indexnode = addnodes.index()
indexnode['entries'] = [
('single', varname, tgtid, '', None),
('single', _('environment variable; %s') % varname, tgtid, '', None)
]
targetnode = nodes.target('', '', ids=[tgtid])
document.note_explicit_target(targetnode)
return [indexnode, targetnode, node], []
def result_nodes(self, document, env, node, is_ref):
# type: (nodes.Node, BuildEnvironment, nodes.Node, bool) -> Tuple[List[nodes.Node], List[nodes.Node]] # NOQA
if not is_ref:
return [node], []
varname = node['reftarget']
tgtid = 'index-%s' % env.new_serialno('index')
indexnode = addnodes.index()
indexnode['entries'] = [
('single', varname, tgtid, '', None),
('single', _('environment variable; %s') % varname, tgtid, '', None)
]
targetnode = nodes.target('', '', ids=[tgtid])
document.note_explicit_target(targetnode)
return [indexnode, targetnode, node], []
def run(self):
env = self.state.document.settings.env
modname = self.arguments[0].strip()
env.temp_data['coffee:module'] = modname
targetnode = nodes.target('',
'',
ids=['module-' + modname],
ismod=True)
self.state.document.note_explicit_target(targetnode)
indextext = _('%s (module)') % modname
inode = addnodes.index(entries=[('single', indextext,
'module-' + modname, '')])
#section = nodes.section()
return [nodes.title('', modname), targetnode, inode]
def run(self):
self.env = self.state.document.settings.env
modname = self.arguments[0].strip()
try:
modname = ErlangSignature.canon_atom(modname)
modname_error = False
except ValueError:
_warn(self.env,
'invalid Erlang module name: %s',
modname,
location=(self.env.docname, self.lineno))
modname = "'invalid-module-name'"
modname_error = True
_ref_context(self.env)['erl:module'] = modname
if 'noindex' in self.options:
return []
targetnode = nodes.target('',
'',
ids=['module-' + modname],
ismod=True)
self.state.document.note_explicit_target(targetnode)
if not modname_error:
minv = self.env.domaindata['erl']['modules']
if modname not in minv:
minv[modname] = (self.env.docname,
self.options.get('synopsis', ''),
self.options.get('platform', ''), 'deprecated'
in self.options)
else:
_warn(
self.env,
'duplicate Erlang module name of %s, other instance in %s.',
modname,
self.env.doc2path(minv[modname][0]),
location=(self.env.docname, self.lineno))
# the synopsis isn't printed; in fact, it is only used in the
# modindex currently
indextext = _('%s (Erlang module)') % modname
inode = addnodes.index(entries=[
_indexentry('single', indextext, 'module-' +
modname, modname, None)
])
return [targetnode, inode]
def make_glossary_term(env: "BuildEnvironment",
textnodes: Iterable[Node],
index_key: str,
source: str,
lineno: int,
node_id: str = None,
document: nodes.document = None) -> nodes.term:
# get a text-only representation of the term and register it
# as a cross-reference target
term = nodes.term('', '', *textnodes)
term.source = source
term.line = lineno
termtext = term.astext()
if node_id:
# node_id is given from outside (mainly i18n module), use it forcedly
term['ids'].append(node_id)
elif document:
node_id = make_id(env, document, 'term', termtext)
term['ids'].append(node_id)
document.note_explicit_target(term)
else:
warnings.warn(
'make_glossary_term() expects document is passed as an argument.',
RemovedInSphinx40Warning)
gloss_entries = env.temp_data.setdefault('gloss_entries', set())
node_id = nodes.make_id('term-' + termtext)
if node_id == 'term':
# "term" is not good for node_id. Generate it by sequence number instead.
node_id = 'term-%d' % env.new_serialno('glossary')
while node_id in gloss_entries:
node_id = 'term-%d' % env.new_serialno('glossary')
gloss_entries.add(node_id)
term['ids'].append(node_id)
std = cast(StandardDomain, env.get_domain('std'))
std.note_object('term',
termtext.lower(),
node_id,
location=(env.docname, lineno))
# add an index entry too
indexnode = addnodes.index()
indexnode['entries'] = [('single', termtext, node_id, 'main', index_key)]
indexnode.source, indexnode.line = term.source, term.line
term.append(indexnode)
return term
def result_nodes(self, document, env, node, is_ref):
try:
indexnode = addnodes.index()
targetid = 'index-%s' % env.new_serialno('index')
targetnode = nodes.target('', '', ids=[targetid])
doctitle = list(document.traverse(nodes.title))[0].astext()
idxtext = "%s; %s" % (node.astext(), doctitle)
idxtext2 = "%s; %s" % ('sourcefile', node.astext())
indexnode['entries'] = [
('single', idxtext, targetid, '', None),
('single', idxtext2, targetid, '', None),
]
return [indexnode, targetnode, node], []
except KeyError as e:
return [node], [e.args[0]]
def run(self):
env = self.state.document.settings.env
app = env.app
group_name = self.arguments[0]
namespace = self.options.get('namespace')
cached_groups = env.domaindata['oslo.config']['groups']
# Store the current group for use later in option directives
env.temp_data['oslo.config:group'] = group_name
app.debug('oslo.config group %s' % group_name)
# Store the location where this group is being defined
# for use when resolving cross-references later.
# FIXME: This should take the source namespace into account, too
cached_groups[group_name] = env.docname
result = ViewList()
source_name = '<' + __name__ + '>'
def _add(text):
"Append some text to the output result view to be parsed."
result.append(text, source_name)
if namespace:
title = '%s: %s' % (namespace, group_name)
else:
title = group_name
_add(title)
_add('-' * len(title))
_add('')
for line in self.content:
_add(line)
node = nodes.section()
node.document = self.state.document
nested_parse_with_titles(self.state, result, node)
first_child = node.children[0]
# Compute the normalized target and set the node to have that
# as an id
target_name = cfg._normalize_group_name(group_name)
first_child['ids'].append(target_name)
indexnode = addnodes.index(entries=[])
return [indexnode] + node.children
def omero_command_role(typ, rawtext, etext, lineno, inliner,
options={}, content=[]):
"""Role for CLI commands that generates an index entry."""
env = inliner.document.settings.env
targetid = 'cmd-%s' % env.new_serialno('index')
# Create index and target nodes
indexnode = addnodes.index()
targetnode = nodes.target('', '', ids=[targetid])
inliner.document.note_explicit_target(targetnode)
indexnode['entries'] = [('single', "omero " + "; ".join(etext.split(" ")), targetid, '')]
# Mark the text using literal node
sn = nodes.literal('omero ' + etext, 'omero ' + etext)
return [indexnode, targetnode, sn], []
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]
def run(self):
env = self.state.document.settings.env
modname = self.arguments[0].strip()
noindex = 'noindex' in self.options
env.temp_data['nscp:module'] = modname
env.domaindata['nscp']['modules'][modname] = (env.docname, self.options.get('synopsis', ''), 'deprecated' in self.options)
ret = []
if not noindex:
targetnode = nodes.target('', '', ids=['module-' + modname], ismod=True)
self.state.document.note_explicit_target(targetnode)
# the platform and synopsis aren't printed; in fact, they are only
# used in the modindex currently
ret.append(targetnode)
indextext = _('%s (module)') % modname
inode = addnodes.index(entries=[('single', indextext, modname, '')])
ret.append(inode)
return ret
def run(self):
# type: () -> Tuple[List[nodes.Node], List[nodes.system_message]] # NOQA
target_id = "index-%s" % self.env.new_serialno("index")
self.http_type = self.name.lower()[4:]
if self.http_type not in HTTPRole.NAME_MAP:
msg = self.inliner.reporter.error("invalid HTTP reference %s" %
self.name,
line=self.lineno)
prb = self.inliner.problematic(self.rawtext, self.rawtext, msg)
return [prb], [msg]
entries = [(
"single",
"HTTP; HTTP %s %s" % (self.http_type, self.target),
target_id,
"",
None,
)]
index = addnodes.index(entries=entries)
target = nodes.target("", "", ids=[target_id])
self.inliner.document.note_explicit_target(target)
try:
refuri = self.build_uri()
reference = nodes.reference("",
"",
internal=False,
refuri=refuri,
classes=["rfc"])
if self.has_explicit_title:
reference += nodes.strong(self.title, self.title)
else:
title = "HTTP %s %s " % (self.http_type, self.target)
if _is_status(self):
title += " " + httpclient.responses[int(self.target)]
reference += nodes.strong(title, title)
except ValueError:
msg = self.inliner.reporter.error(
"invalid HTTP mozilla reference %s" % self.target,
line=self.lineno)
prb = self.inliner.problematic(self.rawtext, self.rawtext, msg)
return [prb], [msg]
return [index, target, reference], []
def run(self):
env = self.state.document.settings.env
directory = normalized_directory_name(self.arguments[0].strip())
env.temp_data['snip:directory'] = directory
if 'noindex' not in self.options:
# create an index entry
directories = env.domaindata['snip']['directories']
directories[directory] = DirectoryEntry(env.docname)
target = nodes.target('', '', ids=[directory])
self.state.document.note_explicit_target(target)
indextext = '{0} (snippet directory)'.format(directory)
index = addnodes.index(
entries=[('single', indextext, directory, '')])
return [target, index]
else:
return []
def run(self):
env = self.state.document.settings.env
section = self.arguments[0].strip()
if ':' in self.name:
self.domain, self.objtype = self.name.split(':', 1)
else:
self.domain, self.objtype = '', self.name
if section == 'None':
env.ref_context.pop(self.section_key, None)
return []
env.ref_context[self.section_key] = section
targetname = self.target_prefix + section
node = nodes.target('', '', ids=[targetname])
self.state.document.note_explicit_target(node)
indexentry = self.get_index_entry(section)
inode = addnodes.index(
entries = [
(self.indextype, indexentry, targetname, '', None)])
# find title of parent section node
title = find_section_title(self.state.parent)
data_key = CabalDomain.types[self.objtype]
# find how many sections in this document were added
num = env.domaindata['cabal']['index-num'].get(env.docname, 0)
env.domaindata['cabal']['index-num'][env.docname] = num + 1
meta = Meta(since=self.options.get('since'),
deprecated=self.options.get('deprecated'),
removed=self.options.get('removed'),
synopsis=self.options.get('synopsis'),
index = num,
title = title)
store = env.domaindata['cabal'][data_key]
if not section in store:
store[section] = env.docname, targetname, meta
return [inode, node]
def run(self):
env = self.state.document.settings.env
workspace_name = self.arguments[0].strip()
workspace_path = self.options.get('path', '')
env.ref_context['bazel:workspace'] = workspace_name
ret = []
env.domaindata['bazel']['workspaces'][workspace_name] = (env.docname,
workspace_path)
# make a duplicate entry in 'objects' to facilitate searching for
# the module in PythonDomain.find_obj()
env.domaindata['bazel']['objects'][workspace_name] = (env.docname, 'workspace')
targetnode = nodes.target('', '', ids=['workspace-' + workspace_name],
ismod=True)
self.state.document.note_explicit_target(targetnode)
# the platform and synopsis aren't printed; in fact, they are only
# used in the modindex currently
ret.append(targetnode)
indextext = _('%s (workspace)') % workspace_name
inode = addnodes.index(entries=[('single', indextext,
'module-' + workspace_name, '', None)])
ret.append(inode)
if self.options.get('hide', False) is None:
# No output is wanted
return ret
workspace_string = workspace_name
if self.options.get('show_type', False) is None:
sig_type_string = 'workspace: '
ret.append(addnodes.desc_name(sig_type_string, sig_type_string,
classes=['bazel', 'type', 'workspace']))
if workspace_path:
workspace_string += ' ({})'.format(workspace_path)
workspace_name_node = addnodes.desc_name(workspace_string, workspace_string)
ret.append(workspace_name_node)
contentnode = addnodes.desc_content()
ret.append(contentnode)
self.state.nested_parse(self.content, self.content_offset, contentnode)
# DocFieldTransformer(self).transform_all(contentnode)
return ret
def __call__(self,
name,
rawtext,
text,
lineno,
inliner,
options={},
content=[]):
targetnode = nodes.target('', '')
inliner.document.note_explicit_target(targetnode)
targetid = targetnode['ids'][0]
indexnode = addnodes.index()
indexnode['entries'] = ne = []
indexnode['inline'] = True
indexnode.source, indexnode.line = inliner.document.current_source, lineno
ne.extend(process_index_entry(text, targetid))
textnode = self.node_class(text, text)
return ([textnode, indexnode, targetnode], [])
def run(self):
env = self.state.document.settings.env
statename = self.arguments[0].strip()
if "noindex" in self.options:
return []
targetnode = nodes.target("", "", ids=["module-" + statename], ismod=True)
self.state.document.note_explicit_target(targetnode)
formula = env.temp_data.get("salt:formula")
indextext = "{1} ({0}-formula)".format(formula, statename)
inode = addnodes.index(
entries=[("single", indextext, "module-{}".format(statename), "")]
)
return [targetnode, inode]
def apply(self):
env = self.document.settings.env
# Treat some documents as ecm domain objects.
objtype, sep, tail = env.docname.rpartition('/')
make_index_entry = _ecm_index_objs.get(objtype)
if make_index_entry:
title = self.parse_title(env.docname)
# Insert the object link target.
targetid = '%s:%s' % (objtype, title)
targetnode = nodes.target('', '', ids=[targetid])
self.document.insert(0, targetnode)
# Insert the object index entry.
indexnode = addnodes.index()
indexnode['entries'] = [make_index_entry(title, targetid)]
self.document.insert(0, indexnode)
# Add to ecm domain object inventory
_ecm_object_inventory(env, self.document, 1, objtype, targetid)
def run(self):
env = self.state.document.settings.env
cppmethod = CppMethod()
cppmethod['name'] = self.arguments[0] # TODO: parse name
targetname = '%s-%s' % ('cppmethod', cppmethod['name'])
targetnode = nodes.target('', '', ids=[targetname])
self.state.document.note_explicit_target(targetnode)
indextext = _('%s (C++ method)') % cppmethod['name']
inode = addnodes.index(entries=[('single', indextext,
'cppmethod-' + cppmethod['name'],
cppmethod['name'])])
self.state.nested_parse(self.content, self.content_offset, cppmethod)
return [inode, targetnode, cppmethod]
def run(self) -> List[Node]:
arguments = self.arguments[0].split('\n')
if 'name' in self.options:
targetname = self.options['name']
targetnode = nodes.target('', '', names=[targetname])
else:
targetid = 'index-%s' % self.env.new_serialno('index')
targetnode = nodes.target('', '', ids=[targetid])
self.state.document.note_explicit_target(targetnode)
indexnode = addnodes.index()
indexnode['entries'] = []
indexnode['inline'] = False
self.set_source_info(indexnode)
for entry in arguments:
indexnode['entries'].extend(process_index_entry(entry, targetnode['ids'][0]))
return [indexnode, targetnode]
def run(self):
env = self.state.document.settings.env
statename = self.arguments[0].strip()
if 'noindex' in self.options:
return []
targetnode = nodes.target('', '', ids=['module-' + statename],
ismod=True)
self.state.document.note_explicit_target(targetnode)
formula = env.temp_data.get('salt:formula')
indextext = u'{1} ({0}-formula)'.format(formula, statename)
inode = addnodes.index(entries=[
('single', indextext, 'module-{0}'.format(statename), ''),
])
return [targetnode, inode]
def result_nodes(self, document, env, node, is_ref):
"""Called before returning the finished nodes. *node* is the reference
node if one was created (*is_ref* is then true), else the content node.
This method can add other nodes and must return a ``(nodes, messages)``
tuple (the usual return value of a role function).
"""
# this code adds index entries for each role instance
if not is_ref:
return [node], []
varname = node['reftarget']
tgtid = 'index-%s' % env.new_serialno('index')
indexnode = addnodes.index()
indexnode['entries'] = [
('single', varname, tgtid, ''),
#('single', _('environment variable; %s') % varname, tgtid, ''),
]
targetnode = nodes.target(node.rawsource, '', ids=[tgtid])
document.note_explicit_target(targetnode)
return [indexnode, targetnode, node], []
def _build_option_index(self, progname, ids, names, synopses):
"""
Build index for program option and register it in the environment
:param progname: program name
:param ids: list of all option ids
:param names: list of all option names
:param synopses: list of all option synopses
:return: index node
"""
env = self.state.document.settings.env
result = addnodes.index(entries=[])
for id, name, synopsis in zip(ids, names, synopses):
env.domaindata['std']['progoptions'][progname, name] = env.docname, id
if synopsis != name:
env.domaindata['std']['progoptions'][progname, synopsis] = env.docname, id
pair = '{} command line option; {}'.format(progname, ', '.join(synopses))
result['entries'].append(('pair', pair, id, '', None))
return result
def _init(self, name: str, qualified_type_name: str):
self._node_id = nodes.make_id(nodes.fully_normalize_name(name))
self._node = ModelElementNode(ids=[self._node_id])
self._parse_msgs = []
self._target = nodes.target()
self.state.add_target(self._node_id, '', self._target, self.lineno)
## add node to index
name_in_index = 'ModelElement; ' + name
target_anchor = self._node_id
self._indexnode = addnodes.index()
self._indexnode['entries'] = ne = []
self._indexnode['inline'] = False
set_source_info(self, self._indexnode)
ne.extend(process_index_entry(name_in_index, target_anchor))
self._model_element_type = reflectionutil.model_element_type(
qualified_type_name=qualified_type_name, )
def _init(self, trait_name: str):
self._node_id = trait_node_id_from_trait_name(trait_name)
self._node = TraitNode(ids=[self._node_id])
self._parse_msgs = []
self._target = nodes.target()
self.state.add_target(self._node_id, '', self._target, self.lineno)
## add node to index
name_in_index = 'Trait; ' + trait_name
target_anchor = self._node_id
self._indexnode = addnodes.index()
self._indexnode['entries'] = ne = []
self._indexnode['inline'] = False
set_source_info(self, self._indexnode)
ne.extend(process_index_entry(name_in_index, target_anchor))
self._trait_instance = reflectionutil.trait_instance(trait_name)
self._trait_class = reflectionutil.trait_class(trait_name)
def run(self):
env = self.state.document.settings.env
cppclass = CppClass()
cppclass['name'] = self.arguments[0]
cppclass['derives'] = self.options.get('derives')
targetname = '%s-%s' % ('cppclass', cppclass['name'])
targetnode = nodes.target('', '', ids=[targetname])
self.state.document.note_explicit_target(targetnode)
indextext = _('%s (C++ class)') % cppclass['name']
inode = addnodes.index(entries=[('single', indextext,
'cppclass-' + cppclass['name'],
cppclass['name'])])
self.state.nested_parse(self.content, self.content_offset, cppclass)
return [inode, targetnode, cppclass]
def run(self):
index, content = ObjectDescription.run(self)
fields = nodes.field_list()
for f in self.fields:
field = f.make_field(self)
if field:
fields += field
# Insert option fields right after signature
content.insert(1, fields)
name = self.arguments[0]
module = self.options.get('module', None)
qname = '{}.{}'.format(module, name) if module else name
classname = self.name[4:] if self.name.startswith(
'fab:') else self.name
indextext = '{} ({} in {})'.format(name, classname, module)
index = addnodes.index(entries=[('single', indextext, name, None,
None)])
return [index, content]
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
