path: root/org/default_paths.org

#+TITLE:       sdp default paths
#+AUTHOR:      Ralph Amissah
#+EMAIL:       [[mailto:ralph.amissah@gmail.com][ralph.amissah@gmail.com]]
#+DESCRIPTION: documents - structuring, publishing in multiple formats & search
#+KEYWORDS
#+LANGUAGE:    en
#+STARTUP:     indent content
#+OPTIONS:     H:3 num:nil toc:t \n:nil @:t ::t |:t ^:nil _:nil -:t f:t *:t <:t
#+OPTIONS:     TeX:t LaTeX:t skip:nil d:nil todo:t pri:nil tags:not-in-toc
#+OPTIONS:     author:nil email:nil creator:nil timestamp:nil
#+PROPERTY:    header-args :padline no :exports code :noweb yes
#+EXPORT_SELECT_TAGS:  export
#+EXPORT_EXCLUDE_TAGS: noexport
#+FILETAGS:            :sdp:rel:path:file:
#+TAGS: assert(a) class(c) debug(d) mixin(m) sdp(s) tangle(T) template(t) WEB(W) noexport(n)

[[./sdp.org][sdp]]  [[./][org/]]
* 0. source paths                                   :module:sdp:paths_source:
** 0. module template

#+BEGIN_SRC d :tangle ../src/sdp/output/paths_source.d
/++
  read configuration files<BR>
  - read config files<BR>
  meta_config_files.d
+/
module sdp.output.paths_source;
import std.array,
  std.file,
  std.path,
  std.regex,
  std.stdio,
  std.conv : to;
import sdp.meta.rgx;
<<template_paths_src>>
<<template_paths_sisupod>>
<<template_paths_sisupod_shallow>>
<<template_paths_sisupods>>
#+END_SRC

** _manifest_                                                       :manifest:

#+name: template_paths_src
#+BEGIN_SRC d
template PodManifest() {
  mixin SiSUrgxInit;
  static auto rgx = Rgx();
  auto PodManifest(P)(
    P   _pth = "",
  ) {
    struct ManifestFile_ {
      auto pod_manifest_filename() {
        string _manifest_file = "sisupod.manifest";
        return _manifest_file;
      }
      auto pod_manifest_path() {
        string _manifest_path;
        if (isValidPath(_pth) && _pth.isDir
        && ((_pth.chainPath(pod_manifest_filename).array).isFile)) {
          _manifest_path = _pth;
        } else if (_pth.match(rgx.src_pth_contents)
        && (_pth.isFile)) {
          _manifest_path = dirName(_pth);
        // } else { // _manifest_path = "";
        }
        return _manifest_path;
      }
      auto pod_manifest_file_with_path() {
        string _manifest_path_and_file = pod_manifest_path.chainPath(pod_manifest_filename).array;
        return _manifest_path_and_file;
      }
    }
    return ManifestFile_();
  }
}
#+END_SRC

** _manifest and source files_                                      :manifest:

