summaryrefslogtreecommitdiffhomepage
path: root/dlang/test/agree.d
blob: bdf1b2e0fa0d24dc5097f6d439f49c2bc14f35bb (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
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 <doc>.ssp <doc>.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 <doc>.ssp <doc>.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;
}