-*- mode: org -*-
#+TITLE:       sisudoc spine (doc_reform) output pod
#+DESCRIPTION: documents - structuring, publishing in multiple formats & search
#+FILETAGS:    :spine:output:source:pod:
#+AUTHOR:      Ralph Amissah
#+EMAIL:       [[mailto:ralph.amissah@gmail.com][ralph.amissah@gmail.com]]
#+COPYRIGHT:   Copyright (C) 2015 - 2024 Ralph Amissah
#+LANGUAGE:    en
#+STARTUP:     content hideblocks hidestars noindent entitiespretty
#+PROPERTY:    header-args  :exports code
#+PROPERTY:    header-args+ :noweb yes
#+PROPERTY:    header-args+ :results no
#+PROPERTY:    header-args+ :cache no
#+PROPERTY:    header-args+ :padline no
#+PROPERTY:    header-args+ :mkdirp yes
#+OPTIONS:     H:3 num:nil toc:t \n:t ::t |:t ^:nil -:t f:t *:t

- [[./doc-reform.org][doc-reform.org]]  [[./][org/]]
- [[./output_hub.org][output_hub]]

* pod
** _module template_ :module:

#+HEADER: :tangle "../src/sisudoc/io_out/source_pod.d"
#+HEADER: :noweb yes
#+BEGIN_SRC d
<<doc_header_including_copyright_and_license>>
module sisudoc.io_out.source_pod;
@system: // is not @safe: use: @system: or @trusted:
template spinePod() {
  <<output_imports>>
  void spinePod(T)(T doc_matters) {
    <<source_pod_init>>
    if (doc_matters.opt.action.pod) {
      try {
        {
          podArchive_directory_tree(doc_matters, pths_pod);
        }
        {
          struct STsrcDigests {
            std.zip.ZipArchive     zip;
            string                 fn_pod;
            string[string][string] digests;
          }
          STsrcDigests _st;
          _st = pod_zipMakeReady(doc_matters, pths_pod, _st);
          {
            zipArchive(doc_matters, _st.fn_pod, _st.zip);
            if (doc_matters.src.language == doc_matters.pod.manifest_list_of_languages[$-1]) {
              zipArchiveDigest(doc_matters, _st.fn_pod, _st.digests);
            }
          }
        }
      } catch (ErrnoException ex) {
        // Handle error
      }
    }
  }
  <<source_pod_mkdirs>>
  <<source_pod_archive_prepare_for_zip_and_get_digests>>
  <<source_pod_archive_zip>>
  <<zip_archive>>
  <<pod_source_files_digests>>
}
#+END_SRC

** init
*** imports

#+NAME: output_imports
#+BEGIN_SRC d
import
  sisudoc.meta.rgx_files,
  sisudoc.io_out;
import
  std.digest.sha,
  std.file,
  std.outbuffer,
  std.zip,
  std.conv : to;
import
  sisudoc.io_out.create_zip_file,
  sisudoc.io_out.xmls;
#+END_SRC

*** init

#+NAME: source_pod_init
#+BEGIN_SRC d
debug(asserts) {
  // static assert(is(typeof(doc_matters) == tuple));
}
mixin spineRgxFiles;
string pwd = doc_matters.env.pwd;
auto pths_pod = spinePathsPods!()(doc_matters);
mixin spineLanguageCodes;
auto lang = Lang();
static auto rgx_files = RgxFiles();
assert (doc_matters.src.filename.match(rgx_files.src_fn));
#+END_SRC

** source pod archive, (prepare for zip) :copy:

