path: root/src/doc_reform/io_out/paths_output.d

/+
- Name: 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 - 2022 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.doc_reform.org]
    [https://www.sisudoc.org]

  - Git
    [https://git.sisudoc.org/projects/?p=software/spine.git;a=summary]

+/
/++
  default settings
+/
module doc_reform.io_out.paths_output;
import
  std.array,
  std.path,
  std.regex,
  std.stdio;
import doc_reform.meta.rgx;
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() {
  mixin spineRgxIn;
  static auto rgx = RgxI();
  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() {
  mixin spineRgxIn;
  static auto rgx = RgxI();
  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;
  mixin spineRgxIn;
  static auto rgx = RgxI();
  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() {
  mixin spineRgxIn;
  static auto rgx = RgxI();
  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;
  mixin spineRgxIn;
  static auto rgx = RgxI();
  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 spinePathsLaTeX() {
  mixin spineRgxIn;
  static auto rgx = RgxI();
  auto spinePathsLaTeX(M)(
    M  doc_matters,
  ) {
    struct _PathsStruct {
      string base_filename(string fn_src) {
        return fn_src.baseName.stripExtension;
      }
      string base() {
        auto out_pth = spineOutPaths!()(doc_matters.output_path, doc_matters.src.language);
        string base_dir = "latex";
        return (((out_pth.output_root).chainPath(base_dir)).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 images() {
        string image_dir = "image";
        return (((base).chainPath(image_dir)).asNormalizedPath).array;
      }
    }
    return _PathsStruct();
  }
}
template spinePathsSQLiteDiscrete() {
  mixin spineRgxIn;
  static auto rgx = RgxI();
  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() {
  mixin spineRgxIn;
  static auto rgx = RgxI();
  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();
  }
}