def handle_signature(self, sig, signode):
m = ks_sig_re.match(sig)
name = m.group('object')
current_struct = self.env.temp_data.get('ks:structure')
if m.group('prefix') is None:
if current_struct is not None:
fullname = current_struct + ':' + name
else:
struct = m.group('prefix').split(':')[-1]
fullname = struct + ':' + name
if struct is not None:
if struct != '':
signode += addnodes.desc_type(struct,struct+':')
signode += addnodes.desc_name(fullname, name)
args = m.group('args')
if args:
signode += addnodes.desc_parameterlist(args,args)
else:
signode += addnodes.desc_parameterlist()
return fullname
def handle_signature(self, sig, signode):
"""Transform a C signature into RST nodes."""
# first try the function pointer signature regex, it's more specific
m = c_funcptr_sig_re.match(sig)
if m is None:
m = c_sig_re.match(sig)
if m is None:
raise ValueError('no match')
rettype, name, arglist, const = m.groups()
signode += addnodes.desc_type('', '')
self._parse_type(signode[-1], rettype)
try:
classname, funcname = name.split('::', 1)
classname += '::'
signode += addnodes.desc_addname(classname, classname)
signode += addnodes.desc_name(funcname, funcname)
# name (the full name) is still both parts
except ValueError:
signode += addnodes.desc_name(name, name)
# clean up parentheses from canonical name
m = c_funcptr_name_re.match(name)
if m:
name = m.group(1)
typename = self.env.temp_data.get('c:type')
if self.name == 'c:member' and typename:
fullname = typename + '.' + name
else:
fullname = name
if not arglist:
if self.objtype == 'function':
# for functions, add an empty parameter list
signode += addnodes.desc_parameterlist()
if const:
signode += addnodes.desc_addname(const, const)
return fullname
paramlist = addnodes.desc_parameterlist()
arglist = arglist.replace('`', '').replace('\\ ', '') # remove markup
# this messes up function pointer types, but not too badly ;)
args = arglist.split(',')
for arg in args:
arg = arg.strip()
param = addnodes.desc_parameter('', '', noemph=True)
try:
ctype, argname = arg.rsplit(' ', 1)
except ValueError:
# no argument name given, only the type
self._parse_type(param, arg)
else:
self._parse_type(param, ctype)
# separate by non-breaking space in the output
param += nodes.emphasis(' '+argname, u'\xa0'+argname)
paramlist += param
signode += paramlist
if const:
signode += addnodes.desc_addname(const, const)
return fullname
def add_sig_args(self, signode, arglist, const):
if not arglist:
if self.sphinx_directive.objtype == 'function':
# for functions, add an empty parameter list
signode += addnodes.desc_parameterlist()
if const:
signode += addnodes.desc_addname(const, const)
return
paramlist = addnodes.desc_parameterlist()
arglist = arglist.replace('`', '').replace('\\ ', '') # remove markup
# this messes up function pointer types, but not too badly ;)
args = arglist.split(',')
for arg in args:
arg = arg.strip()
param = addnodes.desc_parameter('', '', noemph=True)
try:
ctype, argname = arg.rsplit(' ', 1)
except ValueError:
# no argument name given, only the type
self.add_cross_ref(param, arg)
else:
self.add_cross_ref(param, ctype)
# separate by non-breaking space in the output
param += nodes.emphasis(' '+argname, u'\xa0'+argname)
paramlist += param
signode += paramlist
if const:
signode += addnodes.desc_addname(const, const)
def handle_signature(self, sig, signode):
m = ks_sig_re.match(sig)
name = m.group('object')
struct = None #might override further down
current_struct = self.env.temp_data.get('ks:structure')
if m.group('prefix') is None:
if current_struct is not None:
struct = current_struct
fullname = current_struct + ':' + name
else:
raise Exception("Method name lacks a prefix and isn't " +
"indented inside a structure section. Problem " +
"occurred at " + self.env.docname + ", line " +
str(self.lineno) +
".")
else:
struct = m.group('prefix').split(':')[-1]
fullname = struct + ':' + name
if struct is not None:
if struct != '':
signode += addnodes.desc_type(struct,struct+':')
signode += addnodes.desc_name(fullname, name)
args = m.group('args')
if args:
signode += addnodes.desc_parameterlist(args,args)
else:
signode += addnodes.desc_parameterlist()
return fullname
def handle_signature(self, sig, signode):
"""
Transform a CFEngine 3 signature into RST nodes.
"""
sig_d = {}
m = cf3_sig_re.match(sig)
try:
sig_d['type'], sig_d['ns'], sig_d['id'], sig_d['args'] = m.groups()
except AttributeError:
raise ValueError
sig_d['ns'] = sig_d['ns'] or self.options.get(
'namespace', self.env.temp_data.get('cf3:namespace')
)
fullname = []
fn_app = fullname.append
fn_app(self.objtype + _FN_SEP)
if self.objtype in ('body', 'bundle'):
tnode = addnodes.desc_type('', '')
tnode += nodes.Text(self.objtype + _SP, self.objtype)
try:
sig_d['type'] = sig_d['type'].strip()
tnode += nodes.Text(sig_d['type'] + _SP, sig_d['type'])
fn_app(sig_d['type'] + _FN_SEP)
except AttributeError:
self.state_machine.reporter.warning(
'invalid %s definition: %s' % (self.objtype, sig),
line=self.lineno
)
signode += tnode
if sig_d['ns'] and sig_d['ns'] != 'default' \
and self.env.config.add_module_names:
signode += addnodes.desc_addname(
sig_d['ns'], sig_d['ns'] + _NS_SEP
)
signode += addnodes.desc_name(sig_d['id'], sig_d['id'])
fn_app(sig_d['id'])
signode['namespace'] = sig_d['ns']
signode['fullname'] = ''.join(fullname)
if self.objtype == 'class':
signode += addnodes.desc_name(_CL_MRK, _CL_MRK)
return ''.join(fullname), sig_d['ns']
if not sig_d['args'] and self.objtype == 'function':
signode += addnodes.desc_parameterlist()
return ''.join(fullname), sig_d['ns']
if sig_d['args']:
paramlist = addnodes.desc_parameterlist()
for arg in sig_d['args'].split(','):
arg = arg.strip()
paramlist += addnodes.desc_parameter(arg, arg)
signode += paramlist
return ''.join(fullname), sig_d['ns']
def handle_signature(self, sig, signode):
m = ks_sig_re.match(sig)
name = m.group('object')
signode += addnodes.desc_name(name,name)
args = m.group('args')
if args:
signode += addnodes.desc_parameterlist(args,args)
else:
signode += addnodes.desc_parameterlist()
return name
def parse_c_signature(signode, sig, desctype):
"""Transform a C (or C++) signature into RST nodes."""
# first try the function pointer signature regex, it's more specific
m = c_funcptr_sig_re.match(sig)
if m is None:
m = c_sig_re.match(sig)
if m is None:
raise ValueError('no match')
rettype, name, arglist, const = m.groups()
signode += addnodes.desc_type('', '')
parse_c_type(signode[-1], rettype)
try:
classname, funcname = name.split('::', 1)
classname += '::'
signode += addnodes.desc_addname(classname, classname)
signode += addnodes.desc_name(funcname, funcname)
# name (the full name) is still both parts
except ValueError:
signode += addnodes.desc_name(name, name)
# clean up parentheses from canonical name
m = c_funcptr_name_re.match(name)
if m:
name = m.group(1)
if not arglist:
if desctype == 'cfunction':
# for functions, add an empty parameter list
signode += addnodes.desc_parameterlist()
return name
paramlist = addnodes.desc_parameterlist()
arglist = arglist.replace('`', '').replace('\\ ', '') # remove markup
# this messes up function pointer types, but not too badly ;)
args = arglist.split(',')
for arg in args:
arg = arg.strip()
param = addnodes.desc_parameter('', '', noemph=True)
try:
ctype, argname = arg.rsplit(' ', 1)
except ValueError:
# no argument name given, only the type
parse_c_type(param, arg)
else:
parse_c_type(param, ctype)
param += nodes.emphasis(' '+argname, ' '+argname)
paramlist += param
signode += paramlist
if const:
signode += addnodes.desc_addname(const, const)
return name
def _handle_function_signature(self, sig, signode):
m = erl_func_sig_re.match(sig)
if m is None:
raise ValueError
modname, name, arglist, retann = m.groups()
fullname = self._resolve_module_name(signode, modname, name)
if not arglist:
if self.needs_arglist():
# for callables, add an empty parameter list
signode += addnodes.desc_parameterlist()
if retann:
signode += addnodes.desc_returns(retann, retann)
if self.objtype == 'function':
return fullname + '/0'
return fullname
signode += addnodes.desc_parameterlist()
stack = [signode[-1]]
counters = [0, 0]
for token in erl_paramlist_re.split(arglist):
if token == '[':
opt = addnodes.desc_optional()
stack[-1] += opt
stack.append(opt)
elif token == ']':
try:
stack.pop()
except IndexError:
raise ValueError
elif not token or token == ',' or token.isspace():
pass
else:
token = token.strip()
stack[-1] += addnodes.desc_parameter(token, token)
if len(stack) == 1:
counters[0] += 1
else:
counters[1] += 1
if len(stack) != 1:
raise ValueError
if not counters[1]:
fullname = '%s/%d' % (fullname, counters[0])
else:
fullname = '%s/%d..%d' % (fullname, counters[0], sum(counters))
if retann:
signode += addnodes.desc_returns(retann, retann)
return fullname
def _handle_function_signature(self, sig, signode):
m = ada_func_sig_re.match(sig)
if m is None:
print "m did not match the function"
raise ValueError
modname, name, dummy, arglist, returntype, abstract = m.groups()
print "DEBUG: modname %s name %s arglist %s" % (modname, name, arglist)
fullname = self._resolve_module_name(signode, modname, name)
print "DEBUG: fullname %s" % fullname
if not arglist:
if self.needs_arglist():
# for functions and procedures, add an empty parameter list
new_node = addnodes.desc_parameterlist()
new_node.child_text_separator = '; '
signode += new_node
if returntype:
signode += addnodes.desc_returns(returntype, returntype)
return fullname
signode += nodes.Text(' ')
new_node = addnodes.desc_parameterlist()
new_node.child_text_separator = '; '
signode += new_node
stack = [signode[-1]]
counters = [0, 0]
for token in string.split(arglist, ';'):
pieces = string.split(token, ':')
name = pieces[0].strip()
stack[-1] += addnodes.desc_parameter(name, name + " : " + pieces[1].strip())
if len(stack) == 1:
counters[0] += 1
else:
counters[1] += 1
if len(stack) != 1:
raise ValueError
if not counters[1]:
fullname = '%s/%d' % (fullname, counters[0])
else:
fullname = '%s/%d..%d' % (fullname, counters[0], sum(counters))
if returntype:
signode += addnodes.desc_returns(returntype,returntype)
return fullname
def handle_signature(self, sig, signode):
method = self.method.upper() + ' '
signode += addnodes.desc_name(method, method)
offset = 0
path = None
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 += ': '
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)
assert path is not None, 'no matches for sig: %s' % sig
fullname = self.method.upper() + ' ' + path
signode['method'] = self.method
signode['path'] = sig
signode['fullname'] = fullname
return (fullname, self.method, sig)
def attach_function(self, node, func):
owner, name = func.name.split_owner()
# Olaf: Never show Class::
owner = None
if owner is not None:
owner = unicode(owner) + '::'
node += addnodes.desc_addname(owner, owner)
# cast operator is special. in this case the return value
# is reversed.
if isinstance(name, CastOpDefExpr):
node += addnodes.desc_name('operator', 'operator')
node += nodes.Text(u' ')
self.attach_type(node, name.typename)
else:
funcname = unicode(name)
node += addnodes.desc_name(funcname, funcname)
paramlist = addnodes.desc_parameterlist()
for arg in func.signature:
param = addnodes.desc_parameter('', '', noemph=True)
if arg.type is not None:
self.attach_type(param, arg.type)
param += nodes.Text(u' ')
param += nodes.emphasis(unicode(arg.name), unicode(arg.name))
if arg.default is not None:
def_ = u'=' + unicode(arg.default)
param += nodes.emphasis(def_, def_)
paramlist += param
node += paramlist
if func.const:
node += addnodes.desc_addname(' const', ' const')
if func.pure_virtual:
node += addnodes.desc_addname(' = 0', ' = 0')
def lua_desc_parameterlist(argstart, argend):
node = addnodes.desc_parameterlist()
node.param_start = argstart
node.param_end = argend
if argstart == "{":
node.param_class = "brace"
return node
def make_parameters(self):
params = addnodes.desc_parameterlist('', '')
ctor = self.item.constructor
if ctor:
params += make_desc_parameters(ctor.params)
return params
def handle_signature(self, sig, signode):
method = self.method.upper() + " "
signode += addnodes.desc_name(method, method)
offset = 0
path = None
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 += ": "
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)
if path is None:
assert False, "no matches for sig: %s" % sig
fullname = self.method.upper() + " " + path
signode["method"] = self.method
signode["path"] = sig
signode["fullname"] = fullname
return (fullname, self.method, sig)
def handle_signature(self, sig, signode):
cache = _APP_CACHES.get(self.env.app, {})
key = CursorKind.MACRO_DEFINITION, (sig, )
if key in cache:
node, comment, start, end, _ = cache[key]
signode += addnodes.desc_name(node.displayname, node.displayname)
# There is unfortunately no API to get the parameters of a macro,
# so we identify them by looking at the tokens.
tokens = list(node.get_tokens())
if (
tokens[1].kind is TokenKind.PUNCTUATION and
tokens[1].spelling == '('
):
paramlist = addnodes.desc_parameterlist()
for token in tokens[2:]:
if (
token.kind is TokenKind.PUNCTUATION and
token.spelling == ')'
):
break
elif token.kind is TokenKind.IDENTIFIER:
paramlist += addnodes.desc_parameter(token.spelling, token.spelling)
signode += paramlist
self.content = ViewList()
for lineno, line in enumerate(comment.splitlines(), start[0]):
self.content.append(line, '<unknown>', lineno)
return sig
def run(self):
#no good
# node = nodes.paragraph('', 'Hi there!',
# ids=['foo'],
# names = ['foobar']
# )
#works
# node = nodes.section(names=['foobar'])
# self.state.document.note_explicit_target(node)
# node.append(nodes.paragraph('', "foo foo"))
#no good
# node = nodes.admonition(names=['foobar'])
# self.state.document.note_explicit_target(node)
# node.append(nodes.paragraph('', "foo foo"))
# node = nodes.paragraph('', 'foo foo', names=['foobar'])
# self.state.document.note_explicit_target(node)
#This doesn't properly render
desc = addnodes.desc('',
addnodes.desc_signature('',
addnodes.desc_name('', 'namename'),
addnodes.desc_parameterlist('',
addnodes.desc_parameter('', 'def')
),
names=['namename'], fullname="namename", ids=['namename'], module=None, first=False),
desctype="function", domain="py", objtype='objtype')
#no link (because didn't properly render?)
self.state.document.note_explicit_target(desc)
return [desc]
def handle_signature(self, sig, signode):
m = sig_pattern.match(sig)
if m is None:
raise ValueError()
return_type, method_name, arglist = m.groups()
arguments = []
if arglist:
for arg in arglist.split(","):
m = arg_pattern.match(arg)
if m is None:
raise ValueError()
arguments.append(m.groups())
class_name = self.env.temp_data.get("java:class")
if not class_name:
self.env.warn(
self.env.docname, "Java method description of %s outside of class is not supported" % sig, self.lineno
)
raise ValueError()
if return_type is not None: # will be absent for constructors
self._parse_type(return_type, signode)
signode += nodes.Text(" ", " ")
signode += addnodes.desc_name(method_name, method_name)
signode += addnodes.desc_parameterlist()
for type, name in arguments:
signode[-1] += addnodes.desc_parameter("", "", noemph=True)
self._parse_type(type, signode[-1][-1])
signode[-1][-1] += nodes.Text(" ", " ")
signode[-1][-1] += nodes.emphasis(name, name)
return "%s#%s(%s)" % (class_name, method_name, ", ".join(type for type, name in arguments))
def handle_constructor_signature(self, sig, signode):
try:
member = javalang.parse.parse_constructor_signature(sig)
except javalang.parser.JavaSyntaxError:
raise self.error("syntax error in constructor signature")
if not isinstance(member, javalang.tree.ConstructorDeclaration):
raise self.error("expected constructor declaration")
mods = formatter.output_modifiers(member.modifiers).build()
signode += nodes.Text(mods + ' ', mods + ' ')
signode += addnodes.desc_name(member.name, member.name)
paramlist = addnodes.desc_parameterlist()
for parameter in member.parameters:
param = addnodes.desc_parameter('', '', noemph=True)
param += self._build_type_node(parameter.type)
if parameter.varargs:
param += nodes.Text('...', '')
param += nodes.emphasis(' ' + parameter.name, ' ' + parameter.name)
paramlist += param
signode += paramlist
param_reprs = [formatter.output_type(param.type, with_generics=False).build() for param in member.parameters]
return '%s(%s)' % (member.name, ', '.join(param_reprs))
def handle_signature(self, sig, signode):
"""Handle IDL signature lines"""
m = idl_sig_re.match(sig)
if not m:
self.env.app.warn("Signature did not match for {}".format(sig))
raise ValueError("Signature did not match!")
pro_or_function, name, arglist = m.groups()
# Add a prefix for function/program
if self.display_prefix:
signode += addnodes.desc_annotation(self.display_prefix,
self.display_prefix)
signode += addnodes.desc_annotation(self.objtype, self.objtype)
# Register the full name of the program
signode['fullname'] = name
signode += addnodes.desc_name(name, name)
# Parse the argument list from the signature
if not arglist and self.objtype == 'function':
signode += addnodes.desc_parameterlist()
elif arglist:
_pseudo_parse_arglist(signode, arglist)
return (name, '')
def _pseudo_parse_arglist(signode, arglist):
# type: (addnodes.desc_signature, str) -> None
""""Parse" a list of arguments separated by commas.
Arguments can have "optional" annotations given by enclosing them in
brackets. Currently, this will split at any comma, even if it's inside a
string literal (e.g. default argument value).
"""
paramlist = addnodes.desc_parameterlist()
stack = [paramlist] # type: List[nodes.Element]
try:
for argument in arglist.split(','):
argument = argument.strip()
ends_open = ends_close = 0
while argument.startswith('['):
stack.append(addnodes.desc_optional())
stack[-2] += stack[-1]
argument = argument[1:].strip()
while argument.startswith(']'):
stack.pop()
argument = argument[1:].strip()
while argument.endswith(']') and not argument.endswith('[]'):
ends_close += 1
argument = argument[:-1].strip()
while argument.endswith('['):
ends_open += 1
argument = argument[:-1].strip()
if argument:
stack[-1] += addnodes.desc_parameter(argument, argument)
while ends_open:
stack.append(addnodes.desc_optional())
stack[-2] += stack[-1]
ends_open -= 1
while ends_close:
stack.pop()
ends_close -= 1
if len(stack) != 1:
raise IndexError
except IndexError:
# if there are too few or too many elements on the stack, just give up
# and treat the whole argument list as one argument, discarding the
# already partially populated paramlist node
paramlist = addnodes.desc_parameterlist()
paramlist += addnodes.desc_parameter(arglist, arglist)
signode += paramlist
else:
signode += paramlist
def handle_signature(self, sig, signode):
sig = sig.strip()
if '(' in sig and sig[-1:] == ')':
prefix, arglist = sig.split('(', 1)
prefix = prefix.strip()
arglist = arglist[:-1].strip()
else:
prefix = sig
arglist = None
if '.' in prefix:
nameprefix, name = prefix.rsplit('.', 1)
else:
nameprefix = None
name = prefix
objectname = self.env.temp_data.get('js:object')
if nameprefix:
if objectname:
# someone documenting the method of an attribute
# of the current object? shouldn't happen but
# who knows...
nameprefix = objectname + '.' + nameprefix
fullname = nameprefix + '.' + name
elif objectname:
fullname = objectname + '.' + name
else:
# just a function or constructor
objectname = ''
fullname = name
signode['object'] = objectname
signode['fullname'] = fullname
if self.display_prefix:
signode += addnodes.desc_annotation(self.display_prefix,
self.display_prefix)
if nameprefix:
signode += addnodes.desc_addname(nameprefix + '.',
nameprefix + '.')
signode += addnodes.desc_name(name, name)
if self.has_arguments:
if not arglist:
signode += addnodes.desc_parameterlist()
else:
_pseudo_parse_arglist(signode, arglist)
class_name = self.options.get('outertype')
# object belongs to some class or namespace
if class_name:
# func_desc = function return type + function name
func_desc = fullname.split(' ', 1)
if len(func_desc) > 1:
fullname = func_desc[0] + ' ' + class_name +\
'.' + func_desc[1]
return fullname, nameprefix
def make_signature(self):
ret = super(FunctionDocumenter, self).make_signature()
with addto(ret, addnodes.desc_parameterlist()) as params:
params += make_desc_parameters(self.item.params)
retval = self.item.return_val
if retval.type or retval.doc:
ret.append(addnodes.desc_returns(retval.type or '*', retval.type or '*'))
return ret
def handle_signature(self, sig_input, signode):
"""Parses out pieces from construct signatures
Parses out prefix and argument list from construct definition. This is
assuming that the .NET languages this will support will be in a common
format, such as::
Namespace.Class.method(argument, argument, ...)
The namespace and class will be determined by the nesting of rST
directives.
Returns
Altered :py:data:`signode` with attributes corrected for rST
nesting/etc
"""
try:
sig = self.parse_signature(sig_input.strip())
except ValueError:
self.env.warn(self.env.docname,
'Parsing signature failed: "{}"'.format(sig_input),
self.lineno)
raise
prefix = self.env.ref_context.get('dn:prefix', None)
if prefix is not None:
sig.prefix = prefix
signode['object'] = sig.member
signode['prefix'] = sig.prefix
signode['fullname'] = sig.full_name()
# Prefix modifiers
if self.display_prefix:
signode += addnodes.desc_annotation(self.display_prefix,
self.display_prefix)
for prefix in ['public', 'protected', 'static']:
if prefix in self.options:
signode += addnodes.desc_annotation(prefix + ' ',
prefix + ' ')
# Show prefix only on shorter declarations
if sig.prefix is not None and not self.has_arguments:
signode += addnodes.desc_addname(sig.prefix + '.', sig.prefix + '.')
signode += addnodes.desc_name(sig.member, sig.member)
if self.has_arguments:
if not sig.arguments:
signode += addnodes.desc_parameterlist()
else:
# TODO replace this
_pseudo_parse_arglist(signode, ', '.join(sig.arguments))
if isinstance(self, DotNetObjectNested):
return sig.full_name(), sig.full_name()
return sig.full_name(), sig.prefix
def parse_arglist(self, signode, arglist):
"""parses argument lists
largely imported from sphinx.domains.python,
changes are mainly to make it work with space-separated
argument lists and to make it look so"""
paramlist = self._fix_paramlist(addnodes.desc_parameterlist())
stack = [paramlist]
try:
for argument in arglist.split(" "):
argument = argument.strip()
ends_open = ends_close = 0
while argument.startswith("["):
stack.append(self._fix_paramlist(addnodes.desc_optional(), False))
stack[-2] += stack[-1]
argument = argument[1:].strip()
while argument.startswith("]"):
stack.pop()
argument = argument[1:].strip()
while argument.endswith("]"):
ends_close += 1
argument = argument[:-1].strip()
while argument.endswith("["):
ends_open += 1
argument = argument[:-1].strip()
if argument:
stack[-1] += addnodes.desc_parameter(argument, argument)
while ends_open:
stack.append(self._fix_paramlist(addnodes.desc_optional(), False))
stack[-2] += stack[-1]
ends_open -= 1
while ends_close:
stack.pop()
ends_close -= 1
if len(stack) != 1:
raise IndexError
except IndexError:
# if there are too few or too many elements on the stack, just give up
# and treat the whole argument list as one argument, discarding the
# already partially populated paramlist node
signode += self._fix_paramlist(addnodes.desc_parameterlist())
signode[-1] += addnodes.desc_parameter(arglist, arglist)
else:
signode += paramlist
def handle_signature(self, sig, signode):
sig = sig.strip()
if '(' in sig and sig[-1:] == ')':
prefix, arglist = sig.split('(', 1)
prefix = prefix.strip()
arglist = arglist[:-1].strip()
else:
prefix = sig
arglist = None
if '.' in prefix:
nameprefix, name = prefix.rsplit('.', 1)
else:
nameprefix = None
name = prefix
objectname = self.env.temp_data.get('mongodb:object')
if nameprefix:
if objectname:
# someone documenting the method of an attribute of the current
# object? shouldn't happen but who knows...
nameprefix = objectname + '.' + nameprefix
fullname = nameprefix + '.' + name
elif objectname:
fullname = objectname + '.' + name
else:
# just a function or constructor
objectname = ''
fullname = name
signode['object'] = objectname
signode['fullname'] = fullname
if self.display_prefix:
signode += addnodes.desc_annotation(self.display_prefix,
self.display_prefix)
if nameprefix:
if nameprefix in conf['suppress-prefix']:
pass
else:
nameprefix += '.'
for prefix in conf['suppress-prefix']:
if nameprefix.startswith(prefix):
nameprefix = nameprefix[len(prefix)+1:]
break
signode += addnodes.desc_addname(nameprefix, nameprefix)
nameprefix[:-1]
signode += addnodes.desc_name(name, name)
if self.has_arguments:
if not arglist:
signode += addnodes.desc_parameterlist()
else:
_pseudo_parse_arglist(signode, arglist)
return fullname, nameprefix
def parse_opcode_signature(signode, sig):
"""Transform an opcode signature into RST nodes."""
m = opcode_sig_re.match(sig)
if m is None: raise ValueError
opname, arglist = m.groups()
signode += addnodes.desc_name(opname, opname)
paramlist = addnodes.desc_parameterlist()
signode += paramlist
paramlist += addnodes.desc_parameter(arglist, arglist)
return opname.strip()
def append_parameters(self, node, params):
pnodes = addnodes.desc_parameterlist()
for param in params:
pnode = addnodes.desc_parameter('', '', noemph=True)
self.append_type(pnode, param.type)
pnode += nodes.Text(u' ')
pnode += nodes.emphasis(param.name, param.name)
if param.default is not None:
default = u' = ' + param.default
pnode += nodes.emphasis(default, default)
pnodes += pnode
node += pnodes
def handle_signature(self, sig, signode):
"""Transform a Lasso signature into RST nodes.
"""
sig = sig.strip().replace(' ', ' ').replace(' ::', '::').replace(':: ', '::')
if '(' in sig:
if ')::' in sig:
sig, returntype = sig.rsplit('::', 1)
else:
returntype = None
prefix, arglist = sig.split('(', 1)
prefix = prefix.strip()
arglist = arglist[:-1].strip().replace(' =', '=').replace('= ', '=')
else:
if '::' in sig:
sig, returntype = sig.rsplit('::', 1)
else:
returntype = None
prefix = sig
arglist = None
if '->' in prefix:
objectprefix, name = prefix.rsplit('->', 1)
objectprefix += '->'
else:
objectprefix = None
name = prefix
objectname = self.env.ref_context.get('ls:object')
if objectprefix:
fullname = objectprefix + name
elif objectname:
fullname = objectname + '->' + name
else:
objectname = ''
fullname = name
signode['object'] = objectname
signode['fullname'] = fullname
sig_prefix = self.get_signature_prefix(sig)
if sig_prefix:
signode += addnodes.desc_annotation(sig_prefix, sig_prefix)
if objectprefix:
signode += addnodes.desc_addname(objectprefix, objectprefix)
signode += addnodes.desc_name(name, name)
if self.needs_arglist():
if arglist:
_pseudo_parse_arglist(signode, arglist)
else:
signode += addnodes.desc_parameterlist()
if returntype:
signode += addnodes.desc_returns(returntype, returntype)
return fullname, objectprefix
def parse_opcode_signature(env, sig, signode):
"""Transform an opcode signature into RST nodes."""
m = opcode_sig_re.match(sig)
if m is None:
raise ValueError
opname, arglist = m.groups()
signode += addnodes.desc_name(opname, opname)
if arglist is not None:
paramlist = addnodes.desc_parameterlist()
signode += paramlist
paramlist += addnodes.desc_parameter(arglist, arglist)
return opname.strip()
def handle_signature(self, sig, signode):
# type: (unicode, addnodes.desc_signature) -> Tuple[unicode, unicode]
"""Breaks down construct signatures
Parses out prefix and argument list from construct definition. The
namespace and class will be determined by the nesting of domain
directives.
"""
sig = sig.strip()
if '(' in sig and sig[-1:] == ')':
member, arglist = sig.split('(', 1)
member = member.strip()
arglist = arglist[:-1].strip()
else:
member = sig
arglist = None
# If construct is nested, prefix the current prefix
prefix = self.env.ref_context.get('js:object', None)
mod_name = self.env.ref_context.get('js:module')
name = member
try:
member_prefix, member_name = member.rsplit('.', 1)
except ValueError:
member_name = name
member_prefix = ''
finally:
name = member_name
if prefix and member_prefix:
prefix = '.'.join([prefix, member_prefix])
elif prefix is None and member_prefix:
prefix = member_prefix
fullname = name
if prefix:
fullname = '.'.join([prefix, name])
signode['module'] = mod_name
signode['object'] = prefix
signode['fullname'] = fullname
if self.display_prefix:
signode += addnodes.desc_annotation(self.display_prefix,
self.display_prefix)
if prefix:
signode += addnodes.desc_addname(prefix + '.', prefix + '.')
elif mod_name:
signode += addnodes.desc_addname(mod_name + '.', mod_name + '.')
signode += addnodes.desc_name(name, name)
if self.has_arguments:
if not arglist:
signode += addnodes.desc_parameterlist()
else:
_pseudo_parse_arglist(signode, arglist)
return fullname, prefix
def handle_signature(self, sig: str, signode: desc_signature) -> Tuple[str, str]:
"""Breaks down construct signatures
Parses out prefix and argument list from construct definition. The
namespace and class will be determined by the nesting of domain
directives.
"""
sig = sig.strip()
if '(' in sig and sig[-1:] == ')':
member, arglist = sig.split('(', 1)
member = member.strip()
arglist = arglist[:-1].strip()
else:
member = sig
arglist = None
# If construct is nested, prefix the current prefix
prefix = self.env.ref_context.get('js:object', None)
mod_name = self.env.ref_context.get('js:module')
name = member
try:
member_prefix, member_name = member.rsplit('.', 1)
except ValueError:
member_name = name
member_prefix = ''
finally:
name = member_name
if prefix and member_prefix:
prefix = '.'.join([prefix, member_prefix])
elif prefix is None and member_prefix:
prefix = member_prefix
fullname = name
if prefix:
fullname = '.'.join([prefix, name])
signode['module'] = mod_name
signode['object'] = prefix
signode['fullname'] = fullname
if self.display_prefix:
signode += addnodes.desc_annotation(self.display_prefix,
self.display_prefix)
if prefix:
signode += addnodes.desc_addname(prefix + '.', prefix + '.')
elif mod_name:
signode += addnodes.desc_addname(mod_name + '.', mod_name + '.')
signode += addnodes.desc_name(name, name)
if self.has_arguments:
if not arglist:
signode += addnodes.desc_parameterlist()
else:
_pseudo_parse_arglist(signode, arglist)
return fullname, prefix
def _parse_arglist(arglist: str) -> addnodes.desc_parameterlist:
"""Parse a list of arguments using AST parser"""
params = addnodes.desc_parameterlist(arglist)
sig = signature_from_str('(%s)' % arglist)
last_kind = None
for param in sig.parameters.values():
if param.kind != param.POSITIONAL_ONLY and last_kind == param.POSITIONAL_ONLY:
# PEP-570: Separator for Positional Only Parameter: /
params += addnodes.desc_parameter(
'', '', addnodes.desc_sig_operator('', '/'))
if param.kind == param.KEYWORD_ONLY and last_kind in (
param.POSITIONAL_OR_KEYWORD, param.POSITIONAL_ONLY, None):
# PEP-3102: Separator for Keyword Only Parameter: *
params += addnodes.desc_parameter(
'', '', addnodes.desc_sig_operator('', '*'))
node = addnodes.desc_parameter()
if param.kind == param.VAR_POSITIONAL:
node += addnodes.desc_sig_operator('', '*')
node += addnodes.desc_sig_name('', param.name)
elif param.kind == param.VAR_KEYWORD:
node += addnodes.desc_sig_operator('', '**')
node += addnodes.desc_sig_name('', param.name)
else:
node += addnodes.desc_sig_name('', param.name)
if param.annotation is not param.empty:
children = _parse_annotation(param.annotation)
node += addnodes.desc_sig_punctuation('', ':')
node += nodes.Text(' ')
node += addnodes.desc_sig_name('', '', *children) # type: ignore
if param.default is not param.empty:
if param.annotation is not param.empty:
node += nodes.Text(' ')
node += addnodes.desc_sig_operator('', '=')
node += nodes.Text(' ')
else:
node += addnodes.desc_sig_operator('', '=')
node += nodes.inline('',
param.default,
classes=['default_value'],
support_smartquotes=False)
params += node
last_kind = param.kind
if last_kind == Parameter.POSITIONAL_ONLY:
# PEP-570: Separator for Positional Only Parameter: /
params += addnodes.desc_parameter('', '',
addnodes.desc_sig_operator('', '/'))
return params
def parse_event(env, sig, signode):
m = event_sig_re.match(sig)
if not m:
signode += addnodes.desc_name(sig, sig)
return sig
name, args = m.groups()
signode += addnodes.desc_name(name, name)
plist = addnodes.desc_parameterlist()
for arg in args.split(','):
arg = arg.strip()
plist += addnodes.desc_parameter(arg, arg)
signode += plist
return name
def render_sexp(sexp, signode=None, prepend_node=None):
desc_sexplist = addnodes.desc_parameterlist()
desc_sexplist.child_text_separator = ' '
if prepend_node:
desc_sexplist.append(prepend_node)
if signode:
signode.append(desc_sexplist)
for atom in sexp:
if isinstance(atom, list):
render_sexp(atom, desc_sexplist)
else:
render_atom(atom, desc_sexplist)
return desc_sexplist
def parse_event(env, sig, signode):
m = event_sig_re.match(sig)
if not m:
signode += addnodes.desc_name(sig, sig)
return sig
name, args = m.groups()
signode += addnodes.desc_name(name, name)
plist = addnodes.desc_parameterlist()
for arg in args.split(','):
arg = arg.strip()
plist += addnodes.desc_parameter(arg, arg)
signode += plist
return name
def make_process_header(self, slug, typ, version, source_uri, description,
inputs):
"""Generate a process definition header.
:param str slug: process' slug
:param str typ: process' type
:param str version: process' version
:param str source_uri: url to the process definition
:param str description: process' description
:param dict inputs: process' inputs
"""
node = addnodes.desc()
signode = addnodes.desc_signature(slug, '')
node.append(signode)
node['objtype'] = node['desctype'] = typ
signode += addnodes.desc_annotation(typ, typ, classes=['process-type'])
signode += addnodes.desc_addname('', '')
signode += addnodes.desc_name(slug + ' ', slug + ' ')
paramlist = addnodes.desc_parameterlist()
for field_schema, _, _ in iterate_schema({}, inputs, ''):
field_type = field_schema['type']
field_name = field_schema['name']
field_default = field_schema.get('default', None)
field_default = '' if field_default is None else '={}'.format(
field_default)
param = addnodes.desc_parameter('', '', noemph=True)
param += nodes.emphasis(field_type,
field_type,
classes=['process-type'])
# separate by non-breaking space in the output
param += nodes.strong(text='\xa0\xa0' + field_name)
paramlist += param
signode += paramlist
signode += nodes.reference('',
nodes.Text('[Source: v{}]'.format(version)),
refuri=source_uri,
classes=['viewcode-link'])
desc = nodes.paragraph()
desc += nodes.Text(description, description)
return [node, desc]
def handle_signature(self, sig, signode):
"""Transform a Python signature into RST nodes.
Return (fully qualified name of the thing, classname if any).
If inside a class, the current class name is handled intelligently:
* it is stripped from the displayed name if present
* it is added to the full name (return value) if not present
"""
name_prefix = None
name = sig
arglist = None
retann = None
# determine module and class name (if applicable), as well as full name
modname = self.options.get(
'module', self.env.temp_data.get('py:module'))
classname = self.env.temp_data.get('py:class')
fullname = name
signode['module'] = modname
signode['class'] = classname
signode['fullname'] = fullname
sig_prefix = self.get_signature_prefix(sig)
if sig_prefix:
signode += addnodes.desc_annotation(sig_prefix, sig_prefix)
if name_prefix:
signode += addnodes.desc_addname(name_prefix, name_prefix)
anno = self.options.get('annotation')
signode += addnodes.desc_name(name, name)
if not arglist:
if self.needs_arglist():
# for callables, add an empty parameter list
signode += addnodes.desc_parameterlist()
if retann:
signode += addnodes.desc_returns(retann, retann)
if anno:
signode += addnodes.desc_annotation(' ' + anno, ' ' + anno)
return fullname, name_prefix
_pseudo_parse_arglist(signode, arglist)
if retann:
signode += addnodes.desc_returns(retann, retann)
if anno:
signode += addnodes.desc_annotation(' ' + anno, ' ' + anno)
return fullname, name_prefix
def parse_event(env, sig, signode):
event_sig_re = re.compile(r"([a-zA-Z-]+)\s*\((.*)\)")
m = event_sig_re.match(sig)
if not m:
signode += addnodes.desc_name(sig, sig)
return sig
name, args = m.groups()
signode += addnodes.desc_name(name, name)
plist = addnodes.desc_parameterlist()
for arg in args.split(","):
arg = arg.strip()
plist += addnodes.desc_parameter(arg, arg)
signode += plist
return name
def _handle_proc_signature(self, sig, signode, m):
"Transform a Nim proc node into RST nodes."
name, arglist, rettype, pragmas = m.groups()
signode += addnodes.desc_type('proc', 'proc')
signode += addnodes.desc_name(name, name)
if arglist is None:
signode += addnodes.desc_parameterlist()
else:
arguments = nim_arg_sig_re.match(arglist).groups()[0]
signode += addnodes.desc_parameterlist(arguments, arguments)
if rettype is not None:
retnode = addnodes.desc_returns()
self._parse_type(retnode,
nim_rettype_sig_re.match(rettype).groups()[0])
signode += retnode
if pragmas:
signode += addnodes.desc_addname(pragmas, pragmas)
return name
def parse_ystaticattr(env, attr, attrnode):
m = re.match(r'([a-zA-Z0-9_]+)\.(.*)\(=(.*)\)', attr)
if not m:
print 100 * '@' + ' Static attribute %s not matched' % attr
attrnode += addnodes.desc_name(attr, attr)
klass, name, default = m.groups()
#attrnode+=addnodes.desc_type('static','static')
attrnode += addnodes.desc_name(name, name)
plist = addnodes.desc_parameterlist()
if default == '': default = 'unspecified'
plist += addnodes.desc_parameter('=' + default, '=' + default)
attrnode += plist
attrnode += addnodes.desc_annotation(' [static]', ' [static]')
return klass + '.' + name
def handle_options(self, sig, signode):
super(ProtobufServiceMethod, self).handle_options(sig, signode)
shortname = ProtobufDomain.roles[self.objtype].remove_prefix_func(
self.options.get('input'))
params_in = addnodes.desc_parameterlist()
if shortname == self.options.get('input'):
paramnode = nodes.inline(text=self.options.get('input'),
classes=["inputtype"])
else:
paramnode = nodes.inline(classes=["inputtype"])
paramnode += nodes.abbreviation(
text=shortname, explanation=self.options.get('input'))
params_in.append(paramnode)
signode += nodes.inline('', ' ')
signode += params_in
signode += nodes.inline(text=" -> ")
if self.options.get('output_stream') == "yes":
signode += nodes.inline(
text="stream of ",
classes=["type_annotation", "streamannotation"])
signode.parent['classes'].append("streaming")
shortname = ProtobufDomain.roles[self.objtype].remove_prefix_func(
self.options.get('output'))
params_out = addnodes.desc_parameterlist()
if shortname == self.options.get('output'):
paramnode = nodes.inline(text=self.options.get('output'),
classes=["outputtype"])
else:
paramnode = nodes.inline(classes=["outputtype"])
paramnode += nodes.abbreviation(
text=shortname, explanation=self.options.get('output'))
params_out.append(paramnode)
signode += params_out
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 _pseudo_parse_arglist(signode, arglist):
paramlist = addnodes.desc_parameterlist()
stack = [paramlist]
try:
for argument in arglist.split(','):
argument = argument.strip()
ends_open = ends_close = 0
while argument.startswith('['):
stack.append(addnodes.desc_optional())
stack[-2] += stack[-1]
argument = argument[1:].strip()
while argument.startswith(']'):
stack.pop()
argument = argument[1:].strip()
while argument.endswith(']') and not argument.endswith('[]'):
ends_close += 1
argument = argument[:-1].strip()
while argument.endswith('['):
ends_open += 1
argument = argument[:-1].strip()
if argument:
stack[-1] += addnodes.desc_parameter(argument, argument)
while ends_open:
stack.append(addnodes.desc_optional())
stack[-2] += stack[-1]
ends_open -= 1
while ends_close:
stack.pop()
ends_close -= 1
if len(stack) != 1:
raise IndexError
except IndexError:
signode += addnodes.desc_parameterlist()
signode[-1] += addnodes.desc_parameter(arglist, arglist)
else:
signode += paramlist
def append_parameters(self, node, params):
pnodes = addnodes.desc_parameterlist()
for param in params:
pnode = addnodes.desc_parameter('', '', noemph=True)
self.append_modifiers(pnode, param.modifiers)
self.append_type(pnode, param.typ)
pnode += nodes.Text(u' ')
pnode += nodes.emphasis(param.name, param.name)
if param.default is not None:
default = u' = ' + param.default
pnode += nodes.emphasis(default, default)
pnodes += pnode
node += pnodes
def format_parameters(self, parameters):
params = addnodes.desc_parameterlist()
for param in parameters:
node = n.container()
if param['required']:
node += addnodes.desc_parameter(param['name'], param['name'])
else:
node += addnodes.desc_optional(param['name'], param['name'])
node += n.strong(text=' type: %s ' % param['dataType'])
allowableValues = param.get('allowableValues')
if allowableValues:
allowableValues.pop('valueType', None)
node += n.emphasis(text=' %s' % allowableValues)
params += node
return params
def format_parameters(self, parameters):
params = addnodes.desc_parameterlist()
for param in parameters:
node = n.container()
if param["required"]:
node += addnodes.desc_parameter(param["name"], param["name"])
else:
node += addnodes.desc_optional(param["name"], param["name"])
node += n.strong(text=" type: %s " % param["dataType"])
allowableValues = param.get("allowableValues")
if allowableValues:
allowableValues.pop("valueType", None)
node += n.emphasis(text=" %s" % allowableValues)
params += node
return params
def handle_signature(self, sig, signode):
# type: (unicode, addnodes.desc_signature) -> Tuple[unicode, unicode]
sig = sig.strip()
if '(' in sig and sig[-1:] == ')':
prefix, arglist = sig.split('(', 1)
prefix = prefix.strip()
arglist = arglist[:-1].strip()
else:
prefix = sig
arglist = None
if '.' in prefix:
nameprefix, name = prefix.rsplit('.', 1)
else:
nameprefix = None
name = prefix
objectname = self.env.ref_context.get('js:object')
if nameprefix:
if objectname:
# someone documenting the method of an attribute of the current
# object? shouldn't happen but who knows...
nameprefix = objectname + '.' + nameprefix
fullname = nameprefix + '.' + name
elif objectname:
fullname = objectname + '.' + name
else:
# just a function or constructor
objectname = ''
fullname = name
signode['object'] = objectname
signode['fullname'] = fullname
if self.display_prefix:
signode += addnodes.desc_annotation(self.display_prefix,
self.display_prefix)
if nameprefix:
signode += addnodes.desc_addname(nameprefix + '.',
nameprefix + '.')
signode += addnodes.desc_name(name, name)
if self.has_arguments:
if not arglist:
signode += addnodes.desc_parameterlist()
else:
_pseudo_parse_arglist(signode, arglist)
return fullname, nameprefix
def add_args_from_options(self, signode: desc_signature) -> None:
params = addnodes.desc_parameterlist()
argnames = self.options.get('argnames', [])
argtypes = self.options.get('argtypes', [])
if len(argtypes):
argnames, argtypes = list_option(argnames), list_option(argtypes)
arglist = ', '.join([
f'{argname}: {argtype}'
for argname, argtype in zip(argnames, argtypes)
])
params = _parse_arglist(arglist, self.env)
signode += params
else:
signode.extend([
addnodes.desc_sig_punctuation('', '('),
addnodes.desc_sig_punctuation('', ')'),
])
def handle_signature(self, sig, signode):
if sig.startswith("("):
sig = sig[1:]
if sig.endswith(")"):
sig = sig[:-1]
name, args = sig.split(" ", 1)
params = addnodes.desc_parameterlist()
params.child_text_separator = " "
if args:
params += addnodes.desc_name(name, name + " ")
else:
params += addnodes.desc_name(name, name)
for arg in args.split():
params += addnodes.desc_parameter(name, name)
signode += params
return name
def handle_signature(self, sig, signode):
"""
handle the signature of the directive
"""
sig_match = rust_function_sig_re.match(sig)
name = sig_match.group("name")
mods = sig_match.group("mods")
args = sig_match.group("args")
ret = sig_match.group("return")
# formatted_mods = formatter.output_modifiers(mods).build()
signode += nodes.Text(mods + ' ', mods + ' ')
signode += nodes.Text('fn ', 'fn ')
# function name
signode += addnodes.desc_name(name, name)
# function arguments
paramlist = addnodes.desc_parameterlist()
if args is not None:
args = [x.strip() for x in args.split(',')]
for arg in args:
param = addnodes.desc_parameter('', '', noemph=True)
arg_match = rust_arg_re.match(arg)
typ = arg_match.group("type")
var = arg_match.group("var")
param += nodes.emphasis(var, var)
param += nodes.Text(': ', ': ')
param += self._build_type_node(typ)
print('just build type node')
paramlist += param
signode += paramlist
# return value
if ret is not None:
rnode = addnodes.desc_type('', '')
rnode += self._build_type_node(ret)
signode += nodes.Text(' -> ', ' -> ')
signode += rnode
return name
def handle_func_like_macro(self, sig, signode):
u"""Handles signatures of function-like macros.
If the objtype is 'function' and the the signature ``sig`` is a
function-like macro, the name of the macro is returned. Otherwise
``False`` is returned. """
global namespace
if not self.objtype == 'function':
return False
m = c_funcptr_sig_re.match(sig)
if m is None:
m = c_sig_re.match(sig)
if m is None:
raise ValueError('no match')
rettype, fullname, arglist, _const = m.groups()
arglist = arglist.strip()
if rettype or not arglist:
return False
arglist = arglist.replace('`', '').replace('\\ ', '') # remove markup
arglist = [a.strip() for a in arglist.split(",")]
# has the first argument a type?
if len(arglist[0].split(" ")) > 1:
return False
# This is a function-like macro, it's arguments are typeless!
signode += addnodes.desc_name(fullname, fullname)
paramlist = addnodes.desc_parameterlist()
signode += paramlist
for argname in arglist:
param = addnodes.desc_parameter('', '', noemph=True)
# separate by non-breaking space in the output
param += nodes.emphasis(argname, argname)
paramlist += param
if namespace:
fullname = namespace + "." + fullname
return fullname
def handle_signature(self, sig: str,
signode: addnodes.desc_signature) -> Tuple[str, str]:
"""Transform a signature/object into RST nodes."""
try:
self.obj = BlarkSphinxCache.instance().find_by_name(sig)
except KeyError:
self.obj = MissingDeclaration(sig)
logger.error("Could not find object: %r (signatures unsupported)",
sig)
raise ValueError(f"Code object not found: {sig!r}")
self.env.ref_context["bk:function"] = self.obj
signode["ids"] = [sig]
signode["docname"] = self.env.docname
signode["qualified_name"] = sig
domain_data = self.env.domaindata["bk"][self.signature_prefix.lower()]
domain_data.setdefault(sig, []).append(signode)
sig_prefix = self.get_signature_prefix(sig)
signode += addnodes.desc_annotation(str(sig_prefix), '', *sig_prefix)
signode += addnodes.desc_name(self.obj.name, self.obj.name)
paramlist = addnodes.desc_parameterlist("paramlist")
for block in ("VAR_INPUT", "VAR_IN_OUT", "VAR_OUTPUT", "STRUCT"):
decls = self.obj.declarations_by_block.get(block, {})
for variable, decl in decls.items():
node = addnodes.desc_parameter()
# node += addnodes.desc_sig_operator('', '*')
node += addnodes.desc_type("", decl.type)
node += addnodes.desc_sig_space()
node += addnodes.desc_sig_name("", variable)
if block == "VAR_OUTPUT":
node += addnodes.desc_sig_punctuation(text="=>")
paramlist += node
signode += paramlist
if getattr(self.obj, "return_type", None) is not None:
signode += addnodes.desc_returns()
signode += addnodes.desc_type(text=self.obj.return_type)
prefix = ""
return sig, prefix
def handle_signature(self, sig, signode):
sig = sig.strip()
if '(' in sig and sig[-1:] == ')':
prefix, arglist = sig.split('(', 1)
prefix = prefix.strip()
arglist = arglist[:-1].strip()
else:
prefix = sig
arglist = None
if re.search(separators, prefix):
separator = re.findall(separators, prefix)[-1]
nameprefix, name = prefix.rsplit(separator, 1)
else:
separator = None
nameprefix = None
name = prefix
objectname = self.env.temp_data.get('lua:object')
if nameprefix:
if objectname:
nameprefix = objectname + '.' + nameprefix
fullname = nameprefix + separator + name
elif objectname:
fullname = objectname + '.' + name
else:
objectname = ''
fullname = name
signode['object'] = objectname
signode['fullname'] = fullname
if self.display_prefix:
signode += addnodes.desc_annotation(self.display_prefix,
self.display_prefix)
if nameprefix:
signode += addnodes.desc_addname(nameprefix + separator,
nameprefix + separator)
signode += addnodes.desc_name(name, name)
if self.has_arguments:
if not arglist:
signode += addnodes.desc_parameterlist()
else:
_pseudo_parse_arglist(signode, arglist)
return fullname, nameprefix
def handle_signature(self, sig, signode):
sig = sig.strip()
if '(' in sig and sig[-1:] == ')':
# name(arglist)
prefix, arglist = sig.split('(', 1)
prefix = prefix.strip()
arglist = arglist[:-1].strip()
else:
prefix = sig
arglist = None
if '.' in prefix:
nameprefix, name = prefix.rsplit('.', 1)
else:
nameprefix = None
name = prefix
objectname = self.env.temp_data.get('tempoiq:object')
if nameprefix:
if objectname:
# someone documenting the method of an attribute of the current
# object? shouldn't happen but who knows...
nameprefix = objectname + '.' + nameprefix
fullname = nameprefix + '.' + name
elif objectname:
fullname = objectname + '.' + name
else:
objectname = ''
fullname = name
signode['object'] = objectname
signode['fullname'] = fullname
if nameprefix:
signode += addnodes.desc_addname(nameprefix + '.',
nameprefix + '.')
signode += addnodes.desc_name(name, name)
if self.has_arguments:
if not arglist:
signode += addnodes.desc_parameterlist()
else:
_pseudo_parse_arglist(signode, arglist)
return fullname, nameprefix
def parse_macro_uri_path(signode, uri_path):
offset = 0
path = None
for match in http_sig_param_re.finditer(uri_path):
path = uri_path[offset:match.start()]
signode += addnodes.desc_name(path, path)
params = addnodes.desc_parameterlist()
typ = match.group('type')
if 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(uri_path):
path = uri_path[offset:len(uri_path)]
signode += addnodes.desc_name(path, path)
assert path is not None, 'no matches for sig'
def parse_frrfmt(env, text, node):
from sphinx import addnodes
m = frrfmt_re.match(text)
if not m:
logger.warning('could not parse frrfmt:: %r' % (text), location=node)
node += addnodes.desc_name(text, text)
return text
spec, types = m.group('spec'), m.group('types')
node += addnodes.desc_sig_operator('%', '%')
node += addnodes.desc_name(spec + ' ', spec + ' ')
plist = addnodes.desc_parameterlist()
for typ in types.split(','):
typ = typ.strip()
plist += addnodes.desc_parameter(typ, typ)
node += plist
return '%' + spec
def handle_signature(self, sig, signode):
m = plsql_sig_re.match(sig)
if m is None:
raise ValueError
name_prefix, name, arglist, retann = m.groups()
if not name_prefix:
name_prefix = ''
if self.env.temp_data.get('plsql:in_package'):
name_prefix = self.env.temp_data['plsql:current_package'] + '.'
sig_prefix = self.get_signature_prefix(sig)
if sig_prefix:
signode += addnodes.desc_annotation(sig_prefix, sig_prefix)
if not self.env.temp_data.get('plsql:in_package'):
signode += addnodes.desc_annotation(name_prefix, name_prefix)
fullname = ''
if name_prefix:
fullname += name_prefix
fullname += name
signode += addnodes.desc_name(name, name)
if arglist:
signode += addnodes.desc_parameterlist()
stack = [signode[-1]]
for token in arglist.split(','):
if not token or token == ',' or token.isspace():
pass
else:
token = token.strip()
stack[-1] += addnodes.desc_parameter(token, token)
if retann:
signode += addnodes.desc_returns(retann, retann)
return fullname
def handle_method_signature(self, sig, signode):
try:
member = javalang.parse.parse_member_signature(sig)
except javalang.parser.JavaSyntaxError:
raise self.error("syntax error in method signature")
if not isinstance(member, javalang.tree.MethodDeclaration):
raise self.error("expected method declaration")
mods = formatter.output_modifiers(member.modifiers).build()
signode += nodes.Text(mods + ' ', mods + ' ')
if member.type_parameters:
type_params = formatter.output_type_params(
member.type_parameters).build()
signode += nodes.Text(type_params, type_params)
signode += nodes.Text(' ', ' ')
rnode = addnodes.desc_type('', '')
rnode += self._build_type_node(member.return_type)
signode += rnode
signode += nodes.Text(' ', ' ')
signode += addnodes.desc_name(member.name, member.name)
paramlist = addnodes.desc_parameterlist()
for parameter in member.parameters:
param = addnodes.desc_parameter('', '', noemph=True)
param += self._build_type_node(parameter.type)
if parameter.varargs:
param += nodes.Text('...', '')
param += nodes.emphasis(' ' + parameter.name, ' ' + parameter.name)
paramlist += param
signode += paramlist
param_reprs = [
formatter.output_type(param.type, with_generics=False).build()
for param in member.parameters
]
return member.name + '(' + ', '.join(param_reprs) + ')'
def append_parameters(self, node, params, ignore_types=None):
if ignore_types is None:
ignore_types = []
pnodes = addnodes.desc_parameterlist()
for param in params:
pnode = addnodes.desc_parameter('', '', noemph=True)
self.append_modifiers(pnode, param.modifiers)
if ignore_types and param.typ in ignore_types:
pnode += addnodes.desc_type(param.typ, param.typ)
else:
self.append_type(pnode, param.typ, ignore_types)
pnode += nodes.Text('\xa0')
pnode += nodes.emphasis(param.name, param.name)
if param.default is not None:
default = ' = ' + param.default
pnode += nodes.emphasis(default, default)
pnodes += pnode
node += pnodes
def parse_event(env, sig, signode):
"""
Used to set up the ``event`` directive and role for documenting Sphinx events.
Taken from the ``conf.py`` file of `Sphinx's documentation
<https://github.com/sphinx-doc/sphinx/blob/
8653ceca0021f6ac6ff0aac6c26e2a455c6d4b21/doc/conf.py#L123-L138>`_.
Parameters
----------
env : sphinx.environment.BuildEnvironment
Instance of the Sphinx's build environment.
sig : str
The "signature" given the the event directive or role. For example,
.. code-block:: rst
.. event:: foo(bar)
:event:`foo`
in the directive case ``foo(bar)`` would be the signature and in the role
case ``foo`` would be the signature.
signode : sphinx.addnodes.desc_signature
A `docutils` Node for the object signatures.
"""
event_sig_re = re.compile(r"([a-zA-Z-]+)\s*\((.*)\)")
match = event_sig_re.match(sig)
if not match:
signode += addnodes.desc_name(sig, sig)
return sig
name, args = match.groups()
signode += addnodes.desc_name(name, name)
plist = addnodes.desc_parameterlist()
for arg in args.split(","):
arg = arg.strip()
plist += addnodes.desc_parameter(arg, arg)
signode += plist
return name