#+NAME: source_pod_archive_prepare_for_zip_and_get_digests
#+BEGIN_SRC d
auto pod_zipMakeReady(M,P,S)(M doc_matters, P pths_pod, S _st) {
  auto pth_dr_doc_src = doc_matters.src_path_info;
  if (doc_matters.opt.action.debug_do_pod && doc_matters.opt.action.vox_gt1) {
    writeln(__LINE__, ": ",
      doc_matters.src.filename, " -> ",
      pths_pod.fn_doc(doc_matters.src.filename, doc_matters.src.language).filesystem_open_zpod
    );
  }
  auto zip = new ZipArchive(); // needed
  auto fn_pod = pths_pod.pod_filename(doc_matters.src.filename).zpod;
  string[string][string] _digests;
  { // bundle images - get digest
    foreach (image; doc_matters.srcs.image_list) {
      debug(podimages) {
        writeln(
          pth_dr_doc_src.image_root.to!string, "/", image, " -> ",
          pths_pod.image_root(doc_matters.src.filename).zpod, "/", image
        );
      }
      auto fn_src_in = doc_matters.src.image_dir_path ~ "/" ~ image;
      auto fn_src_out_pod_zip_base
        = pths_pod.image_root(doc_matters.src.filename).zpod.to!string
        ~ "/" ~ image;
      auto fn_src_out_filesystem
        = pths_pod.image_root(doc_matters.src.filename).filesystem_open_zpod.to!string
        ~ "/" ~ image;
      if (exists(fn_src_in)) {
        debug(io) { writeln("(io debug) src out found: ", fn_src_in); }
        { // take DIGEST write to pod file digests.txt
          auto data = (cast(byte[]) (fn_src_in).read);
          _digests["shared"]["images"] ~= data.sha256Of.toHexString ~ "::" ~ data.length.to!string ~ " - " ~ image ~ "\n";
          // writeln(data.sha256Of.toHexString, "::", data.length, " - ", image);
        }
        if (doc_matters.opt.action.source_or_pod) {
          fn_src_in.copy(fn_src_out_filesystem);
        }
        if (doc_matters.opt.action.pod) {
          zip = podArchive("file_path_bin", fn_src_in, fn_src_out_pod_zip_base, zip);
        }
      } else {
        if (doc_matters.opt.action.debug_do_pod && doc_matters.opt.action.vox_gt1) {
          writeln("WARNING (io) src out NOT found (image): ", fn_src_in);
        }
      }
    }
  } { // bundle dr_document_make
    auto fn_src_in = ((doc_matters.src.is_pod)
      ? doc_matters.src.conf_dir_path
      : pth_dr_doc_src.conf_root).to!string
      ~ "/" ~ "dr_document_make";
    auto fn_src_out_pod_zip_base
      = pths_pod.conf_root(doc_matters.src.filename).zpod.to!string ~ "/" ~ "dr_document_make";
    auto fn_src_out_filesystem
      = pths_pod.conf_root(doc_matters.src.filename).filesystem_open_zpod.to!string
      ~ "/" ~ "dr_document_make";
    if (exists(fn_src_in)) {
      debug(io) { writeln("(io debug) src out found: ", fn_src_in); }
      if (doc_matters.opt.action.source_or_pod) {
        fn_src_in.copy(fn_src_out_filesystem);
      }
      if (doc_matters.opt.action.pod) {
        zip = podArchive("file_path_text", fn_src_in, fn_src_out_pod_zip_base, zip);
      }
    } else {
      if (doc_matters.opt.action.debug_do_pod && doc_matters.opt.action.vox_gt1) {
        writeln("WARNING (io) src out NOT found (document make): ", fn_src_in);
      }
    }
  } { // pod manifest
    auto fn_src_in = doc_matters.src.file_with_absolute_path.to!string;
    auto fn_src_out_pod_zip_base
      = pths_pod.pod_manifest(doc_matters.src.filename).zpod.to!string;
    auto fn_src_out_filesystem
      = pths_pod.pod_manifest(doc_matters.src.filename).filesystem_open_zpod.to!string; // needed without root path
    auto fn_src_out_inside_pod
      = pths_pod.pod_manifest(doc_matters.src.filename).zpod.to!string; // needed without root path
    string[] filelist_src_out_pod_arr;
    string[] filelist_src_zpod_arr;
    if (exists(fn_src_in)) {
      debug(io) { writeln("(io debug) src in found: ", fn_src_in); }
      filelist_src_out_pod_arr ~= fn_src_out_pod_zip_base;
      filelist_src_zpod_arr ~= fn_src_out_inside_pod;
      {
        import dyaml;
        auto pod_filelist_yaml_string
          = File(pths_pod.fn_pod_filelist(doc_matters.src.filename).filesystem_open_zpod, "w");
        Node _pmy;
        string _pm = "doc:\n  filename: " ~ doc_matters.src.filename ~ "\n  language: " ~ doc_matters.pod.manifest_list_of_languages.to!string ~ "\n";
        if (doc_matters.opt.action.debug_do_pod && doc_matters.opt.action.vox_gt1) {
          try {
            _pmy = Loader.fromString(_pm).load();
          } catch (ErrnoException ex) {
          } catch (Throwable) {
            writeln("ERROR failed to read config file content, not parsed as yaml");
          }
          writeln("pod filename:  ", _pmy["doc"]["filename"].get!string);
          writeln("pod languages: ", doc_matters.pod.manifest_list_of_languages.to!string);
          writeln("pod languages: ", doc_matters.src.language);
          // foreach(string _l; _pmy["doc"]["language"]) {
          //   writeln("language:      ", _l);
          // }
        }
        if (doc_matters.opt.action.source_or_pod) {
          pod_filelist_yaml_string.writeln(_pm);
        }
        if (doc_matters.opt.action.pod) {
          zip = podArchive("string", _pm, fn_src_out_pod_zip_base, zip);
        }
      }
    }
  } { // bundle primary file (.ssm/.sst) - get digest
    auto fn_src_in = doc_matters.src.file_with_absolute_path.to!string;
    auto fn_src_out_pod_zip_base
      = pths_pod.fn_doc(doc_matters.src.filename, doc_matters.src.language).zpod.to!string;
    auto fn_src_out_filesystem
      = pths_pod.fn_doc(doc_matters.src.filename, doc_matters.src.language).filesystem_open_zpod.to!string; // needed without root path:
    auto fn_src_out_inside_pod
      = pths_pod.fn_doc(doc_matters.src.filename, doc_matters.src.language).zpod.to!string; // needed without root path:
    string[] filelist_src_out_pod_arr;
    string[] filelist_src_zpod_arr;
    if (doc_matters.src.language == doc_matters.pod.manifest_list_of_languages[$-1]) { // wait until all language versions of .ssm parsed
      foreach (_lang; doc_matters.pod.manifest_list_of_languages) { // do for all language versions
        string fn_src_out_filesystem_lng
          = pths_pod.fn_doc(doc_matters.src.filename, _lang).filesystem_open_zpod.to!string;
        string _sstm = (doc_matters.pod.manifest_path ~ "/media/text/" ~ _lang ~ "/" ~ doc_matters.src.filename);
        // writeln(_sstm);
        if (exists(_sstm)) { // what of language?
          debug(io) { writeln("(io debug) src in found: ", _sstm); }
          { // take DIGEST write to pod file digests.txt
            auto data = (cast(byte[]) (_sstm).read);
            _digests[_lang]["sstm"] ~= data.sha256Of.toHexString ~ "::" ~ data.length.to!string ~ " - " ~ doc_matters.src.filename ~ " - [" ~ _lang ~ "]";
            // writeln(data.sha256Of.toHexString, "::", data.length, " - ", doc_matters.src.filename);
          }
          filelist_src_out_pod_arr ~= fn_src_out_pod_zip_base;
          filelist_src_zpod_arr ~= fn_src_out_inside_pod;
          string _pod_to_markup_file = doc_matters.src.pod_name ~ "/" ~ "media/text/" ~ _lang ~ "/" ~ doc_matters.src.filename;
          if (doc_matters.opt.action.source_or_pod) {
            _sstm.copy(fn_src_out_filesystem_lng);
          }
          if (doc_matters.opt.action.pod) {
            auto _rgx_sstm = regex(r"(?P<path_to_pod>\S+?)(?P<podname>[a-z_-]+)/(?P<from_root>media/text/)(?P<language>\S+?)/(?P<filename>\S+?\.ss[mt])");
            if (auto _x = _sstm.match(_rgx_sstm)){
              if (doc_matters.src.lng == doc_matters.pod.manifest_list_of_languages[$-1]) { // again wait until all language versions of .ssm parsed
                string _path_to_pod = _x.captures["path_to_pod"];
                string _podname = _x.captures["podname"];
                string _root_to_lang = _x.captures["from_root"];
                string _language = _x.captures["language"]; // .ssi inserts expected to have same name across languages
                string _filename = _x.captures["filename"];
                foreach (_lang1; doc_matters.pod.manifest_list_of_languages) { // do for all language versions
                  string _pth_mkup_src_in = _path_to_pod ~ _podname ~ "/" ~ _root_to_lang ~ _lang1 ~ "/" ~ _filename;
                  string _pth_mkup_src_out = "pod/" ~ _root_to_lang ~ _lang1 ~ "/" ~ _filename;
                  // writeln("\nin:  ", _pth_mkup_src_in, "\nout: ", _pth_mkup_src_out); // DEBUG, REMOVE
                  zip = podArchive("file_path_text", _pth_mkup_src_in, _pth_mkup_src_out, zip);
                }
              }
            } else {
              zip = podArchive("file_path_text", _sstm, fn_src_out_pod_zip_base, zip);
            }
          }
        } else {
          if (doc_matters.opt.action.debug_do_pod && doc_matters.opt.action.vox_gt1) {
            writeln("WARNING (io) src in NOT found (markup source): ", _sstm);
          }
        }
      }
    }
  } { // bundle insert files (.ssi) - get digest
    if (doc_matters.srcs.file_insert_list.length > 0) {
      auto _rgx_ssi = regex(r"(?P<path_to_pod>\S+?)(?P<podname>[a-z_-]+)/(?P<from_root>media/text/)(?P<language>\S+?)/(?P<filename>\S+?\.ss[i])");
      foreach (insert_file; doc_matters.srcs.file_insert_list) {
        debug(pod) {
          writeln(
            insert_file, " -> ",
            pths_pod.fn_doc_insert(
              doc_matters.src.filename,
              insert_file,
              doc_matters.src.language,
            ).zpod
          );
        }
        if (auto _x = insert_file.match(_rgx_ssi)){
          if (doc_matters.src.lng == doc_matters.pod.manifest_list_of_languages[$-1]) {
            string _path_to_pod = _x.captures["path_to_pod"];
            string _podname = _x.captures["podname"];
            string _root_to_lang = _x.captures["from_root"];
            string _language = _x.captures["language"];
            string _filename = _x.captures["filename"];
            foreach (_lang; doc_matters.pod.manifest_list_of_languages) {
              string _pth_mkup_src_in = _path_to_pod ~ _podname ~ "/" ~ _root_to_lang ~ _lang ~ "/" ~ _filename;
              { // take DIGEST write to pod file digests.txt
                auto data = (cast(byte[]) (_pth_mkup_src_in).read);
                _digests[_language]["ssi"] ~= data.sha256Of.toHexString ~ "::" ~ data.length.to!string ~ " - " ~ _filename ~ " - [" ~ _lang ~ "]" ~ "\n";
                // writeln(data.sha256Of.toHexString, "::", data.length, " - ", _filename, " - [", _lang, "]");
              }
              string _pth_mkup_src_out = "pod/" ~ _root_to_lang ~ _lang ~ "/" ~ _filename;
              if (exists(_pth_mkup_src_in)) {
                if (doc_matters.opt.action.source_or_pod) {
                  auto fn_src_out_filesystem // you need to change language sources
                    = pths_pod.fn_doc_insert(
                      doc_matters.src.filename, // doc_matters.src.filename
                      _pth_mkup_src_in, // insert_file
                      _lang,
                    ).filesystem_open_zpod.to!string;
                  _pth_mkup_src_in.copy(fn_src_out_filesystem); // check why here, thought dealt with elsewhere
                }
                if (doc_matters.opt.action.pod) {
                   zip = podArchive("file_path_text", _pth_mkup_src_in, _pth_mkup_src_out, zip);
                }
              } else {
                if (doc_matters.opt.action.debug_do_pod && doc_matters.opt.action.vox_gt1) {
                  writeln("WARNING (io) src out NOT found (insert file): ", _pth_mkup_src_in);
                }
              }
            }
          }
        } else {
          auto fn_src_in = insert_file;
          { // take DIGEST write to pod file digests.txt // FIX likely bug insert_file includes path, not what you wish to write
            auto data = (cast(byte[]) (fn_src_in).read);
            _digests["en"]["ssi"] ~= data.sha256Of.toHexString ~ "::" ~ data.length.to!string ~ " - " ~ insert_file ~ "\n";
            // writeln(data.sha256Of.toHexString, "::", data.length, " - ", insert_file);
          }
          auto fn_src_out_pod_zip_base
            = pths_pod.fn_doc_insert(
              doc_matters.src.filename,
              insert_file,
              doc_matters.src.language,
            ).zpod.to!string;
          auto fn_src_out_filesystem
            = pths_pod.fn_doc_insert(
              doc_matters.src.filename,
              insert_file,
              doc_matters.src.language,
            ).filesystem_open_zpod.to!string;
          if (exists(fn_src_in)) {
            debug(io) { writeln("(io debug) src out found: ", fn_src_in); }
            if (doc_matters.opt.action.source_or_pod) {
              fn_src_in.copy(fn_src_out_filesystem);
            }
            if (doc_matters.opt.action.pod) {
              zip = podArchive("file_path_text", fn_src_in, fn_src_out_pod_zip_base, zip);
            }
          } else {
            if (doc_matters.opt.action.debug_do_pod && doc_matters.opt.action.vox_gt1) {
              writeln("WARNING (io) src out NOT found (insert file): ", fn_src_in);
            }
          }
        }
      }
    }
  }
  {
    _st.zip     = zip;
    _st.fn_pod  = fn_pod;
    _st.digests = _digests;
  }
  return _st;
}
#+END_SRC

