/+
- Name: SisuDoc Spine, Doc Reform [a part of]
- Description: documents, structuring, processing, publishing, search
- static content generator
- Author: Ralph Amissah
[ralph.amissah@gmail.com]
- Copyright: (C) 2015 (continuously updated, current 2026) Ralph Amissah, All Rights Reserved.
- License: AGPL 3 or later:
Spine (SiSU), a framework for document structuring, publishing and
search
Copyright (C) Ralph Amissah
This program is free software: you can redistribute it and/or modify it
under the terms of the GNU AFERO General Public License as published by the
Free Software Foundation, 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 General Public License for
more details.
You should have received a copy of the GNU 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 these locations:
[https://www.fsf.org/licensing/licenses/agpl.html]
[https://www.gnu.org/licenses/agpl.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;
}
/+ ↓ the last modified time, as EPUB3 requires it: exactly one dcterms:modified
on the package, in UTC to the second, CCYY-MM-DDThh:mm:ssZ
+/
string _epub_modified_utc() {
import std.datetime : Clock, UTC;
auto _t = Clock.currTime(UTC());
return format("%04d-%02d-%02dT%02d:%02d:%02dZ",
_t.year, _t.month.to!int, _t.day, _t.hour, _t.minute, _t.second);
}
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 = "18275d951861c77f78acd05672c9906924c59f18a2e0ba06dad95959693e9bd8"; // TODO sort uuid in doc.matters!
string content = format(q"┃
urn:uuid:%s%s
main
%s %s
%s
%s%sCopyright: %s
%s
┃",
_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, // 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),
_epub_modified_utc(),
(pth_epub3.fn_oebps_css).chompPrefix("OEBPS/"),
);
content ~= parts["manifest_documents"];
// TODO sort jpg & png
foreach (image; doc.matters.srcs.image_list) {
content ~= format(q"┃
┃",
image.baseName.stripExtension,
(pth_epub3.doc_oebps_image).chompPrefix("OEBPS/"),
image,
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
\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"┃
┃",
obj.tags.segment_anchor_tag_epub,
obj.tags.segment_anchor_tag_epub,
);
oepbs_content_parts["spine"] ~=
format(q"┃
┃",
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
}
}
}
}
}