implement: Build only after a clean validate (t35)

Author: peterbjohnson

in2lambda/draft/export.py

@@ -59,8 +59,10 @@ def as_set(draft: dict[str, Any], directory: str = ".") -> Set:
         question was written without parts, it becomes a part of its own holding
         nothing but that solution. That is the rule
         :meth:`~in2lambda.api.question.Question.add_solution` applies, so a draft
-        exports as the same sheet converted by `in2lambda convert` does. A block marked
-        ignore is in no question: it is the source's, not the set's.
+        exports as the same sheet converted by `in2lambda convert` does. A question
+        written with neither parts nor a solution holds one part with nothing in it,
+        which is the question as the draft has it. A block marked ignore is in no
+        question: it is the source's, not the set's.
 
     Examples:
         >>> from in2lambda.draft.export import as_set
@@ -100,6 +102,12 @@ def as_set(draft: dict[str, Any], directory: str = ".") -> Set:
                 for part_of in question.parts:
                     if not part_of.worked_solution:
                         part_of.worked_solution = fields[written]["value"]
+        if not question.parts:
+            # A question whose parts are yet to be written is still exported, and an
+            # empty part is what it holds: `json_convert` leaves a question with no
+            # parts at all carrying the template's own placeholder wording, which is
+            # wording no field of the draft holds.
+            question.parts.append(Part())
         # As the export refers to them: beside the draft, since that is where a command
         # naming a file names one. Whether the file is there is `build`'s question, not
         # asked here, so that a draft can be rendered while its figures are being found.

tests/fixtures/drafts/README.md

@@ -28,4 +28,6 @@ into `media/` - the only folder here with a file the fields point at.
 `question_solution_beside_part_solutions` is the only one filled in by a spec rather than by
 commands one at a time, and the only one whose question has two parts: both are answered by the
 spec's own solutions, so the `question solution` after it answers nothing, and the export carries
-it as a part of its own rather than dropping the wording.
+it as a part of its own rather than dropping the wording. `question_without_parts` is a question
+and nothing else, which the checks have nothing to say about: it is here because a question with
+no parts is what the export has to write out as an empty part rather than as the template's.

tests/fixtures/drafts/question_without_parts/commands.json

@@ -0,0 +1,9 @@
+[
+  {
+    "args": {
+      "text": "b1"
+    },
+    "by": "tests",
+    "command": "question add"
+  }
+]

tests/fixtures/drafts/question_without_parts/expected.json

@@ -0,0 +1,14 @@
+{
+  "q1.text": {
+    "by": "tests",
+    "edited": false,
+    "layer": 3,
+    "ranges": [
+      [
+        1,
+        1
+      ]
+    ],
+    "value": "Find the pressure at the bottom of a tank of water $h$ deep."
+  }
+}

tests/fixtures/drafts/question_without_parts/source.md

@@ -0,0 +1 @@
+Find the pressure at the bottom of a tank of water $h$ deep.

tests/test_draft.py

@@ -59,15 +59,18 @@ def _expected_parts(fields: dict[str, Any], number: int) -> int:
 
     One per ``qN.pM.text``, and one more where ``qN.solution`` is written beside a
     solution for every part there is: nothing is left for it to answer, so it is a part
-    of its own, as `in2lambda convert` writes one.
+    of its own, as `in2lambda convert` writes one. A question with no parts written for
+    it at all is one empty part, since a question exported holding none carries the
+    template's placeholder wording instead.
     """
     written = [
         int(found[2])
         for key in fields
         if (found := PART.fullmatch(key)) and int(found[1]) == number
     ]
     answered = all(f"q{number}.p{part}.solution" in fields for part in written)
-    return len(written) + (answered and f"q{number}.solution" in fields)
+    parts = len(written) + (answered and f"q{number}.solution" in fields)
+    return parts or 1
 
 
 def _reported(folder: Path) -> list[dict[str, Any]]:
@@ -568,9 +571,12 @@ def test_build_follows_the_report(folder: Path, tmp_path: Path, monkeypatch) ->
         for index, part in enumerate(question.parts, start=1):
             if f"q{number}.p{index}.text" not in fields:
                 # The question's own solution, written where every part is answered
-                # already: last, and holding nothing but that solution.
+                # already: last, and holding nothing but that solution. Or, where the
+                # question has no solution either, the empty part a question with no
+                # parts written for it exports as.
                 assert part.text == ""
-                assert part.worked_solution == fields[f"q{number}.solution"]["value"]
+                solution = fields.get(f"q{number}.solution")
+                assert part.worked_solution == (solution["value"] if solution else "")
                 continue
             assert part.text == fields[f"q{number}.p{index}.text"]["value"]
             # A part's own solution, or the question's where it has none of its own.