** mkdir :mkdir:

- create directory structure

#+NAME: source_pod_mkdirs
#+BEGIN_SRC d
void podArchive_directory_tree(M,P)(M doc_matters, P pths_pod) { // create directory structure
  if (!exists(pths_pod.pod_dir_())) {
    // used both by pod zipped (& pod filesystem (unzipped) which makes its own recursive dirs)
    pths_pod.pod_dir_().mkdirRecurse;
  }
  if (doc_matters.opt.action.source_or_pod) {
    // if (doc_matters.opt.action.vox_gt0) { writeln(" ", pths_pod.fn_pod_filelist(doc_matters.src.filename).filesystem_open_zpod); }
    if (!exists(pths_pod.text_root(doc_matters.src.filename).filesystem_open_zpod)) {
      pths_pod.text_root(doc_matters.src.filename).filesystem_open_zpod.mkdirRecurse;
    }
    if (!exists(pths_pod.conf_root(doc_matters.src.filename).filesystem_open_zpod)) {
      pths_pod.conf_root(doc_matters.src.filename).filesystem_open_zpod.mkdirRecurse;
    }
    if (!exists(pths_pod.media_root(doc_matters.src.filename).filesystem_open_zpod)) {
      pths_pod.media_root(doc_matters.src.filename).filesystem_open_zpod.mkdirRecurse;
    }
    if (!exists(pths_pod.css(doc_matters.src.filename).filesystem_open_zpod)) {
      pths_pod.css(doc_matters.src.filename).filesystem_open_zpod.mkdirRecurse;
    }
    if (!exists(pths_pod.image_root(doc_matters.src.filename).filesystem_open_zpod)) {
      pths_pod.image_root(doc_matters.src.filename).filesystem_open_zpod.mkdirRecurse;
    }
    if (!exists(pths_pod.doc_lng(doc_matters.src.filename, doc_matters.src.language).filesystem_open_zpod)) {
      pths_pod.doc_lng(doc_matters.src.filename, doc_matters.src.language).filesystem_open_zpod.mkdirRecurse;
    }
  }
  if (!exists(pths_pod.pod_dir_() ~ "/index.html")) {
    import sisudoc.io_out.html_snippet;
    mixin htmlSnippet;
    auto f = File(pths_pod.pod_dir_() ~"/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",
    ));
  }
}
#+END_SRC