#+name: template_paths_src
#+BEGIN_SRC d
template PodMatters() {
  mixin SiSUrgxInit;
  static auto rgx = Rgx();
  auto PodMatters(O,E,P,F)(
    O   _opt_actions,
    E   _env,
    P   _pth                   = "",
    F   _fns                   = "",
    char[][] _manifest_fn_list = [[]],
  ) {
    auto _manifest = PodManifest!()(_pth);
    struct ManifestMatters_ {
      auto pwd() {
        return _env["pwd"];
      }
      auto home() {
        return _env["home"];
      }
      auto opt_action() {
        return _opt_actions;
      }
      auto is_pod() {
        auto _is_pod = (_manifest.pod_manifest_path.length > 0) ? true : false;
        return _is_pod;
      }
      auto pod_manifest_list_of_filenames() {
        return _manifest_fn_list;
      }
      auto pod_manifest_list_of_languages() {
        string[] _lngs;
        foreach (filename_; pod_manifest_list_of_filenames) {
          string _k = "en";
          if (auto m = (filename_).match(rgx.language_code_and_filename)) {
            _k = m.captures[1].to!string;
          }
          _lngs ~= _k; // all the languages from the manifest list of filenames with paths
        }
        return _lngs;
      }
      auto pod_manifest_filename() {
        return _manifest.pod_manifest_filename;
      }
      auto pod_manifest_path() {
        return _manifest.pod_manifest_path;
      }
      auto pod_manifest_file_with_path() {
        return _manifest.pod_manifest_file_with_path;
      }
      auto pod_config_dirs() {                              // TODO
        string[] _config_dirs;
        return _config_dirs;
      }
      auto pod_image_dirs() {                               // TODO
        string[] _image_dirs;
        return _image_dirs;
      }
      auto src_fn() {
        return _fns;
      }
      auto src_lng() {
        string _k;
        if (auto m = (src_fn).match(rgx.language_code_and_filename)) {
          _k = m.captures[1];
        } else {
          _k = "en";
        }
        return _k;
      }
      auto output_path() {
        auto _output_path = pwd;
        if ((_opt_actions.output_dir_set.length > 0)
          && isValidPath(_opt_actions.output_dir_set)
        ) {
          _output_path = asNormalizedPath(_opt_actions.output_dir_set).array;
          if (!exists(_output_path)) {
            try {
              _output_path.mkdirRecurse;
            }
            catch (Exception ex) {
              // Handle error
            }
          }
          assert(_output_path.isDir,
            "not a directory: " ~ _output_path);
          // TODO always test that is a directory and it is writable
        }
        return _output_path;
      }
      auto src_config_dirs() {                              // TODO
        string[] _config_dirs;
        if (is_pod) {
        } else {
        }
        return _config_dirs;
      }
      auto src_image_dirs() {                               // TODO
        string[] _image_dirs;
        if (is_pod) {
        } else {
        }
        return _image_dirs;
      }
    }
    return ManifestMatters_();
  }
}
#+END_SRC

** _config_                                                           :config:

#+name: template_paths_src
#+BEGIN_SRC d
template ConfigFilePaths() {
  mixin SiSUrgxInit;
  static auto rgx = Rgx();
  auto ConfigFilePaths(M,E)(
    M   _manifest,
    E   _env,
  ) {
    struct ConfFilePaths {
      auto possible_config_path_locations() {
        /+ FIX clean up conf paths ↓ +/
        /+ config local site (file system only, not in pod) +/
        string _dot_pwd;
        string _underscore_pwd;
        string _dot_home;
        /+ config document (& or local site) on filesystem +/
        string _sisudoc_conf_pwd; // think about
        string _sisudoc_conf_pwd_a;
        string _sisudoc_conf_pwd_b;
        string _sisudoc_conf_pwd_c;
        string _sisudoc_conf_pwd_d;
        /+ config document in pod +/
        string _sisudoc_conf_pod;
        string _sisudoc_conf_pod_text;
        /+ return paths +/
        string[] _possible_config_path_locations;
        if (_manifest.is_pod) {
          /+ config document in pod +/
          _sisudoc_conf_pod = asNormalizedPath(chainPath(
            to!string(_env["pwd"]),
            _manifest.pod_manifest_path ~ "/conf"
          )).array;
          _sisudoc_conf_pod_text = asNormalizedPath(chainPath(
            to!string(_env["pwd"]),
            _manifest.pod_manifest_path ~ "/media/text/" ~ _manifest.src_lng ~ "/conf"
          )).array;
          /+ return paths +/
          _possible_config_path_locations = [
            _sisudoc_conf_pod_text,
            _sisudoc_conf_pod,
          ];
        } else {
          /+ config local site (file system only, not in pod) +/
          _dot_pwd        = asNormalizedPath(chainPath(to!string(_env["pwd"]), ".sisu")).array;
          _underscore_pwd = asNormalizedPath(chainPath(to!string(_env["pwd"]), "_sisu")).array;
          _dot_home       = asNormalizedPath(chainPath(to!string(_env["home"]), ".sisu")).array;
          /+ config document (& or local site) on filesystem +/
          _sisudoc_conf_pwd   = asNormalizedPath(chainPath(to!string(_env["pwd"]), "sisudoc/conf")).array; // think about
          _sisudoc_conf_pwd_a = asNormalizedPath(chainPath(to!string(_env["pwd"]), "conf")).array;
          _sisudoc_conf_pwd_b = asNormalizedPath(chainPath(to!string(_env["pwd"]), "../conf")).array;
          _sisudoc_conf_pwd_c = asNormalizedPath(chainPath(to!string(_env["pwd"]), "../../conf")).array;
          _sisudoc_conf_pwd_d = asNormalizedPath(chainPath(to!string(_env["pwd"]), "../../../conf")).array;
          /+ return paths +/
          _possible_config_path_locations = [
            _sisudoc_conf_pwd,
            _sisudoc_conf_pwd_a,
            _sisudoc_conf_pwd_b,
            _sisudoc_conf_pwd_c,
            _sisudoc_conf_pwd_d,
            _dot_pwd,
            _underscore_pwd,
            _dot_home,
            "/etc/sisu"
          ];
        }
        /+ FIX clean up conf paths ↑
        (compare pwd to doc path location, and build config path)
        +/
        return _possible_config_path_locations;
      }
    }
    return ConfFilePaths();
  }
}
#+END_SRC

