summaryrefslogtreecommitdiffhomepage
path: root/dlang/src/ocda/model.d
blob: 6c8fc37871d931650ad7c3ad9e915fbd344681e6 (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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
module ocda.model;

struct OcdaImage {
  string      name;           // image filename as referenced by the object
  string      sha256;         // hex-encoded (uppercase) digest of the file
  ulong       bytes;          // file size
  int         width;          // file's own pixel width (not display width)
  int         height;         // file's own pixel height
  bool        missing;        // file absent or unreadable, no sha256/bytes
  string[string] fields;      // any further/unrecognised key:value fields
}

struct OcdaObject {
  int         ocn;
  string      is_a;           // heading, para, toc, table, code, group, block, verse, quote, endnote, glossary, bibliography, bookindex, blurb
  string      section;        // head, toc, body, endnotes, glossary, bibliography, bookindex, blurb
  string      heading_level;  // A, B, C, D, 1, 2, 3, 4 (for headings)
  string      identifier;     // heading: from the declaration line; otherwise .identifier
  string      part;           // frontmatter, body, backmatter
  string      is_of_type;     // para, block, comment: how the text behaves
  string      own_section;    // .section, when it differs from the block it sits in
  string      segment_html_is;// the html segment this object sits in
  string      segment_epub;   // the epub segment this heading opens
  string      segment_epub_is;// the epub segment this object sits in
  string      table_aligns;   // l c r per column
  string[]    stow_link;      // links extracted from the object
  string[]    anchor_tags;    // named targets the markup placed on this object
  int         parent_ocn;
  int         last_descendant_ocn;
  int         ocn_range_first;// a container (a poem): the first and last
  int         ocn_range_last; // ocn of what it holds; 0 otherwise (2.1)
  int[]       children;       // direct child heading OCNs
  int[]       ancestors;      // markedup_ancestors[8]
  bool        dummy_heading;
  bool        ocn_off;
  int         indent_base;
  int         indent_hang;
  bool        bullet;
  string      lang;
  bool        has_links;
  bool        has_notes_reg;
  bool        has_notes_star;
  bool        has_images;
  string      segment;
  string      segment_prev;
  string      segment_next;
  string      anchor;
  string      heading_lev_anchor; // a heading's own named target
  int         table_cols;
  string      table_widths;
  bool        table_header;
  string      code_syntax;
  bool        code_linenumbers;
  string      heading_ancestors_text;
  string      sha256;
  OcdaImage[]  images;         // repeatable .image records, in order
  string      text;           // content (lines joined with newline)

  /+ ↓ whether this object is rendered at all.
       is_of_type "comment" is markup commentary: carried by the
       abstraction so that nothing is lost, and not put into output. An
       output that renders it leaks the author notes into the document,
       which is what spine itself does not do.
  +/
  bool renders() const {
    return is_of_type != "comment";
  }

  /+ ↓ the section this object belongs to, which is the block it sits in
       unless it says otherwise +/
  string sectionOf() const {
    return (own_section.length > 0) ? own_section : section;
  }
}

/+ ↓ what the reader met and did not understand.
     A reader that silently drops what it does not know cannot say whether
     it understood the document, and cannot be used to check a
     specification against an implementation: silence and understanding
     look alike. So the parser counts what it ignored, and
     --report-unknown prints it.
+/
struct OcdaUnknown {
  size_t[string] property;    // .name      -> times seen
  size_t[string] block;       // @name      -> times seen
  size_t[string] line;        // first char -> times seen, lines of no known shape

  bool any() const {
    return property.length > 0 || block.length > 0 || line.length > 0;
  }
}

struct OcdaDocument {
  string            format_version;  // as declared on line 1, "" when absent
  string            source_filename; // from the "% Source:" line
  string[string]    source;     // @source: language, languages, digest
  OcdaUnknown        unknown;    // what was met and not understood
  string[string]    metadata;   // key -> value
  string[string]    make;       // key -> value
  string[string]    doc_has;    // key -> value
  OcdaObject[]       head;
  OcdaObject[]       toc;
  OcdaObject[]       body;
  OcdaObject[]       endnotes;
  OcdaObject[]       glossary;
  OcdaObject[]       bibliography;
  OcdaObject[]       bookindex;
  OcdaObject[]       blurb;
  OcdaObject[]       tail;

  /+ ↓ the major part of the declared version, "" when none was declared +/
  string formatVersionMajor() const {
    import std.string : indexOf;
    if (format_version.length == 0) { return ""; }
    auto dot = format_version.indexOf('.');
    return (dot > 0) ? format_version[0 .. dot] : format_version;
  }

  string meta(string key) {
    if (auto p = key in metadata) return *p;
    return "";
  }

  OcdaObject[]* sectionByName(string name) {
    switch (name) {
      case "head":         return &head;
      case "toc":          return &toc;
      case "body":         return &body;
      case "endnotes":     return &endnotes;
      case "glossary":     return &glossary;
      case "bibliography": return &bibliography;
      case "bookindex":    return &bookindex;
      case "blurb":        return &blurb;
      case "tail":         return &tail;
      default:             return null;
    }
  }
}

/+ ↓ the format major version this reader knows.
     The .ssp and the .ocda.db carry one version between them, declared in
     band: the .ssp on its first line, the database in its schema.version
     row. The minor part is raised when a property is added, and a reader of
     the newer format still reads the older one, so only the major part is
     checked here. Raise this when the reader has been brought to a new
     major, not before: the point of the gate is to refuse what has not been
     looked at.
+/
enum ssp_format_major_read = "2";