class TempoIQMethod(TempoIQObject):
has_arguments = True
doc_field_types = [
TypedField('arguments',
label=l_('Arguments'),
names=('argument', 'arg', 'parameter', 'param'),
typerolename='class',
typenames=('type', 'paramtype'),
can_collapse=True),
Field('endpoint',
label=l_('HTTP Endpoint'),
has_arg=False,
names=('endpoint', )),
GroupedField('errors',
label=l_('Errors'),
rolename='err',
names=('throws', 'errors'),
can_collapse=True),
Field('returns',
label=l_('Returns'),
has_arg=False,
names=('returns', 'return')),
Field('cursored',
label=l_("Cursored"),
names=('cursored', 'cursor'),
has_arg=False)
]
class PSVariable(PSconfigObject):
doc_field_types = [
Field('scope', label=l_('Scope'), has_arg=False,
names=('scope', 'varscope')),
Field('cmdline', label=l_('Command Line'), has_arg=False,
names=('cmdline', 'cline', 'cli')),
Field('configfile', label=l_('Config File'), has_arg=False,
names=('conffile', 'configfile', 'conf', 'cfile')),
Field('dynamic', label=l_('Dynamic'), has_arg=False,
names=('dynvar', 'dyn')),
Field('vartype', label=l_('Variable Type'), has_arg=False,
names=('vartype', 'vtype')),
Field('default', label=l_('Default Value'), has_arg=False,
names=('default', 'df')),
Field('range', label=l_('Range'), has_arg=False,
names=('range', 'range')),
Field('allowed', label=l_('Allowed Values'), has_arg=False,
names=('allowed', 'av')),
Field('unit', label=l_('Units'), has_arg=False,
names=('unit', 'un')),
Field('inpatch', label=l_('Included in Patch'), has_arg=False,
names=('inpatch')),
TypedField('versioninfo', label=l_('Version Info'), rolename='obj',
names=('version', 'versioninfo'),
typerolename='obj', typenames=('paramtype', 'type')),
]
class DylanClassDesc (DylanBindingDesc):
"""A Dylan class."""
display_name = "class"
annotations = [
'open', 'primary', 'free', 'abstract', 'concrete', 'instantiable',
'uninstantiable', 'sealed'
] + DylanBindingDesc.annotations
option_spec = dict(DylanBindingDesc.option_spec.items())
option_spec.update(dict({
'open': DIRECTIVES.flag,
'primary': DIRECTIVES.flag,
'free': DIRECTIVES.flag,
'abstract': DIRECTIVES.flag,
'sealed': DIRECTIVES.flag,
'concrete': DIRECTIVES.flag,
'instantiable': DIRECTIVES.flag,
'uninstantiable': DIRECTIVES.flag,
}.items()))
doc_field_types = [
Field('superclasses', label="Superclasses", has_arg=False,
names=('supers', 'superclasses', 'super', 'superclass')),
TypedField('keyword', label="Init-Keywords",
names=('keyword', 'init-keyword')),
GroupedField('slots', label="Slots",
names=('slot', 'getter')),
Field('conditions', label="Conditions", has_arg=False,
names=('conditions', 'exceptions', 'condition', 'exception',
'signals', 'throws')),
Field('operations', label="Operations", has_arg=False,
names=('operations', 'methods', 'functions')),
] + DylanBindingDesc.doc_field_types
class RemoteCallable(RemoteObject):
"""Description of a Kurento ROM function, method or constructor."""
has_arguments = True
doc_field_types = [
TypedField('arguments',
label=l_('Arguments'),
names=('argument', 'arg', 'parameter', 'param'),
typerolename='func',
typenames=('paramtype', 'type')),
GroupedField('errors',
label=l_('Throws'),
rolename='err',
names=('throws', ),
can_collapse=True),
GroupedField('events',
label=l_('Events'),
rolename='evt',
names=('events', ),
can_collapse=True),
Field('returnvalue',
label=l_('Returns'),
has_arg=False,
names=('returns', 'return')),
Field('returntype',
label=l_('Return type'),
has_arg=False,
names=('rtype', )),
Field('isabstract',
label=l_('Abstract'),
has_arg=False,
names=('abstract', )),
]
class TypeDirective(ObjectDescription):
required_arguments = 1
optional_arguments = 0
final_argument_whitespace = False
has_content = True
option_spec = {}
doc_field_types = [
TypedField('key',
label='Keys',
names=('key', ),
typenames=('keytype', ))
]
def get_signatures(self):
self.type_name = self.arguments[0]
return [self.type_name]
def handle_signature(self, sig, signode):
signode += addnodes.desc_annotation('REST type ', 'REST type ')
signode += addnodes.desc_name(sig, sig)
def add_target_and_index(self, name, sig, signode):
targetname = 'type-' + self.type_name
# record the target for later cross-referencing
targets = self.env.domaindata['api']['targets'].setdefault('type', {})
targets[self.type_name] = self.env.docname, targetname
# record that we've documented the type
self.env.domaindata['api']['types'].add(self.type_name)
# add a target node at the beginning of the result
signode.insert(0, docutils.nodes.target('', '', ids=[targetname]))
class JinjaResource(ObjectDescription):
doc_field_types = [
TypedField('parameter', label='Parameters',
names=('param', 'parameter', 'arg', 'argument'),
typerolename='obj', typenames=('paramtype', 'type')),
]
method = "template"
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 needs_arglist(self):
return False
def add_target_and_index(self, name_cls, sig, signode):
signode['ids'].append(jinja_resource_anchor(*name_cls[1:]))
self.env.domaindata['jinja'][self.method][sig] = (self.env.docname, '')
def get_index_text(self, modname, name):
return ''
class KOSFunction(KOSObject):
doc_field_types = [
Field('access', label=l_('Access'), has_arg=False),
TypedField('parameter',
label=l_('Parameters'),
names=('param', 'parameter', 'arg', 'argument'),
typerolename='struct',
typenames=('paramtype', 'type')),
Field('returnvalue',
label=l_('Returns'),
has_arg=False,
names=('returns', 'return')),
Field('returntype',
label=l_('Return type'),
has_arg=False,
names=('rtype', 'type')),
]
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 get_index_text(self, objectname, name):
return _('{}()'.format(name))
class DylanMacroDesc(DylanBindingDesc):
"""A Dylan macro."""
final_argument_whitespace = True
display_name = "macro"
annotations = ['statement', 'function', 'defining', 'macro-type'
] + DylanBindingDesc.annotations
option_spec = dict(DylanBindingDesc.option_spec.items())
option_spec.update(
dict({
'statement': DIRECTIVES.flag,
'function': DIRECTIVES.flag,
'defining': DIRECTIVES.flag,
'macro-type': DIRECTIVES.unchanged,
}.items()))
doc_field_types = [
TypedField(
'parameters', label="Parameters", names=('param', 'parameter')),
GroupedField('values',
label="Values",
names=('value', 'val', 'retval', 'return')),
Field('call',
label="Macro Call",
has_arg=False,
names=('call', 'macrocall', 'syntax'))
] + DylanBindingDesc.doc_field_types
class CMakeFunction(sphinx.directives.ObjectDescription):
""" CMake Function """
objtype_pretty = u"CMake function"
doc_field_types = [
TypedField('arg', label=l_('Arguments'), names=['arg']),
]
def add_target_and_index(self, name, sig, signode):
""" Add Target and Index """
signode['ids'].append(name)
self.state.document.note_explicit_target(signode)
inv = self.env.domaindata['cmake'][self.objtype]
if name in inv:
msg = 'duplicate CMake {0} description of {1}, other instance ' \
'in {2}'.format(self.objtype, name,
self.env.doc2path(inv[name]))
self.env.warn(self.env.docname, msg, self.lineno)
inv[name] = self.env.docname
indextext = u"{0} ({1})".format(name, self.objtype_pretty)
self.indexnode['entries'].append(('single', indextext, name, name))
def handle_signature(self, sig, signode):
"""
Transform CMake Function Signature to RST nodes.
Return a name to add to the index.
"""
nb_param = len(sig.split(" "))
code = sig.replace("] ", "]\n ")
if nb_param > 1:
code = code.replace(")", "\n)")
literal = docutils.nodes.literal_block(code, code)
literal['language'] = 'cmake'
signode += literal
name = sig.split("(")[0]
return name
class ClifInst(ClifObject):
"""A Cranelift IR instruction."""
doc_field_types = [
TypedField('argument', label=l_('Arguments'),
names=('in', 'arg'),
typerolename='type', typenames=('type',)),
TypedField('result', label=l_('Results'),
names=('out', 'result'),
typerolename='type', typenames=('type',)),
GroupedField(
'typevar', names=('typevar',), label=l_('Type Variables')),
GroupedField('flag', names=('flag',), label=l_('Flags')),
Field('resulttype', label=l_('Result type'), has_arg=False,
names=('rtype',)),
]
def handle_signature(self, sig, signode):
# Look for signatures like
#
# v0, v1 = foo op0, op1
# v0 = foo
# foo op0
parts = re.split(sep_equal, sig, 1)
if len(parts) == 2:
# Outgoing parameters.
parse_params(parts[0], signode)
signode += nodes.Text(' = ')
name = parts[1]
else:
name = parts[0]
# Parse 'name arg, arg'
parts = name.split(None, 1)
name = parts[0]
signode += addnodes.desc_name(name, name)
if len(parts) == 2:
# Incoming parameters.
signode += nodes.Text(' ')
parse_params(parts[1], signode)
return name
def get_index_text(self, name):
return name
def setup(app):
app.add_object_type(directivename='jsxmacro',
rolename='jsxmacro',
indextemplate="pair: %s; jsxmacro",
ref_nodeclass=jsxmacro,
objname='React macro',
doc_field_types=[
TypedField('props',
label=_('Props'),
names=('prop', ),
typerolename='jsxmacro',
typenames=('proptype', 'type')),
])
app.add_node(jsxmacro,
html=(visit_react_macro_html, depart_react_macro_html))
app.add_object_type(directivename='component',
rolename='component',
indextemplate="pair: %s; component",
ref_nodeclass=react_component,
objname='Component',
doc_field_types=[
TypedField('props',
label=_('Props'),
names=('prop', ),
typerolename='component',
typenames=('proptype', 'type')),
])
app.add_node(react_component,
html=(visit_react_component_html,
depart_react_component_html))
app.add_object_type(directivename='jsmacro',
rolename='jsmacro',
indextemplate="pair: %s; jsmacro",
ref_nodeclass=jsmacro,
objname='JS Macro')
app.add_node(jsmacro, html=(visit_jsmacro_html, depart_jsmacro_html))
app.add_crossref_type('config', 'conf')
app.add_crossref_type('icu', 'icu')
app.add_object_type(
directivename="lingui-cli",
rolename="cli",
indextemplate="pair: %s; lingui-cli command",
parse_node=parse_lingui_cli_node,
)
app.add_directive('lingui-cli-option', Cmdoption)
class DmlFunction(DmlObject):
"""Description of a function."""
option_spec: OptionSpec = DmlObject.option_spec.copy()
option_spec.update({
'const': directives.flag,
'virtual': directives.flag,
})
doc_field_types = [
TypedField('parameter', label=_('Parameters'),
names=('param', 'parameter', 'arg', 'argument',
'keyword', 'kwarg', 'kwparam'),
typenames=('paramtype', 'type'),
can_collapse=True),
TypedField('result', label='Return',
names=('return', 'result'),
typenames=('returntype', 'resulttype')),
]
def split_signature(self, sig: str) -> Tuple[str, bool, str, List[str], str]:
# return tuple:
# - type (class, property, event, function) -> str
# - name -> str
# - arglist -> List[str]
# - annotations -> List[str]
typ = "function"
parts = sig.split("(")
name = parts[0]
parts = parts[1].split(")")
arglist = parts[0].split(",")
annotations = []
if 'const' in self.options:
annotations.append("constant")
if 'virtual' in self.options:
annotations.append("virtual")
return (typ, name, arglist, annotations)
def get_index_text(self, name_cls: Tuple[str, str]) -> str:
# add index in own add_target_and_index() instead.
return "FunctionName " + name_cls[0]
class AvroRecord(AvroObject):
prefix = 'record'
doc_field_types = [
TypedField('fields',
label=l_('Fields'),
names=('field', 'member'),
typenames=('type', ),
typerolename='record')
]
class ProtobufMessage(ProtobufObject):
prefix = 'message'
doc_field_types = [
TypedField('fields',
label=_('Fields'),
names=('field', 'member'),
typenames=('type', ),
typerolename='message')
]
class PSColumn(PSschemaObject):
doc_field_types = [
TypedField('coltype', label=_('Type'), rolename='obj',
names=('coltype', 'type'),
typerolename='obj', typenames=('paramtype', 'type')),
Field('inpatch', label=_('Included in Patch'), has_arg=False,
names=('inpatch')),
]
def setup(app):
from sphinx.util.docfields import TypedField
app.add_object_type('confval', 'confval',
objname='configuration value',
indextemplate='pair: %s; configuration value')
fdesc = TypedField('parameter', label='Parameters',
names=['param'], typenames=['type'], can_collapse=True)
app.add_object_type('event', 'event', 'pair: %s; event', parse_event,
doc_field_types=[fdesc])
class DexTable(PyClasslike):
"""The actual Sphinx documentation generation whatchamacallit
"""
doc_field_types = [
TypedField('field', label='Fields',
typerolename='obj', typenames=('fieldname', 'type')),
]
def get_signature_prefix(self, sig):
return ''
#return u'mapped class '
def run(self):
section = nodes.section()
super_result = super(DexTable, self).run()
title_text = self.names[0][0]
section += nodes.title(text=title_text)
section += super_result
section['ids'] = ['dex-table-%s' % title_text.lower()]
return [section]
def before_content(self):
name = self.names[0][0]
for cls in tables.mapped_classes:
if name == cls.__name__:
break
else:
raise ValueError('Table %s not found' % name)
table = cls.__table__
remaining_attrs = set(x for x in dir(cls) if not x.startswith('_'))
remaining_attrs.difference_update(['metadata', 'translation_classes',
'add_relationships', 'summary_column'])
for transl_class in cls.translation_classes:
remaining_attrs.difference_update([
transl_class.relation_name,
transl_class.relation_name + '_table',
transl_class.relation_name + '_local',
])
generated_content = [] # Just a list of lines!
generated_content.extend(generate_table_header(cls, remaining_attrs))
generated_content.extend(generate_common(cls, remaining_attrs))
generated_content.extend(generate_columns(cls, remaining_attrs))
generated_content.extend(generate_strings(cls, remaining_attrs))
generated_content.extend(generate_relationships(cls, remaining_attrs))
generated_content.extend(generate_associationproxies(cls, remaining_attrs))
generated_content.extend(generate_undocumented(cls, remaining_attrs))
generated_content.extend(generate_other(cls, remaining_attrs))
generated_content.append(u'')
self.content = ViewList(generated_content + list(self.content))
return super(DexTable, self).before_content()
def get_index_text(self, modname, name_cls):
return '%s (mapped class)' % name_cls[0]
class HTTPResource(ObjectDescription):
doc_field_types = [
TypedField('parameter',
label='Parameters',
names=('param', 'parameter', 'arg', 'argument'),
typerolename='obj',
typenames=('paramtype', 'type')),
GroupedField('queryparameter',
label='Query Parameters',
names=('queryparameter', 'queryparam', 'qparam',
'query')),
GroupedField('formparameter',
label='Form Parameters',
names=('formparameter', 'formparam', 'fparam', 'form')),
GroupedField('statuscode',
label='Status Codes',
rolename='statuscode',
names=('statuscode', 'status', 'code'))
]
method = NotImplemented
def handle_signature(self, sig, signode):
method = self.method.upper() + ' '
signode += addnodes.desc_name(method, method)
offset = 0
for match in http_sig_param_re.finditer(sig):
path = sig[offset:match.start()]
signode += addnodes.desc_name(path, path)
params = addnodes.desc_parameterlist()
typ = match.group('type')
if typ:
typ = typ + ': '
params += addnodes.desc_annotation(typ, typ)
name = match.group('name')
params += addnodes.desc_parameter(name, name)
signode += params
offset = match.end()
if offset < len(sig):
path = sig[offset:len(sig)]
signode += addnodes.desc_name(path, path)
fullname = self.method.upper() + ' ' + path
signode['method'] = self.method
signode['path'] = sig
signode['fullname'] = fullname
return (fullname, self.method, sig)
def needs_arglist(self):
return False
def add_target_and_index(self, name_cls, sig, signode):
signode['ids'].append(http_resource_anchor(*name_cls[1:]))
self.env.domaindata['http'][self.method][sig] = (self.env.docname, '')
def get_index_text(self, modname, name):
return ''
def get_doc_field_types(self):
return [
TypedField(self.field_name,
label=l_(self.field_label),
names=(self.field_name, ),
typerolename='msg',
typenames=('{0}-{1}'.format(self.field_name,
TYPE_SUFFIX), )),
TypedField(self.constant_name,
label=l_(self.constant_label),
names=(self.constant_name, ),
typerolename='msg',
typenames=('{0}-{1}'.format(self.constant_name,
TYPE_SUFFIX), )),
GroupedField('{0}-{1}'.format(self.constant_name, VALUE_SUFFIX),
label=l_('{0} (Value)'.format(self.constant_label)),
names=('{0}-{1}'.format(self.constant_name,
VALUE_SUFFIX), )),
]
class KOSMethod(KOSObject):
doc_field_types = [
Field('access', label=_('Access'), has_arg=False),
TypedField('parameter',
label=_('Parameters'),
names=('param', 'parameter', 'arg', 'argument'),
typerolename='obj',
typenames=('paramtype', 'type')),
Field('returnvalue',
label=_('Returns'),
has_arg=False,
names=('returns', 'return')),
Field('returntype',
label=_('Return type'),
has_arg=False,
names=('rtype', 'type')),
]
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 get_index_text(self, objectname, name):
return _('{}()'.format(name))
def __init__(self, *args, **kargs):
CPPDomain.__init__(self, *args, **kargs)
self.directives['function'].doc_field_types = [
TypedField('parameter', label=l_('Parameters'),
names=('param', 'parameter', 'arg', 'argument'),
typerolename='type', typenames=('type',)),
Field('returnvalue', label=l_('Returns'), has_arg=False,
names=('returns', 'return')),
Field('returntype', label=l_('Return type'), has_arg=False,
names=('rtype',)),
]
class PSTable(PSschemaObject):
doc_field_types = [
TypedField('column',
label=l_('Columns'),
rolename='obj',
names=('col', 'column', 'cols'),
typerolename='obj',
typenames=('paramtype', 'type')),
Field('inpatch',
label=l_('Included in Patch'),
has_arg=False,
names=('inpatch')),
TypedField('versioninfo',
label=l_('Version Info'),
rolename='obj',
names=('version', 'versioninfo'),
typerolename='obj',
typenames=('paramtype', 'type')),
]
class PSDatabase(PSschemaObject):
doc_field_types = [
TypedField('tbl', label=_('Tables'),
names=('tbl', 'table',),
typerolename='obj', typenames=('paramtype', 'type')),
Field('engine', label=_('Storage Engine'), has_arg=False,
names=('engine')),
Field('inpatch', label=_('Included in Patch'), has_arg=False,
names=('inpatch')),
]
class AvroRPCMessage(AvroObject):
doc_field_types = [
TypedField('arguments',
label=l_('Arguments'),
names=('argument', 'arg', 'param'),
typerolename='rpc'),
GroupedField('errors',
label=l_('Throws'),
names=('throws', 'throw'),
can_collapse=True),
Field('returntype', label=l_('Returns'), names=('returns', 'return'))
]
class LuaVarFunction(LuaObject):
typename = l_("varfunc")
doc_field_types = [
TypedField('parameter',
label=l_('Parameters'),
names=('param', 'parameter', 'arg', 'argument'),
typerolename='obj',
typenames=('paramtype', 'type', 'ptype')),
TypedField('returnvalues',
label=l_('Returns'),
names=('return', 'ret'),
typerolename='obj',
typenames=('rtype', 'type')),
Field('returnvalue',
label=l_('Returns'),
has_arg=False,
names=('returns')),
Field('returntype',
label=l_('Return type'),
has_arg=False,
names=('returntype', )),
]
lua_signature_re = re.compile(
r'''^ ([\w\.\:/\-]+[:.])? # class name(s)
([{|}<>\w/\-/.]+) \s* # thing name(s)
(?: ([({])(.*)([)}]))? # optional: arguments
(?:\s* -> \s* (.*))? # optional: return annotation
$ # and nothing more
''', re.VERBOSE)
def build_objtype(self):
return self.options.get('objtype') or ""
def needs_arglist(self):
return True
def get_index_name(self, names):
return '%s()' % (names['fullname'])
class DylanFunctionDesc (DylanBindingDesc):
"""A Dylan function, method, or generic function."""
doc_field_types = [
TypedField('parameters', label="Parameters",
names=('param', 'parameter')),
GroupedField('values', label="Values",
names=('value', 'val', 'retval', 'return')),
Field('signature', label="Signature", has_arg=False,
names=('sig', 'signature')),
Field('conditions', label="Conditions", has_arg=False,
names=('conditions', 'exceptions', 'signals', 'throws')),
] + DylanBindingDesc.doc_field_types
class JavaMethod(JavaObject):
doc_field_types = [
TypedField('parameter', label=l_('Parameters'),
names=('param', 'parameter', 'arg', 'argument'),
typerolename='type', typenames=('type',)),
Field('returnvalue', label=l_('Returns'), has_arg=False,
names=('returns', 'return')),
GroupedField('throws', names=('throws',), label=l_('Throws'), rolename='type')
]
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 get_index_text(self, package, type, name):
return _('%s (Java method)' % (name,))
class JSCallable(JSObject):
"""Description of a JavaScript function, method or constructor."""
has_arguments = True
doc_field_types = [
TypedField('arguments', label=l_('Arguments'),
names=('argument', 'arg', 'parameter', 'param'),
typerolename='func', typenames=('paramtype', 'type')),
GroupedField('errors', label=l_('Throws'), rolename='err',
names=('throws', ),
can_collapse=True),
Field('returnvalue', label=l_('Returns'), has_arg=False,
names=('returns', 'return')),
]
class JavaConstructor(JavaObject):
doc_field_types = [
TypedField(
'parameter',
label=_('Parameters'), # replaced the old "label=l_('Parameters')"
names=('param', 'parameter', 'arg', 'argument'),
typerolename='type',
typenames=('type', )),
GroupedField(
'throws',
names=('throws', ),
label=_('Throws') # replaced the old "label=l_('Throws')"
)
]
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 get_index_text(self, package, type, name):
return _('%s (Java constructor)' % (name, ))
class DMCallable(DMObject):
"""Description of a DM proc or verb."""
has_arguments = True
doc_field_types = [
TypedField('arguments',
label=l_('Arguments'),
names=('argument', 'arg', 'parameter', 'param'),
typerolename='proc',
typenames=('paramtype', 'type')),
Field('returnvalue',
label=l_('Returns'),
has_arg=False,
names=('returns', 'return')),
]
