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",
];
|