def doctree_read(app, doctree): # Add viewcode nodes for code elements referenced in the document. env = app.builder.env if not hasattr(env, '_viewcode_modules'): env._viewcode_modules = {} # handle desc (description) nodes (module contents) for objnode in doctree.traverse(addnodes.desc): if objnode.get('domain') != 'py': continue names = set() for signode in objnode: if not isinstance(signode, addnodes.desc_signature): continue modname = signode.get('module') if not modname: continue fullname = signode.get('fullname') if not _update_tags(env, modname, fullname): continue if fullname in names: # only one link per name, please continue names.add(fullname) pagename = '_modules/' + modname.replace('.', '/') # build up an xref and add it to the desc node onlynode = addnodes.only(expr='html') onlynode += addnodes.pending_xref( '', reftype='viewcode', refdomain='std', refexplicit=False, reftarget=pagename, refid=fullname, refdoc=env.docname) onlynode[0] += nodes.inline('', _('[source]'), classes=['viewcode-link']) signode += onlynode # handle index nodes (modules themselves) for objnode in doctree.traverse(addnodes.index): # extract module name by de-munging the "target" field index_target = objnode['entries'][0][2] if not index_target.startswith('module-'): continue modname = index_target.replace('module-', '', 1) _update_tags(env, modname) pagename = '_modules/' + modname.replace('.', '/') # build up an xref and add it in a new paragraph after the index node xref = addnodes.pending_xref( '', reftype='viewcode', refdomain='std', refexplicit=False, reftarget=pagename, refid='', refdoc=env.docname) xref += nodes.inline('', _('[source]'), classes=['viewcode-link']) idx = objnode.parent.index(objnode) + 1 objnode.parent.insert(idx, nodes.paragraph('', '', xref))
def handle_signature(self, sig, signode): name = self.options["name"] parameters = json.loads(self.options["parameters"]) if "parameters" in self.options else [] return_v = json.loads(self.options["return"]) if "return" in self.options else ("", "") prefix = self.options["prefix"] if "prefix" in self.options else "" if not ("parameters" in self.options) or not ("return" in self.options): print("WARNING: No parameters or return set for '" + name + "'") signode += nodes.Text(prefix + " ", prefix + u"\xa0") xref = addnodes.pending_xref( ":ref:`" + return_v[1] + "`", refdomain="std", reftype="ref", reftarget=ws_re.sub(" ", return_v[1].lower()), refexplicit=False, ) xref += nodes.Text(return_v[0], return_v[0]) signode += xref signode += nodes.Text(" ", u"\xa0") signode += addnodes.desc_name(name, name) paramlist = addnodes.desc_parameterlist() for tn in parameters: param = addnodes.desc_parameter("", "", noemph=True) prefix = "" if len(tn) > 3 and tn[3] == "True": prefix += "ref " if len(tn) > 4 and tn[4] == "True": prefix += "out " if prefix != "": param += nodes.Text(prefix + " ", prefix + u"\xa0") xref = addnodes.pending_xref( ":ref:`" + tn[2] + "`", refdomain="std", reftype="ref", reftarget=ws_re.sub(" ", tn[2].lower()), refexplicit=False, ) xref += nodes.Text(tn[0], tn[0]) param += xref param += nodes.emphasis(" " + tn[1], u"\xa0" + tn[1]) paramlist += param signode += paramlist return name, ""
def mkYrefNode(target,text,rawtext,role,explicitText,lineno,options={}): """Create hyperlink to yade target. Targets starting with literal 'yade.' are absolute, but the leading 'yade.' will be stripped from the link text. Absolute tergets are supposed to live in page named yade.[module].html, anchored at #yade.[module2].[rest of target], where [module2] is identical to [module], unless mapped over by moduleMap. Other targets are supposed to live in yade.wrapper (such as c++ classes).""" writer=__builtin__.writer # to make sure not shadowed by a local var import string if target.startswith('yade.'): module='.'.join(target.split('.')[0:2]) module2=(module if module not in moduleMap.keys() else moduleMap[module]) if target==module: target='' # to reference the module itself uri=('%%%s#%s'%(module2,target) if writer=='latex' else '%s.html#%s'%(module2,target)) if not explicitText and module!=module2: text=module2+'.'+'.'.join(target.split('.')[2:]) text=string.replace(text,'yade.','',1) elif target.startswith('external:'): exttarget=target.split(':',1)[1] if not explicitText: text=exttarget target=exttarget if '.' in exttarget else 'module-'+exttarget uri=(('%%external#%s'%target) if writer=='latex' else 'external.html#%s'%target) else: uri=(('%%yade.wrapper#yade.wrapper.%s'%target) if writer=='latex' else 'yade.wrapper.html#yade.wrapper.%s'%target) #print writer,uri if 0: refnode=addnodes.pending_xref(rawtext,reftype=role,refexplicit=explicitText,reftarget=target) #refnode.line=lineno #refnode+=nodes.literal(rawtext,text,classes=['ref',role]) return [refnode],[] #ret.rawtext,reftype=role, else: return nodes.reference(rawtext,docutils.utils.unescape(text),refuri=uri,**options)
def attach_type(self, node, type): # XXX: link to c? text = str(type) pnode = addnodes.pending_xref("", refdomain="cpp", reftype="type", reftarget=text, modname=None, classname=None) pnode["cpp:parent"] = self.env.temp_data.get("cpp:parent") pnode += nodes.Text(text) node += pnode
def visit_link(self, mdnode): ref_node = nodes.reference() ref_node['refuri'] = mdnode.destination # TODO okay, so this is acutally not always the right line number, but # these mdnodes won't have sourcepos on them for whatever reason. This # is better than 0 though. ref_node.line = (mdnode.sourcepos[0][0] if mdnode.sourcepos else mdnode.parent.sourcepos[0][0]) if mdnode.title: ref_node['title'] = mdnode.title next_node = ref_node url_check = urlparse(mdnode.destination) if not url_check.scheme and not url_check.fragment: wrap_node = addnodes.pending_xref( reftarget=mdnode.destination, reftype='any', refexplicit=True, refwarn=True ) # TODO also not correct sourcepos wrap_node.line = (mdnode.sourcepos[0][0] if mdnode.sourcepos else mdnode.parent.sourcepos[0][0]) if mdnode.title: wrap_node['title'] = mdnode.title wrap_node.append(ref_node) next_node = wrap_node self.current_node.append(next_node) self.current_node = ref_node
def make_content(self, all_members): doc = self.item content = addnodes.desc_content() if doc.exports or doc.dependencies: with addto(content, nodes.field_list()) as fields: if doc.exports: with addto(fields, nodes.field()) as field: field += nodes.field_name('Exports', 'Exports') with addto(field, nodes.field_body()) as body: ref = doc['exports'] # warning: not the same as doc.exports label = ref or '<anonymous>' link = addnodes.pending_xref( ref, nodes.paragraph(ref, label), refdomain='js', reftype='any', reftarget=ref, ) link['js:module'] = doc.name body += link if doc.dependencies: with addto(fields, nodes.field()) as field: self.make_dependencies(field, doc) if doc.doc: # FIXME: source offset self.directive.state.nested_parse(to_list(doc.doc, source=doc['sourcefile']), 0, content) self.directive.state.nested_parse(self.directive.content, 0, content) content += self.document_properties(all_members) return content
def add_shape_and_attrs(self, signode, modname, ftype, shape, attrs): # add shape if shape: add_shape(signode, shape, modname=modname) #signode += nodes.Text(' '+shape) # add type ('float', 'interger', etc) if ftype or attrs: signode += nodes.emphasis(' [', ' [') if ftype: refnode = addnodes.pending_xref( '', refdomain='f', reftype='type', reftarget=ftype, modname=modname,) refnode += nodes.emphasis(ftype, ftype) signode += refnode #tnode = addnodes.desc_type(ftype, ftype) #tnode += #signode += addnodes.desc_type(ftype, ftype) #signode += # signode += addnodes.desc_type('', '') # self._parse_type(signode[-1], ftype) if attrs: if ftype: signode += nodes.emphasis(',',',') for iatt,att in enumerate(re.split('\s*,\s*', attrs)): if iatt: signode += nodes.emphasis(',',',') if att.startswith('parameter'): value = att.split('=')[1] signode += nodes.emphasis('parameter=', 'parameter=') convert_arithm(signode, value, modname=modname) else: signode += nodes.emphasis(att,att) #signode += nodes.emphasis(attrs, attrs) if ftype or attrs: signode += nodes.emphasis(']', ']')
def make_xref(self, rolename, domain, target, innernode=nodes.emphasis): if not rolename: return innernode(target, target) refnode = addnodes.pending_xref('', refdomain=domain, refexplicit=False, reftype=rolename, reftarget=target) refnode += innernode(target, target) return refnode
def apply(self): config = self.document.settings.env.config github_project = config.github_project issue_pattern = config.github_issue_pattern if isinstance(issue_pattern, str_t): issue_pattern = re.compile(issue_pattern) for node in self.document.traverse(nodes.Text): parent = node.parent if isinstance(parent, (nodes.literal, nodes.FixedTextElement)): continue text = text_t(node) new_nodes = [] last_issue_ref_end = 0 for match in issue_pattern.finditer(text): head = text[last_issue_ref_end:match.start()] if head: new_nodes.append(nodes.Text(head)) last_issue_ref_end = match.end() issuetext = match.group(0) issue_id = match.group(1) refnode = pending_xref() refnode['reftarget'] = issue_id refnode['reftype'] = 'issue' refnode['refdomain'] = 'github' refnode['github_project'] = github_project reftitle = issuetext refnode.append(nodes.inline( issuetext, reftitle, classes=['xref', 'issue'])) new_nodes.append(refnode) if not new_nodes: continue tail = text[last_issue_ref_end:] if tail: new_nodes.append(nodes.Text(tail)) parent.replace(node, new_nodes)
def resolve_xref(self, env, fromdocname, builder, typ, target, node, contnode): if typ == 'ref': if node['refexplicit']: # reference to anonymous label; the reference uses # the supplied link caption docname, labelid = self.data['anonlabels'].get(target, ('','')) sectname = node.astext() else: # reference to named label; the final node will # contain the section name after the label docname, labelid, sectname = self.data['labels'].get(target, ('','','')) if not docname: return None newnode = nodes.reference('', '', internal=True) innernode = nodes.emphasis(sectname, sectname) if docname == fromdocname: newnode['refid'] = labelid else: # set more info in contnode; in case the # get_relative_uri call raises NoUri, # the builder will then have to resolve these contnode = addnodes.pending_xref('') contnode['refdocname'] = docname contnode['refsectname'] = sectname newnode['refuri'] = builder.get_relative_uri( fromdocname, docname) if labelid: newnode['refuri'] += '#' + labelid newnode.append(innernode) return newnode elif typ == 'keyword': # keywords are oddballs: they are referenced by named labels docname, labelid, _ = self.data['labels'].get(target, ('','','')) if not docname: return None return make_refnode(builder, fromdocname, docname, labelid, contnode) elif typ == 'option': progname = node['refprogram'] docname, labelid = self.data['progoptions'].get((progname, target), ('', '')) if not docname: return None return make_refnode(builder, fromdocname, docname, labelid, contnode) else: objtypes = self.objtypes_for_role(typ) or [] for objtype in objtypes: if (objtype, target) in self.data['objects']: docname, labelid = self.data['objects'][objtype, target] break else: docname, labelid = '', '' if not docname: return None return make_refnode(builder, fromdocname, docname, labelid, contnode)
def make_xref(self, rolename, domain, target, innernode=addnodes.literal_emphasis, contnode=None): if not rolename: return contnode or innernode(target, target) refnode = addnodes.pending_xref('', refdomain=domain, refexplicit=False, reftype=rolename, reftarget=target) refnode += contnode or innernode(target, target) return refnode
def format_type(t): ref = addnodes.pending_xref( t, addnodes.literal_emphasis(t, t), refdomain='js', reftype='class', reftarget=t, ) if mod: ref['js:module'] = mod return ref
def handle_signature(self, sig, signode): name = self.options['name'] parameters = json.loads(self.options['parameters']) if 'parameters' in self.options else [] return_v = json.loads(self.options['return']) if 'return' in self.options else ("","") prefix = self.options['prefix'] if 'prefix' in self.options else "" if not ('parameters' in self.options) or not ('return' in self.options): print("WARNING: No parameters or return set for '" + name + "'") signode += nodes.Text(prefix + ' ', prefix + u'\xa0') xref = addnodes.pending_xref( ':ref:`' + return_v[1] + '`', refdomain='std', reftype='ref', reftarget=ws_re.sub(' ', return_v[1].lower()), refexplicit=False) xref += nodes.Text(return_v[0], return_v[0]) signode += xref signode += nodes.Text(' ', u'\xa0') signode += addnodes.desc_name(name, name) paramlist = addnodes.desc_parameterlist() for tn in parameters: param = addnodes.desc_parameter('', '', noemph=True) prefix = '' if len(tn) > 3 and tn[3] == "True": prefix += "ref " if len(tn) > 4 and tn[4] == "True": prefix += "out " if prefix != "": param += nodes.Text(prefix + ' ', prefix + u'\xa0') xref = addnodes.pending_xref( ':ref:`' + tn[2] + '`', refdomain='std', reftype='ref', reftarget=ws_re.sub(' ', tn[2].lower()), refexplicit=False) xref += nodes.Text(tn[0], tn[0]) param += xref param += nodes.emphasis(' '+tn[1], u'\xa0'+tn[1]) paramlist += param signode += paramlist return name, ""
def get_xref(typ, target, title=None): if title is None: title = target ref = addnodes.pending_xref(title, reftype=typ, refdomain="xml", reftarget=target) ref.append(nodes.literal(title, title)) return ref
def doctree_read(app, doctree): env = app.builder.env if not hasattr(env, "_viewcode_modules"): env._viewcode_modules = {} def has_tag(modname, fullname, docname): entry = env._viewcode_modules.get(modname, None) try: analyzer = ModuleAnalyzer.for_module(modname) except Exception: env._viewcode_modules[modname] = False return if not isinstance(analyzer.code, str): code = analyzer.code.decode(analyzer.encoding) else: code = analyzer.code if entry is None or entry[0] != code: analyzer.find_tags() entry = code, analyzer.tags, {} env._viewcode_modules[modname] = entry elif entry is False: return code, tags, used = entry if fullname in tags: used[fullname] = docname return True for objnode in doctree.traverse(addnodes.desc): if objnode.get("domain") != "py": continue names = set() for signode in objnode: if not isinstance(signode, addnodes.desc_signature): continue modname = signode.get("module") if not modname: continue fullname = signode.get("fullname") if not has_tag(modname, fullname, env.docname): continue if fullname in names: # only one link per name, please continue names.add(fullname) pagename = "_modules/" + modname.replace(".", "/") onlynode = addnodes.only(expr="html") onlynode += addnodes.pending_xref( "", reftype="viewcode", refdomain="std", refexplicit=False, reftarget=pagename, refid=fullname, refdoc=env.docname, ) onlynode[0] += nodes.inline("", _("[source]"), classes=["viewcode-link"]) signode += onlynode
def attach_type(self, node, type): # XXX: link to c? text = unicode(type) pnode = addnodes.pending_xref( '', refdomain='matlab', reftype='type', reftarget=text, modname=None, classname=None) pnode['matlab:parent'] = self.env.temp_data.get('matlab:parent') pnode += nodes.Text(text) node += pnode
def apply(self): for citnode in self.document.traverse(nodes.citation_reference): cittext = citnode.astext() refnode = addnodes.pending_xref(cittext, reftype='citation', reftarget=cittext, refwarn=True, ids=citnode["ids"]) refnode.line = citnode.line or citnode.parent.line refnode += nodes.Text('[' + cittext + ']') citnode.parent.replace(citnode, refnode)
def fake_node(domain, type, target, content, **attrs): contnode = nodes.emphasis(content, content) node = addnodes.pending_xref("") node["reftarget"] = target node["reftype"] = type node["refdomain"] = domain node.attributes.update(attrs) node += contnode return node, contnode
def doctree_read(app, doctree): env = app.builder.env if not hasattr(env, '_viewcode_modules'): env._viewcode_modules = {} def has_tag(modname, fullname, docname, refname): entry = env._viewcode_modules.get(modname, None) try: analyzer = ModuleAnalyzer.for_module(modname) except Exception: env._viewcode_modules[modname] = False return if not isinstance(analyzer.code, text_type): code = analyzer.code.decode(analyzer.encoding) else: code = analyzer.code if entry is None or entry[0] != code: analyzer.find_tags() entry = code, analyzer.tags, {}, refname env._viewcode_modules[modname] = entry elif entry is False: return _, tags, used, _ = entry if fullname in tags: used[fullname] = docname return True for objnode in doctree.traverse(addnodes.desc): if objnode.get('domain') != 'py': continue names = set() for signode in objnode: if not isinstance(signode, addnodes.desc_signature): continue modname = signode.get('module') fullname = signode.get('fullname') refname = modname if env.config.viewcode_import: modname = _get_full_modname(app, modname, fullname) if not modname: continue fullname = signode.get('fullname') if not has_tag(modname, fullname, env.docname, refname): continue if fullname in names: # only one link per name, please continue names.add(fullname) pagename = '_modules/' + modname.replace('.', '/') onlynode = addnodes.only(expr='html') onlynode += addnodes.pending_xref( '', reftype='viewcode', refdomain='std', refexplicit=False, reftarget=pagename, refid=fullname, refdoc=env.docname) onlynode[0] += nodes.inline('', _('[source]'), classes=['viewcode-link']) signode += onlynode
def make_checker_chaining(self): symbol = self.lookup_auto_symbol() if not symbol: return next_checkers = symbol.properties.get('flycheck-next-checkers') if not next_checkers: return title = nodes.title('', 'Chained syntax checkers') intro = nodes.paragraph() intro += nodes.Text('The following syntax checkers are ') chained = addnodes.pending_xref( 'chained', reftype='term', refdomain='std', reftarget='chaining', refwarn=True, refexplicit=True, reftitle='chaining', refdoc=self.env.docname) chained += nodes.emphasis('', 'chained') intro += chained intro += nodes.Text(' after this syntax checker:') checker_list = nodes.enumerated_list() para = nodes.paragraph() para += checker_list outro = nodes.paragraph() outro += nodes.Text('The ') outro += nodes.strong('', 'first') outro += nodes.Text(' suitable syntax checker is used.') chaining = nodes.admonition( '', title, intro, para, outro, classes=['note', 'el-flycheck-checker-chaining']) for next_checker in next_checkers: xref = addnodes.pending_xref( next_checker.checker, reftype='flyc-checker', refdomain='el', refexplicit=False, reftarget=next_checker.checker, refwarn=False, refdoc=self.env.docname) set_role_source_info(self.state.inliner, self.lineno, xref) xref += nodes.literal('', next_checker.checker, classes=['xref', 'el', 'el-flyc-checker']) para = nodes.paragraph() para += xref if next_checker.warnings_only: para += nodes.Text(', if there are only warnings') if next_checker.no_errors: para += nodes.Text(', if there are no errors') checker_list += nodes.list_item('', para) return chaining
def handle_signature(self, sig, signode): if self.display_prefix: signode += addnodes.desc_annotation(self.display_prefix, self.display_prefix) name = self.options["name"] namespace = self.options["namespace"] fullname = self.options["fullname"] inherits = json.loads(self.options["inherits"]) if "inherits" in self.options else ("", "") implements = json.loads(self.options["implements"]) if "implements" in self.options else [] signode += addnodes.desc_name(name, name) toappend = [] if inherits[0] != "Object" and inherits[0] != "Enum" and inherits[0] != "": xref = addnodes.pending_xref( ":ref:`" + inherits[1] + "`", refdomain="std", reftype="ref", reftarget=ws_re.sub(" ", inherits[1].lower()), refexplicit=False, ) xref += nodes.Text(inherits[0], inherits[0]) toappend.append(xref) for implement in implements: if len(toappend) > 0: toappend.append(nodes.Text(", ", u",\xa0")) xref = addnodes.pending_xref( ":ref:`" + implement[1] + "`", refdomain="std", reftype="ref", reftarget=ws_re.sub(" ", implement[1].lower()), refexplicit=False, ) xref += nodes.Text(implement[0], implement[0]) toappend.append(xref) if len(toappend) > 0: signode += nodes.Text(" : ", u"\xa0:\xa0") for a in toappend: signode += a return name, namespace
def handle_signature(self, sig, signode): if self.display_prefix: signode += addnodes.desc_annotation(self.display_prefix, self.display_prefix) name = self.options['name'] namespace = self.options['namespace'] fullname = self.options['fullname'] inherits = json.loads(self.options['inherits']) if 'inherits' in self.options else ("","") implements = json.loads(self.options['implements']) if 'implements' in self.options else [] signode += addnodes.desc_name(name, name) toappend = [] if inherits[0] != "Object" and inherits[0] != "Enum" and inherits[0] != "": xref = addnodes.pending_xref( ':ref:`' + inherits[1] + '`', refdomain='std', reftype='ref', reftarget=ws_re.sub(' ', inherits[1].lower()), refexplicit=False) xref += nodes.Text(inherits[0], inherits[0]) toappend.append(xref) for implement in implements: if len(toappend) > 0: toappend.append(nodes.Text(', ', u',\xa0')) xref = addnodes.pending_xref( ':ref:`' + implement[1] + '`', refdomain='std', reftype='ref', reftarget=ws_re.sub(' ', implement[1].lower()), refexplicit=False) xref += nodes.Text(implement[0], implement[0]) toappend.append(xref) if len(toappend) > 0: signode += nodes.Text(' : ', u'\xa0:\xa0') for a in toappend: signode += a return name, namespace
def crossreference_title_ref(self, node, name, desc_type): nodetext = node.children[0].astext() reftype = DESCTYPE_TO_REFTYPE.get(desc_type, desc_type) newnode = pending_xref(nodetext, reftype=reftype, reftarget=name, modname=None, classname=None) node.replace_self(newnode) newnode += literal(nodetext, nodetext, classes=['xref']) # Yay, we found a new ref! self.new_pending_refs = True
def parse_c_type(node, ctype): # add cross-ref nodes for all words for part in filter(None, wsplit_re.split(ctype)): tnode = nodes.Text(part, part) if part[0] in string.letters+'_' and part not in stopwords: pnode = addnodes.pending_xref( '', reftype='ctype', reftarget=part, modname=None, classname=None) pnode += tnode node += pnode else: node += tnode
def visitHole(self, ctx:TacticNotationsParser.HoleContext): hole = ctx.ID().getText() token_name = hole[1:] node = nodes.inline(hole, token_name, classes=["hole"]) sub = ctx.SUB() if sub: sub_index = sub.getText()[2:] node += nodes.subscript(sub_index, sub_index) return [addnodes.pending_xref(token_name, node, reftype='token', refdomain='std', reftarget=token_name)]
def __make_list(self, obj, _lst, _type): def get_entry(node): para = addnodes.compact_paragraph() para += node entry = nodes.entry() entry += para return entry table, body, tgroup = nodes.table(), nodes.tbody(), nodes.tgroup(cols=2) thead = nodes.thead() tgroup += nodes.colspec(colwidth=20) tgroup += nodes.colspec(colwidth=80) tgroup += thead tgroup += body table += tgroup head_row = nodes.row() head_row += get_entry(nodes.Text('Name')) head_row += get_entry(nodes.Text('Brief')) thead += head_row kwargs = { 'refdomain': 'cpp', 'refexplicit': False, 'reftype': _type, } for it in sorted(_lst): row = nodes.row() subobj = self._get_obj(unicode(it.get_name())) if subobj is not None: kwargs['reftarget'] = unicode(it.get_name()) ref = addnodes.pending_xref('', **kwargs) ref += nodes.literal(text=unicode(subobj.name)) else: kwargs['reftarget'] = unicode(it.name) ref = addnodes.pending_xref('', **kwargs) ref += nodes.literal(text=unicode(it.name)) row += get_entry(ref) texts = None if subobj is not None and subobj.brief(): texts = nodes.Text(' '.join(subobj.brief())) row += get_entry(texts) body += row return table
def make_signature(self): ret = super(PropertyDocumenter, self).make_signature() proptype = self.item.type if proptype: typeref = addnodes.pending_xref( proptype, nodes.Text(proptype, proptype), refdomain='js', reftype='class', reftarget=proptype ) typeref['js:module'] = self.item['sourcemodule'].name ret.append(nodes.Text(' ')) ret.append(typeref) return ret
def apply(self): config = self.document.settings.env.config tracker_config = TrackerConfig.from_sphinx_config(config) issue_pattern = config.issuetracker_issue_pattern title_template = config.issuetracker_title_template if isinstance(issue_pattern, basestring): issue_pattern = re.compile(issue_pattern) for node in self.document.traverse(nodes.Text): parent = node.parent if isinstance(parent, (nodes.literal, nodes.FixedTextElement)): # ignore inline and block literal text continue text = unicode(node) new_nodes = [] last_issue_ref_end = 0 for match in issue_pattern.finditer(text): # catch invalid pattern with too many groups if len(match.groups()) != 1: raise ValueError( 'issuetracker_issue_pattern must have ' 'exactly one group: {0!r}'.format(match.groups())) # extract the text between the last issue reference and the # current issue reference and put it into a new text node head = text[last_issue_ref_end:match.start()] if head: new_nodes.append(nodes.Text(head)) # adjust the position of the last issue reference in the # text last_issue_ref_end = match.end() # extract the issue text (including the leading dash) issuetext = match.group(0) # extract the issue number (excluding the leading dash) issue_id = match.group(1) # turn the issue reference into a reference node refnode = pending_xref() refnode['reftarget'] = issue_id refnode['reftype'] = 'issue' refnode['trackerconfig'] = tracker_config reftitle = title_template or issuetext refnode.append(nodes.inline( issuetext, reftitle, classes=['xref', 'issue'])) new_nodes.append(refnode) if not new_nodes: # no issue references were found, move on to the next node continue # extract the remaining text after the last issue reference, and # put it into a text node tail = text[last_issue_ref_end:] if tail: new_nodes.append(nodes.Text(tail)) # find and remove the original node, and insert all new nodes # instead parent.replace(node, new_nodes)
def make_field(self, types, domain, item, env=None): fieldname = nodes.field_name('', self.label) backref = addnodes.pending_xref( '', refdomain="conda", reftype='requiredby', refexplicit=False, reftarget=env.ref_context['conda:package'], refdoc=env.docname ) backref += nodes.inline('', '') fieldbody = nodes.field_body('', backref) return nodes.field('', fieldname, fieldbody)
def data(self, obj): data = obj.attrs[self.field.name] if data is None: return nodes.Text('-', '-') elif data is ...: return nodes.Text('?', '?') else: ref = addnodes.pending_xref( '', refdomain='envy', reftype='genobj', reftarget=data.slug, ) ref += nodes.Text(data.name, data.name) return ref
def make_signature(self): cls = self.item.cls ret = super(InstanceDocumenter, self).make_signature() if cls: super_ref = addnodes.pending_xref( cls.name, nodes.Text(cls.name, cls.name), refdomain='js', reftype='class', reftarget=cls.name ) super_ref['js:module'] = cls['sourcemodule'].name ret.append(addnodes.desc_annotation(' instance of ', ' instance of ')) ret.append(addnodes.desc_type(cls.name, '', super_ref)) if not ret: return [addnodes.desc_name('???', '???')] return ret
def apply(self): # type: () -> None for citnode in self.document.traverse(nodes.citation_reference): cittext = citnode.astext() refnode = addnodes.pending_xref(cittext, refdomain='std', reftype='citation', reftarget=cittext, refwarn=True, ids=citnode["ids"]) refnode.source = citnode.source or citnode.parent.source refnode.line = citnode.line or citnode.parent.line refnode += nodes.Text('[' + cittext + ']') citnode.parent.replace(citnode, refnode)
def _parse_type(self, node, ctype): # type: (nodes.Element, str) -> None # add cross-ref nodes for all words for part in [_f for _f in wsplit_re.split(ctype) if _f]: tnode = nodes.Text(part, part) if part[0] in string.ascii_letters + '_' and \ part not in self.stopwords: pnode = addnodes.pending_xref( '', refdomain='c', reftype='type', reftarget=part, modname=None, classname=None) pnode += tnode node += pnode else: node += tnode
def run(self): version = self.arguments[0].strip() node = xnodes.div(classes=["x-version-added"]) node += nodes.Text("New in version ") node += nodes.inline( "", "", addnodes.pending_xref("", nodes.Text(version), refdomain="std", reftype="doc", refexplicit=True, reftarget="/releases/" + version)) return [node]
def parse_c_type(node, ctype): # add cross-ref nodes for all words for part in filter(None, wsplit_re.split(ctype)): tnode = nodes.Text(part, part) if part[0] in string.letters + '_' and part not in stopwords: pnode = addnodes.pending_xref('', reftype='ctype', reftarget=part, modname=None, classname=None) pnode += tnode node += pnode else: node += tnode
def run(self): tree = self.state.document.settings.env.app.doxyxml table = nodes.table() tgroup = nodes.tgroup(cols=2) tgroup += nodes.colspec(colwidth=50) tgroup += nodes.colspec(colwidth=50) # header tgroup += nodes.thead( '', nodes.row( '', *[ nodes.entry('', nodes.line(text=c)) for c in ["Function", "Description"] ])) # rows tbody = nodes.tbody() for c in self.content: name = c.strip() query = name.replace("&", " &") for elem in tree.findall( "./compounddef/sectiondef/memberdef/[name='%s']" % query): args = ', '.join(e.text for e in elem.findall("./param/declname")) ref = addnodes.pending_xref('', refdomain='cpp', refexplicit=False, reftype='func', reftarget='kitty::' + name) ref += nodes.literal(text='%s(%s)' % (name, args)) reft = nodes.paragraph() reft.extend([ref]) func = nodes.entry('', reft) desc = nodes.entry( '', nodes.line(text=elem.findtext("./briefdescription/para"))) tbody += nodes.row('', func, desc) tgroup += tbody table += tgroup return [table]
def run(self): missing_options = set(self.option_spec).difference(self.options) if missing_options: raise ValueError(f"Missing options: {missing_options!r};" f" content: {list(self.content)!r}") try: wires = getattr(self.env.app, KEY) except AttributeError: wires = [] setattr(self.env.app, KEY, wires) wires.append( WireInfo( value=self.content[0], type=self.options["type"], runtime=self.options["runtime"], config=self.options["config"], requirements=self.options["requirements"].split(), )) node = addnodes.desc() node["objtype"] = "wire" signode = addnodes.desc_signature("", "") signode += addnodes.desc_annotation("type", "type:") signode += addnodes.desc_name(self.options["type"], self.options["type"]) signode += addnodes.desc_annotation("config", "config:") signode += addnodes.pending_xref( "", addnodes.desc_addname(self.options["config"], self.options["config"]), refdomain="proto", reftype="message", reftarget=self.options["config"], ) node.append(signode) contentnode = addnodes.desc_content() if self.options["requirements"]: contentnode += nodes.paragraph("", "Requirements:") bullet_list = nodes.bullet_list("") for requirement in self.options["requirements"].split(): bullet_list += nodes.list_item("", nodes.literal("", requirement)) contentnode += bullet_list else: contentnode += nodes.paragraph("", "No requirements") node.append(contentnode) return [node]
def make_super(self): doc = self.item if not doc.superclass: return [] sup_link = addnodes.pending_xref( doc.superclass.name, nodes.paragraph(doc.superclass.name, doc.superclass.name), refdomain='js', reftype='class', reftarget=doc.superclass.name, ) sup_link['js:module'] = doc.superclass['sourcemodule'].name return nodes.field( '', nodes.field_name("Extends", "Extends"), nodes.field_body(doc.superclass.name, sup_link), )
def type_to_xref(text: str, env: BuildEnvironment = None) -> addnodes.pending_xref: """Convert a type string to a cross reference node.""" if text == 'None': reftype = 'obj' else: reftype = 'class' if env: kwargs = {'py:module': env.ref_context.get('py:module'), 'py:class': env.ref_context.get('py:class')} else: kwargs = {} return pending_xref('', nodes.Text(text), refdomain='py', reftype=reftype, reftarget=text, **kwargs)
def apply(self, **kwargs): # type: (Any) -> None for node in self.document.traverse(nodes.citation_reference): target = node.astext() ref = addnodes.pending_xref(target, refdomain='std', reftype='citation', reftarget=target, refwarn=True, support_smartquotes=False, ids=node["ids"], classes=node.get('classes', [])) ref += nodes.inline(target, '[%s]' % target) copy_source_info(node, ref) node.replace_self(ref)
def create_ref_node(raw_text, text, target): if not target: return nodes.Text(text, text) if url_re_prog.match(target): return nodes.reference(raw_text, text, refuri=target) node = addnodes.pending_xref(raw_text) node['reftype'] = 'ref' node['refdomain'] = 'std' node['reftarget'] = target node['refwarn'] = True node['refexplicit'] = True node += nodes.Text(text, text) return node
def apply(self, **kwargs: Any) -> None: domain = cast(CitationDomain, self.env.get_domain('citation')) for node in self.document.findall(nodes.citation_reference): target = node.astext() ref = pending_xref(target, refdomain='citation', reftype='ref', reftarget=target, refwarn=True, support_smartquotes=False, ids=node["ids"], classes=node.get('classes', [])) ref += nodes.inline(target, '[%s]' % target) copy_source_info(node, ref) node.replace_self(ref) # register reference node to domain domain.note_citation_reference(ref)
def token_xrefs(text): retnodes = [] pos = 0 for m in token_re.finditer(text): if m.start() > pos: txt = text[pos:m.start()] retnodes.append(nodes.Text(txt, txt)) refnode = addnodes.pending_xref( m.group(1), reftype='token', refdomain='std', reftarget=m.group(1)) refnode += nodes.literal(m.group(1), m.group(1), classes=['xref']) retnodes.append(refnode) pos = m.end() if pos < len(text): retnodes.append(nodes.Text(text[pos:], text[pos:])) return retnodes
def _generate_sigbody(self, node): row1 = xnodes.div(classes=["sig-qualifier"]) ref = addnodes.pending_xref("", nodes.Text(self.qualifier), reftarget=self.qualifier[:-1], reftype="class", refdomain="py") # Note: `ref` cannot be added directly: docutils requires that # <reference> nodes were nested inside <TextElement> nodes. row1 += nodes.generated("", "", ref) node += row1 row2 = xnodes.div(classes=["sig-main"]) self._generate_sigmain(row2) node += row2
def visit_link(self, mdnode): ref_node = nodes.reference() # Check destination is supported for cross-linking and remove extension destination = mdnode.destination _, ext = splitext(destination) # Check if the destination starts with a url scheme, since internal and # external links need to be handled differently. url_check = urlparse(destination) known_url_schemes = self.config.get('known_url_schemes') if known_url_schemes: scheme_known = url_check.scheme in known_url_schemes else: scheme_known = bool(url_check.scheme) # TODO check for other supported extensions, such as those specified in # the Sphinx conf.py file but how to access this information? if not scheme_known and ext.replace('.', '') in self.supported: destination = destination.replace(ext, '') ref_node['refuri'] = destination # TODO okay, so this is acutally not always the right line number, but # these mdnodes won't have sourcepos on them for whatever reason. This # is better than 0 though. ref_node.line = self._get_line(mdnode) if mdnode.title: ref_node['title'] = mdnode.title next_node = ref_node # If there's not a url scheme (e.g. 'https' for 'https:...' links), # or there is a scheme but it's not in the list of known_url_schemes, # then assume it's a cross-reference and pass it to Sphinx as an `:any:` ref. if not url_check.fragment and not scheme_known: wrap_node = addnodes.pending_xref( reftarget=unquote(destination), reftype='any', refdomain=None, # Added to enable cross-linking refexplicit=True, refwarn=True ) # TODO also not correct sourcepos wrap_node.line = self._get_line(mdnode) if mdnode.title: wrap_node['title'] = mdnode.title wrap_node.append(ref_node) next_node = wrap_node self.current_node.append(next_node) self.current_node = ref_node
def label_ref_node(docname, ref_to, title): """Generate a node that references a label""" txt = Text(title, rawsource=title) newchild = inline(':ref:`%s`' % ref_to, '', txt, classes=['xref', 'std', 'std-ref']) newnode = pending_xref(':ref:`%s`' % ref_to, newchild, reftype='ref', refwarn='True', reftarget=ref_to, refexplicit='False', refdomain='std', refdoc=docname) return newnode
def _parse_type(self, node, gotype): # add cross-ref nodes for all words for part in filter(None, wsplit_re.split(gotype)): tnode = nodes.Text(part, part) if part[0] in string.ascii_letters+'_' and \ part not in self.stopwords: pnode = addnodes.pending_xref('', refdomain='go', reftype='type', reftarget=part, modname=None, classname=None) pnode += tnode node += pnode else: node += tnode
def apply(self): # type: () -> None # mark citation labels as not smartquoted for citnode in self.document.traverse(nodes.citation): citnode[0]['support_smartquotes'] = False for citnode in self.document.traverse(nodes.citation_reference): cittext = citnode.astext() refnode = addnodes.pending_xref(cittext, refdomain='std', reftype='citation', reftarget=cittext, refwarn=True, support_smartquotes=False, ids=citnode["ids"]) refnode.source = citnode.source or citnode.parent.source refnode.line = citnode.line or citnode.parent.line refnode += nodes.Text('[' + cittext + ']') citnode.parent.replace(citnode, refnode)
def make_mixins(self): doc = self.item if not doc.mixins: return [] ret = nodes.field('', nodes.field_name("Mixes", "Mixes")) with addto(ret, nodes.field_body()) as body: with addto(body, nodes.bullet_list()) as mixins: for mixin in sorted(doc.mixins, key=lambda m: m.name): mixin_link = addnodes.pending_xref( mixin.name, nodes.paragraph(mixin.name, mixin.name), refdomain='js', reftype='mixin', reftarget=mixin.name ) mixin_link['js:module'] = mixin['sourcemodule'].name mixins += nodes.list_item('', mixin_link) return ret
def markup_funcs(docname, app, node): cdom = app.env.domains['c'] t = node.astext() done = 0 repl = [] for m in RE_function.finditer(t): # # Include any text prior to function() as a normal text node. # if m.start() > done: repl.append(nodes.Text(t[done:m.start()])) # # Go through the dance of getting an xref out of the C domain # target = m.group(1)[:-2] target_text = nodes.Text(target + '()') xref = None if target not in Skipfuncs: lit_text = nodes.literal(classes=['xref', 'c', 'c-func']) lit_text += target_text pxref = addnodes.pending_xref('', refdomain='c', reftype='function', reftarget=target, modname=None, classname=None) # # XXX The Latex builder will throw NoUri exceptions here, # work around that by ignoring them. # try: xref = cdom.resolve_xref(app.env, docname, app.builder, 'function', target, pxref, lit_text) except NoUri: xref = None # # Toss the xref into the list if we got it; otherwise just put # the function text. # if xref: repl.append(xref) else: repl.append(target_text) done = m.end() if done < len(t): repl.append(nodes.Text(t[done:])) return repl
def handle_method(signature_node, module, object_name, cache): """ Styles ``automethod`` entries. Adds link to originating class for inherited methods. """ *class_names, attr_name = object_name.split(".") # Handle nested classes class_ = module for class_name in class_names: class_ = getattr(class_, class_name, None) if class_ is None: return try: inspected_attr = cache[class_][attr_name] defining_class = inspected_attr.defining_class except KeyError: # TODO: This is a hack to handle bad interaction between enum and inspect defining_class = class_ if defining_class is not class_: reftarget = "{}.{}".format(defining_class.__module__, defining_class.__name__) xref_node = addnodes.pending_xref("", refdomain="py", refexplicit=True, reftype="class", reftarget=reftarget) name_node = nodes.literal("", "{}".format(defining_class.__name__), classes=["descclassname"]) xref_node.append(name_node) desc_annotation = list( signature_node.traverse(addnodes.desc_annotation)) index = len(desc_annotation) class_annotation = addnodes.desc_addname() class_annotation.extend([nodes.Text("("), xref_node, nodes.Text(").")]) class_annotation["xml:space"] = "preserve" signature_node.insert(index, class_annotation) else: is_overridden = False for class_ in defining_class.__mro__[1:]: if hasattr(class_, attr_name): is_overridden = True if is_overridden: emphasis = nodes.emphasis("overridden ", "overridden ", classes=["property"]) signature_node.insert(0, emphasis)
def handle_signature(self, sig, signode): container_class_name = self.env.temp_data.get('kotlin:class') match = var_sig.match(sig) if not match: self.warn('invalid variable/constant documentation string "%s", ' % sig) return match = match.groupdict() if self.objtype == 'var': signode += addnodes.desc_addname("var", "var ") elif self.objtype == 'val': signode += addnodes.desc_addname("val", "val ") name = match['name'].strip() signature = name signode += addnodes.desc_name(name, name) if match['type']: typ = match['type'].strip() #signature += '-' + typ # signode += addnodes.desc_type(typ, " : " + typ) # Add ref typeNode = addnodes.desc_type(' : ', ' : ') typeXref = addnodes.pending_xref('', refdomain='kotlin', reftype='type', reftarget=typ) typeXref += nodes.Text(typ, typ) typeNode += typeXref signode += typeNode if match['value'] and len(match['value']) > 0: value = match['value'].strip() signode += addnodes.desc_addname(value, " = " + value) elif match['value']: signode += addnodes.desc_addname('{ ... }', ' = { ... }') #signature += "-" + self.objtype if container_class_name: name = container_class_name + '.' + name signature = container_class_name + '.' + signature return name, signature, True
def token_xrefs(text: str, productionGroup: str = '') -> List[Node]: if len(productionGroup) != 0: productionGroup += ':' retnodes = [] # type: List[Node] pos = 0 for m in token_re.finditer(text): if m.start() > pos: txt = text[pos:m.start()] retnodes.append(nodes.Text(txt, txt)) refnode = pending_xref(m.group(1), reftype='token', refdomain='std', reftarget=productionGroup + m.group(1)) refnode += nodes.literal(m.group(1), m.group(1), classes=['xref']) retnodes.append(refnode) pos = m.end() if pos < len(text): retnodes.append(nodes.Text(text[pos:], text[pos:])) return retnodes
def visitHole(self, ctx: TacticNotationsParser.HoleContext): hole = ctx.ID().getText() token_name = hole[1:] node = nodes.inline(hole, token_name, classes=["hole"]) sub = ctx.SUB() if sub: sub_index = sub.getText()[2:] node += nodes.subscript(sub_index, sub_index) return [ addnodes.pending_xref(token_name, node, reftype='token', refdomain='std', reftarget=token_name) ]
def add_class_def(node, classDef): """Add reference on classDef to node """ ref = addnodes.pending_xref( reftarget=classDef, reftype="class", refdomain= "py", # py:class="None" py:module="altair" refdoc="user_guide/marks" refexplicit=False, # refdoc="", refwarn=False) ref["py:class"] = "None" ref["py:module"] = "altair" ref += nodes.literal(text=classDef, classes=["xref", "py", "py-class"]) node += ref return node
def __init__(self, sexp, types=None, show_defaults=False): if not isinstance(sexp, list): self.sexp = _read(sexp) else: self.sexp = sexp self.types = types if self.types: for i, type in enumerate(self.types): type_node = addnodes.pending_xref('', refdomain='cl', reftype='type', reftarget=type) # type = " " + type type_node += addnodes.desc_type(type, type) self.sexp[i] = [self.sexp[i], type_node] self.show_defaults = show_defaults self.show_defaults = True
def make_xref(self, rolename, # type: str domain, # type: str target, # type: str innernode=addnodes.literal_emphasis, # type: Type[TextlikeNode] contnode=None, # type: nodes.Node env=None, # type: BuildEnvironment ): # type: (...) -> nodes.Node if not rolename: return contnode or innernode(target, target) refnode = addnodes.pending_xref('', refdomain=domain, refexplicit=False, reftype=rolename, reftarget=target) refnode += contnode or innernode(target, target) if env: env.get_domain(domain).process_field_xref(refnode) return refnode
def _build_ref_node(self, target): ref = addnodes.pending_xref('', refdomain='java', reftype='type', reftarget=target, modname=None, classname=None) ref['java:outertype'] = self.get_type() package = self.env.temp_data.get('java:imports', dict()).get(target, None) if not package and target in java_dot_lang: package = 'java.lang' if package: ref['java:imported'] = True ref['java:package'] = package else: ref['java:imported'] = False ref['java:package'] = self.get_package() return ref
def handle_signature(self, sig, signode): name = self.options['name'] type_v = json.loads(self.options['type']) xref = addnodes.pending_xref(':ref:`' + type_v[1] + '`', refdomain='std', reftype='ref', reftarget=ws_re.sub( ' ', type_v[1].lower()), refexplicit=False) xref += nodes.Text(type_v[0], type_v[0]) signode += xref signode += nodes.Text(' ', u'\xa0') signode += addnodes.desc_name(name, name) return name, ""