def process_link(self, env, refnode, has_explicit_title, title, target):
program = env.temp_data.get("std:program")
if not has_explicit_title:
if " " in title and not (title.startswith("/") or title.startswith("-")):
program, target = re.split(" (?=-|--|/)", title, 1)
program = ws_re.sub("-", program)
target = target.strip()
elif " " in target:
program, target = re.split(" (?=-|--|/)", target, 1)
program = ws_re.sub("-", program)
refnode["refprogram"] = program
return title, target
def process_link(self, env, refnode, has_explicit_title, title, target):
program = env.temp_data.get('std:program')
if not has_explicit_title:
if ' ' in title and not (title.startswith('/') or
title.startswith('-')):
program, target = re.split(' (?=-|--|/)', title, 1)
program = ws_re.sub('-', program)
target = target.strip()
elif ' ' in target:
program, target = re.split(' (?=-|--|/)', target, 1)
program = ws_re.sub('-', program)
refnode['refprogram'] = program
return title, target
def handle_signature(self, sig, signode):
name = self.options["name"]
parameters = json.loads(self.options["parameters"]) if "parameters" in self.options else []
return_v = json.loads(self.options["return"]) if "return" in self.options else ("", "")
prefix = self.options["prefix"] if "prefix" in self.options else ""
if not ("parameters" in self.options) or not ("return" in self.options):
print("WARNING: No parameters or return set for '" + name + "'")
signode += nodes.Text(prefix + " ", prefix + u"\xa0")
xref = addnodes.pending_xref(
":ref:`" + return_v[1] + "`",
refdomain="std",
reftype="ref",
reftarget=ws_re.sub(" ", return_v[1].lower()),
refexplicit=False,
)
xref += nodes.Text(return_v[0], return_v[0])
signode += xref
signode += nodes.Text(" ", u"\xa0")
signode += addnodes.desc_name(name, name)
paramlist = addnodes.desc_parameterlist()
for tn in parameters:
param = addnodes.desc_parameter("", "", noemph=True)
prefix = ""
if len(tn) > 3 and tn[3] == "True":
prefix += "ref "
if len(tn) > 4 and tn[4] == "True":
prefix += "out "
if prefix != "":
param += nodes.Text(prefix + " ", prefix + u"\xa0")
xref = addnodes.pending_xref(
":ref:`" + tn[2] + "`",
refdomain="std",
reftype="ref",
reftarget=ws_re.sub(" ", tn[2].lower()),
refexplicit=False,
)
xref += nodes.Text(tn[0], tn[0])
param += xref
param += nodes.emphasis(" " + tn[1], u"\xa0" + tn[1])
paramlist += param
signode += paramlist
return name, ""
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 process_link(self, env, refnode, has_explicit_title, title, target):
"""Called after parsing title and target text, and creating the
reference node (given in *refnode*). This method can alter the
reference node and must return a new (or the same) ``(title, target)``
tuple.
"""
return title, ws_re.sub(' ', target)
def resolve_info_references(app, _env, refnode, contnode):
"""Resolve Info references.
Process all :class:`~sphinx.addnodes.pending_xref` nodes whose ``reftype``
is ``infonode``.
Replace the pending reference with a :class:`~docutils.nodes.reference`
node, which references the corresponding web URL, as stored in the database
referred to by :data:`HTMLXREF_URL`.
"""
if refnode["reftype"] != "infonode":
return None
target = ws_re.sub(" ", refnode["reftarget"])
match = INFO_RE.match(target)
if not match:
app.env.warn(refnode.source, "Invalid info target: {0}".format(target), refnode.line)
return contnode
manual = match.group("manual")
node = match.group("node")
xrefdb = app.env.info_htmlxref
uri = xrefdb.resolve(manual, node)
if not uri:
message = "Cannot resolve info manual {0}".format(manual)
app.env.warn(refnode.source, message, refnode.line)
return contnode
else:
reference = nodes.reference("", "", internal=False, refuri=uri, reftitle=target)
reference += contnode
return reference
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 process_link(self, env, refnode, has_explicit_title, title, target):
# type: (BuildEnvironment, nodes.reference, bool, unicode, unicode) -> Tuple[unicode, unicode] # NOQA
"""Called after parsing title and target text, and creating the
reference node (given in *refnode*). This method can alter the
reference node and must return a new (or the same) ``(title, target)``
tuple.
"""
return title, ws_re.sub(' ', target)
def process_link(self, env, refnode, has_explicit_title, title, target):
paren_start = target.index("(")
dot_start = target.rindex(".", 0, paren_start)
dot_start = target.rindex(".", 0, dot_start)
refnode["refdomain"] = "std"
refnode["reftype"] = "ref"
refnode["refexplicit"] = True
return (target[dot_start + 1 : paren_start], ws_re.sub(" ", target.lower()))
def run(self):
# type: () -> List[nodes.Node]
program = ws_re.sub('-', self.arguments[0].strip())
if program == 'None':
self.env.ref_context.pop('std:program', None)
else:
self.env.ref_context['std:program'] = program
return []
def run(self):
env = self.state.document.settings.env
program = ws_re.sub('-', self.arguments[0].strip())
if program == 'None':
env.ref_context.pop('std:program', None)
else:
env.ref_context['std:program'] = program
return []
def run(self):
env = self.state.document.settings.env
program = ws_re.sub("-", self.arguments[0].strip())
if program == "None":
env.ref_context.pop("std:program", None)
else:
env.ref_context["std:program"] = program
return []
def run(self):
env = self.state.document.settings.env
program = ws_re.sub("-", self.arguments[0].strip())
if program == "None":
env.temp_data["std:program"] = None
else:
env.temp_data["std:program"] = program
return []
def process_link(self, env, refnode, has_explicit_title, title, target):
paren_start = target.index("(")
dot_start = target.rindex(".", 0, paren_start)
dot_start = target.rindex(".", 0, dot_start)
refnode['refdomain']='std'
refnode['reftype']='ref'
refnode['refexplicit']=True
return (target[dot_start+1:paren_start], ws_re.sub(' ', target.lower()))
def run(self):
env = self.state.document.settings.env
program = ws_re.sub('-', self.arguments[0].strip())
if program == 'None':
env.temp_data['std:program'] = None
else:
env.temp_data['std:program'] = program
return []
def handle_signature(self, sig, signode):
directive = get_config_directive(sig)
signode.clear()
# only show the directive (not daemon and resource type)
signode += addnodes.desc_name(sig, directive['shortid'])
# normalize whitespace like XRefRole does
name = ws_re.sub('', sig)
return name
def run(self):
env = self.state.document.settings.env
program = ws_re.sub('-', self.arguments[0].strip())
if program == 'None':
env.currprogram = None
else:
env.currprogram = program
return []
def handle_signature(self, sig, signode):
name = self.options['name']
parameters = json.loads(self.options['parameters']) if 'parameters' in self.options else []
return_v = json.loads(self.options['return']) if 'return' in self.options else ("","")
prefix = self.options['prefix'] if 'prefix' in self.options else ""
if not ('parameters' in self.options) or not ('return' in self.options):
print("WARNING: No parameters or return set for '" + name + "'")
signode += nodes.Text(prefix + ' ', prefix + u'\xa0')
xref = addnodes.pending_xref(
':ref:`' + return_v[1] + '`',
refdomain='std',
reftype='ref',
reftarget=ws_re.sub(' ', return_v[1].lower()),
refexplicit=False)
xref += nodes.Text(return_v[0], return_v[0])
signode += xref
signode += nodes.Text(' ', u'\xa0')
signode += addnodes.desc_name(name, name)
paramlist = addnodes.desc_parameterlist()
for tn in parameters:
param = addnodes.desc_parameter('', '', noemph=True)
prefix = ''
if len(tn) > 3 and tn[3] == "True":
prefix += "ref "
if len(tn) > 4 and tn[4] == "True":
prefix += "out "
if prefix != "":
param += nodes.Text(prefix + ' ', prefix + u'\xa0')
xref = addnodes.pending_xref(
':ref:`' + tn[2] + '`',
refdomain='std',
reftype='ref',
reftarget=ws_re.sub(' ', tn[2].lower()),
refexplicit=False)
xref += nodes.Text(tn[0], tn[0])
param += xref
param += nodes.emphasis(' '+tn[1], u'\xa0'+tn[1])
paramlist += param
signode += paramlist
return name, ""
def _split(self, text, refnode, env):
try:
program, target = re.split(" (?=-|--|/)", text, 1)
except ValueError:
env.warn_node("Malformed :option: %r, does not contain option " "marker - or -- or /" % text, refnode)
return None, text
else:
program = ws_re.sub("-", program)
return program, target
def handle_signature(self, sig, signode):
if self.parse_node:
name = self.parse_node(self.env, sig, signode)
else:
signode.clear()
signode += addnodes.desc_name(sig, sig)
# normalize whitespace like XRefRole does
name = ws_re.sub('', sig)
return name
def program_directive(name, arguments, options, content, lineno,
content_offset, block_text, state, state_machine):
env = state.document.settings.env
program = ws_re.sub('-', arguments[0].strip())
if program == 'None':
env.currprogram = None
else:
env.currprogram = program
return []
def handle_signature(self, sig, signode):
if self.display_prefix:
signode += addnodes.desc_annotation(self.display_prefix, self.display_prefix)
name = self.options["name"]
namespace = self.options["namespace"]
fullname = self.options["fullname"]
inherits = json.loads(self.options["inherits"]) if "inherits" in self.options else ("", "")
implements = json.loads(self.options["implements"]) if "implements" in self.options else []
signode += addnodes.desc_name(name, name)
toappend = []
if inherits[0] != "Object" and inherits[0] != "Enum" and inherits[0] != "":
xref = addnodes.pending_xref(
":ref:`" + inherits[1] + "`",
refdomain="std",
reftype="ref",
reftarget=ws_re.sub(" ", inherits[1].lower()),
refexplicit=False,
)
xref += nodes.Text(inherits[0], inherits[0])
toappend.append(xref)
for implement in implements:
if len(toappend) > 0:
toappend.append(nodes.Text(", ", u",\xa0"))
xref = addnodes.pending_xref(
":ref:`" + implement[1] + "`",
refdomain="std",
reftype="ref",
reftarget=ws_re.sub(" ", implement[1].lower()),
refexplicit=False,
)
xref += nodes.Text(implement[0], implement[0])
toappend.append(xref)
if len(toappend) > 0:
signode += nodes.Text(" : ", u"\xa0:\xa0")
for a in toappend:
signode += a
return name, namespace
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
def handle_signature(self, sig, signode):
if self.display_prefix:
signode += addnodes.desc_annotation(self.display_prefix,
self.display_prefix)
name = self.options['name']
namespace = self.options['namespace']
fullname = self.options['fullname']
inherits = json.loads(self.options['inherits']) if 'inherits' in self.options else ("","")
implements = json.loads(self.options['implements']) if 'implements' in self.options else []
signode += addnodes.desc_name(name, name)
toappend = []
if inherits[0] != "Object" and inherits[0] != "Enum" and inherits[0] != "":
xref = addnodes.pending_xref(
':ref:`' + inherits[1] + '`',
refdomain='std',
reftype='ref',
reftarget=ws_re.sub(' ', inherits[1].lower()),
refexplicit=False)
xref += nodes.Text(inherits[0], inherits[0])
toappend.append(xref)
for implement in implements:
if len(toappend) > 0:
toappend.append(nodes.Text(', ', u',\xa0'))
xref = addnodes.pending_xref(
':ref:`' + implement[1] + '`',
refdomain='std',
reftype='ref',
reftarget=ws_re.sub(' ', implement[1].lower()),
refexplicit=False)
xref += nodes.Text(implement[0], implement[0])
toappend.append(xref)
if len(toappend) > 0:
signode += nodes.Text(' : ', u'\xa0:\xa0')
for a in toappend:
signode += a
return name, namespace
def process_link(self, env, refnode, has_explicit_title, title, target):
dot_start = target.rindex(".", 0)
try:
dot_start = target.rindex(".", 0, dot_start)
except ValueError:
dot_start = -1
refnode['refdomain']='std'
refnode['reftype']='ref'
refnode['refexplicit']=True
return (target[dot_start+1:], ws_re.sub(' ', target.lower()))
def parse_signature(self, sig, signode):
parse_node = additional_xref_types[self.desctype][2]
if parse_node:
name = parse_node(self.env, sig, signode)
else:
signode.clear()
signode += addnodes.desc_name(sig, sig)
# normalize whitespace like xfileref_role does
name = ws_re.sub('', sig)
return name
def process_link(self, env, refnode, has_explicit_title, title, target):
dot_start = target.rindex(".", 0)
try:
dot_start = target.rindex(".", 0, dot_start)
except ValueError:
dot_start = -1
refnode["refdomain"] = "std"
refnode["reftype"] = "ref"
refnode["refexplicit"] = True
return (target[dot_start + 1 :], ws_re.sub(" ", target.lower()))
def process_link(self, env, refnode, has_explicit_title, title, target):
"""Called after parsing title and target text, and creating the
reference node (given in *refnode*). This method can alter the
reference node and must return a new (or the same) ``(title, target)``
tuple.
"""
#~ print(20130901, refnode, has_explicit_title, title, target)
#~ 20130901 <pending_xref refdomain="" refexplicit="False" reftype="ddref"/> False cal.Event cal.Event
target = ws_re.sub(' ', target) # replace newlines or tabs by spaces
# ~ target = ' '.join(target.split()) # replace newlines or tabs by spaces
level, x = resolve_name(target)
if x is None:
msg = "Could not resolve name %r" % target
return [self._reporter.warning(msg, line=self._lineno), target]
# raise Exception(msg)
# lng = env.temp_data.get('language', env.config.language)
lng = CurrentLanguage.get_current_value(env)
with translation.override(lng):
if isinstance(x, models.Field):
text = utils.unescape(str(x.verbose_name))
target = model_name(x.model) + '.' + x.name
# print(target)
elif isinstance(x, Plugin):
text = utils.unescape(str(x.verbose_name))
target = settings.SITE.userdocs_prefix + target
elif isinstance(x, type) and issubclass(x, models.Model):
text = utils.unescape(str(x._meta.verbose_name))
target = model_name(x)
elif isinstance(x, type) and issubclass(x, actors.Actor):
text = utils.unescape(str(x.title or x.label))
target = actor_name(x)
elif isinstance(x, actions.Action):
text = utils.unescape(str(x.label))
target = actor_name(x)
else:
raise Exception("Don't know how to handle %r" % x)
if not has_explicit_title:
# avoid replacing title by the heading text
refnode['refexplicit'] = True
title = text
refnode['refwarn'] = False # never warn
#~ refnode['reftype'] = 'ref'
#~ title = "[%s]" % title
#~ if target == 'welfare.reception.waitingvisitors':
#~ print("20130907 ddref to %s : title=%r" % (target,title))
return title, target
def process_link(self, env, refnode, has_explicit_title, title, target):
"""Process the link created by this role.
Swap node and manual name, to more closely match the look of references
in Texinfo.
"""
# Normalize whitespace in info node targets
target = ws_re.sub(" ", target)
refnode["has_explicit_title"] = has_explicit_title
if not has_explicit_title:
match = INFO_RE.match(target)
if match:
# Swap title and node to create a title like info does
title = "{0}({1})".format(match.group("node"), match.group("manual"))
return title, target
def handle_signature(self, sig, signode):
name = self.options['name']
type_v = json.loads(self.options['type'])
xref = addnodes.pending_xref(
':ref:`' + type_v[1] + '`',
refdomain='std',
reftype='ref',
reftarget=ws_re.sub(' ', type_v[1].lower()),
refexplicit=False)
xref += nodes.Text(type_v[0], type_v[0])
signode += xref
signode += nodes.Text(' ', u'\xa0')
signode += addnodes.desc_name(name, name)
return name, ""
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.name, fullname)
node = nodes.target('', '', ids=[targetname])
self.state.document.note_explicit_target(node)
ret = [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,
'')])
ret.insert(0, inode)
name = self.name
if ':' in self.name:
_, name = self.name.split(':', 1)
env.domaindata['std']['objects'][name, fullname] = \
env.docname, targetname
return ret
def handle_signature(self, sig, signode):
signode.clear()
signode += addnodes.desc_name(sig, sig)
return ws_re.sub('', sig)
def resolve_xref(self, env, fromdocname, builder,
typ, target, node, contnode):
if typ == 'ref':
if node['refexplicit']:
# reference to anonymous label; the reference uses
# the supplied link caption
docname, labelid = self.data['anonlabels'].get(target, ('', ''))
sectname = node.astext()
else:
# reference to named label; the final node will
# contain the section name after the label
docname, labelid, sectname = self.data['labels'].get(target,
('', '', ''))
if not docname:
return None
return self.build_reference_node(fromdocname, builder,
docname, labelid, sectname)
elif typ == 'numref':
docname, labelid = self.data['anonlabels'].get(target, ('', ''))
if not docname:
return None
if env.config.numfig is False:
env.warn(fromdocname, 'numfig is disabled. :numref: is ignored.')
return contnode
try:
target_node = env.get_doctree(docname).ids[labelid]
figtype = get_figtype(target_node)
figure_id = target_node['ids'][0]
fignumber = env.toc_fignumbers[docname][figtype][figure_id]
except (KeyError, IndexError):
return None
title = contnode.astext()
if target == fully_normalize_name(title):
title = env.config.numfig_format.get(figtype, '')
newtitle = title % '.'.join(map(str, fignumber))
return self.build_reference_node(fromdocname, builder,
docname, labelid, newtitle,
nodeclass=addnodes.number_reference,
title=title)
elif typ == 'keyword':
# keywords are oddballs: they are referenced by named labels
docname, labelid, _ = self.data['labels'].get(target, ('', '', ''))
if not docname:
return None
return make_refnode(builder, fromdocname, docname,
labelid, contnode)
elif typ == 'option':
target = target.strip()
# most obvious thing: we are a flag option without program
if target.startswith(('-', '/', '+')):
progname = node.get('std:program')
elif re.search(r'[-/+]', target):
try:
progname, target = re.split(r' (?=-|--|/|\+)', target, 1)
except ValueError:
return None
progname = ws_re.sub('-', progname.strip())
else:
progname = None
docname, labelid = self.data['progoptions'].get((progname, target),
('', ''))
if not docname:
return None
return make_refnode(builder, fromdocname, docname,
labelid, contnode)
else:
objtypes = self.objtypes_for_role(typ) or []
for objtype in objtypes:
if (objtype, target) in self.data['objects']:
docname, labelid = self.data['objects'][objtype, target]
break
else:
docname, labelid = '', ''
if not docname:
return None
return make_refnode(builder, fromdocname, docname,
labelid, contnode)
def xfileref_role(typ, rawtext, text, lineno, inliner, options={}, content=[]):
env = inliner.document.settings.env
if not typ:
typ = env.config.default_role
else:
typ = typ.lower()
text = utils.unescape(text)
# if the first character is a bang, don't cross-reference at all
if text[0:1] == '!':
text = _fix_parens(typ, text[1:], env)
return [
innernodetypes.get(typ, nodes.literal)(rawtext,
text,
classes=['xref'])
], []
# we want a cross-reference, create the reference node
nodeclass = (typ == 'download') and addnodes.download_reference or \
addnodes.pending_xref
pnode = nodeclass(rawtext,
reftype=typ,
refcaption=False,
modname=env.currmodule,
classname=env.currclass)
# we may need the line number for warnings
pnode.line = lineno
# the link title may differ from the target, but by default
# they are the same
title = target = text
titleistarget = True
# look if explicit title and target are given with `foo <bar>` syntax
brace = text.find('<')
if brace != -1:
titleistarget = False
pnode['refcaption'] = True
m = caption_ref_re.match(text)
if m:
target = m.group(2)
title = m.group(1)
else:
# fallback: everything after '<' is the target
target = text[brace + 1:]
title = text[:brace]
# special target for Python object cross-references
if typ in ('data', 'exc', 'func', 'class', 'const', 'attr', 'meth', 'mod',
'obj'):
# fix-up parentheses in link title
if titleistarget:
title = title.lstrip('.') # only has a meaning for the target
target = target.lstrip('~') # only has a meaning for the title
title = _fix_parens(typ, title, env)
# if the first character is a tilde, don't display the module/class
# parts of the contents
if title[0:1] == '~':
title = title[1:]
dot = title.rfind('.')
if dot != -1:
title = title[dot + 1:]
# remove parentheses from the target too
if target.endswith('()'):
target = target[:-2]
# if the first character is a dot, search more specific namespaces first
# else search builtins first
if target[0:1] == '.':
target = target[1:]
pnode['refspecific'] = True
# some other special cases for the target
elif typ == 'option':
program = env.currprogram
if titleistarget:
if ' ' in title and not (title.startswith('/')
or title.startswith('-')):
program, target = re.split(' (?=-|--|/)', title, 1)
program = ws_re.sub('-', program)
target = target.strip()
elif ' ' in target:
program, target = re.split(' (?=-|--|/)', target, 1)
program = ws_re.sub('-', program)
pnode['refprogram'] = program
elif typ == 'term':
# normalize whitespace in definition terms (if the term reference is
# broken over a line, a newline will be in target)
target = ws_re.sub(' ', target).lower()
elif typ == 'ref':
# reST label names are always lowercased
target = ws_re.sub('', target).lower()
elif typ == 'cfunc':
# fix-up parens for C functions too
if titleistarget:
title = _fix_parens(typ, title, env)
# remove parentheses from the target too
if target.endswith('()'):
target = target[:-2]
else:
# remove all whitespace to avoid referencing problems
target = ws_re.sub('', target)
pnode['reftarget'] = target
pnode += innernodetypes.get(typ, nodes.literal)(rawtext,
title,
classes=['xref'])
return [pnode], []
def process_link(self, env, refnode, has_explicit_title, title, target):
rel_filename, filename = env.relfn2path(target)
make_changed_file(filename, env)
return (remove_extension(title),
ws_re.sub(' ', remove_extension(target)))
def entity_parse_node(env, sig, signode):
signode += docutils.nodes.strong(sig, sig)
return ws_re.sub('', sig)
def handle_signature(self, sig, signode):
signode.clear()
signode += addnodes.desc_name(sig, sig)
# normalize whitespace like XRefRole does
name = ws_re.sub('', sig)
return name
def desc_directive(desctype, arguments, options, content, lineno,
content_offset, block_text, state, state_machine):
env = state.document.settings.env
inode = addnodes.index(entries=[])
node = addnodes.desc()
node['desctype'] = desctype
noindex = ('noindex' in options)
node['noindex'] = noindex
# remove backslashes to support (dummy) escapes; helps Vim's highlighting
signatures = map(lambda s: s.strip().replace('\\', ''), arguments[0].split('\n'))
names = []
clsname = None
module = options.get('module', env.currmodule)
for i, sig in enumerate(signatures):
# add a signature node for each signature in the current unit
# and add a reference target for it
sig = sig.strip()
signode = addnodes.desc_signature(sig, '')
signode['first'] = False
node.append(signode)
try:
if desctype in ('function', 'data', 'class', 'exception',
'method', 'staticmethod', 'attribute'):
name, clsname = parse_py_signature(signode, sig, desctype, module, env)
elif desctype in ('cfunction', 'cmember', 'cmacro', 'ctype', 'cvar'):
name = parse_c_signature(signode, sig, desctype)
elif desctype == 'cmdoption':
optname = parse_option_desc(signode, sig)
if not noindex:
targetname = optname.replace('/', '-')
if env.currprogram:
targetname = '-' + env.currprogram + targetname
targetname = 'cmdoption' + targetname
signode['ids'].append(targetname)
state.document.note_explicit_target(signode)
inode['entries'].append(
('pair', _('%scommand line option; %s') %
((env.currprogram and env.currprogram + ' ' or ''), sig),
targetname, targetname))
env.note_progoption(optname, targetname)
continue
elif desctype == 'describe':
signode.clear()
signode += addnodes.desc_name(sig, sig)
continue
else:
# another registered generic x-ref directive
rolename, indextemplate, parse_node = additional_xref_types[desctype]
if parse_node:
fullname = parse_node(env, sig, signode)
else:
signode.clear()
signode += addnodes.desc_name(sig, sig)
# normalize whitespace like xfileref_role does
fullname = ws_re.sub('', sig)
if not noindex:
targetname = '%s-%s' % (rolename, fullname)
signode['ids'].append(targetname)
state.document.note_explicit_target(signode)
if indextemplate:
indexentry = _(indextemplate) % (fullname,)
indextype = 'single'
colon = indexentry.find(':')
if colon != -1:
indextype = indexentry[:colon].strip()
indexentry = indexentry[colon+1:].strip()
inode['entries'].append((indextype, indexentry,
targetname, targetname))
env.note_reftarget(rolename, fullname, targetname)
# don't use object indexing below
continue
except ValueError, err:
# signature parsing failed
signode.clear()
signode += addnodes.desc_name(sig, sig)
continue # we don't want an index entry here
# only add target and index entry if this is the first description of the
# function name in this desc block
if not noindex and name not in names:
fullname = (module and module + '.' or '') + name
# note target
if fullname not in state.document.ids:
signode['names'].append(fullname)
signode['ids'].append(fullname)
signode['first'] = (not names)
state.document.note_explicit_target(signode)
env.note_descref(fullname, desctype, lineno)
names.append(name)
indextext = desc_index_text(desctype, module, name,
env.config.add_module_names)
inode['entries'].append(('single', indextext, fullname, fullname))
