"""Motor step 2: a folder of Markdown and text files builds with no code change. An invented folder (subfolders, capitals, Norwegian letters, Windows line breaks, a .txt file without a heading) goes through every step that is code: sources folder, kblocks order and blocks, kpack skeleton, one pack accepted from a hand-written compiler output, kassemble build and the auditor. Every source here is invented; no text from any documentation. Run: python3 -m unittest discover -s tests -p 'test_folder_build.py' """ from __future__ import annotations import io import json import sys import tempfile import unittest from contextlib import redirect_stderr, redirect_stdout from pathlib import Path from typing import Any, Callable ROOT = Path(__file__).resolve().parents[1] sys.path.insert(0, str(ROOT)) from okfwiki import audit, kassemble, kblocks, kpack, sources, view # noqa: E402 FOLDER = { "Hage/Årlig plan.md": "# Årlig plan\r\n\r\nKompost legges ut hver vår.\r\n\r\n## Såing\r\n\r\nGulrot sås i mai.\r\n", "notat.txt": "Bladene samles i en binge om høsten.\n\nBingen snus to ganger.\n", } NEW = {"topic_shape": "en ting en gartner gjør", "citation": "Se planen for det"} def quiet(fn: Callable[[list[str]], int], args: list[str]) -> tuple[int, str]: out, err = io.StringIO(), io.StringIO() with redirect_stdout(out), redirect_stderr(err): code = fn(args) return code, out.getvalue() + err.getvalue() class FolderBuildTest(unittest.TestCase): def setUp(self) -> None: self._tmp = tempfile.TemporaryDirectory() self.tmp = Path(self._tmp.name) self.folder = self.tmp / "Mine dokumenter" for rel, text in FOLDER.items(): p = self.folder / rel p.parent.mkdir(parents=True, exist_ok=True) p.write_bytes(text.encode("utf-8")) self.root = self.tmp / "sources" self.work = self.tmp / "work" self.wiki = self.tmp / "wiki" def tearDown(self) -> None: self._tmp.cleanup() def run_ok(self, fn: Callable[[list[str]], int], args: list[str]) -> str: code, out = quiet(fn, args) self.assertEqual(code, 0, f"{args[0]}: {out}") return out def frag(self, blocks: list[dict[str, Any]], concept: str, file: str, quote: str, text: str, new: bool) -> dict[str, Any]: lines = (self.root / "kilde" / file).read_text(encoding="utf-8").split("\n") line = next(n for n, raw in enumerate(lines, 1) if quote in raw) block = next(b for b in blocks if b["file"] == file and b["start"] <= line <= b["end"]) f: dict[str, Any] = {"concept": concept, "status": "new" if new else "existing", "text": text, "anchor": {"file": file, "start": block["start"], "end": block["end"]}, "quote": quote, "provenance": "documented"} if new: f["tests"] = NEW return f def test_an_invented_folder_builds_and_passes_the_auditor(self) -> None: self.run_ok(sources.main, ["folder", str(self.folder), "--collection", "hage", "--out", str(self.root)]) names = sorted(p.name for p in (self.root / "kilde").iterdir()) self.assertEqual(names, ["hage__aarlig-plan.md", "notat.txt"]) self.work.mkdir() order, blocks_path = self.work / "order.txt", self.work / "blocks.json" self.run_ok(kblocks.main, ["order", str(self.root), "--out", str(order)]) self.assertEqual(order.read_text(encoding="utf-8").split(), names) self.run_ok(kblocks.main, ["blocks", str(self.root), "--order", str(order), "--out", str(blocks_path)]) blocks: list[dict[str, Any]] = json.loads(blocks_path.read_text(encoding="utf-8"))["blocks"] self.assertEqual({b["file"] for b in blocks}, set(names)) self.run_ok(kpack.main, ["skeleton", "--sources", str(self.root), "--work", str(self.work)]) index = json.loads((self.work / "K-work" / "index.json").read_text(encoding="utf-8")) ids = {e["id"] for e in index["entries"]} self.assertIn("aarlig-plan", ids) # B12: the Norwegian letters survive in the page id self.assertIn("saaing", ids) plan, notat = names doc = {"fragments": [ self.frag(blocks, "Årlig plan", plan, "Kompost legges ut hver vår.", "Kompost legges ut hver vår.", False), self.frag(blocks, "Såing", plan, "Gulrot sås i mai.", "Gulrot sås i mai.", False), self.frag(blocks, "Løvkompost", notat, "samles i en binge om høsten", "Løvet samles i en binge om høsten.", True), self.frag(blocks, "Løvkompost", notat, "Bingen snus to ganger.", "Bingen snus to ganger.", False), ], "main_pages": [{"source": plan, "concept": "Årlig plan"}, {"source": notat, "concept": "Løvkompost"}], "homes": [{"concept": "Såing", "home": "Årlig plan"}]} out = self.work / "K-fragments" / "pack-1.json" out.parent.mkdir(parents=True) out.write_text(json.dumps(doc, ensure_ascii=False), encoding="utf-8") common = ["--blocks", str(blocks_path), "--sources", str(self.root), "--work", str(self.work)] self.run_ok(kpack.main, ["pack", "1", *common]) # the trial of 07.11: a .txt without a heading showed the compiler only its safe name, and the new concept was # titled "honninghoesting"; the task names each source's original as well part = (self.work / "K-oppgaver" / "pack-1-part-1.md").read_text(encoding="utf-8") self.assertIn("- hage__aarlig-plan.md (original name: Hage/Årlig plan.md): ", part) # the same trial, run again with the original name shown: still "honninghoesting", an id, because the contract # said nothing of what a new concept is called; it becomes the page's title self.assertIn('"new" with `concept` its title as a reader would write it, in the language and letters of ' "the source (never an id)", " ".join(part.split())) self.run_ok(kpack.main, ["accept", "1", *common]) self.run_ok(kassemble.main, ["build", "--work", str(self.work), "--sources", str(self.root), "--out", str(self.wiki)]) pages = sorted(p.name for p in self.wiki.glob("*.md")) self.assertIn("loevkompost.md", pages) result = self.run_ok(audit.main, [str(self.wiki), str(self.root)]) report = json.loads(result) self.assertEqual(report["findings"], []) self.assertEqual(report["link_rule"]["main_pages"], {"pass": 2, "of": 2}) def test_a_folder_of_pdf_and_office_files_builds_with_the_page_and_paragraph_on_every_footnote(self) -> None: from test_readers import docx, pdf, xlsx folder = self.tmp / "Kontor" folder.mkdir() pdf(folder / "Rapport.pdf", ["Side en om bier", "Side to om honning"]) docx(folder / "Plan.docx") xlsx(folder / "Kuber.xlsx") self.run_ok(sources.main, ["folder", str(folder), "--collection", "kontor", "--out", str(self.root)]) self.work.mkdir() order, blocks_path = self.work / "order.txt", self.work / "blocks.json" self.run_ok(kblocks.main, ["order", str(self.root), "--out", str(order)]) self.run_ok(kblocks.main, ["blocks", str(self.root), "--order", str(order), "--out", str(blocks_path)]) blocks: list[dict[str, Any]] = json.loads(blocks_path.read_text(encoding="utf-8"))["blocks"] self.run_ok(kpack.main, ["skeleton", "--sources", str(self.root), "--work", str(self.work)]) plan, rapport, kuber = "plan.docx.md", "rapport.pdf.md", "kuber.xlsx.md" doc = {"fragments": [ self.frag(blocks, "Årlig plan", plan, "Kompost vendes hver uke.", "Kompost vendes hver uke.", False), self.frag(blocks, "Honning", rapport, "Side to om honning", "Side to om honning.", True), self.frag(blocks, "Bikuber", kuber, "B: 12", "Det står 12 ved bikuber.", True), ], "main_pages": [{"source": plan, "concept": "Årlig plan"}, {"source": rapport, "concept": "Honning"}, {"source": kuber, "concept": "Bikuber"}], "homes": []} out = self.work / "K-fragments" / "pack-1.json" out.parent.mkdir(parents=True) out.write_text(json.dumps(doc, ensure_ascii=False), encoding="utf-8") common = ["--blocks", str(blocks_path), "--sources", str(self.root), "--work", str(self.work)] self.run_ok(kpack.main, ["pack", "1", *common]) self.run_ok(kpack.main, ["accept", "1", *common]) self.run_ok(kassemble.main, ["build", "--work", str(self.work), "--sources", str(self.root), "--out", str(self.wiki)]) honning = (self.wiki / "honning.md").read_text(encoding="utf-8") self.assertIn(" x-locator:\n line: 3\n page: 2\n", honning) self.assertRegex(honning, r"\]: Rapport\.pdf, page 2\n") self.assertRegex((self.wiki / "aarlig-plan.md").read_text(encoding="utf-8"), r"\]: Plan\.docx, paragraph 3\n") # a spreadsheet row is one line; the footnote names the cell the quote stands in bikuber = (self.wiki / "bikuber.md").read_text(encoding="utf-8") self.assertIn(" x-locator:\n line: 3\n sheet: Plan\n cell: B1\n", bikuber) self.assertRegex(bikuber, r"\]: Kuber\.xlsx, sheet Plan, cell B1\n") report = json.loads(self.run_ok(audit.main, [str(self.wiki), str(self.root)])) self.assertEqual(report["findings"], []) self.assertEqual(report["link_rule"]["main_pages"], {"pass": 3, "of": 3}) # a cell outside the quoted row is caught (self.wiki / "bikuber.md").write_text(bikuber.replace("cell: B1", "cell: B3"), encoding="utf-8") report = json.loads(quiet(audit.main, [str(self.wiki), str(self.root)])[1]) self.assertEqual([f["check"] for f in report["findings"]], ["quote-wrong-place"]) (self.wiki / "bikuber.md").write_text(bikuber, encoding="utf-8") # a place that does not match the frozen copy's places is caught page = self.wiki / "honning.md" page.write_text(honning.replace("page: 2", "page: 1").replace("page 2", "page 1"), encoding="utf-8") report = json.loads(quiet(audit.main, [str(self.wiki), str(self.root)])[1]) self.assertEqual([f["check"] for f in report["findings"]], ["quote-wrong-place"]) page.write_text(honning, encoding="utf-8") # the view names the page and opens the original at it html = self.tmp / "html" self.run_ok(view.main, ["render", str(self.wiki), str(self.root), "--out", str(html)]) shown = (html / "honning.html").read_text(encoding="utf-8") self.assertIn("page 2", shown) self.assertIn('href="original/rapport.pdf#page=2"', shown) self.assertEqual((html / "original" / "rapport.pdf").read_bytes(), (folder / "Rapport.pdf").read_bytes()) if __name__ == "__main__": unittest.main()