path: root/gleam/src/ocda/dump.gleam

//// 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 `<key> <value>`, 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)
  |> kn("parent", obj.parent_ocn)
  |> kn("last_descendant", obj.last_descendant_ocn)
  |> 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(",")
  }
}