** _sisupod_ (including generated bundled source)                    :sisupod:
*** notes

tree sisupod
sisupod
└── sisudoc
    ├── conf
    │   └── sisu_document_make
    ├── media
    │   ├── audio
    │   ├── image
    │   ├── text
    │   │   └── en
    │   │      ...
    │   │       ├── [conf]
    │   │       └── [image]
    │   └── video
    └── sisupod.manifest

_replace:_

doc
├── en
│   └── the_wealth_of_networks.yochai_benkler.sst
└── _sisu
    └── sisu_document_make

filelist for processing [things to ponder]

- the plan is to have a src manifest of related .sst or .ssm files that
  can be pointed to for processing
- multilingual documents [ponder persistence for multilingual documents]
  - in the case of multilingual documents, there will be multiple
    source documents on list with different language codes, and to build
    this list, persistence is required
- inserted documents (from master .ssm or .sst) must track document root
  so inserts can be located, else not found
- consider a commandline -o --output path specifier
- steps
  - auto create filelist
    - for single source file
    - for multilinugual source files
  - process document by pointing at filelist (rather than file)
    - if necessary manually create filelist (for multilinugual source)
    - keep document root for document inserts (.ssi)

*** manual source

#+name: template_paths_src
#+BEGIN_SRC d
template SiSUpathsSRC() {
  mixin SiSUrgxInit;
  static auto rgx = Rgx();
  auto SiSUpathsSRC(D,Fn)(
    D   _pwd,
    Fn  _fn_src_and_relative_path,
  ) {
    struct SisuSrcPaths {
      auto pwd() {
        return _pwd;
      }
      auto language() {
        // use command line info as well?
        string _k;
        if (auto m = _fn_src_and_relative_path.match(rgx.language_code_and_filename)) {
          _k = m.captures[1];
        } else { /+ unknown until doc_meta read, (could provide & use command line info?) +/
          _k = "xx"; // original default was "en" but is not known
        }
        return _k;
      }
      auto doc_root() {
        return "sisudoc";
      }
      auto media_root() {
        return asNormalizedPath(doc_root.chainPath("media")).array;
      }
      auto conf_root() {
        return asNormalizedPath(doc_root.chainPath("conf")).array;
      }
      auto text_root() {
        return asNormalizedPath(media_root.chainPath("text")).array;
      }
      auto image_root() {
        return asNormalizedPath(media_root.chainPath("image")).array;
      }
      auto doc_src_fn_with_path_for_text_root_and_lng() {
        return asNormalizedPath(text_root.chainPath(language)).array;
      }
      auto doc_src_with_relative_path() {
        return asNormalizedPath(pwd.chainPath(_fn_src_and_relative_path)).array;
      }
      auto doc_src_fn() {
        return asNormalizedPath(_fn_src_and_relative_path.baseName).array;
      }
    }
    return SisuSrcPaths();
  }
}
#+END_SRC