** pod zip archive

#+NAME: source_pod_archive_zip
#+BEGIN_SRC d
@system auto podArchive(Z)(
  string _source_type,
  string _data_in,
  string _pth_out,
  Z zip
) {
  auto zip_arc_member_file = new ArchiveMember();
  zip_arc_member_file.name = _pth_out;
  auto zip_data = new OutBuffer();
  switch (_source_type) {
  case "file_path_bin":
    zip_data.write(cast(char[]) ((_data_in).read));
    goto default;
  case "file_path_text":
    zip_data.write((_data_in).readText);
    goto default;
  case "string":
    zip_data.write(_data_in);
    goto default;
  default:
    zip_arc_member_file.expandedData = zip_data.toBytes();
    zip.addMember(zip_arc_member_file);
  }
  return zip;
}
#+END_SRC

** zip archive

#+NAME: zip_archive
#+BEGIN_SRC d
void zipArchive(M,F,Z)(M doc_matters, F fn_pod, Z zip) {
  auto fn_src_in = doc_matters.src.filename;
  if (doc_matters.opt.action.pod) {
    if (exists(doc_matters.src.file_with_absolute_path)) {
      try {
        createZipFile!()(fn_pod, zip.build());
      } catch (ErrnoException ex) {
        // Handle errors
      }
    } else { writeln("WARNING check missing source file(s): ", doc_matters.opt.action.pod); }
    if (!(exists(fn_pod))) { writeln("WARNING failed to create pod zip archive: ", fn_pod); }
  }
}
#+END_SRC

