handling latex and resolving bugs

Author: AakashGfude

sphinx_proof/__init__.py

@@ -76,18 +76,21 @@ def setup(app: Sphinx) -> Dict[str, Any]:
         proof_node,
         singlehtml=(visit_proof_node, depart_proof_node),
         html=(visit_proof_node, depart_proof_node),
+        latex=(visit_proof_node, depart_proof_node)
     )
     app.add_node(
         unenumerable_node,
         singlehtml=(visit_unenumerable_node, depart_unenumerable_node),
         html=(visit_unenumerable_node, depart_unenumerable_node),
+        latex=(visit_unenumerable_node, depart_unenumerable_node)
     )
     app.add_enumerable_node(
         enumerable_node,
         "proof",
         None,
         singlehtml=(visit_enumerable_node, depart_enumerable_node),
         html=(visit_enumerable_node, depart_enumerable_node),
+        latex=(visit_enumerable_node, depart_enumerable_node)
     )
 
     return {

sphinx_proof/directive.py

@@ -97,7 +97,7 @@ def run(self) -> List[Node]:
             "prio": 0,
             "nonumber": True if "nonumber" in self.options else False,
         }
-
+        
         return [node]
 
 

sphinx_proof/domain.py

@@ -21,6 +21,7 @@
 from docutils import nodes
 from .directive import ProofDirective
 from .proof_type import PROOF_TYPES
+from copy import copy
 
 logger = logging.getLogger(__name__)
 
@@ -37,7 +38,10 @@ def generate(self, docnames=None) -> Tuple[Dict[str, Any], bool]:
         if not hasattr(self.domain.env, "proof_list"):
             return content, True
 
+        # import pdb;
+        # pdb.set_trace()
         proofs = self.domain.env.proof_list
+        # {'theorem-0': {'docname': 'start/overview', 'type': 'theorem', 'ids': ['theorem-0'], 'label': 'theorem-0', 'prio': 0, 'nonumber': False}}
 
         # name, subtype, docname, typ, anchor, extra, qualifier, description
         for anchor, values in proofs.items():
@@ -71,11 +75,21 @@ class ProofDomain(Domain):
     name = "prf"
     label = "Proof Domain"
 
-    roles = {"ref": ProofXRefRole()}
+    roles = {"ref": ProofXRefRole()} # role name -> role callable
 
-    indices = {ProofIndex}
+    indices = {ProofIndex} # a list of index subclasses
 
