Merge pull request #62 from executablebooks/reset-directives

👌 IMPROVE: Resetting directive numbering between different directives

Author: AakashGfude

.gitignore

@@ -5,6 +5,7 @@ __pycache__
 .DS_Store
 .vscode/
 build/
+_build/
 dist/
 
 # Unit test / coverage reports

sphinx_proof/__init__.py

@@ -10,10 +10,16 @@
 from sphinx.config import Config
 from sphinx.application import Sphinx
 from sphinx.environment import BuildEnvironment
-from .nodes import enumerable_node, visit_enumerable_node, depart_enumerable_node
-from .nodes import unenumerable_node, visit_unenumerable_node, depart_unenumerable_node
+from .nodes import visit_enumerable_node, depart_enumerable_node
+from .nodes import (
+    NODE_TYPES,
+    unenumerable_node,
+    visit_unenumerable_node,
+    depart_unenumerable_node,
+)
 from .nodes import proof_node, visit_proof_node, depart_proof_node
 from .domain import ProofDomain
+from .proof_type import PROOF_TYPES
 from sphinx.util import logging
 from sphinx.util.fileutil import copy_asset
 
@@ -46,9 +52,9 @@ def merge_proofs(
 def init_numfig(app: Sphinx, config: Config) -> None:
     """Initialize proof numfig format."""
     config["numfig"] = True
-    numfig_format = {
-        "proof": "Proof %s",
-    }
+    numfig_format = {}
+    for typ in NODE_TYPES.keys():
+        numfig_format[typ] = typ + " %s"
     numfig_format.update(config.numfig_format)
     config.numfig_format = numfig_format
 
@@ -83,14 +89,15 @@ def setup(app: Sphinx) -> Dict[str, Any]:
         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),
