From 0e2c9fa40ed98ceb7a26c2af69807cf577b6e32a Mon Sep 17 00:00:00 2001 From: Ralph Amissah Date: Fri, 25 Sep 2026 16:34:44 -0400 Subject: the abstraction as a library, and a defect it found at once The readers each read one serialisation and print. A writer needs neither: it needs the document. So the model and both loaders live here, and a writer cannot tell which serialisation it was handed, exactly as spine own writers cannot. ocda.model imports nothing, which is the property that makes writers possible: they depend on the model and on neither loader. The model and the .ssp loader are the ssp-reader code, moved and renamed to the level they belong to: the model is neither the .ssp nor the .ocda.db. ocda.load_db is new, and returns the same value from sqlite that load_ssp returns from text. ocda.load is the one place that decides what a path is. The claim is only true if the two loaders agree, so test/agree.d asks: load a document both ways and compare the models object by object. It found a real defect on its first run. Eight of thirty-six disagreed, and the cause was the .ssp loader, not the formats: an object whose first text line is blank lost it, the loader having decided whether to start a new line by asking whether the accumulated text was empty, which is a different question from whether a line has been seen. Seven documents of the sample set have verse opening on a blank line and every one of them was wrong. Nothing else had caught it: the two .ssp readers were compared on section counts, which the bug does not disturb. It took loading one document two ways and comparing the objects. Fixed here, and in ssp-reader/dlang which carried the same code. 36 of 36 now agree. (assisted by Claude-Code) Co-Authored-By: Claude Opus 5 (1M context) --- dlang/test/agree.d | 84 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 84 insertions(+) create mode 100644 dlang/test/agree.d (limited to 'dlang/test') diff --git a/dlang/test/agree.d b/dlang/test/agree.d new file mode 100644 index 0000000..bdf1b2e --- /dev/null +++ b/dlang/test/agree.d @@ -0,0 +1,84 @@ +/++ + Do the two loaders agree? + + The library's whole purpose is that a writer cannot tell which + serialisation it was handed. That is only true if loading a document's + .ssp and loading its .ocda.db give the same model, so this asks. + + Usage: agree .ssp .ocda.db [lang] ++/ +import std.conv : to; +import std.stdio; +import ocda.model; +import ocda.load; + +int main(string[] args) { + if (args.length < 3) { + stderr.writeln("usage: agree .ssp .ocda.db [lang]"); + return 2; + } + string lang = (args.length > 3) ? args[3] : ""; + OcdaDocument a, b; + try { + a = load(args[1]); + b = load(args[2], lang); + } catch (Exception e) { + stderr.writeln("error: ", e.msg); + return 2; + } + + int differences = 0; + void differ(string what, string from_ssp, string from_db) { + writeln(" differ: ", what); + writeln(" .ssp: ", from_ssp); + writeln(" .ocda.db: ", from_db); + differences++; + } + + if (a.format_version != b.format_version) { + differ("format_version", a.format_version, b.format_version); + } + if (a.source_filename != b.source_filename) { + differ("source_filename", a.source_filename, b.source_filename); + } + + /+ ↓ the sections, object by object. Position within a section is the + identity to compare on: an ocn is not unique and 0 is shared +/ + static immutable sections = ["head", "toc", "body", "endnotes", "glossary", + "bibliography", "bookindex", "blurb", "tail"]; + foreach (name; sections) { + auto sa = a.sectionByName(name); + auto sb = b.sectionByName(name); + if (sa is null || sb is null) { continue; } + if ((*sa).length != (*sb).length) { + differ(name ~ " object count", (*sa).length.to!string, (*sb).length.to!string); + continue; + } + foreach (i, oa; *sa) { + auto ob = (*sb)[i]; + string at = name ~ "[" ~ i.to!string ~ "]"; + if (oa.ocn != ob.ocn) { differ(at ~ " ocn", oa.ocn.to!string, ob.ocn.to!string); } + if (oa.is_a != ob.is_a) { differ(at ~ " is_a", oa.is_a, ob.is_a); } + if (oa.is_of_type != ob.is_of_type) { differ(at ~ " is_of_type", oa.is_of_type, ob.is_of_type); } + if (oa.part != ob.part) { differ(at ~ " part", oa.part, ob.part); } + if (oa.parent_ocn != ob.parent_ocn) { differ(at ~ " parent", oa.parent_ocn.to!string, ob.parent_ocn.to!string); } + if (oa.heading_level != ob.heading_level) { differ(at ~ " level", oa.heading_level, ob.heading_level); } + if (oa.sha256 != ob.sha256) { differ(at ~ " sha256", oa.sha256, ob.sha256); } + if (oa.text != ob.text) { differ(at ~ " text", oa.text, ob.text); } + if (oa.ancestors != ob.ancestors) { + differ(at ~ " ancestors", oa.ancestors.to!string, ob.ancestors.to!string); + } + if (oa.images.length != ob.images.length) { + differ(at ~ " image count", oa.images.length.to!string, ob.images.length.to!string); + } + if (differences > 12) { writeln(" ... stopping after 12"); return 1; } + } + } + + if (differences == 0) { + writeln("agree: the two loaders give the same model"); + return 0; + } + writeln(differences, " difference(s)"); + return 1; +} -- cgit v1.2.3