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

/++
  default settings
+/
module doc_reform.output.paths_output;
import std.array,
  std.path,
  std.regex,
  std.stdio;
import doc_reform.meta.rgx;
template DocReformOutPaths() {
  auto DocReformOutPaths(Po,Lng)(
    Po  output_pth_root,
    Lng lng = "",
  ) {
    struct _PathsStruct {
      string output_root() {
        return (output_pth_root.length > 0)
        ? output_pth_root : "";
      }
      string output_base() {
        return asNormalizedPath(output_root.chainPath(lng)).array;
      }
    }
    return _PathsStruct();
  }
}
template DocReformOutPathSQLite() {
  auto DocReformOutPathSQLite(Po)(
    Po  output_pth_root,
  ) {
    struct _PathsStruct {
      string output_root() {
        return (output_pth_root.length > 0)
        ? output_pth_root : "";
      }
      string output_base() {
        return asNormalizedPath(output_root).array;
      }
    }
    return _PathsStruct();
  }
}
template DocReformOutPathsFnPd() {
  /+ TODO stuff to work out here +/
  auto DocReformOutPathsFnPd(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 DocReformDocRootTreeHTML() {
  mixin DocReformRgxInit;
  static auto rgx = Rgx();
  auto DocReformDocRootTreeHTML()(string lng) {
    auto lng_pth = DocReformOutPaths!()("", 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) ~ "." ~ lng;
      }
      string base_filename_seg(string fn_src) {
        return base_filename(fn_src) ~ "." ~ lng;
      }
      string doc_root() {
        return asNormalizedPath(lng_pth.output_root).array;
      }
      string base() {
        return asNormalizedPath((lng).chainPath(base_dir)).array;
      }
      string image() {
        return asNormalizedPath("image").array;
      }
      string css() {
        return asNormalizedPath("css").array;
      }
      string fn_seg_css() {
        return asNormalizedPath(css.chainPath("html_seg.css")).array;
      }
      string fn_scroll_css() {
        return asNormalizedPath(css.chainPath("html_scroll.css")).array;
      }
      string seg(string fn_src) {
        return asNormalizedPath(base.chainPath(base_filename_seg(fn_src))).array;
      }
      string fn_scroll(string fn_src) {
        return asNormalizedPath(base.chainPath(base_filename_scroll(fn_src) ~ suffix)).array;
      }
      string fn_seg(string fn_src, string seg_filename) {
        return asNormalizedPath(seg(fn_src).chainPath(seg_filename ~ suffix)).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 DocReformPathsHTML() {
  mixin DocReformRgxInit;
  static auto rgx = Rgx();
  auto DocReformPathsHTML()(
    string root_pth,
    string lng,
  ) {
    auto doc_tree = DocReformDocRootTreeHTML!()(lng);
    string base_dir = "html";
    string suffix = ".html";
    struct _PathsStruct {
      string doc_root() {
        return asNormalizedPath(root_pth.chainPath(doc_tree.doc_root)).array;
      }
      string harvest(string fn_harvest) {
        return doc_root ~ "/" ~ fn_harvest;
      }
      string base() {
        return asNormalizedPath(root_pth.chainPath(doc_tree.base)).array;
      }
      string image() {
        return asNormalizedPath(root_pth.chainPath(doc_tree.image)).array;
      }
      string css() {
        return asNormalizedPath(root_pth.chainPath(doc_tree.css)).array;
      }
      string fn_seg_css() {
        return asNormalizedPath(root_pth.chainPath(doc_tree.fn_seg_css)).array;
      }
      string fn_scroll_css() {
        return asNormalizedPath(root_pth.chainPath(doc_tree.fn_scroll_css)).array;
      }
      string seg(string fn_src) {
        return asNormalizedPath(root_pth.chainPath(doc_tree.seg(fn_src))).array;
      }
      string fn_scroll(string fn_src) {
        return asNormalizedPath(root_pth.chainPath(doc_tree.fn_scroll(fn_src))).array;
      }
      string fn_seg(string fn_src, string seg_filename) {
        return asNormalizedPath(root_pth.chainPath(doc_tree.fn_seg(fn_src, seg_filename))).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 DocReformUrlsHTML() {
  import std.format;
  mixin DocReformRgxInit;
  static auto rgx = Rgx();
  auto DocReformUrlsHTML()(
    string url_doc_root,
    string lng,
  ) {
    auto doc_tree = DocReformDocRootTreeHTML!()(lng);
    string base_dir = "html";
    string suffix = ".html";
    struct _PathsStruct {
      string doc_root() {
        return url_doc_root ~ asNormalizedPath(doc_tree.doc_root).array;
      }
      string harvest(string fn_harvest) {
        return format(q"┃%s/%s┃",
          doc_root,
          fn_harvest,
        );
      }
      string base() {
        return format(q"┃%s/%s┃",
          url_doc_root,
          asNormalizedPath(doc_tree.base).array,
        );
      }
      string image() {
        return format(q"┃%s/%s┃",
          url_doc_root,
          asNormalizedPath(doc_tree.image).array,
        );
      }
      string css() {
        return format(q"┃%s/%s┃",
          url_doc_root,
          asNormalizedPath(doc_tree.css).array,
        );
      }
      string fn_seg_css() {
        return format(q"┃%s/%s┃",
          url_doc_root,
          asNormalizedPath(doc_tree.fn_seg_css).array,
        );
      }
      string fn_scroll_css() {
        return format(q"┃%s/%s┃",
          url_doc_root,
          asNormalizedPath(doc_tree.fn_scroll_css).array,
        );
      }
      string seg(string fn_src) {
        return format(q"┃%s/%s┃",
          url_doc_root,
          asNormalizedPath(doc_tree.seg(fn_src)).array,
        );
      }
      string fn_scroll(string fn_src) {
        return format(q"┃%s/%s┃",
          url_doc_root,
          asNormalizedPath(doc_tree.fn_scroll(fn_src)).array,
        );
      }
      string fn_seg(string fn_src, string seg_filename) {
        return format(q"┃%s/%s┃",
          url_doc_root,
          asNormalizedPath(doc_tree.fn_seg(fn_src, seg_filename)).array,
        );
      }
      string fn_scroll_obj_num(string fn_src, string obj_num) {
        return format(q"┃%s/%s#%s┃",
          url_doc_root,
          asNormalizedPath(doc_tree.fn_scroll(fn_src)).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,
          asNormalizedPath(doc_tree.fn_seg(fn_src, seg_filename)).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 DocReformPathsEPUB() {
  mixin DocReformRgxInit;
  static auto rgx = Rgx();
  auto DocReformPathsEPUB()(
    string output_pth_root,
    string lng,
  ) {
    auto out_pth = DocReformOutPaths!()(output_pth_root, lng);
    string base_dir = "epub";
    struct _PathsStruct {
      string base() {
        return asNormalizedPath((out_pth.output_base).chainPath(base_dir)).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 asNormalizedPath("META-INF").array;
      }
      string doc_oebps() {
        return asNormalizedPath("OEBPS").array;
      }
      string doc_oebps_css() {
        return asNormalizedPath(doc_oebps.chainPath("css")).array;
      }
      string doc_oebps_image() {
        return asNormalizedPath(doc_oebps.chainPath("image")).array;
      }
      string epub_file(string fn_src) {
        return asNormalizedPath(base.chainPath(base_filename_epub(fn_src) ~ ".epub")).array;
      }
      string dirtop() {
        return "".chainPath("").array;
      }
      string fn_mimetypes() {
        return asNormalizedPath(dirtop.chainPath("mimetypes")).array;
      }
      string fn_dmi_container_xml() {
        return asNormalizedPath(doc_meta_inf.chainPath("container.xml")).array;
      }
      string fn_oebps_toc_nav_xhtml() {
        return asNormalizedPath(doc_oebps.chainPath("toc_nav.xhtml")).array;
      }
      string fn_oebps_toc_ncx() {
        return asNormalizedPath(doc_oebps.chainPath("toc.ncx")).array;
      }
      string fn_oebps_content_opf() {
        return asNormalizedPath(doc_oebps.chainPath("content.opf")).array;
      }
      string fn_oebps_content_xhtml(string seg_filename) {
        return asNormalizedPath(doc_oebps.chainPath(seg_filename ~ ".xhtml")).array;
      }
      string fn_oebps_css() {
        return asNormalizedPath(doc_oebps_css.chainPath("epub.css")).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("css").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("mimetypes").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 DocReformPathsODT() {
  mixin DocReformRgxInit;
  static auto rgx = Rgx();
  auto DocReformPathsODT(M)(
    M  doc_matters,
  ) {
    auto out_pth = DocReformOutPaths!()( 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 asNormalizedPath((out_pth.output_base).chainPath(base_dir)).array;
      }
      string odt_file() {
        return asNormalizedPath(base_pth.chainPath(doc_matters.src.doc_uid_out ~ ".odt")).array;
      }
      string dirtop(string type) {
        return (type == "zip")
        ? "".chainPath("").array
        : asNormalizedPath(base_pth.chainPath(doc_matters.src.doc_uid_out)).array;
      }
      string mimetype(string type="fs") {
        assert(type == "zip" || "fs");
        return asNormalizedPath(dirtop(type).chainPath("mimetype")).array;
      }
      string manifest_rdf(string type="fs") {
        assert(type == "zip" || "fs");
        return asNormalizedPath(dirtop(type).chainPath("manifest.rdf")).array;
      }
      string settings_xml(string type="fs") {
        assert(type == "zip" || "fs");
        return asNormalizedPath(dirtop(type).chainPath("settings.xml")).array;
      }
      string styles_xml(string type="fs") {
        assert(type == "zip" || "fs");
        return asNormalizedPath(dirtop(type).chainPath("styles.xml")).array;
      }
      string image_dir(string type="fs") {
        assert(type == "zip" || "fs");
        return asNormalizedPath(dirtop(type).chainPath("Pictures")).array;
      }
      string image(string image_fn_src, string type="fs") {
        assert(type == "zip" || "fs");
        return asNormalizedPath(image_dir(type).chainPath(image_fn_src)).array;
      }
      string content_xml(string type="fs") {
        assert(type == "zip" || "fs");
        return asNormalizedPath(dirtop(type).chainPath("content.xml")).array;
      }
      string meta_inf_dir(string type="fs") {
        assert(type == "zip" || "fs");
        return asNormalizedPath(dirtop(type).chainPath("META-INF")).array;
      }
      string manifest_xml(string type="fs") {
        assert(type == "zip" || "fs");
        return asNormalizedPath(meta_inf_dir(type).chainPath("manifest.xml")).array;
      }
      string meta_xml(string type="fs") {
        assert(type == "zip" || "fs");
        return asNormalizedPath(dirtop(type).chainPath("meta.xml")).array;
      }
    }
    return _PathsStruct();
  }
}
template DocReformPathsLaTeX() {
  mixin DocReformRgxInit;
  static auto rgx = Rgx();
  auto DocReformPathsLaTeX(M)(
    M  doc_matters,
  ) {
    struct _PathsStruct {
      string base_filename(string fn_src) {
        return fn_src.baseName.stripExtension;
      }
      string base() {
        auto out_pth = DocReformOutPaths!()(doc_matters.output_path, doc_matters.src.language);
        string base_dir = "latex";
        return asNormalizedPath((out_pth.output_root).chainPath(base_dir)).array;
      }
      string latex_path_stuff() {
        return asNormalizedPath(base.chainPath(base_filename(doc_matters.src.filename))).array;
      }
      string latex_file_with_path() {
        return asNormalizedPath(base.chainPath(base_filename(doc_matters.src.filename) ~ "." ~ doc_matters.src.language ~ ".tex")).array;
      }
      string images() {
        string image_dir = "image";
        return asNormalizedPath((base).chainPath(image_dir)).array;
      }
    }
    return _PathsStruct();
  }
}
template DocReformPathsSQLiteDiscrete() {
  mixin DocReformRgxInit;
  static auto rgx = Rgx();
  auto DocReformPathsSQLiteDiscrete()(
    string output_pth_root,
    string lng,
  ) {
    struct _PathsStruct {
      string base_filename(string fn_src) {
        return fn_src.baseName.stripExtension;
      }
      string base() {
        auto out_pth = DocReformOutPaths!()(output_pth_root, lng);
        string base_dir = "sqlite";
        return asNormalizedPath((out_pth.output_base).chainPath(base_dir)).array;
      }
      string seg(string fn_src) {
        return asNormalizedPath(base.chainPath(base_filename(fn_src))).array;
      }
      string sqlite_file(string fn_src) {
        return asNormalizedPath(base.chainPath(base_filename(fn_src) ~ ".sql.db")).array;
      }
    }
    return _PathsStruct();
  }
}
template DocReformPathsSQLite() {
  mixin DocReformRgxInit;
  static auto rgx = Rgx();
  auto DocReformPathsSQLite(DbN, Po)(
    DbN db_name,
    Po  output_pth_root,
  ) {
    struct _PathsStruct {
      string base_filename(string fn_src) {
        return fn_src.baseName.stripExtension;
      }
      string base() {
        auto out_pth = DocReformOutPathSQLite!()(output_pth_root); // decide whether to have separate files for each language
        string base_dir = "sqlite";
        return asNormalizedPath((out_pth.output_root).chainPath(base_dir)).array;
      }
      string sqlite_file() {
        return asNormalizedPath(base.chainPath(base_filename(db_name) ~ ".sql.db")).array;
      }
    }
    return _PathsStruct();
  }
}