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): """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 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_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 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): """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): # 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 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, fqname, signode): m = fq_classname_pattern.match(fqname) if m is not None: package, classname, generics = m.groups() else: package, classname, generics = None, fqname, None if package is not None and self.env.config.java_show_package: signode += addnodes.desc_addname(package, package) signode += addnodes.desc_name(classname, classname) if generics is not None: signode += addnodes.desc_addname(generics, generics) if package is not None: return package + classname else: return classname
def parse_option_desc(signode, sig): """Transform an option description into RST nodes.""" count = 0 firstname = '' for m in option_desc_re.finditer(sig): prefix, optname, args = m.groups() if count: signode += addnodes.desc_addname(', ', ', ') signode += addnodes.desc_name(prefix+optname, prefix+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): '''return the name of this object from its signature''' # Must be able to match these (without preceding def or rdef) # def macro_name # def macro_name() # def macro_name(arg1, arg2) # rdef macro_name # cdef("macro_name", "content", "groupname", flags) m = spec_func_sig_re.match(sig) or spec_macro_sig_re.match(sig) if m is None: raise ValueError arglist = m.groups() name = arglist[0] args = [] if len(arglist) > 1: args = arglist[1:] if name == 'cdef': # TODO: need to match complete arg list # several different signatures are possible (see cdef-examples.mac) # for now, just get the macro name and ignore the arg list m = spec_cdef_name_sig_re.match(args[0]) arglist = m.groups() name = arglist[0].strip('"') args = ['<<< cdef argument list not handled yet >>>'] # FIXME: signode += addnodes.desc_name(name, name) if len(args) > 0: signode += addnodes.desc_addname(args, args) return name
def handle_signature(self, sig, signode): context, name, argstart, arglist, argend, retann = self.parse_signature(sig) self.context, self.contextsep = self.build_context(context) self.module = self.options.get('module', self.env.temp_data.get('haka:module')) self.objtype = self.build_objtype() self.idxtype = self.options.get('idxtype') or self.options.get('objtype') self.name = name self.argstart = argstart self.arglist = arglist self.argend = argend self.retann = retann add_module = True fullname = name signode['module'] = self.module signode['class'] = self.context signode['fullname'] = fullname prefix = "%s " % (self.objtype) signode += addnodes.desc_annotation(prefix, prefix) if self.module and self.needs_module(): modname = '%s.' % (self.module) signode += addnodes.desc_addname(modname, modname) self.build_signode(signode) anno = self.options.get('annotation') if anno: signode += addnodes.desc_annotation(' ' + anno, ' ' + anno) return {'fullname': fullname, 'context': self.context, 'objtype': self.objtype, 'idxctx': self.options.get('idxctx') or ""}
def attach_name(self, signode, full_name): """Attaches a fully qualified TypeInfo name to the node tree""" # Get the previous namespace # import pdb # pdb.set_trace() prev_namespace = self.resolve_previous_namespace() if prev_namespace: curr = full_name.fqn() if full_name.fqn().startswith(prev_namespace) and not full_name.fqn() == prev_namespace: # print "Partially filled by parent: " # print "Previous namespace: '{}'".format(prev_namespace) # print " Cutting from " + full_name.fqn() new_fqn = full_name.fqn()[len(prev_namespace):] if new_fqn[0] == ".": new_fqn = new_fqn[1:] # print "New fqn is: " + new_fqn full_name = DefinitionParser.ParseNamespace(new_fqn) # print " to " + full_name.fqn() names = full_name.flatten_namespace() for space in names[:-1]: signode += addnodes.desc_addname(space, space) signode += nodes.Text('.') signode += addnodes.desc_name(names[-1], names[-1])
def attach_name(self, node, name): owner, name = name.split_owner() varname = str(name) if owner is not None: owner = str(owner) + "::" node += addnodes.desc_addname(owner, owner) node += addnodes.desc_name(varname, varname)
def handle_signature(self, sig, signode): match = re.search('(\w+)', sig) name = match.groups()[0] # At this point, we make no attempt to break up the arglist into # reqired parameters, keywords, optional arguments etc. # This would be very hard, since we would have to cover the syntax # of shell, IDL, S-Lang, ... # For our output all we want is to attach it to the name in # reasonable formatting. arglist = sig[len(name):] anno = self.options.get('annotation') lang = self.options.get('language') signode += addnodes.desc_name(name, name) # addname has a good formatting, even if it is meant for a # different use in sphinx for python. # Sphinx expects name + parameterlist, but unfortunately, # the parameterlist is automatically wrapped in (), so we avoid that # here. signode += addnodes.desc_addname(arglist, arglist) if lang: signode += addnodes.desc(' ' + lang, ' ' + lang) if anno: signode += addnodes.desc_annotation(' ' + anno, ' ' + anno) return name
def handle_signature(self, sig, signode): sdkname = self.options.get('sdk', self.env.ref_context.get('qbs:sdk')) pkgname = self.options.get('package', self.env.ref_context.get('qbs:package')) modname = self.env.ref_context.get('qbs:module', None) itemname = self.env.ref_context.get('qbs:item', None) type, name, value = self.parse(sig) signode['module'] = modname signode['package'] = pkgname signode['item'] = itemname if self.objtype == 'property': fullname = self.get_signature_name(objname=(modname or itemname), name=name) else: fullname = name signode['sdk'] = sdkname signode['fullname'] = fullname sigprefix = self.get_signature_prefix() if sigprefix: signode += addnodes.desc_annotation(sigprefix, sigprefix) if type: signode += addnodes.desc_addname(type, type) if name: signode += addnodes.desc_name(name, name) if value: signode += addnodes.desc_returns(value, value) return fullname
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): 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 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 handle_signature(self, sig, signode): """Transform an option description into RST nodes.""" starts_with_arg = re.match(r'\s*\*',sig) options = sig.split("!") firstname = None for i in range(len(options)): o = options[i].strip() ws = o.split("*") if not firstname: firstname = ws[0] #is_name = not starts_with_arg is_name = True is_first_name = True for x in ws: if is_name: n = addnodes.desc_name(x,x) if is_first_name: is_first_name = False if i != 0: n['classes'].append('duplicate') signode += n is_name = not is_name else: signode += addnodes.desc_addname(x,x) is_name = not is_name return firstname
def handle_signature(self, sig, signode): """Transform an option description into RST nodes.""" 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): """ 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): 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 handle_signature(self, sig, signode): if 'hidden' in self.options: return sig path = self.get_display_path() for x in path: signode += addnodes.desc_addname(x + '.', x + '.') signode += addnodes.desc_name(sig, sig) return sig
def _handle_enum_signature(self, sig, signode, m): "Transform a Nim enum into RST nodes." name, values = m.groups() signode += addnodes.desc_type('enum', 'enum') signode += addnodes.desc_name(name, name) signode += addnodes.desc_addname(values, '= ' + values) return name
def handle_signature(self, sig, signode): a = (context, name, argstart, arglist, argend, retann) = self.parse_signature(sig) self.context, self.contextsep = self.build_context(context) self.module = self.options.get('module', self.env.temp_data.get('lua:module')) self.clsname = self.options.get('class', self.env.temp_data.get('lua:class')) self.objtype = self.build_objtype() self.idxtype = self.options.get('idxtype') or self.options.get('objtype') self.name = name self.argstart = argstart self.arglist = arglist self.argend = argend self.retann = retann # print "context: '%s', name: '%s'" % a[:2] # print "module: '%s', clsname: '%s', idxtype: '%s'" % (self.module, self.clsname, self.idxtype) # print "typename: '%s', objtype: '%s'" % (self.typename, self.objtype) # print "needs_module: '%s', needs_class: '%s'" % (self.needs_class(), self.needs_module()) # print "" add_module = True fullname = name signode['module'] = self.module signode['class'] = self.context signode['fullname'] = fullname prefix = "%s " % (self.objtype) signode += addnodes.desc_annotation(prefix, prefix) clsname = '' if fullname.find('.') != -1 or str(self.typename) == "object": pass elif self.clsname and self.needs_class(): sprtr = '.' if str(self.typename) == "data" else ':' clsname = '%s%s' % (self.clsname, sprtr) elif self.module and self.needs_module(): clsname = '%s.' % (self.module) if clsname: signode += addnodes.desc_addname(clsname, clsname) # if self.clsname and self.needs_class(): # signode += addnodes.desc_addname(clsname, clsname) # elif str(self.typename) == "data": # clsname = '%s:' % (self.clsname) # signode += addnodes.desc_addname(clsname, clsname) # elif self.module and self.needs_module(): # modname = '%s.' % (self.module) # signode += addnodes.desc_addname(modname, modname) self.build_signode(signode) anno = self.options.get('annotation') if anno: signode += addnodes.desc_annotation(' ' + anno, ' ' + anno) return {'fullname': fullname, 'context': self.context, 'objtype': self.objtype, 'idxctx': self.options.get('idxctx') or ""}
def build_signode(self, signode): if self.type == 'unary': signode += addnodes.desc_name(self.name, self.name) context = self.context + self.contextsep signode += addnodes.desc_addname(context, context) if self.retann: signode += addnodes.desc_returns(self.retann, self.retann) elif self.type == 'binary': context = self.context + self.contextsep name = " %s " % (self.name) signode += addnodes.desc_addname(context, context) signode += addnodes.desc_name(name, name) signode += addnodes.desc_addname(context, context) if self.retann: signode += addnodes.desc_returns(self.retann, self.retann) elif self.type == 'index' or self.type == 'newindex': context = self.context + self.contextsep signode += addnodes.desc_addname(context, context) self.build_parameters(signode) if self.retann: if self.type == 'newindex': retann = " = %s" % (self.retann) signode += addnodes.desc_type(retann, retann) else: signode += addnodes.desc_returns(self.retann, self.retann) elif self.type == 'convert': context = self.context + self.contextsep signode += addnodes.desc_name(self.name, self.name) paramlist = _desc_parameterlist('(', ')') paramlist.append(addnodes.desc_addname(context, context)) signode.append(paramlist) if self.retann: signode += addnodes.desc_returns(self.retann, self.retann)
def handle_signature(self, sig, signode): m = sig.split() full = m[0] short = m[1] ty = m[2] signode += addnodes.desc_addname("", ty + " ") signode += addnodes.desc_name("", short) return full
def attach_name(self, node, name): owner, name = name.split_owner() varname = unicode(name) # Olaf: Never show Class:: owner = None if owner is not None: owner = unicode(owner) + '::' node += addnodes.desc_addname(owner, owner) node += addnodes.desc_name(varname, varname)
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 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 visibility, modifiers, 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] # Method declared as Class::methodName if not classname and '::' in name_prefix: classname = name_prefix.rstrip('::') if self.objtype == 'global' or self.objtype == 'function': add_module = False modname = None classname = None fullname = name else: add_module = True # name_prefix and a non-static method, means the classname was # repeated. Trim off the <class>:: if name_prefix and self.objtype != 'staticmethod': if name_prefix.startswith(classname): name_prefix = name_prefix[len(classname):].rstrip('::') classname = classname.rstrip('::') fullname = name_prefix + classname + separator + name elif name_prefix: classname = classname.rstrip('::') fullname = name_prefix + name # Currently in a class, but not creating another class, elif classname and not self.objtype in [ 'class', 'exception', 'interface', 'trait' ]: if not self.env.temp_data['php:in_class']: name_prefix = classname + separator fullname = classname + separator + name else: classname = '' fullname = name signode['namespace'] = modname signode['class'] = self.class_name = classname signode['fullname'] = fullname if visibility: signode += addnodes.desc_annotation(visibility, visibility) sig_prefix = self.get_signature_prefix(sig) if modifiers and not (sig_prefix and 'static' in sig_prefix): signode += addnodes.desc_annotation(modifiers, modifiers) 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 _pseudo_parse_arglist(signode, arglist) if retann: signode += addnodes.desc_returns(retann, retann) return fullname, name_prefix
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): """ 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 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 typename: name = typename+'%'+name #fullname = name #if modname: 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('BsvDecoratorMixin.handle_signature', sig) ret = super(BsvDecoratorMixin, self).handle_signature(sig, signode) signode.insert(0, addnodes.desc_addname('@', '@')) return ret
def make_signature(self, obj, signode): reg = "reg{} ".format(obj.width) signode += addnodes.desc_addname(reg, reg) signode += addnodes.desc_name(obj.name, obj.name)
def handle_signature(self, sig, signode): # type: (unicode, addnodes.desc_signature) -> Tuple[unicode, unicode] ret = super(PyDecoratorMixin, self).handle_signature(sig, signode) # type: ignore signode.insert(0, addnodes.desc_addname('@', '@')) return ret
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 display_prefix = self.get_display_prefix() if display_prefix: signode += addnodes.desc_annotation('', '', *display_prefix) actual_prefix = None if prefix: actual_prefix = prefix elif mod_name: actual_prefix = mod_name if actual_prefix: addName = addnodes.desc_addname('', '') for p in actual_prefix.split('.'): addName += addnodes.desc_sig_name(p, p) addName += addnodes.desc_sig_punctuation('.', '.') signode += addName signode += addnodes.desc_name('', '', addnodes.desc_sig_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, signode): """Transform a Yacas 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 = yacas_sig_re.match(sig) if m is None: raise ValueError syntax, name, arglist = m.groups() add_module = False fullname = name signode['fullname'] = fullname sig_prefix = self.get_signature_prefix(sig) if sig_prefix: signode += addnodes.desc_annotation(sig_prefix, sig_prefix) if add_module and self.env.config.add_module_names: modname = self.options.get('module', self.env.temp_data.get('ys:module')) if modname: nodetext = modname + '.' signode += addnodes.desc_addname(nodetext, nodetext) anno = self.options.get('annotation') if syntax == 'prefix': signode += addnodes.desc_name(name, name) signode += addnodes.desc_type(arglist, arglist) return fullname, '' if syntax == 'infix': left, right = arglist.split(',') left = left + ' ' right = ' ' + right signode += addnodes.desc_type(left, left) signode += addnodes.desc_name(name, name) signode += addnodes.desc_type(right, right) return fullname, '' if syntax == 'postfix': signode += addnodes.desc_type(arglist, arglist) signode += addnodes.desc_name(name, name) return fullname, '' 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 anno: signode += addnodes.desc_annotation(' ' + anno, ' ' + anno) return fullname, '' if (syntax == 'bodied'): body = arglist.split(',')[0] arglist = str.join(',', arglist.split(',')[1:]) _pseudo_parse_arglist(signode, arglist) if (syntax == 'bodied'): signode += addnodes.desc_type(' ' + body, ' ' + body) if anno: signode += addnodes.desc_annotation(' ' + anno, ' ' + anno) return fullname, ''
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() elif ',' in sig: # Bit ugly. For subcommands w/ aliases member, alias = sig.split(',', 1) member = member.strip() alias = alias.strip() else: member = sig arglist = None alias = None # If construct is nested, prefix the current prefix prefix = self.env.ref_context.get('minio:object', None) mod_name = self.env.ref_context.get('minio:command') 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 and self.allow_nesting == False: fullname = '.'.join([prefix, name]) elif prefix and self.allow_nesting == True: 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) # In our current usage, we only nest for command/subcommand. So we # need to split some of the logic here from nesting of YAML or JSON # So if allow_nesting is true, we should use " " instead of "." for # the prefix description. # We also have an exit for the 'subcommand' type so that we don't end # up building long name strings for subcommands # Finally for subcommands w/ aliases, need to append the alias name if prefix and self.allow_nesting == False: signode += addnodes.desc_addname(prefix + '.', prefix + '.') elif prefix and self.allow_nesting == True and self.objtype != 'subcommand': signode += addnodes.desc_addname(prefix + ' ', prefix + ' ') signode += addnodes.desc_addname(alias + ' ', alias + ' ') elif mod_name: signode += addnodes.desc_addname(mod_name + '.', mod_name + '.') if (alias != None): signode += addnodes.desc_name(name + ", " + alias, name + ", " + alias) else: 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]: ret = super().handle_signature(sig, signode) # type: ignore signode.insert(0, addnodes.desc_addname('@', '@')) return ret
def envy_resolve(app, doctree, fromdocname): objects = app.env.domaindata['envy']['objects'] # add uplink info for holder in doctree.traverse(uplink_placeholder): obj = objects[holder.name] links = [] for sp, pos, name, variants in obj.uplinks: signode = addnodes.desc_signature('', '') signode['first'] = False signode += make_refnode(app.builder, fromdocname, sp.docname, sp.iname + '-' + sp.name, addnodes.desc_addname(sp.name, sp.name), sp.name) text = ' {}: {}{}'.format(pos.format_offset(), name, pos.format_square()) post = pos.format_post() if post: text += ' ({})'.format(', '.join(post)) signode += addnodes.desc_name(text, text) if variants is not None: text = ' [{}]'.format(variants) signode += addnodes.desc_annotation(text, text) links.append(signode) holder.replace_self(links) # add subnode list for holder in doctree.traverse(sub_placeholder): obj = objects[holder.name] add_variant = False for pos, name, child, variants in obj.subs: if variants is not None: add_variant = True if obj.subs: table = nodes.table() headers = [(1, 'Address'), (1, 'Name'), (10, 'Description')] if add_variant: headers.insert(1, (1, 'Variants')) tgroup = nodes.tgroup(cols=len(headers)) table += tgroup for colwidth, header in headers: tgroup += nodes.colspec(colwidth=colwidth) thead = nodes.thead() tgroup += thead headrow = nodes.row() for colwidth, header in headers: entry = nodes.entry() para = nodes.paragraph() entry += para para += nodes.Text(header, header) headrow += entry thead += headrow tbody = nodes.tbody() tgroup += tbody for pos, name, child, variants in obj.subs: row = nodes.row() ptext = pos.format_offset() post = pos.format_post() if post: ptext += ' ({})'.format(', '.join(post)) row += wrap_text_entry(ptext) if add_variant: row += wrap_text_entry('all' if variants is None else variants) row += wrap_text_entry(name + pos.format_square()) entry = nodes.entry() para = nodes.paragraph() entry += para para += make_refnode(app.builder, fromdocname, child.docname, child.iname + '-' + child.name, nodes.Text(child.brief, child.brief), child.brief) row += entry tbody += row holder.replace_self([table]) else: holder.replace_self([])
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: # For subcommands w/ aliases member, alias = sig.split(',', 1) member = member.strip() alias = alias.strip() elif ' ' in sig: # For subcommands with spaces # Need to find a better way of specifying aliases, this is very hacky member = sig.replace(' ', '-') alias = None else: member = sig alias = None # If construct is nested, prefix the current prefix prefix = self.env.ref_context.get('minio:object', None) #Grab the top-level command name. command_name = self.env.ref_context.get('minio:mc').replace("-", " ") name = member format_name = member format_alias = alias if prefix: fullname = '-'.join([prefix, name]) else: fullname = name if 'option' in self.options: format_name = "--" + name if 'option' in self.options and alias != None: format_alias = "--" + alias signode['command'] = command_name signode['object'] = prefix signode['fullname'] = fullname if prefix: signode += addnodes.desc_addname(prefix + '-', ' ') elif command_name and ('fullpath' in self.options): signode += addnodes.desc_addname(command_name + '-', command_name + ' ') elif command_name: signode += addnodes.desc_addname(command_name + '-', ' ') if (alias != None): signode += addnodes.desc_name(name + ', ' + alias, format_name + ', ' + format_alias) elif 'notext' in self.options: signode += addnodes.desc_name(name, '') else: signode += addnodes.desc_name(name, format_name) return fullname, prefix
def handle_signature(self, sig, signode): ret = super(PyDecoratorMixin, self).handle_signature(sig, signode) signode.insert(0, addnodes.desc_addname('@', '@')) return ret
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 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): """Transform a Bsv signature into RST nodes. Return (fully qualified name of the thing, interfacename if any). If inside a interface, the current interface 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 """ print('BsvObject.handle_signature', sig) name_prefix = '' name = sig arglist = '' retann = '' if self.objtype in ['interface', 'instance', 'typeclass']: split = sig.split('#', 1) name = split[0] if len(split) > 1: arglist = split[1] m = bsv_param_re.match(arglist) if m: arglist = m.group(1) elif self.objtype in ['subinterface', 'field']: split = sig.rsplit(' ', 1) print('rsplit', split) name = split[-1] if len(split) > 1: retann = split[0] elif self.objtype in ['method', 'function']: split = sig.split(' ', 1) retann = split[0] nameparams = split[1] split = nameparams.split('(', 1) name = split[0] if len(split) > 1: arglist = split[1][0:-1] elif self.objtype in ['module']: split = sig.split('#', 1) name = split[0] if len(split) > 1: depth = 0 paramreturn = split[1] #print('module', paramreturn, len(paramreturn)) for i in range(0, len(paramreturn)): c = paramreturn[i] if c == '(': depth = depth + 1 elif c == ')': depth = depth - 1 #print(i, c, depth) if depth == 0: endofparam = i break arglist = paramreturn[1:endofparam] retann = paramreturn[endofparam + 1:-1] #print(arglist) #print(endofparam, retann) # determine package and interface name (if applicable), as well as full name modname = self.options.get('package', self.env.temp_data.get('bsv:package')) interfacename = self.env.temp_data.get('bsv:interface') if interfacename: add_package = False if name_prefix and name_prefix.startswith(interfacename): fullname = name_prefix + name # interface name is given again in the signature name_prefix = name_prefix[len(interfacename):].lstrip('.') elif name_prefix: # interface name is given in the signature, but different # (shouldn't happen) fullname = interfacename + '.' + name_prefix + name else: # interface name is not given in the signature fullname = interfacename + '.' + name else: add_package = True if name_prefix: interfacename = name_prefix.rstrip('.') fullname = name_prefix + name else: interfacename = '' fullname = name signode['package'] = modname signode['interface'] = interfacename 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' package. elif add_package and self.env.config.add_package_names: modname = self.options.get('package', self.env.temp_data.get('bsv:package')) if modname and modname != 'exceptions': nodetext = modname + '::' signode += addnodes.desc_addname(nodetext, nodetext) anno = self.options.get('annotation') signode += addnodes.desc_name(name, name) #print('arglist', arglist) if not arglist: if self.needs_arglist(): # for callables, add an empty parameter list if arglist: signode += addnodes.desc_parameterlist(text=arglist) elif self.options.get('parameter'): signode += addnodes.desc_parameterlist( text=self.options.get('parameter')) if retann: signode += addnodes.desc_returns(text=retann) elif self.options.get('returntype'): signode += addnodes.desc_returns( text=self.options.get('returntype')) if anno: signode += addnodes.desc_annotation(' ' + anno, ' ' + anno) #print('signode', signode) 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 make_signature(self, obj, signode): signode += addnodes.desc_addname(self.objtype + ' ', self.objtype + ' ') signode += addnodes.desc_name(obj.name, obj.name)
def handle_signature(self, sig, signode): container_class_name = self.env.temp_data.get('kotlin:class') container_class_type = self.env.temp_data.get('kotlin: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: first_anglebracket = -1 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 parameters = [] if parameter_list: parameters = self._parse_parameter_list(parameter_list) # check for return type return_type = None # balance_braces = 0 # counter = 0 # for c in reversed(rest): # counter += 1 # if balance_braces == 0 and c == ':': # break # # if c == ')': balance_braces += 1 # if c == '(': balance_braces -= 1 # # arrow = len(rest) - counter arrow = rest.find(':') if arrow >= 0: return_type = rest[arrow + 2:].strip() # build signature and add nodes signature = '' if self.objtype == 'static_fun': signode += addnodes.desc_addname("static", "static fun ") elif self.objtype == 'class_method': signode += addnodes.desc_addname("class", "class fun ") elif self.objtype != 'init': signode += addnodes.desc_addname("fun", "fun ") if self.objtype == 'init': signode += addnodes.desc_name('init', 'init') signature += 'init(' for p in parameters: signature += p['name'] + ':' signature += ')' else: signode += addnodes.desc_name(method_name, method_name) signature += method_name signature += '(' for p in parameters: signature += p['name'] + ':' signature += ')' if generics: signode += addnodes.desc_addname(generics, generics) params = [] sig = '' for p in parameters: param = p['name'] + ': ' # + p['type'] sig += p['name'] + ':' #if p['default']: # param += ' = ' + p['default'] paramNode = addnodes.desc_parameter(param, param) paramXref = addnodes.pending_xref('', refdomain='kotlin', 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 return_type: paramNode = addnodes.desc_type(' : ', ' : ') #desc_returns('', '') paramXref = addnodes.pending_xref('', refdomain='kotlin', 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 == 'interface': # signature += "-interface" #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, cid, lineno, sig, signode): # type: (str, addnodes.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 This is the xml string result of signode, whitespace is not equivalent for readability. <desc_signature class="" first="False" fullname="com.google.fonts/check/all_glyphs_have_codepoints" module="fontbakery.profiles.cmap" > <desc_annotation xml:space="preserve">FontBakeryCheck </desc_annotation> <desc_addname xml:space="preserve">fontbakery.profiles.cmap.</desc_addname> <desc_name xml:space="preserve">com_google_fonts_check_all_glyphs_have_codepoints</desc_name> <desc_parameterlist xml:space="preserve"> <desc_parameter xml:space="preserve">ttFont</desc_parameter> </desc_parameterlist> </desc_signature> """ m = py_sig_re.match(sig) if m is None: # this is the immediate fail!!! raise ValueError prefix, name, arglist, retann = m.groups() # print('prefix, name, arglist, retann =', prefix, name, arglist, retann) # > prefix, name, arglist, retann = None com_google_fonts_check_all_glyphs_have_codepoints ttFont None # 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 signode.attributes['lineno'] = lineno #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 + ' ID: ' #signode += addnodes.desc_addname(nodetext, nodetext) pass signode += addnodes.desc_name(name, cid) if arglist: _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 cid, prefix
def parse_py_signature(signode, sig, desctype, module, env): """ Transform a python signature into RST nodes. Return (fully qualified name of the thing, classname if any). If inside a class, the current class name is handled intelligently: * it is stripped from the displayed name if present * it is added to the full name (return value) if not present """ m = py_sig_re.match(sig) if m is None: raise ValueError classname, name, arglist, retann = m.groups() if retann: retann = u' \N{RIGHTWARDS ARROW} ' + retann.strip()[2:] if env.currclass: add_module = False if classname and classname.startswith(env.currclass): fullname = classname + name # class name is given again in the signature classname = classname[len(env.currclass):].lstrip('.') elif classname: # class name is given in the signature, but different # (shouldn't happen) fullname = env.currclass + '.' + classname + name else: # class name is not given in the signature fullname = env.currclass + '.' + name else: add_module = True fullname = classname and classname + name or name if desctype == 'staticmethod': signode += addnodes.desc_annotation('static ', 'static ') if classname: signode += addnodes.desc_addname(classname, classname) # exceptions are a special case, since they are documented in the # 'exceptions' module. elif add_module and env.config.add_module_names and \ module and module != 'exceptions': nodetext = module + '.' signode += addnodes.desc_addname(nodetext, nodetext) signode += addnodes.desc_name(name, name) if not arglist: if desctype in ('function', 'method', 'staticmethod'): # for callables, add an empty parameter list signode += addnodes.desc_parameterlist() if retann: signode += addnodes.desc_type(retann, retann) return fullname, classname signode += addnodes.desc_parameterlist() stack = [signode[-1]] for token in py_paramlist_re.split(arglist): if token == '[': opt = addnodes.desc_optional() stack[-1] += opt stack.append(opt) elif token == ']': try: stack.pop() except IndexError: raise ValueError elif not token or token == ',' or token.isspace(): pass else: token = token.strip() stack[-1] += addnodes.desc_parameter(token, token) if len(stack) != 1: raise ValueError if retann: signode += addnodes.desc_type(retann, retann) return fullname, classname
def handle_signature(self, sig, signode): """Parse the signature *sig* into individual nodes and append them to the *signode*. If ValueError is raises, parsing is aborted and the whole *sig* string is put into a single desc_name node. The return value is the value that identifies the object. IOW, it is the identifier that will be used to reference this object, datum, attribute, proc, etc. It is a tuple of "fullname" (including module and class(es)) and the classes. See also :py:meth:`add_target_and_index`. """ if self._is_attr_like(): sig_match = chpl_attr_sig_pattern.match(sig) if sig_match is None: raise ValueError('Signature does not parse: {0}'.format(sig)) func_prefix, name_prefix, name, retann = sig_match.groups() arglist = None else: sig_match = chpl_sig_pattern.match(sig) if sig_match is None: raise ValueError('Signature does not parse: {0}'.format(sig)) func_prefix, name_prefix, name, arglist, retann = \ sig_match.groups() modname = self.options.get( 'module', self.env.temp_data.get('chpl:module')) classname = self.env.temp_data.get('chpl:class') if classname: 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: 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 func_prefix: # signode += addnodes.desc_addname(func_prefix, func_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 this needs an arglist, and parens were provided in the # signature, add a parameterlist. Chapel supports paren-less # functions and methods, which can act as computed properties. If # arglist is the empty string, the signature included parens. If # arglist is None, it did not include parens. if self.needs_arglist() and arglist is not None: # for callables, add an empty parameter list signode += addnodes.desc_parameterlist() if retann: signode += addnodes.desc_type(retann, retann) if anno: signode += addnodes.desc_annotation(' ' + anno, ' ' + anno) return fullname, name_prefix self._pseudo_parse_arglist(signode, arglist) if retann: signode += addnodes.desc_type(retann, retann) if anno: signode += addnodes.desc_annotation(' ' + anno, ' ' + anno) return fullname, name_prefix
def handle_signature(self, sig, signode): container_class_name = self.env.temp_data.get('kotlin: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_name.count('.'): class_name = class_name.split('.')[-1] # if we have more than one part this class has super classes / interfaces super_classes = None if len(parts) > 1: super_classes = [x.strip() for x in parts[1].split(',')] # Add class name objTypeFixed = self.objtype.replace('_', ' ') signode += addnodes.desc_addname(objTypeFixed, objTypeFixed + ' ') 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='kotlin', 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): # type: (unicode, addnodes.desc_signature) -> unicode """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() desc_type = addnodes.desc_type('', '') signode += desc_type self._parse_type(desc_type, 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' or \ self.objtype == 'macro' and sig.rstrip().endswith('()'): # 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): signode += addnodes.desc_annotation("implementation", "implementation ") signode += addnodes.desc_addname(sig, sig) return sig
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, location=signode) _pseudo_parse_arglist(signode, arglist) else: if self.needs_arglist(): # for callables, add an empty parameter list signode += addnodes.desc_parameterlist() if retann: children = _parse_annotation(retann) signode += addnodes.desc_returns(retann, '', *children) anno = self.options.get('annotation') if anno: signode += addnodes.desc_annotation(' ' + anno, ' ' + anno) return fullname, prefix
def handle_signature(self, sig, signode): signode += addnodes.desc_annotation("typedef", "typedef ") signode += addnodes.desc_addname(sig, sig) return sig
def handle_signature(self, sig, signode): signode += addnodes.desc_annotation("entity", "entity ") signode += addnodes.desc_addname(sig, sig) return sig
def make_signature(self, obj, signode): space = "{}-bit space ".format(obj.width) signode += addnodes.desc_addname(space, space) signode += addnodes.desc_name(self.name, self.name) sz = " [{:#x}]".format(obj.size) signode += addnodes.desc_addname(sz, sz)
def handle_signature(self, sig, signode): signode += addnodes.desc_addname(sig, sig) return sig