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):
#synopsis = unicodedata.normalize('NFD', self.options.get('synopsis'))
synopsis = self.options.get('synopsis')
module = self.env.temp_data.get('nscp:module')
fullname = 'TODO'
if self.objtype == 'query':
fullname = '%s.%s'%(module, sig)
signode['fullname'] = fullname
signode += addnodes.desc_addname(module, module)
signode += addnodes.desc_name(sig, sig)
signode += addnodes.desc_content('')
signode += addnodes.compact_paragraph(synopsis, synopsis)
elif self.objtype == 'option':
command = self.env.temp_data.get('nscp:command')
fullname = '%s.%s:%s'%(module, command, sig)
signode['fullname'] = fullname
ann = ' (%s, %s)'%(module, command)
signode += addnodes.desc_name(sig, sig)
signode += addnodes.desc_annotation(ann, ann)
elif self.objtype == 'confpath':
fullname = '%s:%s'%(module, sig)
signode['fullname'] = fullname
ann = ' (%s)'%(module)
signode += addnodes.desc_name(sig, sig)
signode += addnodes.desc_annotation(ann, ann)
elif self.objtype == 'confkey':
confpath = self.env.temp_data.get('nscp:confpath', '')
fullname = '%s:%s:%s'%(module, confpath, sig)
signode['fullname'] = fullname
ann = ' (%s, %s)'%(module, confpath)
signode += addnodes.desc_name(sig, sig)
signode += addnodes.desc_annotation(ann, ann)
#print 'handle_signature(%s, %s) => %s'%(sig, signode, fullname)
return fullname, sig
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 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 parse_django_adminopt_node(env, sig, signode):
"""A copy of sphinx.directives.CmdoptionDesc.parse_signature()"""
from sphinx.domains.std import option_desc_re
count = 0
firstname = ''
for m in option_desc_re.finditer(sig):
optname, args = m.groups()
if count:
signode += addnodes.desc_addname(', ', ', ')
signode += addnodes.desc_name(optname, optname)
signode += addnodes.desc_addname(args, args)
if not count:
firstname = optname
count += 1
if not count:
for m in simple_option_desc_re.finditer(sig):
optname, args = m.groups()
if count:
signode += addnodes.desc_addname(', ', ', ')
signode += addnodes.desc_name(optname, optname)
signode += addnodes.desc_addname(args, args)
if not count:
firstname = optname
count += 1
if not firstname:
raise ValueError
return firstname
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 parse_macro(env, sig, signode):
#import rpdb2 ; rpdb2.start_embedded_debugger('foo')
m = macro_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 = desc_cmake_argumentlist()
for m in macro_param_re.finditer(args):
arg = m.group(0)
if arg.startswith('['):
arg = arg[1:-1].strip()
x = desc_cmake_argument()
opt = addnodes.desc_optional()
x += opt
m = macro_param_re.match(arg)
assert m is not None, "%s does not match %s" % (arg, macro_param_re.pattern)
opt += _get_param_node(m)
plist += x
# elif arg.startswith('{') choice
else:
x = desc_cmake_argument()
x += _get_param_node(m)
plist += x
signode += plist
return name
def parse_macro(env, sig, signode):
m = macro_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 = desc_cmake_argumentlist()
for m in macro_param_re.finditer(args):
arg = m.group(0)
if arg.startswith('['):
arg = arg[1:-1].strip()
x = desc_cmake_argument()
opt = addnodes.desc_optional()
x += opt
m = macro_param_re.match(arg)
assert m is not None, "%s does not match %s" % (arg, macro_param_re.pattern)
opt += _get_param_node(m, True)
plist += x
else:
x = desc_cmake_argument()
x += _get_param_node(m, False)
plist += x
signode += plist
return name
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):
method = self.method.upper() + ' '
signode += addnodes.desc_name(method, method)
signode += addnodes.desc_name(sig, sig)
fullname = "Template" + ' ' + sig
signode['method'] = self.method
signode['path'] = sig
signode['fullname'] = fullname
return (fullname, self.method, sig)
def handle_signature(self, sig, signode):
symbol_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 render_atom(token, signode, noemph=True):
"add syntax hi-lighting to interesting atoms"
if token.startswith("&") or token.startswith(":"):
signode.append(addnodes.desc_parameter(token, token))
else:
signode.append(addnodes.desc_parameter(token, token))
package = self.env.temp_data.get('el:package')
objtype = self.get_signature_prefix(sig)
signode.append(addnodes.desc_annotation(objtype, objtype))
lisp_args = self.options.get('args', [])
if not lisp_args:
v = self.options.get('value')
lisp_args = [v] if v else []
if not lisp_args:
lisp_args = DATA_ARGS.get(package, {}).get(sig, [])
if not lisp_args:
v = DATA_VALUES.get(package, {}).get(sig)
lisp_args = [quote_value_if_necessary(v)] if v else []
if lisp_args:
function_name = addnodes.desc_name(sig, sig + " ")
else:
function_name = addnodes.desc_name(sig, sig)
if lisp_args:
arg_list = render_sexp(lisp_args, prepend_node=function_name)
signode.append(arg_list)
else:
signode.append(function_name)
symbol_name = sig
if not symbol_name:
raise Exception("Unknown symbol type for signature %s" % sig)
return objtype.strip(), symbol_name
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 p_method_parts(p): '''method : returnval WORD | returnval WORD COLON parameters''' if (len(p) == 5): p[0] = p[1] p[0] += nodes.Text(u' ') p[0] += addnodes.desc_name(p[2], p[2]) p[0] += addnodes.desc_annotation(p[3], p[3]) p[0] += p[4] else: p[0] = p[1] p[0] += nodes.Text(u' ') p[0] += addnodes.desc_name(p[2], p[2])
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 parse_directive(env, sig, signode):
if not sig.startswith('.'):
dec_sig = '.. %s::' % sig
signode += addnodes.desc_name(dec_sig, dec_sig)
return sig
m = dir_sig_re.match(sig)
if not m:
signode += addnodes.desc_name(sig, sig)
return sig
name, args = m.groups()
dec_name = '.. %s::' % name
signode += addnodes.desc_name(dec_name, dec_name)
signode += addnodes.desc_addname(args, args)
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_signature(self, sig, signode):
symbol_name = []
type = []
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)
symbol = False
for atom in sexp:
if isinstance(atom, list):
render_sexp(atom, desc_sexplist)
else:
symbol = render_atom(atom, desc_sexplist)
return desc_sexplist
def render_atom(token, signode, noemph=True):
"add syntax hi-lighting to interesting atoms"
if token.startswith("&") or token.startswith(":"):
signode.append(addnodes.desc_parameter(token, token))
else:
signode.append(addnodes.desc_parameter(token, token))
package = self.env.temp_data.get('cl:package')
objtype = self.get_signature_prefix(sig)
signode.append(addnodes.desc_annotation(objtype, objtype))
lisp_args = args[package].get(sig.upper(), "")
if lisp_args.strip():
function_name = addnodes.desc_name(sig, sig + " ")
else:
function_name = addnodes.desc_name(sig, sig)
if not lisp_args.strip() and self.objtype in ["function"]:
lisp_args = "()"
if lisp_args.strip():
arg_list = render_sexp(_read(lisp_args), prepend_node=function_name)
signode.append(arg_list)
else:
signode.append(function_name)
symbol_name = sig
if not symbol_name:
raise Exception("Unknown symbol type for signature %s" % sig)
return objtype.strip(), symbol_name.upper()
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_signature(self, sig, signode):
"""Transform an option description into RST nodes."""
count = 0
firstname = ''
for potential_option in sig.split(', '):
potential_option = potential_option.strip()
m = option_desc_re.match(potential_option)
if not m:
self.env.warn(
self.env.docname,
'Malformed option description %r, should '
'look like "opt", "-opt args", "--opt args", '
'"/opt args" or "+opt args"' % potential_option,
self.lineno)
continue
optname, args = m.groups()
if count:
signode += addnodes.desc_addname(', ', ', ')
signode += addnodes.desc_name(optname, optname)
signode += addnodes.desc_addname(args, args)
if not count:
firstname = optname
signode['allnames'] = [optname]
else:
signode['allnames'].append(optname)
count += 1
if not firstname:
raise ValueError
return firstname
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, display_text=None):
"""This method determines the appearance of the object.
Overloaded Args:
display_test: Used for overriding the object name.
"""
# Override sig with display_text if provided.
if display_text is None:
display_text = sig
display_text, argument, alt_forms = self.process_name(display_text)
# Add a label before the name of the object.
signode += addnodes.desc_annotation(*('%s ' % self.LABEL,) * 2)
# Add the object name.
signode += addnodes.desc_name(sig, display_text)
# Add arguments.
if argument:
argument = '%s %s' % (self.ARGUMENT_SEPARATOR, argument)
signode += addnodes.desc_annotation(argument, argument)
# Add alternate object names.
if alt_forms:
signode += addnodes.desc_annotation(
*(self.ALT_FORM_TEMPLATE % (', '.join(alt_forms)),) * 2)
signode['fullname'] = sig
return (sig, self.NAME, sig)
def attach_name(self, node, name):
owner, name = name.split_owner()
varname = unicode(name)
if owner is not None:
owner = unicode(owner) + '::'
node += addnodes.desc_addname(owner, owner)
node += addnodes.desc_name(varname, varname)
def parse_django_adminopt_node(env, sig, signode):
"""A copy of sphinx.directives.CmdoptionDesc.parse_signature()"""
option_desc_re = None
# Sphinx >= 1.0 and Sphinx < 1.0, respectively.
for module in ['sphinx.domains.std', 'sphinx.directives.desc']:
try:
mod = import_module(module)
option_desc_re = mod.option_desc_re
except ImportError:
pass
else:
break
count = 0
firstname = ''
for m in option_desc_re.finditer(sig):
optname, args = m.groups()
if count:
signode += addnodes.desc_addname(', ', ', ')
signode += addnodes.desc_name(optname, optname)
signode += addnodes.desc_addname(args, args)
if not count:
firstname = optname
count += 1
if not firstname:
raise ValueError
return firstname
def handle_signature(self, sig, signode):
try:
tag, name = sig.split()
except ValueError:
tag, name = None, sig
cache = _APP_CACHES.get(self.env.app, {})
key = {'struct': CursorKind.STRUCT_DECL}[tag], (name, )
if key in cache:
node, comment, start, end, members = cache[key]
signode += addnodes.desc_type(tag, tag + ' ')
signode += addnodes.desc_name(node.spelling, node.spelling)
self.content = ViewList()
for line in comment.splitlines():
self.content.append(line, '<unknown>')
self.content.append('', '<unknown>')
for (_, member_name), value in members.items():
member_node, member_comment, _, _, _ = value
self.content.append(
'.. c:member:: %s %s' % (member_node.type.spelling, member_node.spelling),
'<unknown>'
)
self.content.append('', '<unknown>')
for line in member_comment.splitlines():
self.content.append(' ' + line, '<unknown>')
self.content.append('', '<unknown>')
return sig
def handle_signature(self, sig: str, signode: addnodes.desc) -> str:
"""Transform signature into RST nodes"""
signode += addnodes.desc_annotation(self.typename, self.typename + " ")
signode += addnodes.desc_name(sig, sig)
if 'badges' in self.options:
badges = addnodes.desc_annotation()
badges['classes'] += ['badges']
content = StringList([self.options['badges']])
self.state.nested_parse(content, 0, badges)
signode += badges
if 'replaces_section_title' in self.options:
section = self.state.parent
if isinstance(section, nodes.section):
title = section[-1]
if isinstance(title, nodes.title):
section.remove(title)
else:
signode += self.state.document.reporter.warning(
"%s:%s:: must follow section directly to replace section title"
% (self.domain, self.objtype), line = self.lineno
)
else:
signode += self.state.document.reporter.warning(
"%s:%s:: must be in section to replace section title"
% (self.domain, self.objtype), line = self.lineno
)
return sig
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):
name, args = parse_directive(sig)
desc_name = '.. %s::' % name
signode += addnodes.desc_name(desc_name, desc_name)
if len(args) > 0:
signode += addnodes.desc_addname(args, args)
return name
def handle_field_signature(self, sig, signode):
try:
member = javalang.parse.parse_member_signature(sig)
except javalang.parser.JavaSyntaxError:
raise self.error("syntax error in field signature")
if not isinstance(member, javalang.tree.FieldDeclaration):
raise self.error("expected field declaration")
mods = formatter.output_modifiers(member.modifiers).build()
signode += nodes.Text(mods + ' ', mods + ' ')
tnode = addnodes.desc_type('', '')
tnode += self._build_type_node(member.type)
signode += tnode
signode += nodes.Text(' ', ' ')
if len(member.declarators) > 1:
self.error('only one field may be documented at a time')
declarator = member.declarators[0]
signode += addnodes.desc_name(declarator.name, declarator.name)
dim = '[]' * len(declarator.dimensions)
signode += nodes.Text(dim)
if declarator.initializer and isinstance(declarator.initializer, javalang.tree.Literal):
signode += nodes.Text(' = ' + declarator.initializer.value)
return declarator.name
def run(self):
"""Run this directive.
In addition to the normal processing of the :class:`EmacsLispSymbol`
directive, also prepend an additional signature that describes the
keybinding of the documented command, if any.
"""
result_nodes = EmacsLispSymbol.run(self)
# Insert a dedicated signature for the key binding before all other
# signatures, but only for commands. Nothing else has key bindings.
binding = self.options.get('binding')
if binding:
binding = self.with_prefix_arg(binding)
desc_node = result_nodes[-1]
assert isinstance(desc_node, addnodes.desc)
signode = addnodes.desc_signature(binding, '')
# No clue what this property is for, but ObjectDescription sets it
# for its signatures, so we should do as well for our signature.
signode['first'] = False
desc_node.insert(0, signode)
signode += addnodes.desc_name(binding, binding)
return result_nodes
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.ref_context.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 ;)
for arg in self._parse_arglist(arglist):
arg = arg.strip()
param = addnodes.desc_parameter('', '', noemph=True)
try:
m = c_funcptr_arg_sig_re.match(arg)
if m:
self._parse_type(param, m.group(1) + '(')
param += nodes.emphasis(m.group(2), m.group(2))
self._parse_type(param, ')(' + m.group(3) + ')')
if m.group(4):
param += addnodes.desc_addname(m.group(4), m.group(4))
else:
ctype, argname = arg.rsplit(' ', 1)
self._parse_type(param, ctype)
# separate by non-breaking space in the output
param += nodes.emphasis(' ' + argname, u'\xa0' + argname)
except ValueError:
# no argument name given, only the type
self._parse_type(param, arg)
paramlist += param
signode += paramlist
if const:
signode += addnodes.desc_addname(const, const)
return fullname
def handle_signature(self, sig, signode):
"""
Transform a PHP signature into RST nodes.
Returns (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
"""
m = php_sig_re.match(sig)
if m is None:
raise ValueError
name_prefix, name, arglist, retann = m.groups()
if not name_prefix:
name_prefix = ""
# determine module and class name (if applicable), as well as full name
modname = self.options.get(
'namespace', self.env.temp_data.get('php:namespace'))
classname = self.env.temp_data.get('php:class')
separator = separators[self.objtype]
if self.objtype == 'global' or self.objtype == 'function':
add_module = False
modname = None
classname = None
fullname = name
else:
add_module = True
# name_prefix and a non-static method, means the classname was
# repeated. Trim off the <class>::
if name_prefix and self.objtype != 'staticmethod':
if name_prefix.startswith(classname):
name_prefix = name_prefix[len(classname):].rstrip('::')
classname = classname.rstrip('::')
fullname = name_prefix + classname + separator + name
elif name_prefix:
classname = classname.rstrip('::')
fullname = name_prefix + name
# Currently in a class, but not creating another class,
elif classname and not self.objtype in ['class', 'exception', 'interface']:
if not self.env.temp_data['php:in_class']:
name_prefix = classname + separator
fullname = classname + separator + name
else:
classname = ''
fullname = name
signode['namespace'] = modname
signode['class'] = self.class_name = 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:
if modname and not self.env.temp_data['php:in_class']:
name_prefix = modname + NS + name_prefix
signode += addnodes.desc_addname(name_prefix, name_prefix)
elif add_module and self.env.config.add_module_names:
if self.objtype == 'global':
nodetext = ''
signode += addnodes.desc_addname(nodetext, nodetext)
else:
modname = self.options.get(
'namespace', self.env.temp_data.get('php:namespace'))
if modname and not self.env.temp_data.get('php:in_class', False):
nodetext = modname + NS
signode += addnodes.desc_addname(nodetext, nodetext)
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)
return fullname, name_prefix
signode += addnodes.desc_parameterlist()
stack = [signode[-1]]
for token in php_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:
raise ValueError
if retann:
signode += addnodes.desc_returns(retann, retann)
return fullname, name_prefix
def handle_signature(self, sig, signode):
container_class_name = self.env.temp_data.get('swift:class')
container_class_type = self.env.temp_data.get('swift:class_type')
# split into method name and rest
first_anglebracket = sig.find('<')
first_paren = sig.find('(')
if first_anglebracket >= 0 and first_paren > first_anglebracket:
split_point = sig.find('>') + 1
else:
split_point = first_paren
# calculate generics
if first_anglebracket >= 0:
sp = sig[first_anglebracket:]
np = sp.find('>')
generics = sp[:np + 1]
else:
generics = None
method_name = sig[0:split_point]
# find method specialization
angle_bracket = method_name.find('<')
if angle_bracket >= 0:
method_name = method_name[:angle_bracket]
rest = sig[split_point:]
# split parameter list
parameter_list = None
depth = 0
for i, c in enumerate(rest):
if c == '(':
depth += 1
elif c == ')':
depth -= 1
if depth == 0:
parameter_list = rest[1:i]
rest = rest[i + 1:]
break
if parameter_list is not None and len(parameter_list) > 0:
parameters = self._parse_parameter_list(parameter_list)
else:
parameters = []
# check if it throws
throws = rest.find('throws') >= 0
# check for return type
return_type = None
arrow = rest.find('->')
if arrow >= 0:
return_type = rest[arrow + 2:].strip()
# build signature and add nodes
signature = ''
if self.objtype == 'static_method':
signode += addnodes.desc_addname("static", "static func ")
elif self.objtype == 'class_method':
signode += addnodes.desc_addname("class", "class func ")
elif self.objtype != 'init':
signode += addnodes.desc_addname("func", "func ")
if self.objtype == 'init':
signode += addnodes.desc_name('init', 'init')
signature += 'init('
for p in parameters:
if p['name'] == p['variable_name']:
signature += p['name'] + ':'
else:
signature += p['name'] + ' ' + p['variable_name'] + ':'
signature += ')'
else:
signode += addnodes.desc_name(method_name, method_name)
signature += method_name
signature += '('
for p in parameters:
if p['name'] == p['variable_name']:
signature += p['name'] + ':'
else:
signature += p['name'] + ' ' + p['variable_name'] + ':'
signature += ')'
if generics:
signode += addnodes.desc_addname(generics, generics)
params = []
sig = ''
for p in parameters:
if p['name'] == p['variable_name']:
param = p['name'] + ': ' # + p['type']
sig += p['name'] + ':'
else:
param = p['name'] + ' ' + p[
'variable_name'] + ':' # + p['type']
sig += p['name'] + ' ' + p['variable_name'] + ':'
#if p['default']:
# param += ' = ' + p['default']
paramNode = addnodes.desc_parameter(param, param)
paramXref = addnodes.pending_xref('',
refdomain='swift',
reftype='type',
reftarget=p['type'])
paramXref += nodes.Text(p['type'], p['type'])
paramNode += paramXref
if p['default']:
paramNode += nodes.Text(' = ' + p['default'],
' = ' + p['default'])
params.append(paramNode)
signode += addnodes.desc_parameterlist(sig, "", *params)
title = signature
if throws:
signode += addnodes.desc_annotation("throws", "throws")
# signature += "throws"
if return_type:
paramNode = addnodes.desc_returns('', '')
paramXref = addnodes.pending_xref('',
refdomain='swift',
reftype='type',
reftarget=return_type)
paramXref += nodes.Text(return_type, return_type)
paramNode += paramXref
signode += paramNode
# signode += addnodes.desc_returns(return_type, return_type)
#signature += "-" + return_type
#if container_class_type == 'protocol':
# signature += "-protocol"
#if self.objtype == 'static_method':
# signature += '-static'
#elif self.objtype == 'class_method':
# signature += '-class'
if container_class_name:
return (container_class_name + '.' +
title), (container_class_name + '.' + signature), True
return title, signature, True
def handle_signature(self, sig, signode):
"""Transform a PSschema signature into RST nodes."""
# first try the function pointer signature regex, it's more specific
name = sig
signode += addnodes.desc_name('', '')
objectname = self.env.temp_data.get('psdom:object')
ot = self.objtype
ws = wsplit_re.split(sig)
if ot == 'db':
sig_prefix = "database "
else:
sig_prefix = ot + " "
signode += addnodes.desc_annotation(sig_prefix, sig_prefix)
# for part in filter(None, ws):
# tnode = nodes.Text(part, part)
# pnode = addnodes.pending_xref(
# '', refdomain='psdom', reftype='type', reftarget=part,
# modname=None, classname=None)
# pnode = tnode
# signode += pnode
if len(ws) > 2:
dbname, tablename, columnname = ws
name = columnname
fullname = tablename + "." + columnname
elif len(ws) == 2:
if ot == 'table':
dbname, tablename = ws
dbname += "."
name = tablename
signode['table'] = tablename
signode += addnodes.desc_addname(dbname, dbname)
signode += addnodes.desc_name(tablename, tablename)
# fullname = dbname + "." + tablename
fullname = tablename
if ot == 'column':
tablename, columnname = ws
tablename += " "
signode += addnodes.desc_addname(tablename, tablename)
signode += addnodes.desc_name(columnname, columnname)
signode['table'] = tablename
fullname = tablename + "." + columnname
else:
if ot == 'table':
tablename = ws[0]
signode['table'] = tablename
dbname = self.options.get(
'db', self.env.temp_data.get('psdom:db'))
dbname += "."
self.env.temp_data['psdom:table'] = tablename
signode += addnodes.desc_addname(dbname, dbname)
signode += addnodes.desc_name(tablename, tablename)
signode['table'] = tablename
if ot == 'column':
columnname = ws[0]
signode['column'] = columnname
tablename = self.options.get(
'table', self.env.temp_data.get('psdom:table'))
tablename += "."
signode += addnodes.desc_addname(tablename, tablename)
signode += addnodes.desc_name(columnname, columnname)
if ot == 'db':
dbname = ws[0]
signode['db'] = dbname
name = dbname
self.env.temp_data['psdom:db'] = dbname
signode += addnodes.desc_name(dbname, dbname)
fullname = ws[0]
signode['fullname'] = fullname
return fullname
def handle_signature(self, sig, signode):
# called from sphinx.directives.ObjectDescription.run()
signode += addnodes.desc_name(sig, sig)
return sig
def parse_django_admin_node(env, sig, signode):
command = sig.split(' ')[0]
env._django_curr_admin_command = command
title = "django-admin.py %s" % sig
signode += addnodes.desc_name(title, title)
return sig
def handle_signature(self, sig, signode):
signode += addnodes.desc_name(sig, sig)
return sig
def handle_signature(self, sig, signode):
# type: (unicode, addnodes.desc_signature) -> Tuple[unicode, unicode]
"""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
"""
m = py_sig_re.match(sig) # type: ignore
if m is None:
raise ValueError
name_prefix, name, arglist, retann = m.groups()
# determine module and class name (if applicable), as well as full name
modname = self.options.get('module',
self.env.ref_context.get('py:module'))
classname = self.env.ref_context.get('py:class')
if classname:
add_module = False
if name_prefix and name_prefix.startswith(classname):
fullname = name_prefix + name
# class name is given again in the signature
name_prefix = name_prefix[len(classname):].lstrip('.')
elif name_prefix:
# class name is given in the signature, but different
# (shouldn't happen)
fullname = classname + '.' + name_prefix + name
else:
# class name is not given in the signature
fullname = classname + '.' + name
else:
add_module = True
if name_prefix:
classname = name_prefix.rstrip('.')
fullname = name_prefix + name
else:
classname = ''
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)
# exceptions are a special case, since they are documented in the
# 'exceptions' module.
elif add_module and self.env.config.add_module_names:
modname = self.options.get('module',
self.env.ref_context.get('py:module'))
if modname and modname != 'exceptions':
nodetext = modname + '.'
signode += addnodes.desc_addname(nodetext, nodetext)
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 _render_signature(self, signature, signode):
position = self.state_machine.get_source_and_line(self.lineno)
tacn_node = parse_notation(signature, *position)
signode += addnodes.desc_name(signature, '', tacn_node)
def handle_signature(self, sig, signode):
"""
Transform a Bazel signature into RST nodes.
:param sig:
:param signode:
:return:
"""
m = bzl_sig_re.match(sig)
if m is None:
logger.error(
"Sphinx-Bazel: Parse problems with signature: {}".format(sig))
raise ValueError
package, after_package, target, after_target, internal, after_internal, attribute = m.groups(
)
# Let's see if we have to use a specific workspace path or if we have to use the latest defined workspace
self.specific_workspace_path = self.options.get('path', None)
if self.specific_workspace_path:
signode['workspace'] = self.specific_workspace_path
else:
try:
signode['workspace'] = self.env.ref_context['bazel:workspace']
except KeyError:
logger.error(
"No workspace defined before given {} on page {} line {}".
format(self.name, self.state.document.current_source,
self.state.document.current_line))
signode['package'] = package
signode['target'] = target
sig_type = 'package'
sig_text = '//{}'.format(package)
if target:
sig_text += ':{}'.format(target)
sig_type = 'target'
if internal:
sig_text += ':{}'.format(internal)
sig_type = self.objtype
if attribute:
sig_text += ':{}'.format(attribute)
sig_type = 'attribute'
if self.options.get('show_type', False) is None:
sig_type_string = sig_type + ': '
signode += addnodes.desc_name(sig_type_string,
sig_type_string,
classes=['bazel', 'type', sig_type])
signode += addnodes.desc_name(sig_text, sig_text)
if self.options.get('show_workspace',
False) is None: # if flag is set, value is None
ws_string = 'workspace: {}'.format(signode['workspace'])
self._add_signature_detail(signode, ws_string)
if self.options.get('show_workspace_path',
False) is None: # if flag is set, value is None
# If no extra workspace path was defined via :path:
if self.specific_workspace_path is None:
# Get the path of the current/latest workspace
current_ws = self.env.ref_context['bazel:workspace']
ws_obj = self.env.domaindata['bazel']['workspaces'][current_ws]
ws_path = ws_obj[
1] # See workspace.py for details about stored data
else:
ws_path = self.specific_workspace_path
ws_path_string = 'workspace path: {}'.format(ws_path)
self._add_signature_detail(signode, ws_path_string)
rule_impl = self.options.get('implementation', "")
if rule_impl:
self.implementation = rule_impl
rule_invocation = self.options.get('invocation', "")
if rule_invocation:
self.invocation = rule_invocation
if self.options.get('show_implementation', False) is None:
impl_string = 'implementation: {}'.format(self.implementation)
self._add_signature_detail(signode, impl_string)
if self.options.get('show_invocation', False) is None:
invocation_string = 'invocation: {}'.format(self.invocation)
self._add_signature_detail(signode, invocation_string)
return sig, sig
def run(self) -> List[Node]:
"""
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
"""
if ':' in self.name:
self.domain, self.objtype = self.name.split(':', 1)
else:
self.domain, self.objtype = '', self.name
self.indexnode = addnodes.index(entries=[])
node = addnodes.desc()
node.document = self.state.document
node['domain'] = self.domain
# 'desctype' is a backwards compatible attribute
node['objtype'] = node['desctype'] = self.objtype
node['noindex'] = noindex = ('noindex' in self.options)
if self.domain:
node['classes'].append(self.domain)
self.names = [] # type: List[Any]
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, '')
self.set_source_info(signode)
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 name not in self.names:
self.names.append(name)
if not noindex:
# only add target and index entry if this is the first
# description of the object with this name in this desc block
self.add_target_and_index(name, sig, signode)
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)
self.env.app.emit('object-description-transform', self.domain,
self.objtype, contentnode)
DocFieldTransformer(self).transform_all(contentnode)
self.env.temp_data['object'] = None
self.after_content()
return [self.indexnode, node]
def parse_signature(self, sig, signode):
"""
Transform a Python signature into RST nodes.
Returns (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
"""
m = py_sig_re.match(sig)
if m is None:
raise ValueError
classname, name, arglist, retann = m.groups()
if self.env.currclass:
add_module = False
if classname and classname.startswith(self.env.currclass):
fullname = classname + name
# class name is given again in the signature
classname = classname[len(self.env.currclass):].lstrip('.')
elif classname:
# class name is given in the signature, but different
# (shouldn't happen)
fullname = self.env.currclass + '.' + classname + name
else:
# class name is not given in the signature
fullname = self.env.currclass + '.' + name
else:
add_module = True
fullname = classname and classname + name or name
prefix = self.get_signature_prefix(sig)
if prefix:
signode += addnodes.desc_annotation(prefix, prefix)
if classname:
signode += addnodes.desc_addname(classname, classname)
# exceptions are a special case, since they are documented in the
# 'exceptions' module.
elif add_module and self.env.config.add_module_names:
modname = self.options.get('module', self.env.currmodule)
if modname and modname != 'exceptions':
nodetext = modname + '.'
signode += addnodes.desc_addname(nodetext, nodetext)
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)
return fullname, classname
signode += addnodes.desc_parameterlist()
stack = [signode[-1]]
for token in py_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:
raise ValueError
if retann:
signode += addnodes.desc_returns(retann, retann)
return fullname, classname
def handle_signature(self, sig: str, signode: desc_signature) -> str:
signode += addnodes.desc_name(':%s:' % sig, ':%s:' % sig)
return sig
def parse_role(env, sig, signode):
signode += addnodes.desc_name(':%s:' % sig, ':%s:' % sig)
return sig
def handle_signature(self, sig, signode):
signode += addnodes.desc_name(sig, sig)
signode += addnodes.desc_annotation(" (Customize Option)",
" (Customize Option)")
return sig
emphasis('', 'self'),
SphinxNodes.desc_name('', '', Text('[')),
emphasis('', parameters_node.children[0].astext()),
SphinxNodes.desc_name('', '', Text(']')),
]
SPECIAL_METHODS = {
'__getitem__': lambda name_node, parameters_node: inline(
'', '', *brackets(parameters_node)
),
'__setitem__': lambda name_node, parameters_node: inline(
'', '',
*brackets(parameters_node),
Text(' '),
SphinxNodes.desc_name('', '', Text('=')),
Text(' '),
emphasis('', (
(parameters_node.children[1].astext())
if len(parameters_node.children) > 1 else ''
)),
),
'__delitem__': lambda name_node, parameters_node: inline(
'', '',
SphinxNodes.desc_name('', '', Text('del')),
Text(' '),
*brackets(parameters_node),
),
'__contains__': lambda name_node, parameters_node: inline(
'', '',
emphasis('', parameters_node.children[0].astext()),
def parse_django_admin_node(env, sig, signode):
command = sig.split(' ')[0]
env.ref_context['std:program'] = command
title = "django-admin %s" % sig
signode += addnodes.desc_name(title, title)
return command
def handle_signature(self, sig, signode):
# type: (unicode, addnodes.desc_signature) -> unicode
signode += addnodes.desc_name(':%s:' % sig, ':%s:' % sig)
return sig
def _render_signature(self, signature, signode):
signode += addnodes.desc_name(signature, signature)
def handle_signature(self, sig, signode):
container_class_name = self.env.temp_data.get('swift:class')
# split on : -> first part is class name, second part is superclass list
parts = [x.strip() for x in sig.split(':', 1)]
# if the class name contains a < then there is a generic type attachment
if '<' in parts[0]:
class_name, generic_type = parts[0].split('<')
generic_type = generic_type[:-1]
else:
class_name = parts[0]
generic_type = None
# did we catch a 'where' ?
type_constraint = None
class_parts = None
if ' ' in class_name:
class_parts = class_name.split(' ')
elif '\t' in class_name:
class_parts = class_name.split('\t')
if class_parts:
# if a part starts with `where` then we have a type constraint
for index, p in enumerate(class_parts):
if p == 'where':
type_constraint = " ".join(
class_parts[index:]) + ": " + parts.pop()
class_name = " ".join(class_parts[:index])
break
if class_name.count('.'):
class_name = class_name.split('.')[-1]
# if we have more than one part this class has super classes / protocols
super_classes = None
if len(parts) > 1:
super_classes = [x.strip() for x in parts[1].split(',')]
# if a part starts with `where` then we have a type constraint
for index, sup in enumerate(super_classes):
if sup == 'where':
type_constraint = " ".join(super_classes[index:])
super_classes = super_classes[:index]
break
# Add class name
signode += addnodes.desc_addname(self.objtype, self.objtype + ' ')
signode += addnodes.desc_name(class_name, class_name)
# if we had super classes add annotation
if super_classes:
children = []
for c in super_classes:
prefix = ', ' if c != super_classes[0] else ''
ref = addnodes.pending_xref('',
reftype='type',
refdomain='swift',
reftarget=c,
refwarn=True)
ref += nodes.Text(prefix + c)
children.append(ref)
signode += addnodes.desc_type('', ' : ', *children)
# add type constraint
if type_constraint:
signode += addnodes.desc_type(type_constraint,
' ' + type_constraint)
add_to_index = True
if self.objtype == 'extension' and not super_classes:
add_to_index = False
if container_class_name:
class_name = container_class_name + '.' + class_name
return self.objtype + ' ' + class_name, self.objtype + ' ' + class_name, add_to_index
def handle_signature(self, sig, signode):
sig = sig.strip()
parent = self.env.temp_data.get('ars:servicename', None)
if not parent:
in_parent = False
split = sig.split('.', 1)
if len(split) == 2:
parent = split[0]
name = split[1]
else:
raise RuntimeError('Parent not found')
else:
in_parent = True
name = sig
self.service = ars_interface.services[parent]
self.procedure_name = name
base = self.service
self.procedure = None
while base is not None:
if base.name + '_' + name in base.procedures:
self.procedure = base.procedures[base.name + '_' + name]
break
base = base.base
if not self.procedure:
raise RuntimeError('Procedure {0} not found in {1} or base services'.format(name, parent))
skipargs = self.options.get('skipargs', 0)
gen_type_node(signode, self.procedure.return_type)
signode += nodes.Text(' ')
if not in_parent:
signode += addnodes.desc_addname(self.service.name, self.service.name)
signode += nodes.Text('.')
signode += addnodes.desc_name(self.procedure_name, self.procedure_name)
paramlist_node = addnodes.desc_parameterlist()
for param in list(self.procedure.parameters)[skipargs:]:
param_node = addnodes.desc_parameter('', '', noemph=True)
gen_type_node(param_node, param.type)
param_node += nodes.Text(' ')
param_node += nodes.emphasis(param.name, param.name)
paramlist_node += param_node
signode += paramlist_node
if len(self.procedure.exception_types) > len(global_exception_types):
signode += nodes.Text(' ')
signode += nodes.literal('throws', 'throws')
signode += nodes.Text(' (')
first = True
for exception in list(self.procedure.exception_types)[len(global_exception_types):]:
if first:
first = False
else:
signode += nodes.Text(', ')
gen_type_node(signode, exception)
signode += nodes.Text(')')
return self.service.name + '.' + self.procedure_name
def handle_signature(self, sig, signode):
"""
Transform a Fortran signature into RST nodes.
Returns (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
"""
m = f_sig_re.match(sig)
if m is None:
raise ValueError
ftype, objtype, modname, typename, name, arglist = m.groups()
if not typename:
typename = ""
# determine module, type, shape and attributes
modname = (modname and modname[:-1]) or self.options.get(
'module', self.env.temp_data.get('f:module'))
if typename:
name = typename[:-1]
attrs = self.options.get('attrs')
shape = parse_shape(self.options.get('shape'))
ftype = ftype or self.options.get('type')
if self.objtype == 'typefield' and not typename:
raise ValueError
if self.objtype == 'program':
fullname = name
else:
fullname = (modname or '_') + f_sep + name
signode['module'] = modname
signode['type'] = typename
signode['fullname'] = fullname
# Add "function" or "subroutine" tag
sig_prefix = self.get_signature_prefix(sig)
if objtype or sig_prefix:
objtype = objtype or sig_prefix
signode += addnodes.desc_annotation(objtype + ' ', objtype + ' ')
# Add module
if self.env.config.add_module_names and modname and self.objtype != 'typefield':
nodetext = modname + f_sep
signode += addnodes.desc_addname(nodetext, nodetext)
# Add name
signode += addnodes.desc_name(name, name)
# In the parenthesis
if self.needs_arglist(): # call for functions and subroutines
if arglist: # Calling arguments
_pseudo_parse_arglist(signode, arglist)
elif self.needs_arglist(
): # for callables, add an empty parameter list
signode += addnodes.desc_parameterlist()
elif arglist and not shape: # Declare shape instead of arguments (variables)
shape = arglist
# Add remaining
self.add_shape_and_attrs(signode, modname, ftype, shape, attrs)
return fullname, ftype
def handle_signature(self, sig, signode):
print(sig)
signode += addnodes.desc_name(text=sig)
return sig
def handle_signature(self, sig, signode):
signode += addnodes.desc_annotation(text="property ")
signode += addnodes.desc_name(text=sig)
return sig
def handle_signature(self, sig, signode):
"""
Transform a Ruby signature into RST nodes.
Returns (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
"""
m = rb_sig_re.match(sig)
if m is None:
raise ValueError
name_prefix, name, arglist, retann = m.groups()
if not name_prefix:
name_prefix = ""
# determine module and class name (if applicable), as well as full name
modname = self.options.get('module',
self.env.temp_data.get('rb:module'))
classname = self.env.temp_data.get('rb:class')
if self.objtype == 'global':
add_module = False
modname = None
classname = None
fullname = name
elif classname:
add_module = False
if name_prefix and name_prefix.startswith(classname):
fullname = name_prefix + name
# class name is given again in the signature
name_prefix = name_prefix[len(classname):].lstrip('.')
else:
separator = separators[self.objtype]
fullname = classname + separator + name_prefix + name
else:
add_module = True
if name_prefix:
classname = name_prefix.rstrip('.')
fullname = name_prefix + name
else:
classname = ''
fullname = name
signode['module'] = modname
signode['class'] = self.class_name = 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)
# exceptions are a special case, since they are documented in the
# 'exceptions' module.
elif add_module and self.env.config.add_module_names:
if self.objtype == 'global':
nodetext = ''
signode += addnodes.desc_addname(nodetext, nodetext)
else:
modname = self.options.get('module',
self.env.temp_data.get('rb:module'))
if modname and modname != 'exceptions':
nodetext = modname + separators[self.objtype]
signode += addnodes.desc_addname(nodetext, nodetext)
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)
return fullname, name_prefix
signode += addnodes.desc_parameterlist()
stack = [signode[-1]]
for token in rb_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:
raise ValueError
if retann:
signode += addnodes.desc_returns(retann, retann)
return fullname, name_prefix
def parse_value(self, env, text, nodes):
nodes += addnodes.desc_name(text, text)
if self._current_option is None:
return text
return self._current_option + '=' + text
def parse_django_admin_node(env, sig, signode):
command = sig.split(' ')[0]
env.ref_context['std:program'] = command
signode += addnodes.desc_name(sig, sig)
return command
def parse_ghci_cmd(env, sig, signode):
name = sig.split(';')[0]
sig = sig.replace(';', '')
signode += addnodes.desc_name(name, sig)
return name
def handle_signature(self, sig: str,
signode: desc_signature) -> Tuple[str, str]:
"""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
"""
m = py_sig_re.match(sig)
if m is None:
raise ValueError
prefix, name, arglist, retann = m.groups()
# determine module and class name (if applicable), as well as full name
modname = self.options.get('module',
self.env.ref_context.get('py:module'))
classname = self.env.ref_context.get('py:class')
if classname:
add_module = False
if prefix and (prefix == classname
or prefix.startswith(classname + ".")):
fullname = prefix + name
# class name is given again in the signature
prefix = prefix[len(classname):].lstrip('.')
elif prefix:
# class name is given in the signature, but different
# (shouldn't happen)
fullname = classname + '.' + prefix + name
else:
# class name is not given in the signature
fullname = classname + '.' + name
else:
add_module = True
if prefix:
classname = prefix.rstrip('.')
fullname = prefix + name
else:
classname = ''
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 prefix:
signode += addnodes.desc_addname(prefix, prefix)
elif add_module and self.env.config.add_module_names:
if modname and modname != 'exceptions':
# exceptions are a special case, since they are documented in the
# 'exceptions' module.
nodetext = modname + '.'
signode += addnodes.desc_addname(nodetext, nodetext)
signode += addnodes.desc_name(name, name)
if arglist:
try:
signode += _parse_arglist(arglist)
except SyntaxError:
# fallback to parse arglist original parser.
# it supports to represent optional arguments (ex. "func(foo [, bar])")
_pseudo_parse_arglist(signode, arglist)
except NotImplementedError as exc:
logger.warning("could not parse arglist (%r): %s", arglist,
exc)
_pseudo_parse_arglist(signode, arglist)
else:
if self.needs_arglist():
# for callables, add an empty parameter list
signode += addnodes.desc_parameterlist()
if retann:
signode += addnodes.desc_returns(retann, retann)
anno = self.options.get('annotation')
if anno:
signode += addnodes.desc_annotation(' ' + anno, ' ' + anno)
return fullname, prefix
def parse_option(self, env, text, nodes):
nodes += addnodes.desc_name(text, text)
self._current_option = text
return text
