//// The model, written out canonically. //// //// Not an output format: an *oracle*. Two libraries in two languages //// implement the same model from the same specification, and the cheap way //// to ask whether they agree is to have each write the whole loaded //// document as text and diff the two. Byte for byte identical to the D //// library's `ocda/dump.d`, which is the whole point of it. //// //// The rules, which both implementations follow: //// //// - every line is ` `, the value running to end of line, //// and only one free-form value per line; //// - a field at its default is *omitted*, so the output says what the //// document has rather than what the type declares; //// - dictionaries come in sorted key order, because neither language's //// map has an order worth relying on; //// - sections come in the fixed order of the format. //// //// Anything that reads this to reconstruct a document has misunderstood //// it. Load the `.ssp` or the `.ocda.db`. import gleam/dict.{type Dict} import gleam/int import gleam/list import gleam/string import ocda/model.{type Document, type Object} pub fn document(doc: Document) -> String { let lines = [] |> kv("version", doc.format_version) |> kv("source_filename", doc.source_filename) |> entries("source", doc.source) |> entries("meta", doc.metadata) |> entries("make", doc.make) |> entries("doc_has", doc.doc_has) |> counts(doc) |> objects(doc) lines |> list.reverse |> join } /// What the loader met and did not understand, sorted. /// /// Separate from the document dump: it describes the loader, not the /// document, and the `.ocda.db` loader has nothing to report where the /// `.ssp` loader does. pub fn unknown(doc: Document) -> String { [] |> numbered("property", doc.unknown.property) |> numbered("block", doc.unknown.block) |> numbered("line", doc.unknown.line) |> list.reverse |> join } fn join(lines: List(String)) -> String { case lines { [] -> "" _ -> string.join(lines, "\n") <> "\n" } } /// Accumulated newest-first and reversed once, so that nothing appends to /// the tail of a list that grows to a few hundred thousand lines. fn kv(acc: List(String), key: String, value: String) -> List(String) { case value { "" -> acc v -> [key <> " " <> v, ..acc] } } fn kn(acc: List(String), key: String, value: Int) -> List(String) { case value { 0 -> acc n -> [key <> " " <> int.to_string(n), ..acc] } } fn kb(acc: List(String), key: String, value: Bool) -> List(String) { case value { False -> acc True -> [key <> " 1", ..acc] } } fn entries( acc: List(String), prefix: String, d: Dict(String, String), ) -> List(String) { d |> dict.to_list |> list.sort(fn(a, b) { string.compare(a.0, b.0) }) |> list.fold(acc, fn(lines, pair) { [prefix <> " " <> pair.0 <> " " <> pair.1, ..lines] }) } fn numbered( acc: List(String), prefix: String, d: Dict(String, Int), ) -> List(String) { d |> dict.to_list |> list.sort(fn(a, b) { string.compare(a.0, b.0) }) |> list.fold(acc, fn(lines, pair) { [prefix <> " " <> pair.0 <> " " <> int.to_string(pair.1), ..lines] }) } fn counts(acc: List(String), doc: Document) -> List(String) { list.fold(model.section_names, acc, fn(lines, name) { case model.section(doc, name) { [] -> lines objects -> [ "section " <> name <> " " <> int.to_string(list.length(objects)), ..lines ] } }) } fn objects(acc: List(String), doc: Document) -> List(String) { list.fold(model.section_names, acc, fn(lines, name) { model.section(doc, name) |> list.index_fold(lines, fn(l, obj, i) { object(l, name, i, obj) }) }) } fn object( acc: List(String), section: String, index: Int, obj: Object, ) -> List(String) { let acc = ["object " <> section <> " " <> int.to_string(index), ..acc] acc |> kn("ocn", obj.ocn) |> kv("is_a", obj.is_a) |> kv("own_section", obj.own_section) |> kv("level", obj.heading_level) |> kv("identifier", obj.identifier) |> kv("part", obj.part) |> kv("is_of_type", obj.is_of_type) |> kv("segment_html_is", obj.segment_html_is) |> kv("segment_epub", obj.segment_epub) |> kv("segment_epub_is", obj.segment_epub_is) |> kn("parent", obj.parent_ocn) |> kn("last_descendant", obj.last_descendant_ocn) |> kn("ocn_range_first", obj.ocn_range_first) |> kn("ocn_range_last", obj.ocn_range_last) |> kv("children", ints(obj.children)) |> kv("ancestors", ints(obj.ancestors)) |> kb("dummy", obj.dummy_heading) |> kb("ocn_off", obj.ocn_off) |> kn("indent_base", obj.indent_base) |> kn("indent_hang", obj.indent_hang) |> kb("bullet", obj.bullet) |> kv("lang", obj.lang) |> kb("has_links", obj.has_links) |> kb("has_notes_reg", obj.has_notes_reg) |> kb("has_notes_star", obj.has_notes_star) |> kb("has_images", obj.has_images) |> kv("segment", obj.segment) |> kv("segment_prev", obj.segment_prev) |> kv("segment_next", obj.segment_next) |> kv("anchor", obj.anchor) |> kv("heading_lev_anchor", obj.heading_lev_anchor) |> kn("table_cols", obj.table_cols) |> kv("table_widths", obj.table_widths) |> kv("table_aligns", obj.table_aligns) |> kb("table_header", obj.table_header) |> kv("code_syntax", obj.code_syntax) |> kb("code_linenumbers", obj.code_linenumbers) |> kv("heading_ancestors_text", obj.heading_ancestors_text) |> kv("sha256", obj.sha256) |> links(obj) |> anchor_tags(obj) |> images(obj) |> text(obj) } fn links(acc: List(String), obj: Object) -> List(String) { list.fold(obj.stow_link, acc, fn(lines, url) { kv(lines, "stow_link", url) }) } fn anchor_tags(acc: List(String), obj: Object) -> List(String) { list.fold(obj.anchor_tags, acc, fn(lines, a) { kv(lines, "anchor_tag", a) }) } fn images(acc: List(String), obj: Object) -> List(String) { list.fold(obj.images, acc, fn(lines, img) { // the name last, because a filename may hold a space where none of the // other fields can let lines = kv( lines, "image", img.sha256 <> " " <> int.to_string(img.bytes) <> " " <> int.to_string(img.width) <> "x" <> int.to_string(img.height) <> " " <> case img.missing { True -> "1" False -> "0" } <> " " <> img.name, ) img.fields |> dict.to_list |> list.sort(fn(a, b) { string.compare(a.0, b.0) }) |> list.fold(lines, fn(l, pair) { kv(l, "image_field", pair.0 <> " " <> pair.1) }) }) } /// Text, when there is any. /// /// An object whose only text line is blank holds "" here, indistinguishable /// from no text at all, because the model joins the lines into one string. /// Both libraries lose the same distinction in the same place, which is /// what makes them comparable; it is recorded rather than hidden. fn text(acc: List(String), obj: Object) -> List(String) { case obj.text { "" -> acc t -> { let lines = string.split(t, on: "\n") let acc = kv(acc, "text", int.to_string(list.length(lines))) list.fold(lines, acc, fn(l, line) { ["| " <> line, ..l] }) } } } fn ints(xs: List(Int)) -> String { case xs { [] -> "" _ -> xs |> list.map(int.to_string) |> string.join(",") } }