//// ocda-lib, in Gleam: the abstraction as a library, put to the question. //// //// A library has no binary, so this is the programs over it: the reader, //// and the two that test its claims. //// //// ocda-lib dump [--unknown] .ssp|.ocda.db [lang] //// ocda-lib agree .ssp .ocda.db [lang] //// ocda-lib read [options] [lang] (also installed as ocda-read) //// //// `dump` writes the whole loaded model out canonically, byte for byte as //// the D library's `ocda-dump` writes it, so that the two implementations //// can be diffed. `agree` asks the same question the D library's //// `ocda-agree` asks, within this language: does loading a document's //// `.ssp` give what loading its `.ocda.db` gives? import argv import gleam/int import gleam/io import gleam/list import gleam/string import ocda/dump import ocda/load import ocda/model.{type Document} import read/main as reader pub fn main() { case argv.load().arguments { ["dump", "--unknown", path] -> dump_file(path, "", True) ["dump", "--unknown", path, lang] -> dump_file(path, lang, True) ["dump", path] -> dump_file(path, "", False) ["dump", path, lang] -> dump_file(path, lang, False) ["agree", ssp, db] -> agree(ssp, db, "") ["agree", ssp, db, lang] -> agree(ssp, db, lang) ["read", ..rest] -> case reader.run(rest) { 0 -> Nil code -> halt(code) } _ -> usage() } } fn usage() -> Nil { io.println_error( "usage: ocda-lib dump [--unknown] .ssp|.ocda.db [lang] ocda-lib agree .ssp .ocda.db [lang] ocda-lib read [--help] [options] [lang]", ) halt(2) } fn dump_file(path: String, lang: String, unknown: Bool) -> Nil { case load.load(path, lang, False) { Error(message) -> fail(message) Ok(doc) -> case unknown { True -> io.print(dump.unknown(doc)) False -> io.print(dump.document(doc)) } } } /// The library's whole purpose is that a writer cannot tell which /// serialisation it was handed. That is only true if the two loaders give /// the same model, so this asks, and says where they part company rather /// than only that they did. fn agree(ssp_path: String, db_path: String, lang: String) -> Nil { case load.load(ssp_path, "", False), load.load(db_path, lang, False) { Error(message), _ -> fail(message) _, Error(message) -> fail(message) Ok(from_ssp), Ok(from_db) -> { let differences = compare(from_ssp, from_db) case differences { [] -> io.println("agree: the two loaders give the same model") _ -> { list.each(list.take(differences, 12), io.println) case list.length(differences) > 12 { True -> io.println(" ... stopping after 12") False -> Nil } io.println(int.to_string(list.length(differences)) <> " difference(s)") halt(1) } } } } } /// Compared through the dump rather than field by field, which is both /// shorter and stricter: the dump carries every field, so nothing can /// differ without showing here. fn compare(from_ssp: Document, from_db: Document) -> List(String) { let a = dump.document(from_ssp) let b = dump.document(from_db) case a == b { True -> [] False -> diff_lines(a, b) } } fn diff_lines(a: String, b: String) -> List(String) { let la = split_lines(a) let lb = split_lines(b) case list.length(la) == list.length(lb) { False -> [ " differ: line count", " .ssp: " <> int.to_string(list.length(la)), " .ocda.db: " <> int.to_string(list.length(lb)), ..pairwise(la, lb) ] True -> pairwise(la, lb) } } fn pairwise(la: List(String), lb: List(String)) -> List(String) { list.zip(la, lb) |> list.index_map(fn(pair, i) { #(i, pair.0, pair.1) }) |> list.filter(fn(t) { t.1 != t.2 }) |> list.map(fn(t) { " differ: line " <> int.to_string(t.0 + 1) <> "\n .ssp: " <> t.1 <> "\n .ocda.db: " <> t.2 }) } fn split_lines(text: String) -> List(String) { case text { "" -> [] _ -> string.split(text, on: "\n") } } fn fail(message: String) -> Nil { io.println_error("error: " <> message) halt(2) } /// Gleam has no standard exit, and the exit status is what a sweep script /// reads. @external(erlang, "erlang", "halt") fn halt(code: Int) -> Nil