*** pod archive base

#+name: template_paths_sisupod
#+BEGIN_SRC d
template SiSUpathsSisupod() {
  mixin SiSUrgxInit;
  static auto rgx = Rgx();
  string _base_dir_pod = "sisupod";
  string _base_dir_doc = "sisudoc";
  string _suffix = ".zip";
  auto SiSUpathsSisupod()() {
    struct _PathsStruct {
      string base_filename(string fn_src) {
        auto pth = fn_src.baseName.stripExtension;
        return pth;
      }
      string sisupod_dir() {
        auto pth = _base_dir_pod;
        return pth;
      }
      string sisudoc_dir() {
        auto pth = _base_dir_doc;
        return pth;
      }
      string sisupod_filename(string fn_src) {
        string pth = _base_dir_pod.chainPath(base_filename(fn_src) ~ _suffix).array;
        return pth;
      }
      string base_filesystem(string fn_src) {
        string pth = _base_dir_pod.chainPath(base_filename(fn_src)).array;
        assert(pth == _base_dir_pod ~ "/"  ~ base_filename(fn_src),
          pth ~ " == "  ~ _base_dir_pod ~ "/" ~ base_filename(fn_src) ~ "?");
        return pth;
      }
      string base_pod(string fn_src) {
        string pth = _base_dir_pod.chainPath(base_filename(fn_src)).array; // change this
        return pth;
      }
    }
    return _PathsStruct();
  }
}
#+END_SRC

*** pods internal, zipped, unzipped

