path: root/org/output_hub.org

-*- mode: org -*-
#+TITLE:       spine(doc_reform) output hub
#+DESCRIPTION: documents - structuring, publishing in multiple formats & search
#+FILETAGS:    :spine:output:hub:
#+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 [#A]
** _module template_ :module:

#+HEADER: :tangle "../src/doc_reform/io_out/hub.d"
#+HEADER: :noweb yes
#+BEGIN_SRC d
<<doc_header_including_copyright_and_license>>
/++
  output hub<BR>
  check & generate output types requested
+/
module doc_reform.io_out.hub;
@safe:
template outputHub() {
  <<output_imports>>
  @system void outputHub(D,I)(
    const D doc_abstraction,
    I doc_matters
  ) {
    mixin Msg;
    auto msg = Msg!()(doc_matters);
    enum outTask { source_or_pod, sqlite, sqlite_multi, latex, odt, epub, html_scroll, html_seg, html_stuff }
    void Scheduled(D,I)(int sched, D doc_abstraction, I doc_matters) {
      auto msg = Msg!()(doc_matters);
      <<output_scheduled_task_source_or_pod>>
      <<output_scheduled_task_epub>>
      <<output_scheduled_task_html_meta>>
      <<output_scheduled_task_html_scroll>>
      <<output_scheduled_task_html_seg>>
      <<output_scheduled_task_html_out>>
      <<output_scheduled_task_latex>>
      <<output_scheduled_task_odt>>
      <<output_scheduled_task_sqlite>>
    }
    if (doc_matters.opt.action.vox_gt0) {
      writeln(" ", doc_matters.src.filename_base);
    }
    if (!(doc_matters.opt.action.parallelise_subprocesses)) {
      foreach(schedule; doc_matters.opt.action.output_task_scheduler) {
        Scheduled!()(schedule, doc_abstraction, doc_matters);
      }
    } else {
      import std.parallelism;
      foreach(schedule; parallel(doc_matters.opt.action.output_task_scheduler)) {
        Scheduled!()(schedule, doc_abstraction, doc_matters);
      }
    }
    <<output_shared_sqlite_db>>
  }
}
template outputHubInitialize() {
  import std.file;
  import doc_reform.io_out,
    doc_reform.io_out.metadata,
    doc_reform.io_out.paths_output;
  string _bespoke_homepage = "./spine-bespoke-output/html/homepage.index.html";
  @system void outputHubInitialize(O,I)(
    O opt_action,
    I program_info
  ) {
    if ((opt_action.html || opt_action.html_seg || opt_action.html_scroll)
        && opt_action.output_dir_set.length > 0
        && !(opt_action.output_dir_set ~ "/index.html").exists
    ) {
      writeln(_bespoke_homepage);
      if ((_bespoke_homepage).exists) {
        writeln("copy bespoke html homepage\n", _bespoke_homepage, " -> ", opt_action.output_dir_set, "/index.html");
        _bespoke_homepage.copy(opt_action.output_dir_set ~ "/index.html");
      } else {
        writeln("place bespoke homepage in ", _bespoke_homepage);
      }
    }
    if (
      opt_action.latex_document_header_sty
      || (
        opt_action.latex
        && opt_action.output_dir_set.length > 0
        && !(isValidPath(opt_action.output_dir_set ~ "/latex/sty")))
    ) { // .sty need to be produced only once (if unchanged per output-dir of which there usually will be only one)
      import doc_reform.io_out.latex;
      outputLaTeXstyInit!()(
        opt_action.output_dir_set,
        opt_action.generated_by,
        program_info.name_version_and_compiler,
        program_info.time_output_generated,
      );
      writeln(opt_action.latex);
    }
  }
}
template outputHubOp() {
  <<output_imports>>
  @system void outputHubOp(E,O,C)(E env, O opt_action, C config) {
    <<output_options_op_sqlite_db_drop>>
    <<output_options_op_sqlite_db_create>>
  }
}
#+END_SRC

** initialize / imports

#+NAME: output_imports
#+BEGIN_SRC d
import doc_reform.io_out,
  doc_reform.io_out.metadata,
  doc_reform.io_out.xmls,
  doc_reform.io_out.create_zip_file,
  doc_reform.io_out.paths_output;
#+END_SRC

** outputs
*** files
**** source: _dr_src_ &/or _pod_ :source:pod:
- [[./output_pod.org][output_pod]]

#+NAME: output_scheduled_task_source_or_pod
#+BEGIN_SRC d
if (sched == outTask.source_or_pod) {
  msg.v("spine (doc reform) source processing... ");
  if (doc_matters.opt.action.pod) {
    msg.v("spine (doc reform) source pod processing... ");
  }
  import doc_reform.io_out.source_pod;
  spinePod!()(doc_matters);
  if (doc_matters.opt.action.source) {
    msg.vv("spine (doc reform) source done");
  }
  if (doc_matters.opt.action.pod) {
    msg.vv("spine (doc reform) source pod done");
  }
}
#+END_SRC

**** epub :epub:

#+NAME: output_scheduled_task_epub
#+BEGIN_SRC d
if (sched == outTask.epub) {
  msg.v("epub3 processing... ");
  import doc_reform.io_out.epub3;
  doc_abstraction.outputEPub3!()(doc_matters);
  msg.vv("epub3 done");
}
#+END_SRC

