def handle_signature(self, sig, signode): method = self.method.upper() + " " signode += addnodes.desc_name(method, method) offset = 0 path = None for match in http_sig_param_re.finditer(sig): path = sig[offset : match.start()] signode += addnodes.desc_name(path, path) params = addnodes.desc_parameterlist() typ = match.group("type") if typ: typ += ": " params += addnodes.desc_annotation(typ, typ) name = match.group("name") params += addnodes.desc_parameter(name, name) signode += params offset = match.end() if offset < len(sig): path = sig[offset : len(sig)] signode += addnodes.desc_name(path, path) if path is None: assert False, "no matches for sig: %s" % sig fullname = self.method.upper() + " " + path signode["method"] = self.method signode["path"] = sig signode["fullname"] = fullname return (fullname, self.method, sig)
def handle_signature(self, sig, signode): #synopsis = unicodedata.normalize('NFD', self.options.get('synopsis')) synopsis = self.options.get('synopsis') module = self.env.temp_data.get('nscp:module') fullname = 'TODO' if self.objtype == 'query': fullname = '%s.%s'%(module, sig) signode['fullname'] = fullname signode += addnodes.desc_addname(module, module) signode += addnodes.desc_name(sig, sig) signode += addnodes.desc_content('') signode += addnodes.compact_paragraph(synopsis, synopsis) elif self.objtype == 'option': command = self.env.temp_data.get('nscp:command') fullname = '%s.%s:%s'%(module, command, sig) signode['fullname'] = fullname ann = ' (%s, %s)'%(module, command) signode += addnodes.desc_name(sig, sig) signode += addnodes.desc_annotation(ann, ann) elif self.objtype == 'confpath': fullname = '%s:%s'%(module, sig) signode['fullname'] = fullname ann = ' (%s)'%(module) signode += addnodes.desc_name(sig, sig) signode += addnodes.desc_annotation(ann, ann) elif self.objtype == 'confkey': confpath = self.env.temp_data.get('nscp:confpath', '') fullname = '%s:%s:%s'%(module, confpath, sig) signode['fullname'] = fullname ann = ' (%s, %s)'%(module, confpath) signode += addnodes.desc_name(sig, sig) signode += addnodes.desc_annotation(ann, ann) #print 'handle_signature(%s, %s) => %s'%(sig, signode, fullname) return fullname, sig
def handle_signature(self, sig, signode): method = self.method.upper() + ' ' signode += addnodes.desc_name(method, method) offset = 0 path = None for match in http_sig_param_re.finditer(sig): path = sig[offset:match.start()] signode += addnodes.desc_name(path, path) params = addnodes.desc_parameterlist() typ = match.group('type') if typ: typ += ': ' params += addnodes.desc_annotation(typ, typ) name = match.group('name') params += addnodes.desc_parameter(name, name) signode += params offset = match.end() if offset < len(sig): path = sig[offset:len(sig)] signode += addnodes.desc_name(path, path) assert path is not None, 'no matches for sig: %s' % sig fullname = self.method.upper() + ' ' + path signode['method'] = self.method signode['path'] = sig signode['fullname'] = fullname return (fullname, self.method, sig)
def handle_signature(self, sig, signode): """Transform a C signature into RST nodes.""" # first try the function pointer signature regex, it's more specific m = c_funcptr_sig_re.match(sig) if m is None: m = c_sig_re.match(sig) if m is None: raise ValueError('no match') rettype, name, arglist, const = m.groups() signode += addnodes.desc_type('', '') self._parse_type(signode[-1], rettype) try: classname, funcname = name.split('::', 1) classname += '::' signode += addnodes.desc_addname(classname, classname) signode += addnodes.desc_name(funcname, funcname) # name (the full name) is still both parts except ValueError: signode += addnodes.desc_name(name, name) # clean up parentheses from canonical name m = c_funcptr_name_re.match(name) if m: name = m.group(1) typename = self.env.temp_data.get('c:type') if self.name == 'c:member' and typename: fullname = typename + '.' + name else: fullname = name if not arglist: if self.objtype == 'function': # for functions, add an empty parameter list signode += addnodes.desc_parameterlist() if const: signode += addnodes.desc_addname(const, const) return fullname paramlist = addnodes.desc_parameterlist() arglist = arglist.replace('`', '').replace('\\ ', '') # remove markup # this messes up function pointer types, but not too badly ;) args = arglist.split(',') for arg in args: arg = arg.strip() param = addnodes.desc_parameter('', '', noemph=True) try: ctype, argname = arg.rsplit(' ', 1) except ValueError: # no argument name given, only the type self._parse_type(param, arg) else: self._parse_type(param, ctype) # separate by non-breaking space in the output param += nodes.emphasis(' '+argname, u'\xa0'+argname) paramlist += param signode += paramlist if const: signode += addnodes.desc_addname(const, const) return fullname
def parse_django_adminopt_node(env, sig, signode): """A copy of sphinx.directives.CmdoptionDesc.parse_signature()""" from sphinx.domains.std import option_desc_re count = 0 firstname = '' for m in option_desc_re.finditer(sig): optname, args = m.groups() if count: signode += addnodes.desc_addname(', ', ', ') signode += addnodes.desc_name(optname, optname) signode += addnodes.desc_addname(args, args) if not count: firstname = optname count += 1 if not count: for m in simple_option_desc_re.finditer(sig): optname, args = m.groups() if count: signode += addnodes.desc_addname(', ', ', ') signode += addnodes.desc_name(optname, optname) signode += addnodes.desc_addname(args, args) if not count: firstname = optname count += 1 if not firstname: raise ValueError return firstname
def attach_function(self, node, func): owner, name = func.name.split_owner() # Olaf: Never show Class:: owner = None if owner is not None: owner = unicode(owner) + '::' node += addnodes.desc_addname(owner, owner) # cast operator is special. in this case the return value # is reversed. if isinstance(name, CastOpDefExpr): node += addnodes.desc_name('operator', 'operator') node += nodes.Text(u' ') self.attach_type(node, name.typename) else: funcname = unicode(name) node += addnodes.desc_name(funcname, funcname) paramlist = addnodes.desc_parameterlist() for arg in func.signature: param = addnodes.desc_parameter('', '', noemph=True) if arg.type is not None: self.attach_type(param, arg.type) param += nodes.Text(u' ') param += nodes.emphasis(unicode(arg.name), unicode(arg.name)) if arg.default is not None: def_ = u'=' + unicode(arg.default) param += nodes.emphasis(def_, def_) paramlist += param node += paramlist if func.const: node += addnodes.desc_addname(' const', ' const') if func.pure_virtual: node += addnodes.desc_addname(' = 0', ' = 0')
def parse_macro(env, sig, signode): #import rpdb2 ; rpdb2.start_embedded_debugger('foo') m = macro_sig_re.match(sig) if not m: signode += addnodes.desc_name(sig, sig) return sig name, args = m.groups() signode += addnodes.desc_name(name, name) plist = desc_cmake_argumentlist() for m in macro_param_re.finditer(args): arg = m.group(0) if arg.startswith('['): arg = arg[1:-1].strip() x = desc_cmake_argument() opt = addnodes.desc_optional() x += opt m = macro_param_re.match(arg) assert m is not None, "%s does not match %s" % (arg, macro_param_re.pattern) opt += _get_param_node(m) plist += x # elif arg.startswith('{') choice else: x = desc_cmake_argument() x += _get_param_node(m) plist += x signode += plist return name
def parse_macro(env, sig, signode): m = macro_sig_re.match(sig) if not m: signode += addnodes.desc_name(sig, sig) return sig name, args = m.groups() signode += addnodes.desc_name(name, name) plist = desc_cmake_argumentlist() for m in macro_param_re.finditer(args): arg = m.group(0) if arg.startswith('['): arg = arg[1:-1].strip() x = desc_cmake_argument() opt = addnodes.desc_optional() x += opt m = macro_param_re.match(arg) assert m is not None, "%s does not match %s" % (arg, macro_param_re.pattern) opt += _get_param_node(m, True) plist += x else: x = desc_cmake_argument() x += _get_param_node(m, False) plist += x signode += plist return name
def handle_signature(self, sig, signode): """ Transform a CFEngine 3 signature into RST nodes. """ sig_d = {} m = cf3_sig_re.match(sig) try: sig_d['type'], sig_d['ns'], sig_d['id'], sig_d['args'] = m.groups() except AttributeError: raise ValueError sig_d['ns'] = sig_d['ns'] or self.options.get( 'namespace', self.env.temp_data.get('cf3:namespace') ) fullname = [] fn_app = fullname.append fn_app(self.objtype + _FN_SEP) if self.objtype in ('body', 'bundle'): tnode = addnodes.desc_type('', '') tnode += nodes.Text(self.objtype + _SP, self.objtype) try: sig_d['type'] = sig_d['type'].strip() tnode += nodes.Text(sig_d['type'] + _SP, sig_d['type']) fn_app(sig_d['type'] + _FN_SEP) except AttributeError: self.state_machine.reporter.warning( 'invalid %s definition: %s' % (self.objtype, sig), line=self.lineno ) signode += tnode if sig_d['ns'] and sig_d['ns'] != 'default' \ and self.env.config.add_module_names: signode += addnodes.desc_addname( sig_d['ns'], sig_d['ns'] + _NS_SEP ) signode += addnodes.desc_name(sig_d['id'], sig_d['id']) fn_app(sig_d['id']) signode['namespace'] = sig_d['ns'] signode['fullname'] = ''.join(fullname) if self.objtype == 'class': signode += addnodes.desc_name(_CL_MRK, _CL_MRK) return ''.join(fullname), sig_d['ns'] if not sig_d['args'] and self.objtype == 'function': signode += addnodes.desc_parameterlist() return ''.join(fullname), sig_d['ns'] if sig_d['args']: paramlist = addnodes.desc_parameterlist() for arg in sig_d['args'].split(','): arg = arg.strip() paramlist += addnodes.desc_parameter(arg, arg) signode += paramlist return ''.join(fullname), sig_d['ns']
def handle_signature(self, sig, signode): method = self.method.upper() + ' ' signode += addnodes.desc_name(method, method) signode += addnodes.desc_name(sig, sig) fullname = "Template" + ' ' + sig signode['method'] = self.method signode['path'] = sig signode['fullname'] = fullname return (fullname, self.method, sig)
def handle_signature(self, sig, signode): symbol_name = [] def render_sexp(sexp, signode=None, prepend_node=None): desc_sexplist = addnodes.desc_parameterlist() desc_sexplist.child_text_separator = ' ' if prepend_node: desc_sexplist.append(prepend_node) if signode: signode.append(desc_sexplist) for atom in sexp: if isinstance(atom, list): render_sexp(atom, desc_sexplist) else: render_atom(atom, desc_sexplist) return desc_sexplist def render_atom(token, signode, noemph=True): "add syntax hi-lighting to interesting atoms" if token.startswith("&") or token.startswith(":"): signode.append(addnodes.desc_parameter(token, token)) else: signode.append(addnodes.desc_parameter(token, token)) package = self.env.temp_data.get('el:package') objtype = self.get_signature_prefix(sig) signode.append(addnodes.desc_annotation(objtype, objtype)) lisp_args = self.options.get('args', []) if not lisp_args: v = self.options.get('value') lisp_args = [v] if v else [] if not lisp_args: lisp_args = DATA_ARGS.get(package, {}).get(sig, []) if not lisp_args: v = DATA_VALUES.get(package, {}).get(sig) lisp_args = [quote_value_if_necessary(v)] if v else [] if lisp_args: function_name = addnodes.desc_name(sig, sig + " ") else: function_name = addnodes.desc_name(sig, sig) if lisp_args: arg_list = render_sexp(lisp_args, prepend_node=function_name) signode.append(arg_list) else: signode.append(function_name) symbol_name = sig if not symbol_name: raise Exception("Unknown symbol type for signature %s" % sig) return objtype.strip(), symbol_name
def parse_event(env, sig, signode): m = event_sig_re.match(sig) if not m: signode += addnodes.desc_name(sig, sig) return sig name, args = m.groups() signode += addnodes.desc_name(name, name) plist = addnodes.desc_parameterlist() for arg in args.split(','): arg = arg.strip() plist += addnodes.desc_parameter(arg, arg) signode += plist return name
def p_method_parts(p): '''method : returnval WORD | returnval WORD COLON parameters''' if (len(p) == 5): p[0] = p[1] p[0] += nodes.Text(u' ') p[0] += addnodes.desc_name(p[2], p[2]) p[0] += addnodes.desc_annotation(p[3], p[3]) p[0] += p[4] else: p[0] = p[1] p[0] += nodes.Text(u' ') p[0] += addnodes.desc_name(p[2], p[2])
def parse_ystaticattr(env,attr,attrnode): m=re.match(r'([a-zA-Z0-9_]+)\.(.*)\(=(.*)\)',attr) if not m: print 100*'@'+' Static attribute %s not matched'%attr attrnode+=addnodes.desc_name(attr,attr) klass,name,default=m.groups() #attrnode+=addnodes.desc_type('static','static') attrnode+=addnodes.desc_name(name,name) plist=addnodes.desc_parameterlist() if default=='': default='unspecified' plist+=addnodes.desc_parameter('='+default,'='+default) attrnode+=plist attrnode+=addnodes.desc_annotation(' [static]',' [static]') return klass+'.'+name
def parse_directive(env, sig, signode): if not sig.startswith('.'): dec_sig = '.. %s::' % sig signode += addnodes.desc_name(dec_sig, dec_sig) return sig m = dir_sig_re.match(sig) if not m: signode += addnodes.desc_name(sig, sig) return sig name, args = m.groups() dec_name = '.. %s::' % name signode += addnodes.desc_name(dec_name, dec_name) signode += addnodes.desc_addname(args, args) return name
def parse_c_signature(signode, sig, desctype): """Transform a C (or C++) signature into RST nodes.""" # first try the function pointer signature regex, it's more specific m = c_funcptr_sig_re.match(sig) if m is None: m = c_sig_re.match(sig) if m is None: raise ValueError('no match') rettype, name, arglist, const = m.groups() signode += addnodes.desc_type('', '') parse_c_type(signode[-1], rettype) try: classname, funcname = name.split('::', 1) classname += '::' signode += addnodes.desc_addname(classname, classname) signode += addnodes.desc_name(funcname, funcname) # name (the full name) is still both parts except ValueError: signode += addnodes.desc_name(name, name) # clean up parentheses from canonical name m = c_funcptr_name_re.match(name) if m: name = m.group(1) if not arglist: if desctype == 'cfunction': # for functions, add an empty parameter list signode += addnodes.desc_parameterlist() return name paramlist = addnodes.desc_parameterlist() arglist = arglist.replace('`', '').replace('\\ ', '') # remove markup # this messes up function pointer types, but not too badly ;) args = arglist.split(',') for arg in args: arg = arg.strip() param = addnodes.desc_parameter('', '', noemph=True) try: ctype, argname = arg.rsplit(' ', 1) except ValueError: # no argument name given, only the type parse_c_type(param, arg) else: parse_c_type(param, ctype) param += nodes.emphasis(' '+argname, ' '+argname) paramlist += param signode += paramlist if const: signode += addnodes.desc_addname(const, const) return name
def handle_signature(self, sig, signode): symbol_name = [] type = [] def render_sexp(sexp, signode=None, prepend_node=None): desc_sexplist = addnodes.desc_parameterlist() desc_sexplist.child_text_separator = ' ' if prepend_node: desc_sexplist.append(prepend_node) if signode: signode.append(desc_sexplist) symbol = False for atom in sexp: if isinstance(atom, list): render_sexp(atom, desc_sexplist) else: symbol = render_atom(atom, desc_sexplist) return desc_sexplist def render_atom(token, signode, noemph=True): "add syntax hi-lighting to interesting atoms" if token.startswith("&") or token.startswith(":"): signode.append(addnodes.desc_parameter(token, token)) else: signode.append(addnodes.desc_parameter(token, token)) package = self.env.temp_data.get('cl:package') objtype = self.get_signature_prefix(sig) signode.append(addnodes.desc_annotation(objtype, objtype)) lisp_args = args[package].get(sig.upper(), "") if lisp_args.strip(): function_name = addnodes.desc_name(sig, sig + " ") else: function_name = addnodes.desc_name(sig, sig) if not lisp_args.strip() and self.objtype in ["function"]: lisp_args = "()" if lisp_args.strip(): arg_list = render_sexp(_read(lisp_args), prepend_node=function_name) signode.append(arg_list) else: signode.append(function_name) symbol_name = sig if not symbol_name: raise Exception("Unknown symbol type for signature %s" % sig) return objtype.strip(), symbol_name.upper()
def parse_ystaticattr(env, attr, attrnode): m = re.match(r"([a-zA-Z0-9_]+)\.(.*)\(=(.*)\)", attr) if not m: print 100 * "@" + " Static attribute %s not matched" % attr attrnode += addnodes.desc_name(attr, attr) klass, name, default = m.groups() # attrnode+=addnodes.desc_type('static','static') attrnode += addnodes.desc_name(name, name) plist = addnodes.desc_parameterlist() if default == "": default = "unspecified" plist += addnodes.desc_parameter("=" + default, "=" + default) attrnode += plist attrnode += addnodes.desc_annotation(" [static]", " [static]") return klass + "." + name
def handle_signature(self, sig, signode): """Transform an option description into RST nodes.""" count = 0 firstname = '' for potential_option in sig.split(', '): potential_option = potential_option.strip() m = option_desc_re.match(potential_option) if not m: self.env.warn( self.env.docname, 'Malformed option description %r, should ' 'look like "opt", "-opt args", "--opt args", ' '"/opt args" or "+opt args"' % potential_option, self.lineno) continue optname, args = m.groups() if count: signode += addnodes.desc_addname(', ', ', ') signode += addnodes.desc_name(optname, optname) signode += addnodes.desc_addname(args, args) if not count: firstname = optname signode['allnames'] = [optname] else: signode['allnames'].append(optname) count += 1 if not firstname: raise ValueError return firstname
def handle_signature(self, sig, signode): cache = _APP_CACHES.get(self.env.app, {}) key = CursorKind.MACRO_DEFINITION, (sig, ) if key in cache: node, comment, start, end, _ = cache[key] signode += addnodes.desc_name(node.displayname, node.displayname) # There is unfortunately no API to get the parameters of a macro, # so we identify them by looking at the tokens. tokens = list(node.get_tokens()) if ( tokens[1].kind is TokenKind.PUNCTUATION and tokens[1].spelling == '(' ): paramlist = addnodes.desc_parameterlist() for token in tokens[2:]: if ( token.kind is TokenKind.PUNCTUATION and token.spelling == ')' ): break elif token.kind is TokenKind.IDENTIFIER: paramlist += addnodes.desc_parameter(token.spelling, token.spelling) signode += paramlist self.content = ViewList() for lineno, line in enumerate(comment.splitlines(), start[0]): self.content.append(line, '<unknown>', lineno) return sig
def run(self): #no good # node = nodes.paragraph('', 'Hi there!', # ids=['foo'], # names = ['foobar'] # ) #works # node = nodes.section(names=['foobar']) # self.state.document.note_explicit_target(node) # node.append(nodes.paragraph('', "foo foo")) #no good # node = nodes.admonition(names=['foobar']) # self.state.document.note_explicit_target(node) # node.append(nodes.paragraph('', "foo foo")) # node = nodes.paragraph('', 'foo foo', names=['foobar']) # self.state.document.note_explicit_target(node) #This doesn't properly render desc = addnodes.desc('', addnodes.desc_signature('', addnodes.desc_name('', 'namename'), addnodes.desc_parameterlist('', addnodes.desc_parameter('', 'def') ), names=['namename'], fullname="namename", ids=['namename'], module=None, first=False), desctype="function", domain="py", objtype='objtype') #no link (because didn't properly render?) self.state.document.note_explicit_target(desc) return [desc]
def handle_signature(self, sig, signode, display_text=None): """This method determines the appearance of the object. Overloaded Args: display_test: Used for overriding the object name. """ # Override sig with display_text if provided. if display_text is None: display_text = sig display_text, argument, alt_forms = self.process_name(display_text) # Add a label before the name of the object. signode += addnodes.desc_annotation(*('%s ' % self.LABEL,) * 2) # Add the object name. signode += addnodes.desc_name(sig, display_text) # Add arguments. if argument: argument = '%s %s' % (self.ARGUMENT_SEPARATOR, argument) signode += addnodes.desc_annotation(argument, argument) # Add alternate object names. if alt_forms: signode += addnodes.desc_annotation( *(self.ALT_FORM_TEMPLATE % (', '.join(alt_forms)),) * 2) signode['fullname'] = sig return (sig, self.NAME, sig)
def attach_name(self, node, name): owner, name = name.split_owner() varname = unicode(name) if owner is not None: owner = unicode(owner) + '::' node += addnodes.desc_addname(owner, owner) node += addnodes.desc_name(varname, varname)
def parse_django_adminopt_node(env, sig, signode): """A copy of sphinx.directives.CmdoptionDesc.parse_signature()""" option_desc_re = None # Sphinx >= 1.0 and Sphinx < 1.0, respectively. for module in ['sphinx.domains.std', 'sphinx.directives.desc']: try: mod = import_module(module) option_desc_re = mod.option_desc_re except ImportError: pass else: break count = 0 firstname = '' for m in option_desc_re.finditer(sig): optname, args = m.groups() if count: signode += addnodes.desc_addname(', ', ', ') signode += addnodes.desc_name(optname, optname) signode += addnodes.desc_addname(args, args) if not count: firstname = optname count += 1 if not firstname: raise ValueError return firstname
def handle_signature(self, sig, signode): try: tag, name = sig.split() except ValueError: tag, name = None, sig cache = _APP_CACHES.get(self.env.app, {}) key = {'struct': CursorKind.STRUCT_DECL}[tag], (name, ) if key in cache: node, comment, start, end, members = cache[key] signode += addnodes.desc_type(tag, tag + ' ') signode += addnodes.desc_name(node.spelling, node.spelling) self.content = ViewList() for line in comment.splitlines(): self.content.append(line, '<unknown>') self.content.append('', '<unknown>') for (_, member_name), value in members.items(): member_node, member_comment, _, _, _ = value self.content.append( '.. c:member:: %s %s' % (member_node.type.spelling, member_node.spelling), '<unknown>' ) self.content.append('', '<unknown>') for line in member_comment.splitlines(): self.content.append(' ' + line, '<unknown>') self.content.append('', '<unknown>') return sig
def handle_signature(self, sig: str, signode: addnodes.desc) -> str: """Transform signature into RST nodes""" signode += addnodes.desc_annotation(self.typename, self.typename + " ") signode += addnodes.desc_name(sig, sig) if 'badges' in self.options: badges = addnodes.desc_annotation() badges['classes'] += ['badges'] content = StringList([self.options['badges']]) self.state.nested_parse(content, 0, badges) signode += badges if 'replaces_section_title' in self.options: section = self.state.parent if isinstance(section, nodes.section): title = section[-1] if isinstance(title, nodes.title): section.remove(title) else: signode += self.state.document.reporter.warning( "%s:%s:: must follow section directly to replace section title" % (self.domain, self.objtype), line = self.lineno ) else: signode += self.state.document.reporter.warning( "%s:%s:: must be in section to replace section title" % (self.domain, self.objtype), line = self.lineno ) return sig
def handle_constructor_signature(self, sig, signode): try: member = javalang.parse.parse_constructor_signature(sig) except javalang.parser.JavaSyntaxError: raise self.error("syntax error in constructor signature") if not isinstance(member, javalang.tree.ConstructorDeclaration): raise self.error("expected constructor declaration") mods = formatter.output_modifiers(member.modifiers).build() signode += nodes.Text(mods + ' ', mods + ' ') signode += addnodes.desc_name(member.name, member.name) paramlist = addnodes.desc_parameterlist() for parameter in member.parameters: param = addnodes.desc_parameter('', '', noemph=True) param += self._build_type_node(parameter.type) if parameter.varargs: param += nodes.Text('...', '') param += nodes.emphasis(' ' + parameter.name, ' ' + parameter.name) paramlist += param signode += paramlist param_reprs = [formatter.output_type(param.type, with_generics=False).build() for param in member.parameters] return '%s(%s)' % (member.name, ', '.join(param_reprs))
def handle_signature(self, sig, signode): name, args = parse_directive(sig) desc_name = '.. %s::' % name signode += addnodes.desc_name(desc_name, desc_name) if len(args) > 0: signode += addnodes.desc_addname(args, args) return name
def handle_field_signature(self, sig, signode): try: member = javalang.parse.parse_member_signature(sig) except javalang.parser.JavaSyntaxError: raise self.error("syntax error in field signature") if not isinstance(member, javalang.tree.FieldDeclaration): raise self.error("expected field declaration") mods = formatter.output_modifiers(member.modifiers).build() signode += nodes.Text(mods + ' ', mods + ' ') tnode = addnodes.desc_type('', '') tnode += self._build_type_node(member.type) signode += tnode signode += nodes.Text(' ', ' ') if len(member.declarators) > 1: self.error('only one field may be documented at a time') declarator = member.declarators[0] signode += addnodes.desc_name(declarator.name, declarator.name) dim = '[]' * len(declarator.dimensions) signode += nodes.Text(dim) if declarator.initializer and isinstance(declarator.initializer, javalang.tree.Literal): signode += nodes.Text(' = ' + declarator.initializer.value) return declarator.name
def run(self): """Run this directive. In addition to the normal processing of the :class:`EmacsLispSymbol` directive, also prepend an additional signature that describes the keybinding of the documented command, if any. """ result_nodes = EmacsLispSymbol.run(self) # Insert a dedicated signature for the key binding before all other # signatures, but only for commands. Nothing else has key bindings. binding = self.options.get('binding') if binding: binding = self.with_prefix_arg(binding) desc_node = result_nodes[-1] assert isinstance(desc_node, addnodes.desc) signode = addnodes.desc_signature(binding, '') # No clue what this property is for, but ObjectDescription sets it # for its signatures, so we should do as well for our signature. signode['first'] = False desc_node.insert(0, signode) signode += addnodes.desc_name(binding, binding) return result_nodes
def handle_signature(self, sig, signode): """Transform a C signature into RST nodes.""" # first try the function pointer signature regex, it's more specific m = c_funcptr_sig_re.match(sig) if m is None: m = c_sig_re.match(sig) if m is None: raise ValueError('no match') rettype, name, arglist, const = m.groups() signode += addnodes.desc_type('', '') self._parse_type(signode[-1], rettype) try: classname, funcname = name.split('::', 1) classname += '::' signode += addnodes.desc_addname(classname, classname) signode += addnodes.desc_name(funcname, funcname) # name (the full name) is still both parts except ValueError: signode += addnodes.desc_name(name, name) # clean up parentheses from canonical name m = c_funcptr_name_re.match(name) if m: name = m.group(1) typename = self.env.ref_context.get('c:type') if self.name == 'c:member' and typename: fullname = typename + '.' + name else: fullname = name if not arglist: if self.objtype == 'function': # for functions, add an empty parameter list signode += addnodes.desc_parameterlist() if const: signode += addnodes.desc_addname(const, const) return fullname paramlist = addnodes.desc_parameterlist() arglist = arglist.replace('`', '').replace('\\ ', '') # remove markup # this messes up function pointer types, but not too badly ;) for arg in self._parse_arglist(arglist): arg = arg.strip() param = addnodes.desc_parameter('', '', noemph=True) try: m = c_funcptr_arg_sig_re.match(arg) if m: self._parse_type(param, m.group(1) + '(') param += nodes.emphasis(m.group(2), m.group(2)) self._parse_type(param, ')(' + m.group(3) + ')') if m.group(4): param += addnodes.desc_addname(m.group(4), m.group(4)) else: ctype, argname = arg.rsplit(' ', 1) self._parse_type(param, ctype) # separate by non-breaking space in the output param += nodes.emphasis(' ' + argname, u'\xa0' + argname) except ValueError: # no argument name given, only the type self._parse_type(param, arg) paramlist += param signode += paramlist if const: signode += addnodes.desc_addname(const, const) return fullname
def handle_signature(self, sig, signode): """ Transform a PHP signature into RST nodes. Returns (fully qualified name of the thing, classname if any). If inside a class, the current class name is handled intelligently: * it is stripped from the displayed name if present * it is added to the full name (return value) if not present """ m = php_sig_re.match(sig) if m is None: raise ValueError name_prefix, name, arglist, retann = m.groups() if not name_prefix: name_prefix = "" # determine module and class name (if applicable), as well as full name modname = self.options.get( 'namespace', self.env.temp_data.get('php:namespace')) classname = self.env.temp_data.get('php:class') separator = separators[self.objtype] if self.objtype == 'global' or self.objtype == 'function': add_module = False modname = None classname = None fullname = name else: add_module = True # name_prefix and a non-static method, means the classname was # repeated. Trim off the <class>:: if name_prefix and self.objtype != 'staticmethod': if name_prefix.startswith(classname): name_prefix = name_prefix[len(classname):].rstrip('::') classname = classname.rstrip('::') fullname = name_prefix + classname + separator + name elif name_prefix: classname = classname.rstrip('::') fullname = name_prefix + name # Currently in a class, but not creating another class, elif classname and not self.objtype in ['class', 'exception', 'interface']: if not self.env.temp_data['php:in_class']: name_prefix = classname + separator fullname = classname + separator + name else: classname = '' fullname = name signode['namespace'] = modname signode['class'] = self.class_name = classname signode['fullname'] = fullname sig_prefix = self.get_signature_prefix(sig) if sig_prefix: signode += addnodes.desc_annotation(sig_prefix, sig_prefix) if name_prefix: if modname and not self.env.temp_data['php:in_class']: name_prefix = modname + NS + name_prefix signode += addnodes.desc_addname(name_prefix, name_prefix) elif add_module and self.env.config.add_module_names: if self.objtype == 'global': nodetext = '' signode += addnodes.desc_addname(nodetext, nodetext) else: modname = self.options.get( 'namespace', self.env.temp_data.get('php:namespace')) if modname and not self.env.temp_data.get('php:in_class', False): nodetext = modname + NS signode += addnodes.desc_addname(nodetext, nodetext) signode += addnodes.desc_name(name, name) if not arglist: if self.needs_arglist(): # for callables, add an empty parameter list signode += addnodes.desc_parameterlist() if retann: signode += addnodes.desc_returns(retann, retann) return fullname, name_prefix signode += addnodes.desc_parameterlist() stack = [signode[-1]] for token in php_paramlist_re.split(arglist): if token == '[': opt = addnodes.desc_optional() stack[-1] += opt stack.append(opt) elif token == ']': try: stack.pop() except IndexError: raise ValueError elif not token or token == ',' or token.isspace(): pass else: token = token.strip() stack[-1] += addnodes.desc_parameter(token, token) if len(stack) != 1: raise ValueError if retann: signode += addnodes.desc_returns(retann, retann) return fullname, name_prefix
def handle_signature(self, sig, signode): container_class_name = self.env.temp_data.get('swift:class') container_class_type = self.env.temp_data.get('swift:class_type') # split into method name and rest first_anglebracket = sig.find('<') first_paren = sig.find('(') if first_anglebracket >= 0 and first_paren > first_anglebracket: split_point = sig.find('>') + 1 else: split_point = first_paren # calculate generics if first_anglebracket >= 0: sp = sig[first_anglebracket:] np = sp.find('>') generics = sp[:np + 1] else: generics = None method_name = sig[0:split_point] # find method specialization angle_bracket = method_name.find('<') if angle_bracket >= 0: method_name = method_name[:angle_bracket] rest = sig[split_point:] # split parameter list parameter_list = None depth = 0 for i, c in enumerate(rest): if c == '(': depth += 1 elif c == ')': depth -= 1 if depth == 0: parameter_list = rest[1:i] rest = rest[i + 1:] break if parameter_list is not None and len(parameter_list) > 0: parameters = self._parse_parameter_list(parameter_list) else: parameters = [] # check if it throws throws = rest.find('throws') >= 0 # check for return type return_type = None arrow = rest.find('->') if arrow >= 0: return_type = rest[arrow + 2:].strip() # build signature and add nodes signature = '' if self.objtype == 'static_method': signode += addnodes.desc_addname("static", "static func ") elif self.objtype == 'class_method': signode += addnodes.desc_addname("class", "class func ") elif self.objtype != 'init': signode += addnodes.desc_addname("func", "func ") if self.objtype == 'init': signode += addnodes.desc_name('init', 'init') signature += 'init(' for p in parameters: if p['name'] == p['variable_name']: signature += p['name'] + ':' else: signature += p['name'] + ' ' + p['variable_name'] + ':' signature += ')' else: signode += addnodes.desc_name(method_name, method_name) signature += method_name signature += '(' for p in parameters: if p['name'] == p['variable_name']: signature += p['name'] + ':' else: signature += p['name'] + ' ' + p['variable_name'] + ':' signature += ')' if generics: signode += addnodes.desc_addname(generics, generics) params = [] sig = '' for p in parameters: if p['name'] == p['variable_name']: param = p['name'] + ': ' # + p['type'] sig += p['name'] + ':' else: param = p['name'] + ' ' + p[ 'variable_name'] + ':' # + p['type'] sig += p['name'] + ' ' + p['variable_name'] + ':' #if p['default']: # param += ' = ' + p['default'] paramNode = addnodes.desc_parameter(param, param) paramXref = addnodes.pending_xref('', refdomain='swift', reftype='type', reftarget=p['type']) paramXref += nodes.Text(p['type'], p['type']) paramNode += paramXref if p['default']: paramNode += nodes.Text(' = ' + p['default'], ' = ' + p['default']) params.append(paramNode) signode += addnodes.desc_parameterlist(sig, "", *params) title = signature if throws: signode += addnodes.desc_annotation("throws", "throws") # signature += "throws" if return_type: paramNode = addnodes.desc_returns('', '') paramXref = addnodes.pending_xref('', refdomain='swift', reftype='type', reftarget=return_type) paramXref += nodes.Text(return_type, return_type) paramNode += paramXref signode += paramNode # signode += addnodes.desc_returns(return_type, return_type) #signature += "-" + return_type #if container_class_type == 'protocol': # signature += "-protocol" #if self.objtype == 'static_method': # signature += '-static' #elif self.objtype == 'class_method': # signature += '-class' if container_class_name: return (container_class_name + '.' + title), (container_class_name + '.' + signature), True return title, signature, True
def handle_signature(self, sig, signode): """Transform a PSschema signature into RST nodes.""" # first try the function pointer signature regex, it's more specific name = sig signode += addnodes.desc_name('', '') objectname = self.env.temp_data.get('psdom:object') ot = self.objtype ws = wsplit_re.split(sig) if ot == 'db': sig_prefix = "database " else: sig_prefix = ot + " " signode += addnodes.desc_annotation(sig_prefix, sig_prefix) # for part in filter(None, ws): # tnode = nodes.Text(part, part) # pnode = addnodes.pending_xref( # '', refdomain='psdom', reftype='type', reftarget=part, # modname=None, classname=None) # pnode = tnode # signode += pnode if len(ws) > 2: dbname, tablename, columnname = ws name = columnname fullname = tablename + "." + columnname elif len(ws) == 2: if ot == 'table': dbname, tablename = ws dbname += "." name = tablename signode['table'] = tablename signode += addnodes.desc_addname(dbname, dbname) signode += addnodes.desc_name(tablename, tablename) # fullname = dbname + "." + tablename fullname = tablename if ot == 'column': tablename, columnname = ws tablename += " " signode += addnodes.desc_addname(tablename, tablename) signode += addnodes.desc_name(columnname, columnname) signode['table'] = tablename fullname = tablename + "." + columnname else: if ot == 'table': tablename = ws[0] signode['table'] = tablename dbname = self.options.get( 'db', self.env.temp_data.get('psdom:db')) dbname += "." self.env.temp_data['psdom:table'] = tablename signode += addnodes.desc_addname(dbname, dbname) signode += addnodes.desc_name(tablename, tablename) signode['table'] = tablename if ot == 'column': columnname = ws[0] signode['column'] = columnname tablename = self.options.get( 'table', self.env.temp_data.get('psdom:table')) tablename += "." signode += addnodes.desc_addname(tablename, tablename) signode += addnodes.desc_name(columnname, columnname) if ot == 'db': dbname = ws[0] signode['db'] = dbname name = dbname self.env.temp_data['psdom:db'] = dbname signode += addnodes.desc_name(dbname, dbname) fullname = ws[0] signode['fullname'] = fullname return fullname
def handle_signature(self, sig, signode): # called from sphinx.directives.ObjectDescription.run() signode += addnodes.desc_name(sig, sig) return sig
def parse_django_admin_node(env, sig, signode): command = sig.split(' ')[0] env._django_curr_admin_command = command title = "django-admin.py %s" % sig signode += addnodes.desc_name(title, title) return sig
def handle_signature(self, sig, signode): signode += addnodes.desc_name(sig, sig) return sig
def handle_signature(self, sig, signode): # type: (unicode, addnodes.desc_signature) -> Tuple[unicode, unicode] """Transform a Python signature into RST nodes. Return (fully qualified name of the thing, classname if any). If inside a class, the current class name is handled intelligently: * it is stripped from the displayed name if present * it is added to the full name (return value) if not present """ m = py_sig_re.match(sig) # type: ignore if m is None: raise ValueError name_prefix, name, arglist, retann = m.groups() # determine module and class name (if applicable), as well as full name modname = self.options.get('module', self.env.ref_context.get('py:module')) classname = self.env.ref_context.get('py:class') if classname: add_module = False if name_prefix and name_prefix.startswith(classname): fullname = name_prefix + name # class name is given again in the signature name_prefix = name_prefix[len(classname):].lstrip('.') elif name_prefix: # class name is given in the signature, but different # (shouldn't happen) fullname = classname + '.' + name_prefix + name else: # class name is not given in the signature fullname = classname + '.' + name else: add_module = True if name_prefix: classname = name_prefix.rstrip('.') fullname = name_prefix + name else: classname = '' fullname = name signode['module'] = modname signode['class'] = classname signode['fullname'] = fullname sig_prefix = self.get_signature_prefix(sig) if sig_prefix: signode += addnodes.desc_annotation(sig_prefix, sig_prefix) if name_prefix: signode += addnodes.desc_addname(name_prefix, name_prefix) # exceptions are a special case, since they are documented in the # 'exceptions' module. elif add_module and self.env.config.add_module_names: modname = self.options.get('module', self.env.ref_context.get('py:module')) if modname and modname != 'exceptions': nodetext = modname + '.' signode += addnodes.desc_addname(nodetext, nodetext) anno = self.options.get('annotation') signode += addnodes.desc_name(name, name) if not arglist: if self.needs_arglist(): # for callables, add an empty parameter list signode += addnodes.desc_parameterlist() if retann: signode += addnodes.desc_returns(retann, retann) if anno: signode += addnodes.desc_annotation(' ' + anno, ' ' + anno) return fullname, name_prefix _pseudo_parse_arglist(signode, arglist) if retann: signode += addnodes.desc_returns(retann, retann) if anno: signode += addnodes.desc_annotation(' ' + anno, ' ' + anno) return fullname, name_prefix
def _render_signature(self, signature, signode): position = self.state_machine.get_source_and_line(self.lineno) tacn_node = parse_notation(signature, *position) signode += addnodes.desc_name(signature, '', tacn_node)
def handle_signature(self, sig, signode): """ Transform a Bazel signature into RST nodes. :param sig: :param signode: :return: """ m = bzl_sig_re.match(sig) if m is None: logger.error( "Sphinx-Bazel: Parse problems with signature: {}".format(sig)) raise ValueError package, after_package, target, after_target, internal, after_internal, attribute = m.groups( ) # Let's see if we have to use a specific workspace path or if we have to use the latest defined workspace self.specific_workspace_path = self.options.get('path', None) if self.specific_workspace_path: signode['workspace'] = self.specific_workspace_path else: try: signode['workspace'] = self.env.ref_context['bazel:workspace'] except KeyError: logger.error( "No workspace defined before given {} on page {} line {}". format(self.name, self.state.document.current_source, self.state.document.current_line)) signode['package'] = package signode['target'] = target sig_type = 'package' sig_text = '//{}'.format(package) if target: sig_text += ':{}'.format(target) sig_type = 'target' if internal: sig_text += ':{}'.format(internal) sig_type = self.objtype if attribute: sig_text += ':{}'.format(attribute) sig_type = 'attribute' if self.options.get('show_type', False) is None: sig_type_string = sig_type + ': ' signode += addnodes.desc_name(sig_type_string, sig_type_string, classes=['bazel', 'type', sig_type]) signode += addnodes.desc_name(sig_text, sig_text) if self.options.get('show_workspace', False) is None: # if flag is set, value is None ws_string = 'workspace: {}'.format(signode['workspace']) self._add_signature_detail(signode, ws_string) if self.options.get('show_workspace_path', False) is None: # if flag is set, value is None # If no extra workspace path was defined via :path: if self.specific_workspace_path is None: # Get the path of the current/latest workspace current_ws = self.env.ref_context['bazel:workspace'] ws_obj = self.env.domaindata['bazel']['workspaces'][current_ws] ws_path = ws_obj[ 1] # See workspace.py for details about stored data else: ws_path = self.specific_workspace_path ws_path_string = 'workspace path: {}'.format(ws_path) self._add_signature_detail(signode, ws_path_string) rule_impl = self.options.get('implementation', "") if rule_impl: self.implementation = rule_impl rule_invocation = self.options.get('invocation', "") if rule_invocation: self.invocation = rule_invocation if self.options.get('show_implementation', False) is None: impl_string = 'implementation: {}'.format(self.implementation) self._add_signature_detail(signode, impl_string) if self.options.get('show_invocation', False) is None: invocation_string = 'invocation: {}'.format(self.invocation) self._add_signature_detail(signode, invocation_string) return sig, sig
def run(self) -> List[Node]: """ Main directive entry function, called by docutils upon encountering the directive. This directive is meant to be quite easily subclassable, so it delegates to several additional methods. What it does: * find out if called as a domain-specific directive, set self.domain * create a `desc` node to fit all description inside * parse standard options, currently `noindex` * create an index node if needed as self.indexnode * parse all given signatures (as returned by self.get_signatures()) using self.handle_signature(), which should either return a name or raise ValueError * add index entries using self.add_target_and_index() * parse the content and handle doc fields in it """ if ':' in self.name: self.domain, self.objtype = self.name.split(':', 1) else: self.domain, self.objtype = '', self.name self.indexnode = addnodes.index(entries=[]) node = addnodes.desc() node.document = self.state.document node['domain'] = self.domain # 'desctype' is a backwards compatible attribute node['objtype'] = node['desctype'] = self.objtype node['noindex'] = noindex = ('noindex' in self.options) if self.domain: node['classes'].append(self.domain) self.names = [] # type: List[Any] signatures = self.get_signatures() for i, sig in enumerate(signatures): # add a signature node for each signature in the current unit # and add a reference target for it signode = addnodes.desc_signature(sig, '') self.set_source_info(signode) node.append(signode) try: # name can also be a tuple, e.g. (classname, objname); # this is strictly domain-specific (i.e. no assumptions may # be made in this base class) name = self.handle_signature(sig, signode) except ValueError: # signature parsing failed signode.clear() signode += addnodes.desc_name(sig, sig) continue # we don't want an index entry here if name not in self.names: self.names.append(name) if not noindex: # only add target and index entry if this is the first # description of the object with this name in this desc block self.add_target_and_index(name, sig, signode) contentnode = addnodes.desc_content() node.append(contentnode) if self.names: # needed for association of version{added,changed} directives self.env.temp_data['object'] = self.names[0] self.before_content() self.state.nested_parse(self.content, self.content_offset, contentnode) self.env.app.emit('object-description-transform', self.domain, self.objtype, contentnode) DocFieldTransformer(self).transform_all(contentnode) self.env.temp_data['object'] = None self.after_content() return [self.indexnode, node]
def parse_signature(self, sig, signode): """ Transform a Python signature into RST nodes. Returns (fully qualified name of the thing, classname if any). If inside a class, the current class name is handled intelligently: * it is stripped from the displayed name if present * it is added to the full name (return value) if not present """ m = py_sig_re.match(sig) if m is None: raise ValueError classname, name, arglist, retann = m.groups() if self.env.currclass: add_module = False if classname and classname.startswith(self.env.currclass): fullname = classname + name # class name is given again in the signature classname = classname[len(self.env.currclass):].lstrip('.') elif classname: # class name is given in the signature, but different # (shouldn't happen) fullname = self.env.currclass + '.' + classname + name else: # class name is not given in the signature fullname = self.env.currclass + '.' + name else: add_module = True fullname = classname and classname + name or name prefix = self.get_signature_prefix(sig) if prefix: signode += addnodes.desc_annotation(prefix, prefix) if classname: signode += addnodes.desc_addname(classname, classname) # exceptions are a special case, since they are documented in the # 'exceptions' module. elif add_module and self.env.config.add_module_names: modname = self.options.get('module', self.env.currmodule) if modname and modname != 'exceptions': nodetext = modname + '.' signode += addnodes.desc_addname(nodetext, nodetext) signode += addnodes.desc_name(name, name) if not arglist: if self.needs_arglist(): # for callables, add an empty parameter list signode += addnodes.desc_parameterlist() if retann: signode += addnodes.desc_returns(retann, retann) return fullname, classname signode += addnodes.desc_parameterlist() stack = [signode[-1]] for token in py_paramlist_re.split(arglist): if token == '[': opt = addnodes.desc_optional() stack[-1] += opt stack.append(opt) elif token == ']': try: stack.pop() except IndexError: raise ValueError elif not token or token == ',' or token.isspace(): pass else: token = token.strip() stack[-1] += addnodes.desc_parameter(token, token) if len(stack) != 1: raise ValueError if retann: signode += addnodes.desc_returns(retann, retann) return fullname, classname
def handle_signature(self, sig: str, signode: desc_signature) -> str: signode += addnodes.desc_name(':%s:' % sig, ':%s:' % sig) return sig
def parse_role(env, sig, signode): signode += addnodes.desc_name(':%s:' % sig, ':%s:' % sig) return sig
def handle_signature(self, sig, signode): signode += addnodes.desc_name(sig, sig) signode += addnodes.desc_annotation(" (Customize Option)", " (Customize Option)") return sig
emphasis('', 'self'), SphinxNodes.desc_name('', '', Text('[')), emphasis('', parameters_node.children[0].astext()), SphinxNodes.desc_name('', '', Text(']')), ] SPECIAL_METHODS = { '__getitem__': lambda name_node, parameters_node: inline( '', '', *brackets(parameters_node) ), '__setitem__': lambda name_node, parameters_node: inline( '', '', *brackets(parameters_node), Text(' '), SphinxNodes.desc_name('', '', Text('=')), Text(' '), emphasis('', ( (parameters_node.children[1].astext()) if len(parameters_node.children) > 1 else '' )), ), '__delitem__': lambda name_node, parameters_node: inline( '', '', SphinxNodes.desc_name('', '', Text('del')), Text(' '), *brackets(parameters_node), ), '__contains__': lambda name_node, parameters_node: inline( '', '', emphasis('', parameters_node.children[0].astext()),
def parse_django_admin_node(env, sig, signode): command = sig.split(' ')[0] env.ref_context['std:program'] = command title = "django-admin %s" % sig signode += addnodes.desc_name(title, title) return command
def handle_signature(self, sig, signode): # type: (unicode, addnodes.desc_signature) -> unicode signode += addnodes.desc_name(':%s:' % sig, ':%s:' % sig) return sig
def _render_signature(self, signature, signode): signode += addnodes.desc_name(signature, signature)
def handle_signature(self, sig, signode): container_class_name = self.env.temp_data.get('swift:class') # split on : -> first part is class name, second part is superclass list parts = [x.strip() for x in sig.split(':', 1)] # if the class name contains a < then there is a generic type attachment if '<' in parts[0]: class_name, generic_type = parts[0].split('<') generic_type = generic_type[:-1] else: class_name = parts[0] generic_type = None # did we catch a 'where' ? type_constraint = None class_parts = None if ' ' in class_name: class_parts = class_name.split(' ') elif '\t' in class_name: class_parts = class_name.split('\t') if class_parts: # if a part starts with `where` then we have a type constraint for index, p in enumerate(class_parts): if p == 'where': type_constraint = " ".join( class_parts[index:]) + ": " + parts.pop() class_name = " ".join(class_parts[:index]) break if class_name.count('.'): class_name = class_name.split('.')[-1] # if we have more than one part this class has super classes / protocols super_classes = None if len(parts) > 1: super_classes = [x.strip() for x in parts[1].split(',')] # if a part starts with `where` then we have a type constraint for index, sup in enumerate(super_classes): if sup == 'where': type_constraint = " ".join(super_classes[index:]) super_classes = super_classes[:index] break # Add class name signode += addnodes.desc_addname(self.objtype, self.objtype + ' ') signode += addnodes.desc_name(class_name, class_name) # if we had super classes add annotation if super_classes: children = [] for c in super_classes: prefix = ', ' if c != super_classes[0] else '' ref = addnodes.pending_xref('', reftype='type', refdomain='swift', reftarget=c, refwarn=True) ref += nodes.Text(prefix + c) children.append(ref) signode += addnodes.desc_type('', ' : ', *children) # add type constraint if type_constraint: signode += addnodes.desc_type(type_constraint, ' ' + type_constraint) add_to_index = True if self.objtype == 'extension' and not super_classes: add_to_index = False if container_class_name: class_name = container_class_name + '.' + class_name return self.objtype + ' ' + class_name, self.objtype + ' ' + class_name, add_to_index
def handle_signature(self, sig, signode): sig = sig.strip() parent = self.env.temp_data.get('ars:servicename', None) if not parent: in_parent = False split = sig.split('.', 1) if len(split) == 2: parent = split[0] name = split[1] else: raise RuntimeError('Parent not found') else: in_parent = True name = sig self.service = ars_interface.services[parent] self.procedure_name = name base = self.service self.procedure = None while base is not None: if base.name + '_' + name in base.procedures: self.procedure = base.procedures[base.name + '_' + name] break base = base.base if not self.procedure: raise RuntimeError('Procedure {0} not found in {1} or base services'.format(name, parent)) skipargs = self.options.get('skipargs', 0) gen_type_node(signode, self.procedure.return_type) signode += nodes.Text(' ') if not in_parent: signode += addnodes.desc_addname(self.service.name, self.service.name) signode += nodes.Text('.') signode += addnodes.desc_name(self.procedure_name, self.procedure_name) paramlist_node = addnodes.desc_parameterlist() for param in list(self.procedure.parameters)[skipargs:]: param_node = addnodes.desc_parameter('', '', noemph=True) gen_type_node(param_node, param.type) param_node += nodes.Text(' ') param_node += nodes.emphasis(param.name, param.name) paramlist_node += param_node signode += paramlist_node if len(self.procedure.exception_types) > len(global_exception_types): signode += nodes.Text(' ') signode += nodes.literal('throws', 'throws') signode += nodes.Text(' (') first = True for exception in list(self.procedure.exception_types)[len(global_exception_types):]: if first: first = False else: signode += nodes.Text(', ') gen_type_node(signode, exception) signode += nodes.Text(')') return self.service.name + '.' + self.procedure_name
def handle_signature(self, sig, signode): """ Transform a Fortran signature into RST nodes. Returns (fully qualified name of the thing, classname if any). If inside a class, the current class name is handled intelligently: * it is stripped from the displayed name if present * it is added to the full name (return value) if not present """ m = f_sig_re.match(sig) if m is None: raise ValueError ftype, objtype, modname, typename, name, arglist = m.groups() if not typename: typename = "" # determine module, type, shape and attributes modname = (modname and modname[:-1]) or self.options.get( 'module', self.env.temp_data.get('f:module')) if typename: name = typename[:-1] attrs = self.options.get('attrs') shape = parse_shape(self.options.get('shape')) ftype = ftype or self.options.get('type') if self.objtype == 'typefield' and not typename: raise ValueError if self.objtype == 'program': fullname = name else: fullname = (modname or '_') + f_sep + name signode['module'] = modname signode['type'] = typename signode['fullname'] = fullname # Add "function" or "subroutine" tag sig_prefix = self.get_signature_prefix(sig) if objtype or sig_prefix: objtype = objtype or sig_prefix signode += addnodes.desc_annotation(objtype + ' ', objtype + ' ') # Add module if self.env.config.add_module_names and modname and self.objtype != 'typefield': nodetext = modname + f_sep signode += addnodes.desc_addname(nodetext, nodetext) # Add name signode += addnodes.desc_name(name, name) # In the parenthesis if self.needs_arglist(): # call for functions and subroutines if arglist: # Calling arguments _pseudo_parse_arglist(signode, arglist) elif self.needs_arglist( ): # for callables, add an empty parameter list signode += addnodes.desc_parameterlist() elif arglist and not shape: # Declare shape instead of arguments (variables) shape = arglist # Add remaining self.add_shape_and_attrs(signode, modname, ftype, shape, attrs) return fullname, ftype
def handle_signature(self, sig, signode): print(sig) signode += addnodes.desc_name(text=sig) return sig
def handle_signature(self, sig, signode): signode += addnodes.desc_annotation(text="property ") signode += addnodes.desc_name(text=sig) return sig
def handle_signature(self, sig, signode): """ Transform a Ruby signature into RST nodes. Returns (fully qualified name of the thing, classname if any). If inside a class, the current class name is handled intelligently: * it is stripped from the displayed name if present * it is added to the full name (return value) if not present """ m = rb_sig_re.match(sig) if m is None: raise ValueError name_prefix, name, arglist, retann = m.groups() if not name_prefix: name_prefix = "" # determine module and class name (if applicable), as well as full name modname = self.options.get('module', self.env.temp_data.get('rb:module')) classname = self.env.temp_data.get('rb:class') if self.objtype == 'global': add_module = False modname = None classname = None fullname = name elif classname: add_module = False if name_prefix and name_prefix.startswith(classname): fullname = name_prefix + name # class name is given again in the signature name_prefix = name_prefix[len(classname):].lstrip('.') else: separator = separators[self.objtype] fullname = classname + separator + name_prefix + name else: add_module = True if name_prefix: classname = name_prefix.rstrip('.') fullname = name_prefix + name else: classname = '' fullname = name signode['module'] = modname signode['class'] = self.class_name = classname signode['fullname'] = fullname sig_prefix = self.get_signature_prefix(sig) if sig_prefix: signode += addnodes.desc_annotation(sig_prefix, sig_prefix) if name_prefix: signode += addnodes.desc_addname(name_prefix, name_prefix) # exceptions are a special case, since they are documented in the # 'exceptions' module. elif add_module and self.env.config.add_module_names: if self.objtype == 'global': nodetext = '' signode += addnodes.desc_addname(nodetext, nodetext) else: modname = self.options.get('module', self.env.temp_data.get('rb:module')) if modname and modname != 'exceptions': nodetext = modname + separators[self.objtype] signode += addnodes.desc_addname(nodetext, nodetext) signode += addnodes.desc_name(name, name) if not arglist: if self.needs_arglist(): # for callables, add an empty parameter list signode += addnodes.desc_parameterlist() if retann: signode += addnodes.desc_returns(retann, retann) return fullname, name_prefix signode += addnodes.desc_parameterlist() stack = [signode[-1]] for token in rb_paramlist_re.split(arglist): if token == '[': opt = addnodes.desc_optional() stack[-1] += opt stack.append(opt) elif token == ']': try: stack.pop() except IndexError: raise ValueError elif not token or token == ',' or token.isspace(): pass else: token = token.strip() stack[-1] += addnodes.desc_parameter(token, token) if len(stack) != 1: raise ValueError if retann: signode += addnodes.desc_returns(retann, retann) return fullname, name_prefix
def parse_value(self, env, text, nodes): nodes += addnodes.desc_name(text, text) if self._current_option is None: return text return self._current_option + '=' + text
def parse_django_admin_node(env, sig, signode): command = sig.split(' ')[0] env.ref_context['std:program'] = command signode += addnodes.desc_name(sig, sig) return command
def parse_ghci_cmd(env, sig, signode): name = sig.split(';')[0] sig = sig.replace(';', '') signode += addnodes.desc_name(name, sig) return name
def handle_signature(self, sig: str, signode: desc_signature) -> Tuple[str, str]: """Transform a Python signature into RST nodes. Return (fully qualified name of the thing, classname if any). If inside a class, the current class name is handled intelligently: * it is stripped from the displayed name if present * it is added to the full name (return value) if not present """ m = py_sig_re.match(sig) if m is None: raise ValueError prefix, name, arglist, retann = m.groups() # determine module and class name (if applicable), as well as full name modname = self.options.get('module', self.env.ref_context.get('py:module')) classname = self.env.ref_context.get('py:class') if classname: add_module = False if prefix and (prefix == classname or prefix.startswith(classname + ".")): fullname = prefix + name # class name is given again in the signature prefix = prefix[len(classname):].lstrip('.') elif prefix: # class name is given in the signature, but different # (shouldn't happen) fullname = classname + '.' + prefix + name else: # class name is not given in the signature fullname = classname + '.' + name else: add_module = True if prefix: classname = prefix.rstrip('.') fullname = prefix + name else: classname = '' fullname = name signode['module'] = modname signode['class'] = classname signode['fullname'] = fullname sig_prefix = self.get_signature_prefix(sig) if sig_prefix: signode += addnodes.desc_annotation(sig_prefix, sig_prefix) if prefix: signode += addnodes.desc_addname(prefix, prefix) elif add_module and self.env.config.add_module_names: if modname and modname != 'exceptions': # exceptions are a special case, since they are documented in the # 'exceptions' module. nodetext = modname + '.' signode += addnodes.desc_addname(nodetext, nodetext) signode += addnodes.desc_name(name, name) if arglist: try: signode += _parse_arglist(arglist) except SyntaxError: # fallback to parse arglist original parser. # it supports to represent optional arguments (ex. "func(foo [, bar])") _pseudo_parse_arglist(signode, arglist) except NotImplementedError as exc: logger.warning("could not parse arglist (%r): %s", arglist, exc) _pseudo_parse_arglist(signode, arglist) else: if self.needs_arglist(): # for callables, add an empty parameter list signode += addnodes.desc_parameterlist() if retann: signode += addnodes.desc_returns(retann, retann) anno = self.options.get('annotation') if anno: signode += addnodes.desc_annotation(' ' + anno, ' ' + anno) return fullname, prefix
def parse_option(self, env, text, nodes): nodes += addnodes.desc_name(text, text) self._current_option = text return text