#+name: template_paths_sisupods
#+BEGIN_SRC d
template SiSUpathsSisupods() {
  mixin SiSUrgxInit;
  static auto rgx = Rgx();
  string _base_dir_pod = "sisupod";
  string _base_dir_doc = "sisudoc";
  string _suffix = ".zip";
  auto SiSUpathsSisupods()() {
    struct _PodPaths {
      string base_filename_(string fn_src) {
        auto pth = fn_src.baseName.stripExtension;
        return pth;
      }
      string sisupod_dir_() {
        auto pth = _base_dir_pod;
        return pth;
      }
      string sisudoc_dir_() {
        auto pth = _base_dir_doc;
        return pth;
      }
      string sisupod_filename_(string fn_src) {
        string pth = _base_dir_pod.chainPath(base_filename_(fn_src) ~ _suffix).array;
        return pth;
      }
      string base_filesystem_(string fn_src) {
        string pth = _base_dir_pod.chainPath(base_filename_(fn_src)).array;
        assert(pth == _base_dir_pod ~ "/"  ~ base_filename_(fn_src),
          pth ~ " == "  ~ _base_dir_pod ~ "/" ~ base_filename_(fn_src) ~ "?");
        return pth;
      }
      string base_pod_(string fn_src) {
        string pth = _base_dir_pod.chainPath(base_filename_(fn_src)).array; // change this
        return pth;
      }
      auto base_filename(string fn_src) {
        auto pth_1_ = base_filename_(fn_src);
        auto pth_2_ = base_filename_(fn_src);
        struct _pods {
          auto zpod() {
            return pth_1_;
          }
          auto filesystem_open_zpod() {
            return pth_2_;
          }
        }
        return _pods();
      }
      auto sisupod_filename(string fn_src) {
        auto pth_1_ = sisupod_filename_(fn_src);
        auto pth_2_ = sisupod_filename_(fn_src);
        struct _pods {
          auto zpod() {
            return pth_1_;
          }
          auto filesystem_open_zpod() {
            return pth_2_;
          }
        }
        return _pods();
      }
      auto base(string fn_src) {
        auto pth_1_ = "";
        auto pth_2_ = base_filesystem_(fn_src);
        struct _pods {
          auto zpod() {
            return pth_1_;
          }
          auto filesystem_open_zpod() {
            return pth_2_;
          }
        }
        return _pods();
      }
      auto pod_root(string fn_src) {
        auto pth_1_ = "";
        auto pth_2_ = asNormalizedPath(base(fn_src).filesystem_open_zpod.chainPath("")).array; // "sisudoc"
        struct _pods {
          auto zpod() {
            return pth_1_;
          }
          auto filesystem_open_zpod() {
            return pth_2_;
          }
        }
        return _pods();
      }
      auto conf_root(string fn_src) {
        auto pod_root_ = pod_root(fn_src);
        auto pth_1_ = "conf";
        auto pth_2_ = asNormalizedPath(pod_root(fn_src).filesystem_open_zpod.chainPath("conf")).array;
        struct _pods {
          auto zpod() {
            return pth_1_;
          }
          auto filesystem_open_zpod() {
            assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
            return pth_2_;
          }
        }
        return _pods();
      }
      auto css(string fn_src) {
        auto pod_root_ = pod_root(fn_src);
        auto pth_1_ = asNormalizedPath(conf_root(fn_src).zpod.chainPath("css")).array;
        auto pth_2_ = asNormalizedPath(conf_root(fn_src).filesystem_open_zpod.chainPath("css")).array;
        struct _pods {
          auto zpod() {
            return pth_1_;
          }
          auto filesystem_open_zpod() {
            assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
            return pth_2_;
          }
        }
        return _pods();
      }
      auto media_root(string fn_src) {
        auto pod_root_ = pod_root(fn_src);
        auto pth_1_ = "media";
        auto pth_2_ = asNormalizedPath(pod_root(fn_src).filesystem_open_zpod.chainPath("media")).array;
        struct _pods {
          auto zpod() {
            return pth_1_;
          }
          auto filesystem_open_zpod() {
            assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
            return pth_2_;
          }
        }
        return _pods();
      }
      auto text_root(string fn_src) {
        auto pod_root_ = pod_root(fn_src);
        auto pth_1_ = asNormalizedPath(media_root(fn_src).zpod.chainPath("text")).array;
        auto pth_2_ = asNormalizedPath(media_root(fn_src).filesystem_open_zpod.chainPath("text")).array;
        struct _pods {
          auto zpod() {
            return pth_1_;
          }
          auto filesystem_open_zpod() {
            assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
            return pth_2_;
          }
        }
        return _pods();
      }
      auto doc(string fn_src) {
        auto pod_root_ = pod_root(fn_src);
        auto pth_1_ = text_root(fn_src).zpod;
        auto pth_2_ = text_root(fn_src).filesystem_open_zpod;
        struct _pods {
          auto zpod() {
            return pth_1_;
          }
          auto filesystem_open_zpod() {
            assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
            return pth_2_;
          }
        }
        return _pods();
      }
      auto doc_lng(string fn_src, string lng) {
        auto pod_root_ = pod_root(fn_src);
        auto pth_1_ = asNormalizedPath(text_root(fn_src).zpod.chainPath(lng)).array;
        auto pth_2_ = asNormalizedPath(text_root(fn_src).filesystem_open_zpod.chainPath(lng)).array;
        struct _pods {
          auto zpod() {
            return pth_1_;
          }
          auto filesystem_open_zpod() {
            assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
            return pth_2_;
          }
        }
        return _pods();
      }
      auto image_root(string fn_src) {
        auto pod_root_ = pod_root(fn_src);
        auto pth_1_ = asNormalizedPath(media_root(fn_src).zpod.chainPath("image")).array;
        auto pth_2_ = asNormalizedPath(media_root(fn_src).filesystem_open_zpod.chainPath("image")).array;
        struct _pods {
          auto zpod() {
            return pth_1_;
          }
          auto filesystem_open_zpod() {
            assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
            return pth_2_;
          }
        }
        return _pods();
      }
      auto fn_pod_filelist(string fn_src) {
        auto pod_root_ = pod_root(fn_src);
        auto _manifest = PodManifest!()(fn_src).pod_manifest_filename;
        auto pth_1_ = _manifest;
        auto pth_2_ = asNormalizedPath(pod_root(fn_src).filesystem_open_zpod.chainPath(_manifest)).array;
        struct _pods {
          auto zpod() {
            return pth_1_;
          }
          auto filesystem_open_zpod() {
            assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
            return pth_2_;
          }
        }
        return _pods();
      }
      auto fn_doc(string fn_src, string lng) {
        auto pod_root_ = pod_root(fn_src);
        auto pth_1_ = asNormalizedPath(doc_lng(fn_src, lng).zpod.chainPath(fn_src.baseName)).array;
        auto pth_2_ = asNormalizedPath(doc_lng(fn_src, lng).filesystem_open_zpod.chainPath(fn_src.baseName)).array;
        struct _pods {
          auto zpod() {
            return pth_1_;
          }
          auto filesystem_open_zpod() {
            assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
            return pth_2_;
          }
        }
        return _pods();
      }
      auto fn_doc_insert(string fn_src, string fn_insert, string lng) {
        auto pod_root_ = pod_root(fn_src);
        auto pth_1_ = asNormalizedPath(doc_lng(fn_src, lng).zpod.chainPath(fn_insert.baseName)).array;
        auto pth_2_ = asNormalizedPath(doc_lng(fn_src, lng).filesystem_open_zpod.chainPath(fn_insert.baseName)).array;
        struct _pods {
          auto zpod() {
            return pth_1_;
          }
          auto filesystem_open_zpod() {
            assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
            return pth_2_;
          }
        }
        return _pods();
      }
    }
    return _PodPaths();
  }
}
#+END_SRC