**** html :html:
***** metadata :metadata:

#+NAME: output_scheduled_task_html_meta
#+BEGIN_SRC d
if (sched == outTask.html_stuff) {
  outputMetadata!()(doc_matters);
  msg.vv("html metadata done");
}
#+END_SRC

***** scroll :scroll:

#+NAME: output_scheduled_task_html_scroll
#+BEGIN_SRC d
if (sched == outTask.html_scroll) {
  msg.v("html scroll processing... ");
  import doc_reform.io_out.html;
  outputHTML!().scroll(doc_abstraction, doc_matters);
  msg.vv("html scroll done");
}
#+END_SRC

***** seg :seg:

#+NAME: output_scheduled_task_html_seg
#+BEGIN_SRC d
if (sched == outTask.html_seg) {
  msg.v("html seg processing... ");
  import doc_reform.io_out.html;
  outputHTML!().seg(doc_abstraction, doc_matters);
  msg.vv("html seg done");
}
#+END_SRC

***** css, images etc :css:images:

#+NAME: output_scheduled_task_html_out
#+BEGIN_SRC d
if (sched == outTask.html_stuff) {
  import doc_reform.io_out.html;
  outputHTML!().css(doc_matters);
  outputHTML!().images_cp(doc_matters);
  msg.vv("html css & images done");
}
#+END_SRC

**** latex / pdf :latex:pdf:

- (unchanged) latex document headers (sty) need to be produced only once for a
  given document set output directory path, but they are required
  - this makes sure that the latex sty directory is produced with its doc header
    .sty contents at least once for a latex output directory, it is not
    subsequently modified however
  - to initialize or update latex document header (sty) run --latex-init along
    with the --latex command while providing the output directory
    --output="[output path]"

#+NAME: output_scheduled_task_latex
#+BEGIN_SRC d
if (sched == outTask.latex) {
  msg.v("latex processing... (available for downstream processing & pdf output");
  import doc_reform.io_out.latex;
  import std.file;
  if ((isValidPath(doc_matters.output_path ~ "/latex/sty"))
    && (!(exists(doc_matters.output_path ~ "/latex/sty")))
  ) {
    outputLaTeXstyInit!()(
      doc_matters.output_path,
      doc_matters.opt.action.generated_by,
      doc_matters.generator_program.name_version_and_compiler,
      doc_matters.generator_program.time_output_generated,
    );
  }
  outputLaTeX!()(doc_abstraction, doc_matters);
  msg.vv("latex done");
}
#+END_SRC

**** odf / odt :odf:odt:

#+NAME: output_scheduled_task_odt
#+BEGIN_SRC d
if (sched == outTask.odt) {
  msg.v("odf:odt processing... ");
  import doc_reform.io_out.odt;
  outputODT!()(doc_abstraction, doc_matters);
  msg.vv("odf:odt done");
}
#+END_SRC

**** sqlite discrete :sqlite:

#+NAME: output_scheduled_task_sqlite
#+BEGIN_SRC d
if (sched == outTask.sqlite) {
  msg.v("sqlite processing... ");
  import doc_reform.io_out.sqlite;
  doc_abstraction.SQLiteHubDiscreteBuildTablesAndPopulate!()(doc_matters);
  msg.vv("sqlite done");
}
#+END_SRC

*** db:sql
**** sqlite collection :sqlite:
***** update / populate :update:

#+NAME: output_shared_sqlite_db
#+BEGIN_SRC d
if (doc_matters.opt.action.sqlite_update) {
  msg.v("sqlite update processing...");
  import doc_reform.io_out.sqlite;
  doc_abstraction.SQLiteHubBuildTablesAndPopulate!()(doc_matters);
  msg.vv("sqlite update done");
} else if (doc_matters.opt.action.sqlite_delete) {
  msg.v("sqlite delete processing...");
  import doc_reform.io_out.sqlite;
  doc_abstraction.SQLiteHubBuildTablesAndPopulate!()(doc_matters);
  msg.vv("sqlite delete done");
}
#+END_SRC

***** no markup source files to process
****** drop :drop:

#+NAME: output_options_op_sqlite_db_drop
#+BEGIN_SRC d
if ((opt_action.sqlite_db_drop)) {
  if ((opt_action.vox_gt1)) {
    writeln("sqlite drop db...");
  }
  import doc_reform.io_out.sqlite;
  SQLiteDbDrop!()(opt_action, config);
  if ((opt_action.vox_gt2)) {
    writeln("sqlite drop db done");
  }
}
#+END_SRC

****** create :create:

#+NAME: output_options_op_sqlite_db_create
#+BEGIN_SRC d
if ((opt_action.sqlite_db_create)) {
  if ((opt_action.vox_gt1)) {
    auto pth_sqlite_db = spinePathsSQLite!()(opt_action.cgi_sqlite_search_filename, opt_action.output_dir_set);
    writeln("sqlite create table...");
  }
  import doc_reform.io_out.sqlite;
  SQLiteTablesCreate!()(env, opt_action, config);
  if ((opt_action.vox_gt2)) {
    writeln("sqlite create table done");
  }
}
#+END_SRC

* document header including copyright & license

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

* __END__