def missing_reference(app, env, node, contnode): target = node['reftarget'] typ = node['reftype'] domain = node.get('refdomain') if domain in exacts and target in exacts[domain]: raise NoUri() if (domain, typ) in exactsType and target in exactsType[(domain, typ)]: raise NoUri() if domain in prefixes and any( target.startswith(a) for a in prefixes[domain]): raise NoUri() if not domain and typ == "any" and target in anys: raise NoUri()
def run(self, **kwargs: Any) -> None: for node in self.document.traverse(addnodes.pending_xref): contnode = cast(nodes.TextElement, node[0].deepcopy()) newnode = None typ = node['reftype'] target = node['reftarget'] refdoc = node.get('refdoc', self.env.docname) domain = None try: if 'refdomain' in node and node['refdomain']: # let the domain try to resolve the reference try: domain = self.env.domains[node['refdomain']] except KeyError as exc: raise NoUri(target, typ) from exc newnode = domain.resolve_xref(self.env, refdoc, self.app.builder, typ, target, node, contnode) # really hardwired reference types elif typ == 'any': newnode = self.resolve_anyref(refdoc, node, contnode) # no new node found? try the missing-reference event if newnode is None: newnode = self.app.emit_firstresult('missing-reference', self.env, node, contnode, allowed_exceptions=(NoUri,)) # still not found? warn if node wishes to be warned about or # we are in nit-picky mode if newnode is None: self.warn_missing_reference(refdoc, typ, target, node, domain) except NoUri: newnode = contnode node.replace_self(newnode or contnode)
def run(self, **kwargs: Any) -> None: for node in self.document.traverse(addnodes.pending_xref): content = self.find_pending_xref_condition(node, ("resolved", "*")) if content: contnode = cast(Element, content[0].deepcopy()) else: contnode = cast(Element, node[0].deepcopy()) newnode = None typ = node['reftype'] target = node['reftarget'] refdoc = node.get('refdoc', self.env.docname) domain = None try: if 'refdomain' in node and node['refdomain']: # let the domain try to resolve the reference try: domain = self.env.domains[node['refdomain']] except KeyError as exc: raise NoUri(target, typ) from exc newnode = domain.resolve_xref(self.env, refdoc, self.app.builder, typ, target, node, contnode) # really hardwired reference types elif typ == 'any': newnode = self.resolve_anyref(refdoc, node, contnode) # no new node found? try the missing-reference event if newnode is None: newnode = self.app.emit_firstresult( 'missing-reference', self.env, node, contnode, allowed_exceptions=(NoUri, )) # still not found? warn if node wishes to be warned about or # we are in nit-picky mode if newnode is None: self.warn_missing_reference(refdoc, typ, target, node, domain) except NoUri: newnode = None if newnode: newnodes: List[Node] = [newnode] else: newnodes = [contnode] if newnode is None and isinstance( node[0], addnodes.pending_xref_condition): matched = self.find_pending_xref_condition(node, ("*", )) if matched: newnodes = matched else: logger.warning(__( 'Could not determine the fallback text for the ' 'cross-reference. Might be a bug.'), location=node) node.replace_self(newnodes)
def missing_reference( app: Sphinx, env: BuildEnvironment, node: pending_xref, contnode: Element ) -> Element: """ Remove or resolve references to third party packages. - The ``kubernetes_asyncio`` package doesn't provide any reference documentsion for its API. To allow nitpicking on missing references we take the approach to exclude all ``kubernetes_asyncio`` references. - The ``aiopg`` package uses top-level imports (e.g. ``from aiopg import Connection``) and writes the documentation as such. But the actual classes and functions are defined in e.g. ``aiopg.conection`` or ``aiopg.cursor``. We rewrite the references accordingly. """ reftarget = node.get("reftarget", "") if node.get("refdomain") == "py": if reftarget.startswith("kubernetes_asyncio."): raise NoUri() elif reftarget.startswith("aiohttp.client_reqrep."): node.attributes["reftarget"] = "aiohttp." + reftarget[22:] elif reftarget.startswith("aiopg.connection."): node.attributes["reftarget"] = "aiopg." + reftarget[17:] elif reftarget.startswith("aiopg.cursor."): node.attributes["reftarget"] = "aiopg." + reftarget[13:]
def get_target_uri(self, docname, typ=None): if docname not in self._docnames: # TODO: check whether docname is included in another target # document and somehow link to it raise NoUri(docname, typ) else: return '%' + docname
def get_target_uri(self, docname: str, typ: str = None) -> str: if docname not in self.docnames: raise NoUri(docname, typ) else: return '%' + docname
def get_target_uri(self, docname: str, typ: str = None) -> str: if typ == 'token': return '' raise NoUri(docname, typ)