** sha256 of pod.zip, zip debug, read zip archive

#+NAME: pod_source_files_digests
#+BEGIN_SRC d
void zipArchiveDigest(M,F,D)(M doc_matters, F fn_pod, D _digests) {
  import sisudoc.io_out.paths_output;
  auto pths_pod = spinePathsPods!()(doc_matters);
  char[] _zip_digest;
  try {
    if (!exists(pths_pod.pod_dir_())) {
      // used both by pod zipped (& pod filesystem (unzipped) which makes its own recursive dirs)
      pths_pod.pod_dir_().mkdirRecurse;
    }
  } catch (ErrnoException ex) {
    // Handle error
  }
  try {
    // if (doc_matters.opt.action.vox_gt1) { writeln(" ", pths_pod.pod_dir_(), "/", doc_matters.src.filename_base, ".digests.txt"); }
    string _digest_fn = pths_pod.pod_dir_() ~ "/" ~ doc_matters.src.filename_base ~ ".digests.txt";
    // if (doc_matters.opt.action.vox_gt1) { writeln(_digest_fn); }
    auto f = File(_digest_fn, "w");
    if (exists(fn_pod)) {
      try {
        auto data = (cast(byte[]) (fn_pod).read);
        // if (doc_matters.opt.action.vox_gt1) { writeln(" ", doc_matters.src.filename, " > ", doc_matters.src.filename_base, ".zip"); }
        if (doc_matters.opt.action.pod) {
          _zip_digest = (data.sha256Of.toHexString ~ "::" ~ data.length.to!string ~ " - " ~ doc_matters.src.filename_base ~ ".zip");
          if (doc_matters.opt.action.vox_gt0) { writeln(" ", _zip_digest); }
          if (doc_matters.opt.action.vox_gt0) { writeln(" ", pths_pod.pod_dir_(), "/", doc_matters.src.filename_base, "/"); }
          if (doc_matters.opt.action.vox_gt0) { writeln(" ", _digest_fn); }
          f.writeln(_zip_digest);
        }
      } catch (ErrnoException ex) {
        // Handle errors
      }
    }
    foreach (_lang; doc_matters.pod.manifest_list_of_languages) {
      if (_lang in _digests) {
        if (("sstm" in _digests[_lang]) && (_digests[_lang]["sstm"].length > 0)) {
          // if (doc_matters.opt.action.vox_gt1) { writeln(_digests[_lang]["sstm"]); }
          f.writeln(_digests[_lang]["sstm"]);
        }
        if (("ssi" in _digests[_lang]) && (_digests[_lang]["ssi"].length > 0)) {
          // if (doc_matters.opt.action.vox_gt1) { writeln(_digests[_lang]["ssi"]); }
          f.writeln(_digests[_lang]["ssi"]);
        }
      }
    }
    if ("shared" in _digests) {
      if (("images" in _digests["shared"]) && (_digests["shared"]["images"].length > 0)) {
        // if (doc_matters.opt.action.vox_gt1) { writeln(_digests["shared"]["images"]); }
        f.writeln(_digests["shared"]["images"]);
      }
    }
  } catch (ErrnoException ex) {
    // Handle error
  }
}
#+END_SRC

