/+ - 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/] +/ /++ default settings +/ module sisudoc.outputs.io_out.paths_output; @safe: import std.array; import std.path; import std.regex; import std.stdio; import sisudoc.ocda.meta.rgx_files; template spineOutPaths() { auto spineOutPaths()( string output_pth_root, string lng = "", ) { struct _PathsStruct { string output_root() { return (output_pth_root.length > 0) ? output_pth_root : ""; } string output_base() { return ((output_root.chainPath(lng)).asNormalizedPath).array; } string internal_base() { return lng.asNormalizedPath.array; } } return _PathsStruct(); } } template spineOutPathSQLite() { auto spineOutPathSQLite(Po)( Po output_pth_root, ) { struct _PathsStruct { string output_root() { return (output_pth_root.length > 0) ? output_pth_root : ""; } string output_base() { return ((output_root).asNormalizedPath).array; } } return _PathsStruct(); } } template spineOutPathSQLiteCGI() { auto spineOutPathSQLiteCGI(Po)( Po output_pth_root, ) { struct _PathsStruct { string output_root() { return (output_pth_root.length > 0) ? output_pth_root : ""; } string output_base() { return ((output_root).asNormalizedPath).array; } } return _PathsStruct(); } } template spineOutPathsFnPd() { /+ TODO stuff to work out here +/ auto spineOutPathsFnPd(Fn,Pn)( Fn fn_src_pth, Pn pod_name_with_path ) { struct _PathsStruct { string base_filename() { return fn_src_pth.baseName.stripExtension; } string base_pod_and_filename() { // TODO /+ - if pod, - pod_name - file_name - if pod_name == file_name - file_name - else if pod_name != file_name - pod_name.file_name +/ string _fn_src = fn_src_pth.baseName.stripExtension; string _output_base_name; if (!(pod_name_with_path.empty)) { if (pod_name_with_path == _fn_src) { _output_base_name = _fn_src; } else { _output_base_name = pod_name_with_path ~ "." ~ _fn_src; } } else { _output_base_name = _fn_src; } return _output_base_name; } } return _PathsStruct(); } } template spineDocRootTreeHTML() { auto spineDocRootTreeHTML()(string lng) { auto lng_pth = spineOutPaths!()("", lng); string base_dir = "html"; string suffix = ".html"; struct _PathsStruct { string base_filename(string fn_src) { return fn_src.baseName.stripExtension; } string base_filename_scroll(string fn_src) { return base_filename(fn_src); } string base_filename_seg(string fn_src) { return base_filename(fn_src); } string doc_root() { return ((lng_pth.output_root).asNormalizedPath).array; } string base() { return (((lng).chainPath(base_dir)).asNormalizedPath).array; } string image() { return (("image").asNormalizedPath).array; } string css() { return (("css").asNormalizedPath).array; } string fn_seg_css() { return ((css.chainPath("html_seg.css")).asNormalizedPath).array; } string fn_scroll_css() { return ((css.chainPath("html_scroll.css")).asNormalizedPath).array; } string seg(string fn_src) { return ((base.chainPath(base_filename_seg(fn_src))).asNormalizedPath).array; } string fn_metadata(string fn_src) { return ((base.chainPath("metadata." ~ base_filename_scroll(fn_src) ~ suffix)).asNormalizedPath).array; } string fn_scroll(string fn_src) { return ((base.chainPath(base_filename_scroll(fn_src) ~ suffix)).asNormalizedPath).array; } string fn_seg(string fn_src, string seg_filename) { return ((seg(fn_src).chainPath(seg_filename ~ suffix)).asNormalizedPath).array; } string tail_seg(string fn_src) { return lng ~ "/html/" ~ base_filename_seg(fn_src); } string tail_fn_scroll(string fn_src) { return lng ~ "/html/" ~ base_filename_scroll(fn_src) ~ suffix; } string tail_fn_seg(string fn_src, string seg_filename) { return lng ~ "/html/" ~ seg(fn_src) ~ "/" ~ seg_filename ~ suffix; } } return _PathsStruct(); } } template spinePathsHTML() { auto spinePathsHTML()( string output_path_root, string lng, ) { auto doc_tree = spineDocRootTreeHTML!()(lng); string base_dir = "html"; string suffix = ".html"; struct _PathsStruct { string doc_root() { return ((output_path_root.chainPath(doc_tree.doc_root)).asNormalizedPath).array; } string curate(string fn_curate) { return doc_root ~ "/" ~ fn_curate; } string internal_base() { return ((doc_tree.base).asNormalizedPath).array; } string base() { return ((output_path_root.chainPath(doc_tree.base)).asNormalizedPath).array; } string image() { return ((output_path_root.chainPath(doc_tree.image)).asNormalizedPath).array; } string css() { return ((output_path_root.chainPath(doc_tree.css)).asNormalizedPath).array; } string fn_seg_css() { return ((output_path_root.chainPath(doc_tree.fn_seg_css)).asNormalizedPath).array; } string fn_scroll_css() { return ((output_path_root.chainPath(doc_tree.fn_scroll_css)).asNormalizedPath).array; } string seg(string fn_src) { return ((output_path_root.chainPath(doc_tree.seg(fn_src))).asNormalizedPath).array; } string fn_metadata(string fn_src) { return ((output_path_root.chainPath(doc_tree.fn_metadata(fn_src))).asNormalizedPath).array; } string fn_scroll(string fn_src) { return ((output_path_root.chainPath(doc_tree.fn_scroll(fn_src))).asNormalizedPath).array; } string fn_seg(string fn_src, string seg_filename) { return ((output_path_root.chainPath(doc_tree.fn_seg(fn_src, seg_filename))).asNormalizedPath).array; } string tail_seg(string fn_src) { return doc_tree.tail_seg(fn_src); } string tail_fn_scroll(string fn_src) { return doc_tree.tail_fn_scroll(fn_src); } string tail_fn_seg(string fn_src, string seg_filename) { return doc_tree.tail_fn_seg(fn_src, seg_filename); } } return _PathsStruct(); } } template spineUrlsHTML() { import std.format; auto spineUrlsHTML()( string url_doc_root, string lng, ) { auto doc_tree = spineDocRootTreeHTML!()(lng); string base_dir = "html"; string suffix = ".html"; struct _PathsStruct { string doc_root() { return url_doc_root ~ ((doc_tree.doc_root).asNormalizedPath).array; } string curate(string fn_curate) { return format(q"┃%s/%s┃", doc_root, fn_curate, ); } string base() { return format(q"┃%s/%s┃", url_doc_root, ((doc_tree.base).asNormalizedPath).array, ); } string image() { return format(q"┃%s/%s┃", url_doc_root, ((doc_tree.image).asNormalizedPath).array, ); } string css() { return format(q"┃%s/%s┃", url_doc_root, ((doc_tree.css).asNormalizedPath).array, ); } string fn_seg_css() { return format(q"┃%s/%s┃", url_doc_root, ((doc_tree.fn_seg_css).asNormalizedPath).array, ); } string fn_scroll_css() { return format(q"┃%s/%s┃", url_doc_root, ((doc_tree.fn_scroll_css).asNormalizedPath).array, ); } string seg(string fn_src) { return format(q"┃%s/%s┃", url_doc_root, ((doc_tree.seg(fn_src)).asNormalizedPath).array, ); } string fn_metadata(string fn_src) { return format(q"┃%s/%s┃", url_doc_root, ((doc_tree.fn_metadata(fn_src)).asNormalizedPath).array, ); } string fn_scroll(string fn_src) { return format(q"┃%s/%s┃", url_doc_root, ((doc_tree.fn_scroll(fn_src)).asNormalizedPath).array, ); } string fn_seg(string fn_src, string seg_filename) { return format(q"┃%s/%s┃", url_doc_root, ((doc_tree.fn_seg(fn_src, seg_filename)).asNormalizedPath).array, ); } string fn_scroll_obj_num(string fn_src, string obj_num) { return format(q"┃%s/%s#%s┃", url_doc_root, ((doc_tree.fn_scroll(fn_src)).asNormalizedPath).array, obj_num, ); } string fn_seg_obj_num(string fn_src, string seg_filename, string obj_num) { return format(q"┃%s/%s#%s┃", url_doc_root, ((doc_tree.fn_seg(fn_src, seg_filename)).asNormalizedPath).array, obj_num, ); } string tail_seg(string fn_src) { return doc_tree.tail_seg(fn_src); } string tail_fn_scroll(string fn_src) { return doc_tree.tail_fn_scroll(fn_src); } string tail_fn_seg(string fn_src, string seg_filename) { return doc_tree.tail_fn_seg(fn_src, seg_filename); } } return _PathsStruct(); } } template spinePathsEPUB() { auto spinePathsEPUB()( string output_pth_root, string lng, ) { auto out_pth = spineOutPaths!()(output_pth_root, lng); string base_dir = "epub"; struct _PathsStruct { string internal_base() { return (((out_pth.internal_base).chainPath(base_dir)).asNormalizedPath).array; } string base() { return (((out_pth.output_base).chainPath(base_dir)).asNormalizedPath).array; } string base_filename(string fn_src) { return fn_src.baseName.stripExtension; } string base_filename_epub(string fn_src) { return base_filename(fn_src) ~ "." ~ lng; } string doc_meta_inf() { return (("META-INF").asNormalizedPath).array; } string doc_oebps() { return (("OEBPS").asNormalizedPath).array; } string doc_oebps_css() { return ((doc_oebps.chainPath("Styles")).asNormalizedPath).array; } string doc_oebps_image() { return ((doc_oebps.chainPath("image")).asNormalizedPath).array; } string epub_file(string fn_src) { return ((base.chainPath(base_filename_epub(fn_src) ~ ".epub")).asNormalizedPath).array; } string dirtop() { return "".chainPath("").array; } string fn_mimetypes() { return ((dirtop.chainPath("mimetype")).asNormalizedPath).array; } string fn_dmi_container_xml() { return ((doc_meta_inf.chainPath("container.xml")).asNormalizedPath).array; } string fn_oebps_toc_nav_xhtml() { return ((doc_oebps.chainPath("toc_nav.xhtml")).asNormalizedPath).array; } string fn_oebps_toc_ncx() { return ((doc_oebps.chainPath("toc.ncx")).asNormalizedPath).array; } string fn_oebps_content_opf() { return ((doc_oebps.chainPath("content.opf")).asNormalizedPath).array; } string fn_oebps_content_xhtml(string seg_filename) { return ((doc_oebps.chainPath(seg_filename ~ ".xhtml")).asNormalizedPath).array; } string fn_oebps_css() { return ((doc_oebps_css.chainPath("epub.css")).asNormalizedPath).array; } /+ debug +/ string dbg_docdir(string fn_src) { return base.chainPath(base_filename(fn_src)).array; } string dbg_docdir_oebps(string fn_src) { return dbg_docdir(fn_src).chainPath("OEBPS").array; } string dbg_doc_meta_inf(string fn_src) { return dbg_docdir(fn_src).chainPath("META-INF").array; } string dbg_doc_oebps(string fn_src) { return dbg_docdir(fn_src).chainPath("OEBPS").array; } string dbg_doc_oebps_css(string fn_src) { return dbg_doc_oebps(fn_src).chainPath("Styles").array; } string dbg_doc_oebps_image(string fn_src) { return dbg_doc_oebps(fn_src).chainPath("image").array; } string dbg_fn_mimetypes(string fn_src) { return dbg_docdir(fn_src).chainPath("mimetype").array; } string dbg_fn_dmi_container_xml(string fn_src) { return dbg_doc_meta_inf(fn_src).chainPath("container.xml").array; } string dbg_fn_oebps_toc_nav_xhtml(string fn_src) { return dbg_docdir_oebps(fn_src).chainPath("toc_nav.xhtml").array; } string dbg_fn_oebps_toc_ncx(string fn_src) { return dbg_docdir_oebps(fn_src).chainPath("toc.ncx").array; } string dbg_fn_oebps_content_opf(string fn_src) { return dbg_docdir_oebps(fn_src).chainPath("content.opf").array; } string dbg_fn_oebps_content_xhtml(string fn_src, string seg_filename) { return dbg_docdir_oebps(fn_src).chainPath(seg_filename ~ ".xhtml").array; } string dbg_fn_oebps_css(string fn_src) { return dbg_doc_oebps_css(fn_src).chainPath("epub.css").array; } } return _PathsStruct(); } } template spinePathsODT() { import std.conv; auto spinePathsODT(M)( M doc_matters, ) { auto out_pth = spineOutPaths!()(doc_matters.output_path, doc_matters.src.language); string base_dir = "odf"; struct _PathsStruct { string base_pth() { // dir will contain odt document file (also debug file tree) return (((out_pth.output_base).chainPath(base_dir)).asNormalizedPath).array; } string odt_file() { return ((base_pth.chainPath(doc_matters.src.doc_uid_out ~ ".odt")).asNormalizedPath).array; } string dirtop(string type) { return (type == "zip") ? "" // ".chainPath("").array : ((base_pth.chainPath(doc_matters.src.doc_uid_out)).asNormalizedPath).array.to!string; } string mimetype(string type="fs") { assert(type == "zip" || "fs"); return ((dirtop(type).chainPath("mimetype")).asNormalizedPath).array; } string manifest_rdf(string type="fs") { assert(type == "zip" || "fs"); return ((dirtop(type).chainPath("manifest.rdf")).asNormalizedPath).array; } string settings_xml(string type="fs") { assert(type == "zip" || "fs"); return ((dirtop(type).chainPath("settings.xml")).asNormalizedPath).array; } string styles_xml(string type="fs") { assert(type == "zip" || "fs"); return ((dirtop(type).chainPath("styles.xml")).asNormalizedPath).array; } string image_dir(string type="fs") { assert(type == "zip" || "fs"); return ((dirtop(type).chainPath("Pictures")).asNormalizedPath).array; } string image(string image_fn_src, string type="fs") { assert(type == "zip" || "fs"); return ((image_dir(type).chainPath(image_fn_src)).asNormalizedPath).array; } string content_xml(string type="fs") { assert(type == "zip" || "fs"); return ((dirtop(type).chainPath("content.xml")).asNormalizedPath).array; } string meta_inf_dir(string type="fs") { assert(type == "zip" || "fs"); return ((dirtop(type).chainPath("META-INF")).asNormalizedPath).array; } string manifest_xml(string type="fs") { assert(type == "zip" || "fs"); return ((meta_inf_dir(type).chainPath("manifest.xml")).asNormalizedPath).array; } string meta_xml(string type="fs") { assert(type == "zip" || "fs"); return ((dirtop(type).chainPath("meta.xml")).asNormalizedPath).array; } } return _PathsStruct(); } } template spinePathsPDF() { auto spinePathsPDF(M)( M doc_matters, ) { struct _PathsStruct { string base_filename(string fn_src) { return fn_src.baseName.stripExtension; } auto out_pth() { string output_dir = doc_matters.output_path ~ "/pdf"; return spineOutPaths!()(output_dir); } string base() { return (((out_pth.output_root).chainPath("pdf")).asNormalizedPath).array; } string pdf_path_stuff() { return ((base.chainPath(base_filename(doc_matters.src.filename))).asNormalizedPath).array; } } return _PathsStruct(); } } template spinePathsLaTeX() { auto spinePathsLaTeX(M)( M doc_matters, ) { struct _PathsStruct { string base_filename(string fn_src) { return fn_src.baseName.stripExtension; } auto out_pth() { return spineOutPaths!()(doc_matters.output_path, doc_matters.src.language); } string base() { return (((out_pth.output_root).chainPath("latex")).asNormalizedPath).array; } string base_sty() { return (((out_pth.output_root).chainPath("latex").chainPath("sty")).asNormalizedPath).array; } string latex_path_stuff() { return ((base.chainPath(base_filename(doc_matters.src.filename))).asNormalizedPath).array; } string latex_file_with_path(string paper_size_orientation) { return ((base.chainPath(base_filename(doc_matters.src.filename) ~ "." ~ doc_matters.src.language ~ "." ~ paper_size_orientation ~ ".tex") ).asNormalizedPath).array; } string latex_sty_with_path(string paper_size_orientation) { // spineA4portrait.sty return ((base_sty.chainPath("spine" ~ paper_size_orientation ~ ".sty") ).asNormalizedPath).array; } string latex_sty_with_path_static() { // spineShared.sty return ((base_sty.chainPath("spineShared.sty")).asNormalizedPath).array; } string images() { string image_dir = "image"; return (((base).chainPath(image_dir)).asNormalizedPath).array; } } return _PathsStruct(); } } template spinePathsLaTeXsty() { auto spinePathsLaTeXsty(string output_dir) { struct _PathsStruct { auto out_pth() { return spineOutPaths!()(output_dir); } string base() { return (((out_pth.output_root).chainPath("latex")).asNormalizedPath).array; } string base_sty() { return (((out_pth.output_root).chainPath("latex").chainPath("sty")).asNormalizedPath).array; } string latex_sty_with_path(string paper_size_orientation) { // spineA4portrait.sty return ((base_sty.chainPath("spine" ~ paper_size_orientation ~ ".sty") ).asNormalizedPath).array; } string latex_sty_with_path_static() { // spineShared.sty return ((base_sty.chainPath("spineShared.sty")).asNormalizedPath).array; } string latex_document_header_sty(string filename) { // spineShared.sty return ((base_sty.chainPath(filename)).asNormalizedPath).array; } } return _PathsStruct(); } } template spinePathsSQLiteDiscrete() { auto spinePathsSQLiteDiscrete()( string output_pth_root, string lng, ) { struct _PathsStruct { string base_filename(string fn_src) { return fn_src.baseName.stripExtension; } string base() { auto out_pth = spineOutPaths!()(output_pth_root, lng); string base_dir = "sqlite"; return (((out_pth.output_base).chainPath(base_dir)).asNormalizedPath).array; } string seg(string fn_src) { return ((base.chainPath(base_filename(fn_src))).asNormalizedPath).array; } string sqlite_file(string fn_src) { return ((base.chainPath(base_filename(fn_src) ~ ".sql.db")).asNormalizedPath).array; } } return _PathsStruct(); } } template spinePathsSQLite() { auto spinePathsSQLite()( string db_name, string output_pth_root, ) { struct _PathsStruct { string base_filename(string fn_src) { return fn_src.baseName.stripExtension; } string base() { auto out_pth = spineOutPathSQLite!()(output_pth_root); // decide whether to have separate files for each language string base_dir = ""; return (((out_pth.output_root).chainPath(base_dir)).asNormalizedPath).array; } string sqlite_file() { return (base.chainPath(db_name).asNormalizedPath).array; } } return _PathsStruct(); } } /+ ↓ where the markdown output goes. . /markdown/..md, which is where the other three document outputs go: html, epub and text all sit under the language, and markdown is a document rather than a rendered artefact. (latex, typst and pdf are flat, being the print path.) Called "markdown" and not "md" because none of its four siblings is a name shortened to its extension - text is the word where the extension is .txt, odf the family where it is .odt - and because "md" beside the language directories reads as an eleventh language. . The language stays in the filename, as it does for the epub and the text, because a .md is the format most likely to be copied out of the tree and the directory carries the language only while the file stays in it. . The images are the shared set at the output root, the ones the html references, not a copy: two directories down the reference is ../../image/, exactly as the scroll html's is. +/ template spinePathsMarkdown() { import std.conv; auto spinePathsMarkdown(M)( M doc_matters, ) { auto out_pth = spineOutPaths!()(doc_matters.output_path, doc_matters.src.language); struct _PathsStruct { /+ ↓ named as the epub, the html and the latex are: from the document filename and the language, not from the document uid. The uid joins the pod name where the two differ, and every artefact the site links to is named for the document +/ string base_filename(string fn_src) { return fn_src.baseName.stripExtension; } string base_pth() { return (((out_pth.output_base).chainPath("markdown")).asNormalizedPath).array; } string markdown_file() { return ((base_pth.chainPath(base_filename(doc_matters.src.filename) ~ "." ~ doc_matters.src.language ~ ".md") ).asNormalizedPath).array; } /+ ↓ the shared image directory at the output root, written by whichever output gets there first and read by all of them +/ string images() { return (((out_pth.output_root).chainPath("image")).asNormalizedPath).array; } /+ ↓ how the .md refers to them, from two directories down +/ string images_rel() { return "../../image"; } } return _PathsStruct(); } } /+ ↓ where the typst output goes. One .typ per document-language, because the paper is an input to the compile rather than a thing compiled in, and the images beside it because a .typ names them by path. The pdfs go where the latex path's pdfs go, under the same names, so that a site built either way looks the same. +/ template spinePathsTypst() { import std.conv; auto spinePathsTypst(M)( M doc_matters, ) { auto out_pth = spineOutPaths!()(doc_matters.output_path, doc_matters.src.language); struct _PathsStruct { /+ ↓ as latex: the .typ and the pdfs made from it carry the names the .tex and its pdfs carried, so that a site built either way is the same site and the html's pdf links resolve +/ string base_filename(string fn_src) { return fn_src.baseName.stripExtension; } string base_pth() { return (((out_pth.output_root).chainPath("typst")).asNormalizedPath).array; } string typst_file() { // return ((base_pth.chainPath(doc_matters.src.doc_uid_out ~ ".typ")).asNormalizedPath).array; return ((base_pth.chainPath(base_filename(doc_matters.src.filename) ~ "." ~ doc_matters.src.language ~ ".typ") ).asNormalizedPath).array; } string images() { return (((base_pth).chainPath("image")).asNormalizedPath).array; } string pdf_pth() { return (((out_pth.output_root).chainPath("pdf")).asNormalizedPath).array; } string pdf_file_with_path(string paper_size_orientation) { // return ((pdf_pth.chainPath(doc_matters.src.doc_uid_out return ((pdf_pth.chainPath(base_filename(doc_matters.src.filename) ~ "." ~ doc_matters.src.language ~ "." ~ paper_size_orientation ~ ".pdf") ).asNormalizedPath).array; } } return _PathsStruct(); } } template spinePathsText() { import std.conv; auto spinePathsText(M)( M doc_matters, ) { auto out_pth = spineOutPaths!()(doc_matters.output_path, doc_matters.src.language); string base_dir = "text"; struct _PathsStruct { string base_pth() { return (((out_pth.output_base).chainPath(base_dir)).asNormalizedPath).array; } string base_filename(string fn_src) { return fn_src.baseName.stripExtension; } string text_file() { return ((base_pth.chainPath(doc_matters.src.doc_uid_out ~ ".txt")).asNormalizedPath).array; } string dirtop() { return "".chainPath("").array; } } return _PathsStruct(); } } template spinePathsSkel() { import std.conv; auto spinePathsSkel(M)( M doc_matters, ) { auto out_pth = spineOutPaths!()(doc_matters.output_path, doc_matters.src.language); string base_dir = "skel"; struct _PathsStruct { string base_pth() { return (((out_pth.output_base).chainPath(base_dir)).asNormalizedPath).array; } string base_filename(string fn_src) { return fn_src.baseName.stripExtension; } string skel_file() { return ((base_pth.chainPath(doc_matters.src.doc_uid_out ~ ".skel")).asNormalizedPath).array; } string dirtop() { return "".chainPath("").array; } } return _PathsStruct(); } }