module ocda.model; struct OcdaImage { string name; // image filename as referenced by the object string sha256; // hex-encoded (uppercase) digest of the file ulong bytes; // file size int width; // file's own pixel width (not display width) int height; // file's own pixel height bool missing; // file absent or unreadable, no sha256/bytes string[string] fields; // any further/unrecognised key:value fields } struct OcdaObject { int ocn; string is_a; // heading, para, toc, table, code, group, block, verse, quote, endnote, glossary, bibliography, bookindex, blurb string section; // head, toc, body, endnotes, glossary, bibliography, bookindex, blurb string heading_level; // A, B, C, D, 1, 2, 3, 4 (for headings) string identifier; // heading: from the declaration line; otherwise .identifier string part; // frontmatter, body, backmatter string is_of_type; // para, block, comment: how the text behaves string own_section; // .section, when it differs from the block it sits in string segment_html_is;// the html segment this object sits in string segment_epub; // the epub segment this heading opens string segment_epub_is;// the epub segment this object sits in string table_aligns; // l c r per column string[] stow_link; // links extracted from the object string[] anchor_tags; // named targets the markup placed on this object int parent_ocn; int last_descendant_ocn; int ocn_range_first;// a container (a poem): the first and last int ocn_range_last; // ocn of what it holds; 0 otherwise (2.1) int[] children; // direct child heading OCNs int[] ancestors; // markedup_ancestors[8] bool dummy_heading; bool ocn_off; int indent_base; int indent_hang; bool bullet; string lang; bool has_links; bool has_notes_reg; bool has_notes_star; bool has_images; string segment; string segment_prev; string segment_next; string anchor; string heading_lev_anchor; // a heading's own named target int table_cols; string table_widths; bool table_header; string code_syntax; bool code_linenumbers; string heading_ancestors_text; string sha256; OcdaImage[] images; // repeatable .image records, in order string text; // content (lines joined with newline) /+ ↓ whether this object is rendered at all. is_of_type "comment" is markup commentary: carried by the abstraction so that nothing is lost, and not put into output. An output that renders it leaks the author notes into the document, which is what spine itself does not do. +/ bool renders() const { return is_of_type != "comment"; } /+ ↓ the section this object belongs to, which is the block it sits in unless it says otherwise +/ string sectionOf() const { return (own_section.length > 0) ? own_section : section; } } /+ ↓ what the reader met and did not understand. A reader that silently drops what it does not know cannot say whether it understood the document, and cannot be used to check a specification against an implementation: silence and understanding look alike. So the parser counts what it ignored, and --report-unknown prints it. +/ struct OcdaUnknown { size_t[string] property; // .name -> times seen size_t[string] block; // @name -> times seen size_t[string] line; // first char -> times seen, lines of no known shape bool any() const { return property.length > 0 || block.length > 0 || line.length > 0; } } struct OcdaDocument { string format_version; // as declared on line 1, "" when absent string source_filename; // from the "% Source:" line string[string] source; // @source: language, languages, digest OcdaUnknown unknown; // what was met and not understood string[string] metadata; // key -> value string[string] make; // key -> value string[string] doc_has; // key -> value OcdaObject[] head; OcdaObject[] toc; OcdaObject[] body; OcdaObject[] endnotes; OcdaObject[] glossary; OcdaObject[] bibliography; OcdaObject[] bookindex; OcdaObject[] blurb; OcdaObject[] tail; /+ ↓ the major part of the declared version, "" when none was declared +/ string formatVersionMajor() const { import std.string : indexOf; if (format_version.length == 0) { return ""; } auto dot = format_version.indexOf('.'); return (dot > 0) ? format_version[0 .. dot] : format_version; } string meta(string key) { if (auto p = key in metadata) return *p; return ""; } OcdaObject[]* sectionByName(string name) { switch (name) { case "head": return &head; case "toc": return &toc; case "body": return &body; case "endnotes": return &endnotes; case "glossary": return &glossary; case "bibliography": return &bibliography; case "bookindex": return &bookindex; case "blurb": return &blurb; case "tail": return &tail; default: return null; } } } /+ ↓ the format major version this reader knows. The .ssp and the .ocda.db carry one version between them, declared in band: the .ssp on its first line, the database in its schema.version row. The minor part is raised when a property is added, and a reader of the newer format still reads the older one, so only the major part is checked here. Raise this when the reader has been brought to a new major, not before: the point of the gate is to refuse what has not been looked at. +/ enum ssp_format_major_read = "2";