* document header including copyright & license

#+NAME: doc_header_including_copyright_and_license
#+HEADER: :noweb yes
#+BEGIN_SRC emacs-lisp
<<./sisudoc_spine_version_info_and_doc_header_including_copyright_and_license.org:spine_doc_header_including_copyright_and_license()>>
#+END_SRC

* __END__
** pod gitignore
*** pod/{pods/}

#+NAME: pod_gitignore
#+BEGIN_SRC sh
# git ls-files --others --exclude-from=.git/info/exclude
,*
!.gitignore
!COPYRIGHT
!README
!shell.nix
!packages.nix
!version.txt
!pod/
!pod/.dr/config_local_site
# pod.manifest
!pod/*/
!pod/*/pod.manifest
# conf/sisu_document_make
!pod/*/conf/
!pod/*/conf/sisu_document_make
# media/text
!pod/*/media/
!pod/*/media/text/
!pod/*/media/text/*/
!pod/*/media/text/*/*.sst
!pod/*/media/text/*/*.ssm
!pod/*/media/text/*/*.ssi
!pod/*/media/text/*/index.html.in
# media/image
!pod/*/media/image/
!pod/*/media/image/*.png
!pod/*/media/image/*.jpg
!pod/*/media/image/*.PNG
!pod/*/media/image/*.JPG
# tools/po4a
!pod/*/tools/
!pod/*/tools/Makefile
!pod/*/tools/bin/
!pod/*/tools/bin/*.sh
!pod/*/tools/po4a/
!pod/*/tools/po4a/pot/
!pod/*/tools/po4a/pot/*.sst.pot
!pod/*/tools/po4a/pot/*.ssm.pot
!pod/*/tools/po4a/pot/*.ssi.pot
!pod/*/tools/po4a/pot/index.html.in.pot
!pod/*/tools/po4a/po/
!pod/*/tools/po4a/po/*/
!pod/*/tools/po4a/po/*/*.sst.po
!pod/*/tools/po4a/po/*/*.ssm.po
!pod/*/tools/po4a/po/*/*.ssi.po
!pod/*/tools/po4a/po/*/index.html.in.po
# depreciate, separate from media/text use tools
!pod/*/media/text/Makefile
!pod/*/media/text/bin/
!pod/*/media/text/bin/*.sh
!pod/*/media/text/pot/
!pod/*/media/text/pot/*.sst.pot
!pod/*/media/text/pot/*.ssm.pot
!pod/*/media/text/pot/*.ssi.pot
!pod/*/media/text/pot/index.html.in.pot
!pod/*/media/text/po/
!pod/*/media/text/po/*/
!pod/*/media/text/po/*/*.sst.po
!pod/*/media/text/po/*/*.ssm.po
!pod/*/media/text/po/*/*.ssi.po
!pod/*/media/text/po/*/index.html.in.po
# skip
.dub/**
tmp/**
,*_.org
,*_.d
,*_.txt
,*_
,*~
\#*
,*.\#*
#+END_SRC

*** document pod structure

#+NAME: pod_gitignore
#+BEGIN_SRC sh
# git ls-files --others --exclude-from=.git/info/exclude
,*
!.gitignore
!pod.manifest
!conf/
!conf/sisu_document_make
!media/
!media/text/
!media/text/*/
!media/text/*/*.sst
!media/text/*/*.ssm
!media/text/*/*.ssi
!media/image/
!media/image/*.png
!media/image/*.jpg
!media/image/*.PNG
!media/image/*.JPG
#!media/**
#!*.sst
#!*.ssm
#!*.ssi
#!**/*.sst
#!**/*.ssm
#!**/*.ssi
#+END_SRC

*** pod po4a structure

#+NAME: pod_gitignore
#+BEGIN_SRC sh
# git ls-files --others --exclude-from=.git/info/exclude
,*
!.gitignore
!pot/
!pot/*.sst.pot
!pot/*.ssm.pot
!pot/*.ssi.pot
!po/
!po/*/
!po/*/*.sst.po
!po/*/*.ssm.po
!po/*/*.ssi.po
#+END_SRC