/+
- Name: SisuDoc Spine
- Description: part of SiSU spine (Doc Reform):
for document structuring, processing, publishing and search
- Author: Ralph Amissah
[ralph.amissah@gmail.com]
- Copyright: (C) 2015 (continuously updated, current 2026) Ralph Amissah,
All Rights Reserved.
- License: AGPL 3 or later, for everything in this repository unless a file or
a directory specifies otherwise.
This program is free software: you can redistribute it and/or modify it
under the terms of the GNU Affero General Public License (AGPLv3) as
published by the Free Software Foundation (FSF), either version 3 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License
for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see [https://www.gnu.org/licenses/].
If you have Internet connection, the latest version of the AGPL should be
available at: [https://www.gnu.org/licenses/agpl-3.0.html]
- Spine (by Doc Reform, related to SiSU) uses standard:
- docReform markup syntax
- standard SiSU markup syntax with modified headers and minor modifications
- docReform object numbering
- standard SiSU object citation numbering & system
- Homepages:
[https://www.sisudoc.org]
[https://www.doc-reform.org]
- Git
[https://git.sisudoc.org/]
+/
module sisudoc.outputs.io_out.epub3;
@safe:
template outputEPub3() {
import std.file;
import std.outbuffer;
import std.uri;
import std.zip;
import std.conv : to;
import sisudoc.outputs.io_out;
import sisudoc.outputs.io_out.rgx;
import sisudoc.outputs.io_out.rgx_xhtml;
import sisudoc.outputs.io_out.zip_pod;
import sisudoc.outputs.io_out.xmls;
import sisudoc.outputs.io_out.xmls_css;
mixin InternalMarkup;
mixin outputXHTMLs;
static auto rgx = RgxO();
static auto rgx_xhtml = RgxXHTML();
string special_characters_text(string _txt) {
_txt = _txt
.replaceAll(rgx_xhtml.ampersand, "&") // "&"
.replaceAll(rgx_xhtml.quotation, """) // """
.replaceAll(rgx_xhtml.less_than, "<") // "<"
.replaceAll(rgx_xhtml.greater_than, ">") // ">"
.replaceAll(rgx.br_line, " ")
.replaceAll(rgx.br_line_inline, " ")
.replaceAll(rgx.br_line_spaced, " \n ")
.replaceAll(rgx.nbsp_char, " ");
return _txt;
}
/+ ↓ a manifest item id, which has to be an XML name.
An XML name may not begin with a digit, and a file quite happily
may: "2bits_02_01-100.png" gave id="2bits_02_01-100", which is not
a name. A prefix settles the first character, and anything else a
filename allows and a name does not becomes an underscore. +/
string _manifest_id(string _prefix, string _name) {
string _id;
foreach (c; _name) {
_id ~= ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')
|| (c >= '0' && c <= '9') || c == '_' || c == '-' || c == '.')
? c : '_';
}
return _prefix ~ "_" ~ _id;
}
/+ ↓ the media type of an image, which is not its file extension.
There is no "image/jpg"; a manifest that claims one is declaring a
foreign resource, and EPUB then demands a fallback for it. The
core image types are these, and anything else genuinely is
foreign. +/
string _image_media_type(string _ext) {
switch (_ext.toLower) {
case "jpg": case "jpeg": return "image/jpeg";
case "png": return "image/png";
case "gif": return "image/gif";
case "svg": case "svgz": return "image/svg+xml";
case "webp": return "image/webp";
default: return "image/" ~ _ext.toLower;
}
}
/+ ↓ the landmarks navigation.
This is what EPUB3 offers in place of the EPUB2 that was
dropped: not a list of headings, which is what the toc nav is, but a
handful of named places a reader offers as buttons - start reading
here, the contents, the index. It is a nav in the navigation document
rather than a section of the package, and it is hidden, being
machinery rather than content.
.
Every entry names a file that is in the manifest, found the same way
the manifest found it: the first heading of the section that opens a
segment of its own.
+/
string _epub_landmark_file(D)(D doc, string _section) {
if (!(_section in doc.abstraction)) { return ""; }
string _first;
foreach (obj; doc.abstraction[_section]) {
if (obj.metainfo.is_a != "heading"
|| obj.metainfo.heading_lev_markup > 4
|| obj.tags.segment_anchor_tag_epub.length == 0
) { continue; }
/+ ↓ a level 4 heading is where the text of the section actually
starts. Above it are the part wrappers, which hold no text, so
a landmark that lands on one has sent the reader to a title and
not to the thing named. Take the level 4 where there is one. +/
if (obj.metainfo.heading_lev_markup == 4) {
return obj.tags.segment_anchor_tag_epub ~ ".xhtml";
}
if (_first.empty) { _first = obj.tags.segment_anchor_tag_epub ~ ".xhtml"; }
}
return _first;
}
string _epub_landmarks(D)(D doc) {
string[3][] _wanted = [
["toc", "toc", "Table of Contents"],
["body", "bodymatter", "Start of Content"],
["bookindex", "index", "Index"],
["glossary", "glossary", "Glossary"],
["bibliography", "bibliography", "Bibliography"],
];
string _items;
foreach (_w; _wanted) {
string _file = _epub_landmark_file(doc, _w[0]);
if (_file.empty) { continue; }
_items ~= format(
"
\n",
_w[1], _file, _w[2]);
}
if (_items.empty) { return ""; }
return " \n";
}
/+ ↓ the accessibility metadata EPUB Accessibility 1.1 asks for.
accessMode, accessibilityFeature and accessibilityHazard are required
of every EPUB by that specification (W3C Recommendation, 2024-10-17),
and accessModeSufficient and accessibilitySummary are recommended.
epubcheck does not test for them, which is why their absence never
showed in the error count; a reader looking for a book it can use
does test for them, and so does anyone distributing into the EU under
Directive 2019/882.
.
Every value here is derived from the document rather than asserted.
Nothing claims conformance to WCAG: that is a claim about an
evaluation that has not been made, and dcterms:conformsTo is
deliberately absent.
.
"schema" is a reserved prefix in EPUB 3, so it needs no declaring.
+/
struct ST_epubA11y {
bool images;
bool some_image_lacks_alt;
bool bookindex;
}
ST_epubA11y _epub_a11y(D)(D doc) {
auto xhtml_format = outputXHTMLs();
ST_epubA11y _a;
foreach (section; doc.matters.has.keys_seq.seg) {
if (section == "tail") { continue; }
if (!(section in doc.abstraction)) { continue; }
if (section == "bookindex") { _a.bookindex = true; }
foreach (obj; doc.abstraction[section]) {
foreach (m; obj.text.matchAll(rgx.inline_image)) {
_a.images = true;
if (xhtml_format._image_alt(m["post"].to!string).empty) {
_a.some_image_lacks_alt = true;
}
}
}
}
return _a;
}
string _epub_a11y_metadata(D)(D doc) {
auto _a = _epub_a11y(doc);
bool _alt_throughout = _a.images && !(_a.some_image_lacks_alt);
string _m;
string _meta(string _property, string _value) {
return format(" %s\n", _property, _value);
}
_m ~= _meta("schema:accessMode", "textual");
if (_a.images) { _m ~= _meta("schema:accessMode", "visual"); }
/+ ↓ a sufficient set is one a reader can get the whole publication
through. Text alone is sufficient where there are no images, and
where every image says what it is; where an image says nothing,
claiming it would be untrue. +/
if (!(_a.images) || _alt_throughout) {
_m ~= _meta("schema:accessModeSufficient", "textual");
} else {
_m ~= _meta("schema:accessModeSufficient", "textual,visual");
}
_m ~= _meta("schema:accessibilityFeature", "structuralNavigation");
_m ~= _meta("schema:accessibilityFeature", "tableOfContents");
_m ~= _meta("schema:accessibilityFeature", "readingOrder");
if (_a.bookindex) { _m ~= _meta("schema:accessibilityFeature", "index"); }
if (_alt_throughout) { _m ~= _meta("schema:accessibilityFeature", "alternativeText"); }
/+ ↓ nothing spine writes flashes, moves or makes a sound +/
_m ~= _meta("schema:accessibilityHazard", "none");
string _summary =
"Structured text with headings at every level, a navigation document,"
~ " and a reading order the publication declares."
~ " Every substantive object carries a citation number that is the same"
~ " in every format this document is published in.";
if (!(_a.images)) {
_summary ~= " There are no images.";
} else if (_alt_throughout) {
_summary ~= " Every image carries alternative text.";
} else {
_summary ~= " Some images carry no alternative text.";
}
_m ~= _meta("schema:accessibilitySummary", _summary);
return _m;
}
/+ ↓ the publication identifier, as a real RFC 4122 UUID.
Version 5, name based: the name is the document's own uid, so the
identifier is stable across rebuilds and distinct per document,
which is what dc:identifier is for. A random v4 would be neither.
The namespace is v5 of "sisudoc.org" under the DNS namespace. +/
string _epub_publication_uuid(string _doc_uid) {
import std.uuid : sha1UUID, dnsNamespace;
auto _ns = sha1UUID("sisudoc.org", dnsNamespace);
return sha1UUID(_doc_uid, _ns).toString;
}
/+ ↓ the last modified time EPUB3 requires, exactly one dcterms:modified on
the package in UTC to the second, comes from doc_matters.modified_utc.
Set in spine rather than here because an odt's office:meta needs the
same instant, and a single definition cannot drift apart.
+/
string epub3_mimetypes() {
string o;
o = format(q"┃application/epub+zip┃") ~ "\n";
return o;
}
string epub3_container_xml() {
string o;
o = format(q"┃┃") ~ "\n";
o ~= format(q"┃┃") ~ "\n\n";
return o;
}
string epub3_oebps_content(D,P)(D doc, P parts) {
auto xhtml_format = outputXHTMLs();
auto pth_epub3 = spinePathsEPUB!()(doc.matters.output_path, doc.matters.src.language);
string _uuid = _epub_publication_uuid(doc.matters.src.doc_uid_out);
string content = format(q"┃
urn:uuid:%s%s
main
%s %s
%s
%s%sCopyright: %s
%s
%s
┃",
doc.matters.src.language_tag,
_uuid,
xhtml_format.special_characters_plain(doc.matters.conf_make_meta.meta.title_main),
(doc.matters.conf_make_meta.meta.title_sub.empty) ? "" : format(
" %s\n"
~ " subtitle\n",
xhtml_format.special_characters_plain(doc.matters.conf_make_meta.meta.title_sub)),
(doc.matters.conf_make_meta.meta.creator_author.empty)
? "" : xhtml_format.special_characters_plain(doc.matters.conf_make_meta.meta.creator_author),
(doc.matters.conf_make_meta.meta.creator_author_surname_fn.empty)
? "" : xhtml_format.special_characters_plain(doc.matters.conf_make_meta.meta.creator_author_surname_fn),
doc.matters.src.language_tag, // language, fix (needed in dochead metadata)
(doc.matters.conf_make_meta.meta.date_published.empty)
? "" : xhtml_format.special_characters_plain_date(doc.matters.conf_make_meta.meta.date_published),
(doc.matters.conf_make_meta.meta.rights_copyright.empty)
? "" : xhtml_format.special_characters_plain(doc.matters.conf_make_meta.meta.rights_copyright),
doc.matters.modified_utc,
_epub_a11y_metadata(doc),
(pth_epub3.fn_oebps_css).chompPrefix("OEBPS/"),
);
content ~= parts["manifest_documents"];
foreach (image; doc.matters.srcs.image_list) {
content ~= format(q"┃
┃",
_manifest_id("img", image.baseName.stripExtension),
(pth_epub3.doc_oebps_image).chompPrefix("OEBPS/"),
image,
_image_media_type(image.extension.chompPrefix(".")),
);
}
content ~= " " ~ "" ~ "\n ";
content ~= " " ~ "" ~ "\n ";
content ~= parts["spine"];
content ~= " " ~ "" ~ "\n ";
content ~= "" ~ "";
debug(epubmanifest) {
foreach (section; doc.matters.has.keys_seq.seg) { // TODO
foreach (obj; doc.abstraction[section]) {
if (obj.metainfo.is_a == "heading") {
if (obj.metainfo.heading_lev_markup == 4) {
writefln(
"%s~ [%s.xhtml] %s",
obj.marked_up_level,
obj.tags.segment_anchor_tag_epub,
obj.text
);
} else if (obj.metainfo.heading_lev_markup > 4) {
writefln(
"%s~ [%s.xhtml#%s] %s",
obj.marked_up_level,
obj.tags.segment_anchor_tag_epub,
obj.metainfo.object_number,
obj.text
);
}
}
}
}
}
return content;
}
string epub3_oebps_toc_nav_xhtml(D)(D doc) {
enum DomTags { none, open, close, close_and_open, open_still, }
auto markup = InlineMarkup();
static auto rgx = RgxO();
static auto rgx_xhtml = RgxXHTML();
string toc;
bool _new_title_set = false;
string toc_head = format(q"┃
%s
Contents
";
_toc_nav_tail ~= _epub_landmarks(doc);
_toc_nav_tail ~="
\n";
}
}
}
}
}
}
toc ~= _toc_nav_tail;
return toc;
}
@system void outputEPub3(D)(D doc) {
mixin spineRgxOut;
mixin spineRgxXHTML;
auto xhtml_format = outputXHTMLs();
static auto rgx = RgxO();
static auto rgx_xhtml = RgxXHTML();
string segment_filename;
/+ ↓ a segment file gets one document head, not one per heading. +/
bool[string] _seg_head_written;
string _segHead(M)(M _m, string _seg) {
if (_seg in _seg_head_written) { return ""; }
_seg_head_written[_seg] = true;
return xhtml_format.epub3_seg_head(_m);
}
string[] top_level_headings = ["","","",""];
string[string] oepbs_content_parts;
bool[string] _segment_files_seen; /+ a segment file is listed once +/
string suffix = ".xhtml";
struct writeOut { /+ epub specific documents +/
/+ fixed output +/
string mimetypes;
string meta_inf_container_xml;
string oebps_toc_nav_xhtml;
/+ variable output +/
string oebps_content_opf;
string[][string] doc_epub3;
string[][string] doc_epub3_endnotes;
string[] doc_parts;
}
auto epubWrite = writeOut();
foreach (section; doc.matters.has.keys_seq.seg) {
foreach (obj; doc.abstraction[section]) {
string _txt = xhtml_format.special_characters_breaks_indents_bullets(obj);
if (obj.metainfo.is_a == "heading") {
assert(section == "head" || "toc" || "body" || "endnotes" || "glossary" || "bibliography" || "bookindex" || "blurb" || "tail");
switch (obj.metainfo.heading_lev_markup) {
case 0: .. case 3:
/+ fill buffer, and replace with new levels from 1 to 3 +/
switch (obj.metainfo.heading_lev_markup) {
case 0:
top_level_headings[0] = "";
top_level_headings[1] = "";
top_level_headings[2] = "";
top_level_headings[3] = "";
goto default;
case 1:
top_level_headings[1] = "";
top_level_headings[2] = "";
top_level_headings[3] = "";
goto default;
case 2:
top_level_headings[2] = "";
top_level_headings[3] = "";
goto default;
case 3:
top_level_headings[3] = "";
goto default;
default:
epubWrite.doc_parts ~= obj.tags.segment_anchor_tag_epub;
epubWrite.doc_epub3[obj.tags.segment_anchor_tag_epub] ~= _segHead(doc.matters, obj.tags.segment_anchor_tag_epub);
Tuple!(string, string[]) t = xhtml_format.heading_seg(_txt, obj, doc.matters, suffix, "epub");
epubWrite.doc_epub3[obj.tags.segment_anchor_tag_epub] ~= t[0];
epubWrite.doc_epub3_endnotes[obj.tags.segment_anchor_tag_epub] ~= t[1];
break;
}
break;
case 4:
segment_filename = obj.tags.segment_anchor_tag_epub;
epubWrite.doc_epub3[segment_filename] ~= _segHead(doc.matters, segment_filename);
Tuple!(string, string[]) t = xhtml_format.heading_seg(_txt, obj, doc.matters, suffix, "epub");
epubWrite.doc_epub3[segment_filename] ~= t[0];
epubWrite.doc_epub3_endnotes[segment_filename] ~= t[1];
break;
case 5: .. case 7:
Tuple!(string, string[]) t = xhtml_format.heading_seg(_txt, obj, doc.matters, suffix, "epub");
epubWrite.doc_epub3[segment_filename] ~= t[0];
epubWrite.doc_epub3_endnotes[segment_filename] ~= t[1];
break;
case 8: .. case 9:
{ /+ debug +/
if (doc.matters.opt.action.debug_do_epub) {
writeln(__FILE__, ":", __LINE__, ": ", obj.metainfo.is_a, ": ", obj.metainfo.heading_lev_markup);
writeln(__FILE__, ":", __LINE__, ": ", obj.text);
}
}
break;
default:
{ /+ debug +/
if (doc.matters.opt.action.debug_do_epub) {
writeln(__FILE__, ":", __LINE__, ": ", obj.metainfo.is_a, ": ", obj.metainfo.heading_lev_markup);
}
}
break;
}
} else {
assert(section == "head" || "toc" || "body" || "endnotes" || "glossary" || "bibliography" || "bookindex" || "blurb" || "tail");
Tuple!(string, string[]) t;
switch (obj.metainfo.is_of_part) {
case "frontmatter": assert(section == "head" || "toc");
switch (obj.metainfo.is_of_type) {
case "para":
switch (obj.metainfo.is_a) {
case "toc":
t = xhtml_format.para_seg(_txt, obj, doc.matters, suffix, "epub");
epubWrite.doc_epub3[segment_filename] ~= t[0];
epubWrite.doc_epub3_endnotes[segment_filename] ~= t[1];
break;
default:
{ /+ debug +/
if (doc.matters.opt.action.debug_do_epub) {
writeln(__FILE__, ":", __LINE__, ": ", obj.metainfo.is_a);
}
}
break;
}
break;
default:
{ /+ debug +/
if (doc.matters.opt.action.debug_do_epub) {
writeln(__FILE__, ":", __LINE__, ": ", obj.metainfo.is_of_type);
}
}
break;
}
break;
case "body": assert(section == "body");
switch (obj.metainfo.is_of_type) {
case "para":
switch (obj.metainfo.is_a) {
case "para":
t = xhtml_format.para_seg(_txt, obj, doc.matters, suffix, "epub");
epubWrite.doc_epub3[segment_filename] ~= t[0];
epubWrite.doc_epub3_endnotes[segment_filename] ~= t[1];
break;
default:
{ /+ debug +/
if (doc.matters.opt.action.debug_do_epub) {
writeln(__FILE__, ":", __LINE__, ": ", obj.metainfo.is_a);
}
}
break;
}
break;
case "block":
switch (obj.metainfo.is_a) {
case "quote":
t = xhtml_format.quote_seg(_txt, obj, doc.matters, suffix, "epub");
epubWrite.doc_epub3[segment_filename] ~= t[0].to!string;
epubWrite.doc_epub3_endnotes[segment_filename] ~= t[1];
break;
case "group":
t = xhtml_format.group_seg(_txt, obj, doc.matters, suffix, "epub");
epubWrite.doc_epub3[segment_filename] ~= t[0].to!string;
epubWrite.doc_epub3_endnotes[segment_filename] ~= t[1];
break;
case "block":
t = xhtml_format.block_seg(_txt, obj, doc.matters, suffix, "epub");
epubWrite.doc_epub3[segment_filename] ~= t[0].to!string;
epubWrite.doc_epub3_endnotes[segment_filename] ~= t[1];
break;
case "poem":
break;
case "verse":
t = xhtml_format.verse_seg(_txt, obj, doc.matters, suffix, "epub");
epubWrite.doc_epub3[segment_filename] ~= t[0].to!string;
epubWrite.doc_epub3_endnotes[segment_filename] ~= t[1];
break;
case "code":
epubWrite.doc_epub3[segment_filename] ~= xhtml_format.code(_txt, obj, doc.matters);
break;
case "table":
epubWrite.doc_epub3[segment_filename] ~= xhtml_format.table(_txt, obj, doc.matters);
epubWrite.doc_epub3_endnotes[segment_filename] ~= "";
break;
default:
{ /+ debug +/
if (doc.matters.opt.action.debug_do_epub) {
writeln(__FILE__, ":", __LINE__, ": ", obj.metainfo.is_a);
}
}
break;
}
break;
default:
{ /+ debug +/
if (doc.matters.opt.action.debug_do_epub) {
writeln(__FILE__, ":", __LINE__, ": ", obj.metainfo.is_of_type);
}
}
break;
}
break;
case "backmatter":
assert(section == "endnotes" || "glossary" || "bibliography" || "bookindex" || "blurb" || "tail");
switch (obj.metainfo.is_of_type) {
case "para":
switch (obj.metainfo.is_a) {
case "endnote": assert(section == "endnotes");
t = xhtml_format.para_seg(_txt, obj, doc.matters, suffix, "epub");
epubWrite.doc_epub3[segment_filename] ~= t[0];
break;
case "glossary": assert(section == "glossary");
t = xhtml_format.para_seg(_txt, obj, doc.matters, suffix, "epub");
epubWrite.doc_epub3[segment_filename] ~= t[0];
epubWrite.doc_epub3_endnotes[segment_filename] ~= t[1];
break;
case "bibliography": assert(section == "bibliography");
t = xhtml_format.para_seg(_txt, obj, doc.matters, suffix, "epub");
epubWrite.doc_epub3[segment_filename] ~= t[0];
epubWrite.doc_epub3_endnotes[segment_filename] ~= t[1];
break;
case "bookindex": assert(section == "bookindex");
t = xhtml_format.para_seg(_txt, obj, doc.matters, suffix, "epub");
epubWrite.doc_epub3[segment_filename] ~= t[0];
epubWrite.doc_epub3_endnotes[segment_filename] ~= t[1];
break;
case "blurb": assert(section == "blurb");
t = xhtml_format.para_seg(_txt, obj, doc.matters, suffix, "epub");
epubWrite.doc_epub3[segment_filename] ~= t[0];
epubWrite.doc_epub3_endnotes[segment_filename] ~= t[1];
break;
case "tail": assert(section == "tail");
t = xhtml_format.para_seg(_txt, obj, doc.matters, suffix, "epub");
epubWrite.doc_epub3[segment_filename] ~= t[0];
epubWrite.doc_epub3_endnotes[segment_filename] ~= t[1];
break;
default:
{ /+ debug +/
if (doc.matters.opt.action.debug_do_epub) {
writeln(__FILE__, ":", __LINE__, ": ", obj.metainfo.is_a);
}
}
break;
}
break;
default:
{ /+ debug +/
if (doc.matters.opt.action.debug_do_epub) {
writeln(__FILE__, ":", __LINE__, ": ", obj.metainfo.is_of_type);
}
}
break;
}
break;
case "comment":
break;
default:
{ /+ debug +/
if (doc.matters.opt.action.debug_do_epub) {
writeln(__FILE__, ":", __LINE__, ": ", obj.metainfo.is_of_part);
}
}
break;
}
}
/+ ↓ the manifest lists *files* and the spine is the reading order
of *files*, so one entry per segment document, named once.
.
A heading at level 4 or above opens a segment file; a heading
below that is an anchor inside one and needs no declaration,
an item href not being allowed a fragment and an item id
having to be an XML name, which "x.xhtml#8" is not. Several
headings can open onto the same file, so a file already seen
is not listed again.
+/
if (obj.metainfo.is_a == "heading"
/+ ↓ "tail" is the end of document marker, and no file is written for it (the
writing loop skips the section), so it is not in the manifest either.
+/
&& section != "tail"
&& obj.metainfo.heading_lev_markup <= 4
&& obj.tags.segment_anchor_tag_epub.length > 0
&& !(obj.tags.segment_anchor_tag_epub in _segment_files_seen)
) {
_segment_files_seen[obj.tags.segment_anchor_tag_epub] = true;
oepbs_content_parts["manifest_documents"] ~=
format(q"┃
┃",
_manifest_id("seg", obj.tags.segment_anchor_tag_epub),
obj.tags.segment_anchor_tag_epub,
);
oepbs_content_parts["spine"] ~=
format(q"┃
┃",
_manifest_id("seg", obj.tags.segment_anchor_tag_epub),
);
}
}
}
/+ epub specific documents +/
epubWrite.mimetypes = epub3_mimetypes;
epubWrite.meta_inf_container_xml = epub3_container_xml;
epubWrite.oebps_toc_nav_xhtml = doc.epub3_oebps_toc_nav_xhtml;
epubWrite.oebps_content_opf = doc.epub3_oebps_content(oepbs_content_parts);
epubWrite.epub3_write_output_files(doc.matters);
}
@system void epub3_write_output_files(W,M)(
W epub_write,
M doc_matters,
) {
debug(asserts) {
static assert(is(typeof(epub_write.doc_epub3) == string[][string]));
static assert(is(typeof(epub_write.mimetypes) == string));
static assert(is(typeof(epub_write.meta_inf_container_xml) == string));
static assert(is(typeof(epub_write.oebps_toc_nav_xhtml) == string));
static assert(is(typeof(epub_write.oebps_content_opf) == string));
}
static auto rgx = RgxO();
static auto rgx_xhtml = RgxXHTML();
auto pth_epub3 = spinePathsEPUB!()(doc_matters.output_path, doc_matters.src.language);
auto xhtml_format = outputXHTMLs();
/+ zip file +/
auto fn_epub = pth_epub3.epub_file(doc_matters.src.filename);
auto zip = new ZipArchive(); // ZipArchive zip = new ZipArchive();
/+ zip archive member files.
ZipArchive.build() emits members sorted by ArchiveMember.index, and
addMember does not set one. An epub is not free to choose: OCF requires the
mimetype entry to be the first in the archive, a reader being entitled to
look only there to tell what the file is. The index is therefore set
deliberately, 0 for the mimetype and 1 upward for the rest as they are
added.
.
Compression is already done for every member (ArchiveMember defaults to
it), which is the other half of what OCF asks of the mimetype.
+/
uint _zip_seq = 1;
void EPUBzip()(string contents, string fn, bool _is_mimetype = false) {
auto zip_arc_member_file = new ArchiveMember();
zip_arc_member_file.name = fn;
zip_arc_member_file.index = _is_mimetype ? 0 : _zip_seq++;
if (_is_mimetype) {
zip_arc_member_file.compressionMethod = CompressionMethod.none;
}
auto zip_data = new OutBuffer();
(doc_matters.opt.action.debug_do_epub)
? zip_data.write(contents.dup)
: zip_data.write(contents.dup
.replaceAll(rgx.spaces_line_start, "")
.replaceAll(rgx.newline, " ")
.strip
);
zip_arc_member_file.expandedData = zip_data.toBytes();
zip.addMember(zip_arc_member_file);
createZipFile!()(fn_epub, zip.build());
}
try {
if (!exists(pth_epub3.base)) {
pth_epub3.base.mkdirRecurse;
}
if (!exists(pth_epub3.base ~ "/index.html")) {
import sisudoc.outputs.io_out.html_snippet;
mixin htmlSnippet;
auto f = File(pth_epub3.base ~"/index.html", "w");
f.writeln(format_html_blank_page_guide_home(
"../../css/html_scroll.css",
(doc_matters.opt.action.webserver_url_doc_root.length > 0)
? doc_matters.opt.action.webserver_url_doc_root
: doc_matters.conf_make_meta.conf.w_srv_data_root_url,
"../../index.html",
));
}
{ /+ debug +/
if (doc_matters.opt.action.debug_do_epub) {
if (!exists(pth_epub3.dbg_doc_meta_inf(doc_matters.src.filename))) {
pth_epub3.dbg_doc_meta_inf(doc_matters.src.filename).mkdirRecurse;
}
if (!exists(pth_epub3.dbg_doc_oebps_css(doc_matters.src.filename))) {
pth_epub3.dbg_doc_oebps_css(doc_matters.src.filename).mkdirRecurse;
}
if (!exists(pth_epub3.dbg_doc_oebps_image(doc_matters.src.filename))) {
pth_epub3.dbg_doc_oebps_image(doc_matters.src.filename).mkdirRecurse;
}
}
}
{ /+ OEBPS/[segments].xhtml (the document contents) +/
foreach (seg_filename; doc_matters.has.segnames_lv_0_to_4) {
string fn = pth_epub3.fn_oebps_content_xhtml(seg_filename);
auto zip_arc_member_file = new ArchiveMember();
zip_arc_member_file.name = fn;
auto zip_data = new OutBuffer();
{ /+ debug +/
if (doc_matters.opt.action.debug_do_epub) {
string fn_dbg = pth_epub3.dbg_fn_oebps_content_xhtml(doc_matters.src.filename, seg_filename);
auto f = File(fn_dbg, "w");
foreach (docseg; epub_write.doc_epub3[seg_filename]) {
f.writeln(docseg);
}
foreach (docseg; epub_write.doc_epub3_endnotes[seg_filename]) {
f.writeln(docseg);
}
f.writeln(xhtml_format.tail(doc_matters));
}
}
foreach (docseg; epub_write.doc_epub3[seg_filename]) {
zip_data.write(docseg.dup);
}
foreach (docseg; epub_write.doc_epub3_endnotes[seg_filename]) {
zip_data.write(docseg.dup);
}
zip_data.write(xhtml_format.tail(doc_matters).dup);
zip_arc_member_file.expandedData = zip_data.toBytes();
zip.addMember(zip_arc_member_file);
/+ create the zip file +/
createZipFile!()(fn_epub, zip.build());
}
}
string fn;
string fn_dbg;
File f;
{ /+ mimetypes (identify zip file type) +/
{ /+ debug +/
if (doc_matters.opt.action.debug_do_epub) {
fn_dbg = pth_epub3.dbg_fn_mimetypes(doc_matters.src.filename);
File(fn_dbg, "w").writeln(epub_write.mimetypes);
}
}
fn = pth_epub3.fn_mimetypes;
EPUBzip(epub_write.mimetypes, fn, true); /+ first in the archive +/
}
{ /+ META-INF/container.xml (identify doc root) +/
{ /+ debug +/
if (doc_matters.opt.action.debug_do_epub) {
fn_dbg = pth_epub3.dbg_fn_dmi_container_xml(doc_matters.src.filename);
File(fn_dbg, "w").writeln(epub_write.meta_inf_container_xml);
}
}
fn = pth_epub3.fn_dmi_container_xml;
EPUBzip(epub_write.meta_inf_container_xml, fn);
}
{ /+ OEBPS/toc_nav.xhtml (navigation toc epub3) +/
{ /+ debug +/
if (doc_matters.opt.action.debug_do_epub) {
fn_dbg = pth_epub3.dbg_fn_oebps_toc_nav_xhtml(doc_matters.src.filename);
File(fn_dbg, "w").writeln(epub_write.oebps_toc_nav_xhtml);
}
}
fn = pth_epub3.fn_oebps_toc_nav_xhtml;
EPUBzip(epub_write.oebps_toc_nav_xhtml, fn);
}
{ /+ OEBPS/content.opf (doc manifest) +/
{ /+ debug +/
if (doc_matters.opt.action.debug_do_epub) {
fn_dbg = pth_epub3.dbg_fn_oebps_content_opf(doc_matters.src.filename);
File(fn_dbg, "w").writeln(epub_write.oebps_content_opf);
}
}
fn = pth_epub3.fn_oebps_content_opf;
EPUBzip(epub_write.oebps_content_opf, fn);
}
{ /+ OEBPS/_dr/image (images) +/
foreach (image; doc_matters.srcs.image_list) {
{ /+ debug +/
if (doc_matters.opt.action.debug_do_epub) {
if (doc_matters.opt.action.vox_gt_3) {
writeln(
doc_matters.src.image_dir_path, "/", image, " -> ",
pth_epub3.dbg_doc_oebps_image(doc_matters.src.filename), "/", image
);
}
if (exists(doc_matters.src.image_dir_path ~ "/" ~ image)) {
(doc_matters.src.image_dir_path ~ "/" ~ image)
.copy((pth_epub3.dbg_doc_oebps_image(doc_matters.src.filename)) ~ "/" ~ image);
}
}
}
auto fn_src = doc_matters.src.image_dir_path ~ "/" ~ image;
auto fn_out = pth_epub3.doc_oebps_image ~ "/" ~ image;
if (exists(fn_src)) {
{
auto zip_arc_member_file = new ArchiveMember();
zip_arc_member_file.name = fn_out;
auto zip_data = new OutBuffer();
zip_data.write(cast(char[]) ((fn_src).read));
zip_arc_member_file.expandedData = zip_data.toBytes();
zip.addMember(zip_arc_member_file);
createZipFile!()(fn_epub, zip.build());
}
}
}
}
{ /+ OEBPS/epub.css +/
auto css = spineCss(doc_matters);
{ /+ debug +/
if (doc_matters.opt.action.debug_do_epub) {
fn_dbg = pth_epub3.dbg_fn_oebps_css(doc_matters.src.filename);
File(fn_dbg, "w").writeln(css.epub);
}
}
fn = pth_epub3.fn_oebps_css;
auto zip_arc_member_file = new ArchiveMember();
zip_arc_member_file.name = fn;
auto zip_data = new OutBuffer();
zip_data.write(css.epub.dup);
zip_arc_member_file.expandedData = zip_data.toBytes();
zip.addMember(zip_arc_member_file);
createZipFile!()(fn_epub, zip.build());
}
} catch (ErrnoException ex) {
// Handle error
}
if (doc_matters.opt.action.vox_gt_1) {
writeln(" ", fn_epub);
}
debug(epub_archive) {
if (exists(fn_epub)) {
try {
auto zipped = new ZipArchive((fn_epub).read);
foreach (filename, member; zipped.directory) {
auto data = zipped.expand(member);
writeln(filename, " length ", data.length);
}
} catch (ZipException ex) {
// Handle errors
}
}
}
}
}