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):
#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 _pseudo_parse_arglist(sig_node: addnodes.desc_signature, arg_list: str):
param_list = addnodes.desc_parameterlist()
stack = [param_list]
processed_args_list = []
try:
for argument in arg_list.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)
processed_args_list.append({"name": argument})
if ends_close > 0:
processed_args_list[-1]["optional"] = True
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
sig_node += addnodes.desc_parameterlist()
sig_node[-1] += addnodes.desc_parameter(arg_list, arg_list)
finally:
sig_node += param_list
return processed_args_list
def _pseudo_parse_arglist(signode, arglist):
# type: (addnodes.desc_signature, unicode) -> 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 _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 make_desc_parameters(params):
for p in params:
if '.' in p.name:
continue
node = addnodes.desc_parameter(p.name, p.name)
if p.optional:
node = addnodes.desc_optional('', '', node)
yield node
def make_desc_parameters(params):
for p in params:
if '.' in p.name:
continue
node = addnodes.desc_parameter(p.name, p.name)
if p.optional:
node = addnodes.desc_optional('', '', node)
yield node
def _pseudo_parse_arglist(signode, argstart, arglist, argend):
""""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 = _desc_parameterlist(argstart, argend)
stack = [paramlist]
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(']'):
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
signode += paramlist
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 _pseudo_parse_arglist(signode, argstart, arglist, argend):
""""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 = _desc_parameterlist(argstart, argend)
stack = [paramlist]
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(']'):
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
signode += paramlist
def _pseudo_parse_arglist(signode, arglist):
"""Parse list of comma separated arguments.
Arguments can have optional types.
"""
paramlist = addnodes.desc_parameterlist()
stack = [paramlist]
try:
for argument in arglist.split(','):
argument = argument.strip()
ends_open = 0
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.
signode += addnodes.desc_parameterlist()
signode[-1] += addnodes.desc_parameter(arglist, arglist)
else:
signode += paramlist
def _pseudo_parse_generic(signode, arglist, desc_listtype, desc_type):
# type: (addnodes.desc_signature, unicode) -> None
""" "Parse" a list of returns separated by commas.
"""
genericlist = desc_listtype()
stack = [genericlist]
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] += desc_type(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 returnlist node
signode += desc_listtype()
signode[-1] += desc_type(arglist, arglist)
else:
signode += genericlist
def handle_signature(self, sig: str,
sig_node: addnodes.desc_signature) -> str:
self.input_sig = sig
self.table_call = "table_call" in self.options
if self.table_call:
print(re.search(r'([A-Za-z_-]+)\b', sig).group(1))
self.obj_name = re.search(r'([A-Za-z_-]+)\b', sig).group(1)
self.register_signature(self.obj_name, sig)
sig_node += addnodes.desc_name(sig, sig)
else:
m = sig_re.match(sig)
if m is None:
raise ValueError
name, arg_list = m.groups()
if name is None:
raise ValueError
self.register_signature(name, sig)
sig_node += addnodes.desc_name(name, name)
self.parsed_args = _pseudo_parse_arglist(sig_node, arg_list)
self.obj_name = name
if "has_table_overload" in self.options:
sig_node += addnodes.desc_optional("has-table-overload",
"has-table-overload")
if self.table_call:
sig_node += addnodes.desc_optional("table_call", "table_call")
return sig
def _handle_function_signature(self, sig, signode):
# extract parts of the signature.
m = mat_func_sig_re.match(sig)
if m is None:
raise ValueError
retann, toolbox, name, arglist = m.groups()
# resolve full function name.
fullname = self._resolve_toolbox_name(signode, toolbox, name)
# handle (absence of) arguments list.
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 mat_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 = 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 _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 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 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):
m = http_method_sig_re.match(sig)
if m is None:
raise ValueError
verb, url, query = m.groups()
if verb is None:
verb = 'GET'
signode += addnodes.desc_addname(verb, verb)
signode += addnodes.desc_name(url, url)
if query:
params = query.strip().split()
for param in params:
signode += addnodes.desc_optional(param, param)
return url
def handle_signature(self, sig, signode):
symbol_name = []
package = self.env.temp_data.get('cl:package')
objtype = self.get_signature_prefix(sig)
sig_split = sig.split(" ")
sig = sig_split[0]
signode.append(addnodes.desc_annotation(objtype, objtype))
lisp_args = ARGS[package].get(sig.upper(), "")
function_name = addnodes.desc_name(sig, sig)
if not lisp_args.strip() and self.objtype in ["function"]:
lisp_args = "()"
if lisp_args.strip():
types = []
if self.objtype in ["method"]:
types = self.arguments[0].split(' ')[1:]
sexp = SEXP(lisp_args,
types=types,
show_defaults=self.env.app.config.cl_show_defaults)
arg_list = sexp.as_parameterlist(function_name)
signode.append(arg_list)
else:
signode.append(function_name)
# Add Slots
slots = SLOTS[package].get(sig.upper())
if slots and "noinitargs" not in self.options:
# TODO add slot details if describing a class
for slot in slots:
initarg = slot.get(u'initarg')
if initarg and initarg.lower() != 'nil':
slotarg = addnodes.literal_emphasis(
slot.get(u'name'), slot.get(u'name'))
slotsig = initarg.lower() + u' '
signode.append(
addnodes.desc_optional(slotsig, slotsig, slotarg))
symbol_name = sig
if not symbol_name:
raise Exception("Unknown symbol type for signature %s" % sig)
record_use(package, symbol_name, self.objtype)
return objtype.strip(), symbol_name
def _parse_parameter_list(params):
"""Parse a SpeedCrunch parameter list into nodes."""
paramlist = sc_parameterlist()
stack = deque([paramlist])
for param in params.split(';'):
param = param.strip()
if param and param[-1] in '[]':
p = param[:-1].strip()
stack[-1] += addnodes.desc_parameter(p, p)
else:
stack[-1] += addnodes.desc_parameter(param, param)
if param.endswith('['):
node = addnodes.desc_optional()
stack[-1] += node
stack.append(node)
elif param.endswith(']'):
stack.pop()
return paramlist
def _parse_parameter_list(params):
"""Parse a SpeedCrunch parameter list into nodes."""
paramlist = sc_parameterlist()
stack = deque([paramlist])
for param in params.split(';'):
param = param.strip()
if param and param[-1] in '[]':
p = param[:-1].strip()
stack[-1] += addnodes.desc_parameter(p, p)
else:
stack[-1] += addnodes.desc_parameter(param, param)
if param.endswith('['):
node = addnodes.desc_optional()
stack[-1] += node
stack.append(node)
elif param.endswith(']'):
stack.pop()
return paramlist
def format_response_class(self, response_class_name):
ret = n.container()
ret += addnodes.desc_returns(text=response_class_name)
model = self.models.get(response_class_name)
props = addnodes.desc_parameterlist()
for key, property in model['properties'].items():
pc = n.container()
if property['required']:
pc += addnodes.desc_parameter(key, key)
else:
pc += addnodes.desc_optional(key, key)
pc += n.strong(text=' type: %s ' % property['type'])
allowableValues = property.get('allowableValues')
if allowableValues:
allowableValues.pop('valueType', None)
pc += n.subscript(text=' %s' % allowableValues)
props += pc
ret += props
return ret
def format_response_class(self, response_class_name):
ret = n.container()
ret += addnodes.desc_returns(text=response_class_name)
model = self.models.get(response_class_name)
props = addnodes.desc_parameterlist()
for key, property in model["properties"].items():
pc = n.container()
if property["required"]:
pc += addnodes.desc_parameter(key, key)
else:
pc += addnodes.desc_optional(key, key)
pc += n.strong(text=" type: %s " % property["type"])
allowableValues = property.get("allowableValues")
if allowableValues:
allowableValues.pop("valueType", None)
pc += n.subscript(text=" %s" % allowableValues)
props += pc
ret += props
return ret
def handle_signature(self, sig, signode):
symbol_name = []
package = self.env.temp_data.get('cl:package')
objtype = self.get_signature_prefix(sig)
sig_split = sig.split(" ")
sig = sig_split[0]
signode.append(addnodes.desc_annotation(objtype, objtype))
lisp_args = ARGS[package].get(sig.upper(), "")
function_name = addnodes.desc_name(sig, sig)
if not lisp_args.strip() and self.objtype in ["function"]:
lisp_args = "()"
if lisp_args.strip():
types = []
if self.objtype in ["method"]:
types = self.arguments[0].split(' ')[1:]
sexp = SEXP(lisp_args,
types=types,
show_defaults=self.env.app.config.cl_show_defaults)
arg_list = sexp.as_parameterlist(function_name)
signode.append(arg_list)
else:
signode.append(function_name)
# Add Slots
slots = SLOTS[package].get(sig.upper())
if slots and "noinitargs" not in self.options:
# TODO add slot details if describing a class
for slot in slots:
initarg = slot.get(u'initarg')
if initarg and initarg.lower() != 'nil':
slotarg = addnodes.literal_emphasis(slot.get(u'name'), slot.get(u'name'))
slotsig = initarg.lower() + u' '
signode.append(addnodes.desc_optional(slotsig, slotsig, slotarg))
symbol_name = sig
if not symbol_name:
raise Exception("Unknown symbol type for signature %s" % sig)
record_use(package, symbol_name, self.objtype)
return objtype.strip(), symbol_name
def format_response_class(self, response_class_name):
ret = n.container()
ret += addnodes.desc_returns(text=response_class_name)
model = self.models.get(response_class_name)
props = addnodes.desc_parameterlist()
for key, property in model['properties'].items():
pc = n.container()
if property['required']:
pc += addnodes.desc_parameter(key, key)
else:
pc += addnodes.desc_optional(key, key)
pc += n.strong(text=' type: %s ' % property['type'])
allowableValues = property.get('allowableValues')
if allowableValues:
allowableValues.pop('valueType', None)
pc += n.subscript(text=' %s' % allowableValues)
props += pc
ret += props
return ret
def _construct_nodes(self, signode):
sigdata = self.erl_sigdata
env_object = self.erl_env_object
# emulate erlang directives, like '-type', '-record', etc.
if self.objtype not in ('function', 'clause'):
objtype_part = '-%s' % (self.objtype, )
signode += addnodes.desc_annotation(objtype_part, objtype_part)
signode += nodes.inline(' ', ' ')
modname_part = '%s:' % (sigdata.modname, )
signode += addnodes.desc_addname(modname_part, modname_part)
name_part = sigdata.to_desc_name()
signode += addnodes.desc_name(name_part, name_part)
if sigdata.arg_list is not None:
paramlist_node = addnodes.desc_parameterlist()
signode += paramlist_node
last_node = paramlist_node
for (req, txt) in sigdata.arg_list:
if req == 'mandatory':
last_node += addnodes.desc_parameter(txt, txt)
else:
opt = addnodes.desc_optional()
opt += addnodes.desc_parameter(txt, txt)
last_node += opt
last_node = opt
if sigdata.explicit_flavor:
flavor_text = ' @%s' % (sigdata.flavor, )
signode += nodes.inline(flavor_text, flavor_text)
if sigdata.when_text is not None:
when_text = ' when %s' % (sigdata.when_text, )
signode += nodes.emphasis(when_text, when_text)
if sigdata.ret_ann:
signode += addnodes.desc_returns(sigdata.ret_ann, sigdata.ret_ann)
def parse_arg(plist, e):
type_ = parser.ast_type(e)
if type_ == "list":
head = e and e[0]
mode = None
if head == "?":
paramlist = addnodes.desc_optional()
paramlist.child_text_separator = ' '
for arg in e[1:]:
parse_arg(paramlist, arg)
plist += paramlist
elif head == "<splice>":
print "YES"
for arg in e[1:]:
parse_arg(plist, arg)
elif head == "|":
for i, arg in enumerate(e[1:]):
if i > 0:
plist += addnodes.desc_parameter("|",
" | ",
noemph=True)
parse_arg(plist, arg)
else:
paramlist = addnodes.desc_parameterlist()
paramlist.child_text_separator = ' '
for arg in e:
parse_arg(paramlist, arg)
plist += paramlist
elif type_ == "symbol":
if e.startswith('_:'):
e = e[2:]
plist += addnodes.desc_name(e, " " + e + " ")
else:
plist += addnodes.desc_parameter(e, " " + e + " ")
else:
e = repr(e)
plist += addnodes.desc_parameter(e, e)
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', 'trait']:
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 parse_py_signature(signode, sig, desctype, module, env):
"""
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
classname, name, arglist, retann = m.groups()
if retann:
retann = u' \N{RIGHTWARDS ARROW} ' + retann.strip()[2:]
if env.currclass:
add_module = False
if classname and classname.startswith(env.currclass):
fullname = classname + name
# class name is given again in the signature
classname = classname[len(env.currclass):].lstrip('.')
elif classname:
# class name is given in the signature, but different
# (shouldn't happen)
fullname = env.currclass + '.' + classname + name
else:
# class name is not given in the signature
fullname = env.currclass + '.' + name
else:
add_module = True
fullname = classname and classname + name or name
if desctype == 'staticmethod':
signode += addnodes.desc_annotation('static ', 'static ')
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 env.config.add_module_names and \
module and module != 'exceptions':
nodetext = module + '.'
signode += addnodes.desc_addname(nodetext, nodetext)
signode += addnodes.desc_name(name, name)
if not arglist:
if desctype in ('function', 'method', 'staticmethod'):
# for callables, add an empty parameter list
signode += addnodes.desc_parameterlist()
if retann:
signode += addnodes.desc_type(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_type(retann, retann)
return fullname, classname
def parse_py_signature(signode, sig, desctype, module, env):
"""
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
classname, name, arglist, retann = m.groups()
if env.currclass:
add_module = False
if classname and classname.startswith(env.currclass):
fullname = classname + name
# class name is given again in the signature
classname = classname[len(env.currclass):].lstrip('.')
elif classname:
# class name is given in the signature, but different
# (shouldn't happen)
fullname = env.currclass + '.' + classname + name
else:
# class name is not given in the signature
fullname = env.currclass + '.' + name
else:
add_module = True
fullname = classname and classname + name or name
if desctype == 'staticmethod':
signode += addnodes.desc_annotation('static ', 'static ')
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 env.config.add_module_names and \
module and module != 'exceptions':
nodetext = module + '.'
signode += addnodes.desc_addname(nodetext, nodetext)
signode += addnodes.desc_name(name, name)
if not arglist:
if desctype in ('function', 'method', 'staticmethod'):
# for callables, add an empty parameter list
signode += addnodes.desc_parameterlist()
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:
retann = u' \N{RIGHTWARDS ARROW} ' + retann.strip()[2:]
signode += addnodes.desc_type(retann, retann)
return fullname, classname
def handle_signature(self, sig, signode):
"""
Transform a TCP/IP 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 = tcpip_sig_re.match(sig)
if m is None:
print 'FAILED', sig
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.temp_data.get('tcpip:module'))
classname = self.env.temp_data.get('tcpip: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.temp_data.get('tcpip:module'))
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, name_prefix
signode += addnodes.desc_parameterlist()
stack = [signode[-1]]
for token in tcpip_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 getArgLabel(Arg):
if 'default' in Arg:
return desc_optional('', '{}={}'.format(Arg['name'], getReadableValue(Arg['default'])))
else:
return (desc_parameter if not 'default' in Arg else desc_optional)('', Arg['name'])
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, 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 = kl_sig_re.match(sig)
if m is None:
raise ValueError
functype, retann, name_prefix, name, arglist = 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('kl:module'))
classname = self.env.temp_data.get('kl: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
signode += addnodes.desc_annotation(functype, functype)
if retann:
signode += addnodes.desc_annotation(retann, retann)
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('kl: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()
return fullname, name_prefix
signode += addnodes.desc_parameterlist()
stack = [signode[-1]]
for token in kl_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
return fullname, name_prefix
def getArgLabel(Arg):
if 'default' in Arg:
return desc_optional('', '{}={}'.format(Arg['name'], getReadableValue(Arg['default'])))
else:
return (desc_parameter if not 'default' in Arg else desc_optional)('', Arg['name'])
