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