-    )
+    for node in PROOF_TYPES.keys():
+        app.add_enumerable_node(
+            NODE_TYPES[node],
+            node,
+            None,
+            singlehtml=(visit_enumerable_node, depart_enumerable_node),
+            html=(visit_enumerable_node, depart_enumerable_node),
+            latex=(visit_enumerable_node, depart_enumerable_node),
+        )
 
     return {
         "version": "builtin",

sphinx_proof/directive.py

@@ -13,7 +13,7 @@
 from sphinx.util import logging
 from docutils.parsers.rst import directives
 from sphinx.util.docutils import SphinxDirective
-from .nodes import enumerable_node, unenumerable_node
+from .nodes import unenumerable_node, NODE_TYPES
 from .nodes import proof_node
 
 logger = logging.getLogger(__name__)
@@ -37,7 +37,6 @@ def run(self) -> List[Node]:
         env = self.env
         typ = self.name.split(":")[1]
         serial_no = env.new_serialno()
-
         if not hasattr(env, "proof_list"):
             env.proof_list = {}
 
@@ -76,7 +75,8 @@ def run(self) -> List[Node]:
         if "nonumber" in self.options:
             node = unenumerable_node()
         else:
-            node = enumerable_node()
+            node_type = NODE_TYPES[typ]
+            node = node_type()
 
         node.document = self.state.document
         node += nodes.title(title_text, "", *textnodes)

sphinx_proof/domain.py

@@ -119,12 +119,12 @@ def resolve_xref(
 
         todocname = match["docname"]
         title = contnode[0]
+
         if target in contnode[0]:
             number = ""
             if not env.proof_list[target]["nonumber"]:
-                number = ".".join(
-                    map(str, env.toc_fignumbers[todocname]["proof"][target])
-                )
+                typ = env.proof_list[target]["type"]
+                number = ".".join(map(str, env.toc_fignumbers[todocname][typ][target]))
             title = nodes.Text(f"{match['type'].title()} {number}")
         # builder, fromdocname, todocname, targetid, child, title=None
         return make_refnode(builder, fromdocname, todocname, target, title)

sphinx_proof/nodes.py

@@ -16,18 +16,6 @@
 latex_admonition_end = "\\end{sphinxadmonition}" + CR
 
 
-class proof_node(nodes.Admonition, nodes.Element):
-    pass
-
-
-class enumerable_node(nodes.Admonition, nodes.Element):
-    pass
-
-
-class unenumerable_node(nodes.Admonition, nodes.Element):
-    pass
-
-
 def visit_enumerable_node(self, node: Node) -> None:
     if isinstance(self, LaTeXTranslator):
         docname = find_parent(self.builder.env, node, "section")
@@ -40,14 +28,14 @@ def visit_enumerable_node(self, node: Node) -> None:
 def depart_enumerable_node(self, node: Node) -> None:
     typ = node.attributes.get("type", "")
     if isinstance(self, LaTeXTranslator):
-        number = get_node_number(self, node)
+        number = get_node_number(self, node, typ)
         idx = list_rindex(self.body, latex_admonition_start) + 2
         self.body.insert(idx, f"{typ.title()} {number}")
         self.body.append(latex_admonition_end)
     else:
         # Find index in list of 'Proof #'
-        number = get_node_number(self, node)
-        idx = self.body.index(f"Proof {number} ")
+        number = get_node_number(self, node, typ)
+        idx = self.body.index(f"{typ} {number} ")
         self.body[idx] = f"{typ.title()} {number} "
         self.body.append("</div>")
 
@@ -86,9 +74,8 @@ def depart_proof_node(self, node: Node) -> None:
     pass
 
 
-def get_node_number(self, node: Node) -> str:
+def get_node_number(self, node: Node, typ) -> str:
     """Get the number for the directive node for HTML."""
-    key = "proof"
     ids = node.attributes.get("ids", [])[0]
     if isinstance(self, LaTeXTranslator):
         docname = find_parent(self.builder.env, node, "section")
@@ -97,7 +84,7 @@ def get_node_number(self, node: Node) -> str:
         )  # Latex does not have builder.fignumbers
     else:
         fignumbers = self.builder.fignumbers
-    number = fignumbers.get(key, {}).get(ids, ())
+    number = fignumbers.get(typ, {}).get(ids, ())
     return ".".join(map(str, number))
 
 
@@ -127,3 +114,80 @@ def list_rindex(li, x) -> int:
         if li[i] == x:
             return i
     raise ValueError("{} is not in list".format(x))
+
+
+class proof_node(nodes.Admonition, nodes.Element):
+    pass
+
+
+class axiom_node(nodes.Admonition, nodes.Element):
+    pass
+
+
+class theorem_node(nodes.Admonition, nodes.Element):
+    pass
+
+
+class lemma_node(nodes.Admonition, nodes.Element):
+    pass
+
+
+class algorithm_node(nodes.Admonition, nodes.Element):
+    pass
+
+
+class definition_node(nodes.Admonition, nodes.Element):
+    pass
+
+
+class remark_node(nodes.Admonition, nodes.Element):
+    pass
+
+
+class conjecture_node(nodes.Admonition, nodes.Element):
+    pass
+
+
+class corollary_node(nodes.Admonition, nodes.Element):
+    pass
+
+
+class criterion_node(nodes.Admonition, nodes.Element):
+    pass
+
+
+class example_node(nodes.Admonition, nodes.Element):
+    pass
+
+
+class property_node(nodes.Admonition, nodes.Element):
+    pass
+
+
+class observation_node(nodes.Admonition, nodes.Element):
+    pass
+
+
+class proposition_node(nodes.Admonition, nodes.Element):
+    pass
+
+
+class unenumerable_node(nodes.Admonition, nodes.Element):
+    pass
+
+
+NODE_TYPES = {
+    "axiom": axiom_node,
+    "theorem": theorem_node,
+    "lemma": lemma_node,
+    "algorithm": algorithm_node,
+    "definition": definition_node,
+    "remark": remark_node,
+    "conjecture": conjecture_node,
+    "corollary": corollary_node,
+    "criterion": criterion_node,
+    "example": example_node,
+    "property": property_node,
+    "observation": observation_node,
+    "proposition": proposition_node,
+}

sphinx_proof/proof_type.py

@@ -93,11 +93,11 @@ class PropositionDirective(ElementDirective):
     "axiom": AxiomDirective,
     "theorem": TheoremDirective,
     "lemma": LemmaDirective,
+    "algorithm": AlgorithmDirective,
     "definition": DefinitionDirective,
     "remark": RemarkDirective,
     "conjecture": ConjectureDirective,
     "corollary": CorollaryDirective,
-    "algorithm": AlgorithmDirective,
     "criterion": CriterionDirective,
     "example": ExampleDirective,
     "property": PropertyDirective,

tests/books/test-mybook/index.rst

@@ -9,6 +9,7 @@ A Test Program!
    algorithm/_algo_labeled_titled_with_classname
    algorithm/_algo_numbered_reference
    algorithm/_algo_text_reference
+   theorem/_theorems_with_number
    proof/_proof_with_classname
    proof/_proof_with_labeled_math
    proof/_proof_no_classname

tests/books/test-mybook/theorem/_theorems_with_number.rst

@@ -0,0 +1,7 @@
+theorem 1
+=========
+
+.. prf:theorem:: Important Theorem
+    :label: theorem-one
+
+    It's true.

tests/test_html.py

@@ -12,12 +12,16 @@ def test_missing_ref(app, warnings):
 # Tests for algorithms
 @pytest.mark.sphinx("html", testroot="mybook")
 @pytest.mark.parametrize(
-    "idir", ["_algo_labeled_titled_with_classname.html", "_algo_nonumber.html"]
+    "idir",
+    [
+        "algorithm/_algo_labeled_titled_with_classname.html",
+        "algorithm/_algo_nonumber.html",
+    ],
 )
 def test_algorithm(app, idir, file_regression):
     """Test algorithm directive markup."""
     app.build()
-    path_algo_directive = app.outdir / "algorithm" / idir
+    path_algo_directive = app.outdir / idir
     assert path_algo_directive.exists()
 
     # get content markup
@@ -28,12 +32,13 @@ def test_algorithm(app, idir, file_regression):
 
 @pytest.mark.sphinx("html", testroot="mybook")
 @pytest.mark.parametrize(
-    "idir", ["_algo_numbered_reference.html", "_algo_text_reference.html"]
+    "idir",
+    ["algorithm/_algo_numbered_reference.html", "algorithm/_algo_text_reference.html"],
 )
 def test_reference(app, idir, file_regression):
     """Test algorithm ref role markup."""
     app.builder.build_all()
-    path_algo_directive = app.outdir / "algorithm" / idir
+    path_algo_directive = app.outdir / idir
     assert path_algo_directive.exists()
     # get content markup
     soup = BeautifulSoup(path_algo_directive.read_text(encoding="utf8"), "html.parser")
@@ -53,21 +58,42 @@ def test_duplicate_label(app, warnings):
 @pytest.mark.parametrize(
     "idir",
     [
-        "_proof_with_classname.html",
-        "_proof_no_classname.html",
-        "_proof_with_argument_content.html",
-        "_proof_with_labeled_math.html",
-        "_proof_with_unlabeled_math.html",
+        "proof/_proof_with_classname.html",
+        "proof/_proof_no_classname.html",
+        "proof/_proof_with_argument_content.html",
+        "proof/_proof_with_labeled_math.html",
+        "proof/_proof_with_unlabeled_math.html",
     ],
 )
 def test_proof(app, idir, file_regression):
     """Test proof directive markup."""
     app.build()
-    path_proof_directive = app.outdir / "proof" / idir
+    path_proof_directive = app.outdir / idir
     assert path_proof_directive.exists()
 
     # get content markup
     soup = BeautifulSoup(path_proof_directive.read_text(encoding="utf8"), "html.parser")
 
     proof = soup.select("div.proof")[0]
     file_regression.check(str(proof), basename=idir.split(".")[0], extension=".html")
+
+
+# Tests for numbering
+@pytest.mark.sphinx("html", testroot="mybook")
+@pytest.mark.parametrize(
+    "idir",
+    [
+        "algorithm/_algo_labeled_titled_with_classname.html",
+        "theorem/_theorems_with_number.html",
+    ],
+)
+def test_numbering(app, idir, file_regression):
+    """Test numbering of different directives."""
+    app.build()
+    path_directive = app.outdir / idir
+    assert path_directive.exists()
+
+    # get content markup
+    soup = BeautifulSoup(path_directive.read_text(encoding="utf8"), "html.parser")
+    proof = soup.select("div.proof")[0]
+    file_regression.check(str(proof), basename=idir.split(".")[0], extension=".html")