summaryrefslogtreecommitdiffhomepage
path: root/dlang/src/read/images.d
blob: afddc74180285b3883e075b2440781c4cd008df0 (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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
module read.images;

import std.array : join;
import std.conv : to;
import std.stdio : writeln, File;
import ocda.model;

/+ ↓ the .image records of a document, gathered per distinct file, with the
   objects referencing each file, in order of first appearance +/
struct ImageEntry {
  string    name;
  string    sha256;
  ulong     bytes;
  int       width;
  int       height;
  bool      missing;
  string[]  refs;
  string[]  other_sha256;  // same filename, differing digest
}

struct ImageRecords {
  int          records;    // .image lines, an image referenced twice counts twice
  ImageEntry[] entries;    // distinct files
}

ImageRecords gatherImageRecords(OcdaDocument doc) {
  ImageRecords ret;
  size_t[string] seen;
  foreach (section; sectionNames) {
    auto objs = doc.sectionByName(section);
    if (objs is null) continue;
    foreach (obj; *objs) {
      foreach (img; obj.images) {
        ret.records += 1;
        string _ref = section ~ "[" ~ obj.ocn.to!string ~ "]";
        if (auto at = img.name in seen) {
          if (ret.entries[*at].sha256 != img.sha256
            && img.sha256.length > 0
            && ret.entries[*at].sha256.length > 0) {
            ret.entries[*at].other_sha256 ~= img.sha256;
          }
          ret.entries[*at].refs ~= _ref;
        } else {
          ImageEntry e_;
          e_.name    = img.name;
          e_.sha256  = img.sha256;
          e_.bytes   = img.bytes;
          e_.width   = img.width;
          e_.height  = img.height;
          e_.missing = img.missing;
          e_.refs    = [_ref];
          seen[img.name] = ret.entries.length;
          ret.entries ~= e_;
        }
      }
    }
  }
  return ret;
}

/+ ↓ image manifest, line oriented and greppable:

     <sha256>  <bytes>  <px>  <filename>  refs: body[97] body[412]
     MISSING                  <filename>  refs: body[840]

   The point of the record in the .ssp is verification (is the image
   shipped in this pod the image the abstraction was built from), so this
   output is the shape a verifier wants: one line per distinct file.
+/
void outputImages(OcdaDocument doc, string output_file) {
  auto gathered = gatherImageRecords(doc);
  string[] lines;
  int missing = 0;
  foreach (e; gathered.entries) {
    if (e.missing) missing += 1;
  }
  lines ~= "Images: " ~ gathered.records.to!string ~ " record"
    ~ ((gathered.records == 1) ? "" : "s")
    ~ ", " ~ gathered.entries.length.to!string ~ " distinct file"
    ~ ((gathered.entries.length == 1) ? "" : "s")
    ~ ", " ~ missing.to!string ~ " missing";
  lines ~= "";
  foreach (e; gathered.entries) {
    string px = (e.width > 0 && e.height > 0)
      ? e.width.to!string ~ "x" ~ e.height.to!string : "-";
    lines ~= (e.missing)
      ? "MISSING" ~ "  " ~ e.name ~ "  refs: " ~ e.refs.join(" ")
      : e.sha256 ~ "  " ~ e.bytes.to!string ~ "  " ~ px
        ~ "  " ~ e.name ~ "  refs: " ~ e.refs.join(" ");
    /+ ↓ one filename, more than one digest: the .ssp is inconsistent,
       or two distinct files share a name +/
    foreach (other; e.other_sha256) {
      lines ~= "  WARNING differing digest for same filename: " ~ other;
    }
  }

  /+ ↓ write output +/
  if (output_file.length > 0) {
    auto f = File(output_file, "w");
    foreach (line; lines) f.writeln(line);
  } else {
    foreach (line; lines) writeln(line);
  }
}

/+ ↓ count of .image records in a document, for the parse summary +/
int imageRecordCount(OcdaDocument doc) {
  return gatherImageRecords(doc).records;
}

package immutable string[] sectionNames = [
  "head", "toc", "body", "endnotes",
  "glossary", "bibliography", "bookindex", "blurb",
];