-    directives = {**{"proof": ProofDirective}, **PROOF_TYPES}
+    directives = {**{"proof": ProofDirective}, **PROOF_TYPES} # list of directives
+
+    enumerable_nodes = {}  # type: Dict[Type[Node], Tuple[str, Callable]]
+
+    def __init__(self, env: "BuildEnvironment") -> None:
+        super().__init__(env)
+
+        # set up enumerable nodes
+        self.enumerable_nodes = copy(self.enumerable_nodes)  # create a copy for this instance
+        for node, settings in env.app.registry.enumerable_nodes.items():
+            self.enumerable_nodes[node] = settings
 
     def resolve_xref(
         self,
@@ -87,7 +101,13 @@ def resolve_xref(
         node: pending_xref,
         contnode: Element,
     ) -> Element:
-
+        """
+        Resolve the pending_xref node with the given typ and target. This method should return a new node, 
+        to replace the xref node, containing the contnode which is the markup content of the cross-reference.
+        If no resolution can be found, None can be returned; the xref node will then given to the missing-reference event, 
+        and if that yields no resolution, replaced by contnode.The method can also raise sphinx.environment.NoUri 
+        to suppress the missing-reference event being emitted.
+        """
         try:
             match = env.proof_list[target]
         except Exception:
@@ -98,7 +118,6 @@ def resolve_xref(
 
         todocname = match["docname"]
         title = contnode[0]
-
         if target in contnode[0]:
             number = ""
             if not env.proof_list[target]["nonumber"]:

sphinx_proof/nodes.py

@@ -10,7 +10,9 @@
 from sphinx.builders.html import HTMLTranslator
 from docutils import nodes
 from docutils.nodes import Node
+from sphinx.writers.latex import LaTeXTranslator
 
+CR = '\n'
 
 class proof_node(nodes.Admonition, nodes.Element):
     pass
@@ -25,35 +27,55 @@ class unenumerable_node(nodes.Admonition, nodes.Element):
 
 
 def visit_enumerable_node(self, node: Node) -> None:
-    self.body.append(self.starttag(node, "div", CLASS="admonition"))
+    if isinstance(self, LaTeXTranslator):
+        self.body.append(CR + '\\begin{sphinxadmonition}{note}')
+    else:
+        self.body.append(self.starttag(node, "div", CLASS="admonition"))
 
 
 def depart_enumerable_node(self, node: Node) -> None:
     typ = node.attributes.get("type", "")
-
-    # Find index in list of 'Proof #'
-    number = get_node_number(self, node)
-    idx = self.body.index(f"Proof {number} ")
-    self.body[idx] = f"{typ.title()} {number} "
-    self.body.append("</div>")
+    if isinstance(self, LaTeXTranslator):
+        number = get_node_number_latex(self, node)
+        text = node.children[0].astext()
+        idx = list_rindex(self.body,CR + '\\begin{sphinxadmonition}{note}') + 2
+        self.body.insert(idx, f"{typ.title()} {number}")
+        self.body.append('\\end{sphinxadmonition}' + CR)
+    else:
+        # Find index in list of 'Proof #'
+        number = get_node_number(self, node)
+        idx = self.body.index(f"Proof {number} ")
+        self.body[idx] = f"{typ.title()} {number} "
+        self.body.append("</div>")
 
 
 def visit_unenumerable_node(self, node: Node) -> None:
-    self.body.append(self.starttag(node, "div", CLASS="admonition"))
+    if isinstance(self, LaTeXTranslator):
+        self.body.append(CR + '\\begin{sphinxadmonition}{note}')
+    else:
+        self.body.append(self.starttag(node, "div", CLASS="admonition"))
 
 
 def depart_unenumerable_node(self, node: Node) -> None:
     typ = node.attributes.get("type", "")
     title = node.attributes.get("title", "")
-
-    if title == "":
-        idx = len(self.body) - self.body[-1::-1].index('<p class="admonition-title">')
+    if isinstance(self, LaTeXTranslator):
+        if title == "":
+            idx = (len(self.body) - self.body[-1::-1].index(CR + '\\begin{sphinxadmonition}{note}')) + 1
+        else:
+            text = node.children[0].astext()
+            idx = list_rindex(self.body,CR + '\\begin{sphinxadmonition}{note}') + 2
+        self.body.insert(idx, f"{typ.title()}")
+        self.body.append('\\end{sphinxadmonition}' + CR)
     else:
-        idx = self.body.index(title)
+        if title == "":
+            idx = len(self.body) - self.body[-1::-1].index('<p class="admonition-title">')
+        else:
+            idx = list_rindex(self.body,title)
 
-    element = f"<span>{typ.title()} </span>"
-    self.body.insert(idx, element)
-    self.body.append("</div>")
+        element = f"<span>{typ.title()} </span>"
+        self.body.insert(idx, element)
+        self.body.append("</div>")
 
 
 def visit_proof_node(self, node: Node) -> None:
@@ -69,3 +91,36 @@ def get_node_number(self: HTMLTranslator, node: Node) -> str:
     ids = node.attributes.get("ids", [])[0]
     number = self.builder.fignumbers.get(key, {}).get(ids, ())
     return ".".join(map(str, number))
+
+def find_parent(env, node , parent_tag):
+    """Find the parent node."""
+    while True:
+        node = node.parent
+        if node is None:
+            return None
+        # parent should be a document in toc
+        if (
+            "docname" in node.attributes
+            and env.titles[node.attributes["docname"]].astext().lower()
+            in node.attributes["names"]
+        ):
+            return node.attributes['docname']
+
+    if node.tagname == parent_tag:
+        return node.attributes['docname']
+
+    return None
+
+def get_node_number_latex(self, node: Node) -> str:
+    key = "proof"
+    docname = find_parent(self.builder.env, node, "section")
+    ids = node.attributes.get("ids", [])[0]
+    fignumbers = self.builder.env.toc_fignumbers.get(docname, {})
+    number = fignumbers.get(key, {}).get(ids, ())
+    return ".".join(map(str, number))
+
+def list_rindex(li, x):
+    for i in reversed(range(len(li))):
+        if li[i] == x:
+            return i
+    raise ValueError("{} is not in list".format(x))