* 1. output paths                                   :module:sdp:paths_output:
** 0. module template

#+BEGIN_SRC d :tangle ../src/sdp/output/paths_output.d
/++
  default settings
+/
module sdp.output.paths_output;
import std.array,
  std.path,
  std.regex,
  std.stdio;
import sdp.meta.rgx;
<<template_paths_out>>
<<template_paths_html>>
<<template_paths_epub>>
<<template_paths_sqlite>>
#+END_SRC

** shared out path, base directory                                     :out:

#+name: template_paths_out
#+BEGIN_SRC d
template SiSUoutPaths() {
  auto SiSUoutPaths(Po,Lng)(
    Po  output_pth_root,
    Lng lng,
  ) {
    struct _PathsStruct {
      string output_root() {
        string out_root_;
        if (output_pth_root.length > 0) {
          out_root_ = output_pth_root;
        } else {
          out_root_ = "sisugen";
        }
        return out_root_;
      }
      string output_base() {
        return asNormalizedPath(output_root.chainPath(lng)).array;
      }
    }
    return _PathsStruct();
  }
}
#+END_SRC

** _html_                                                               :html:

#+name: template_paths_html
#+BEGIN_SRC d
template SiSUpathsHTML() {
  mixin SiSUrgxInit;
  static auto rgx = Rgx();
  auto SiSUpathsHTML(Po,Lng)(
    Po  output_pth_root,
    Lng lng,
  ) {
    auto out_pth = SiSUoutPaths!()(output_pth_root, lng);
    string base_dir = "html";
    string suffix = ".html";
    struct _PathsStruct {
      string base_filename(string fn_src) {
        return fn_src.baseName.stripExtension;
      }
      string base() {
        return asNormalizedPath((out_pth.output_base).chainPath(base_dir)).array;
      }
      string image() {
        return asNormalizedPath((out_pth.output_root).chainPath("image")).array;
      }
      string css() {
        return asNormalizedPath((out_pth.output_root).chainPath("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(fn_src))).array;
      }
      string fn_scroll(string fn_src) {
        return asNormalizedPath(base.chainPath(base_filename(fn_src) ~ suffix)).array;
      }
      string fn_seg(string fn_src, string seg_filename) {
        return asNormalizedPath(seg(fn_src).chainPath(seg_filename ~ suffix)).array;
      }
    }
    return _PathsStruct();
  }
}
#+END_SRC

** _epub_                                                               :epub:

#+name: template_paths_epub
#+BEGIN_SRC d
template SiSUpathsEPUB() {
  mixin SiSUrgxInit;
  static auto rgx = Rgx();
  auto SiSUpathsEPUB(Po,Lng)(
    Po  output_pth_root,
    Lng lng,
  ) {
    auto out_pth = SiSUoutPaths!()( 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 epub_file(string fn_src) {
        return asNormalizedPath(base.chainPath(base_filename(fn_src) ~ ".epub")).array;
      }
      string dirtop() {
        return "".chainPath("").array;
      }
      string doc_meta_inf(string fn_src) {
        return asNormalizedPath(dirtop.chainPath("META-INF")).array;
      }
      string doc_oebps(string fn_src) {
        return asNormalizedPath(dirtop.chainPath("OEBPS")).array;
      }
      string doc_oebps_css(string fn_src) {
        return asNormalizedPath(doc_oebps(fn_src).chainPath("css")).array;
      }
      string doc_oebps_image(string fn_src) {
        return asNormalizedPath(doc_oebps(fn_src).chainPath("image")).array;
      }
      string fn_mimetypes(string fn_src) {
        return asNormalizedPath(dirtop.chainPath("mimetypes")).array;
      }
      string fn_dmi_container_xml(string fn_src) {
        return asNormalizedPath(doc_meta_inf(fn_src).chainPath("container.xml")).array;
      }
      string fn_oebps_toc_nav_xhtml(string fn_src) {
        return asNormalizedPath(doc_oebps(fn_src).chainPath("toc_nav.xhtml")).array;
      }
      string fn_oebps_toc_ncx(string fn_src) {
        return asNormalizedPath(doc_oebps(fn_src).chainPath("toc.ncx")).array;
      }
      string fn_oebps_content_opf(string fn_src) {
        return asNormalizedPath(doc_oebps(fn_src).chainPath("content.opf")).array;
      }
      string fn_oebps_content_xhtml(string fn_src, string seg_filename) {
        return asNormalizedPath(doc_oebps(fn_src).chainPath(seg_filename ~ ".xhtml")).array;
      }
      string fn_oebps_css(string fn_src) {
        return asNormalizedPath(doc_oebps_css(fn_src).chainPath("epub.css")).array;
      }
      debug(epub_output) {
        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();
  }
}
#+END_SRC

** _sqlite_                                                           :sqlite:
*** discrete

#+name: template_paths_sqlite
#+BEGIN_SRC d
template SiSUpathsSQLiteDiscrete() {
  mixin SiSUrgxInit;
  static auto rgx = Rgx();
  auto SiSUpathsSQLiteDiscrete(Po,Lng)(
    Po  output_pth_root,
    Lng lng,
  ) {
    auto out_pth = SiSUoutPaths!()(output_pth_root, lng);
    string base_dir = "sqlite";
    struct _PathsStruct {
      string base_filename(string fn_src) {
        return fn_src.baseName.stripExtension;
      }
      string base() {
        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) ~ ".sqlite")).array;
      }
    }
    return _PathsStruct();
  }
}
#+END_SRC

*** TODO collection

#+name: template_paths_sqlite
#+BEGIN_SRC d
template SiSUpathsSQLite() {
  mixin SiSUrgxInit;
  static auto rgx = Rgx();
  auto SiSUpathsSQLite(Po,Lng)(
    Po  output_pth_root,
    Lng lng,
  ) {
    auto out_pth = SiSUoutPaths!()(output_pth_root, lng);
    string base_dir = "sqlite";
    struct _PathsStruct {
      string base_filename(string fn_src) {
        return fn_src.baseName.stripExtension;
      }
      string base() {
        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) ~ ".sqlite")).array;
      }
    }
    return _PathsStruct();
  }
}
#+END_SRC