#+TITLE:       doc_reform output hub
#+DESCRIPTION: documents - structuring, publishing in multiple formats & search
#+FILETAGS:    :doc_reform:output:hub:
#+AUTHOR:      Ralph Amissah
#+EMAIL:       [[mailto:ralph.amissah@gmail.com][ralph.amissah@gmail.com]]
#+COPYRIGHT:   Copyright (C) 2015 - 2019 Ralph Amissah
#+LANGUAGE:    en
#+STARTUP:     indent content hideblocks hidestars
#+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 :cache no :noweb yes
#+EXPORT_SELECT_TAGS:  export
#+EXPORT_EXCLUDE_TAGS: noexport
#+TAGS: assert(a) class(c) debug(d) mixin(m) doc_reform(s) tangle(T) template(t) WEB(W) noexport(n)

- [[./doc_reform.org][doc_reform]]  [[./][org/]]

* 0. output hub [#A]
** module template                                                  :module:

#+BEGIN_SRC d :tangle "../src/doc_reform/output/hub.d"
/++
  output hub<BR>
  check & generate output types requested
+/
module doc_reform.output.hub;
template outputHub() {
  <<output_imports>>
  import std.parallelism;
  void outputHub(D,I)(const D doc_abstraction, I doc_matters) {
    mixin DocReformOutputRgxInit;
    mixin Msg;
    auto msg = Msg!()(doc_matters);
    static auto rgx = Rgx();
    enum outTask { pod, source, 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>>
    }
    if (!(doc_matters.opt.action.quiet)) {
      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 {
      foreach(schedule; parallel(doc_matters.opt.action.output_task_scheduler)) {
        Scheduled!()(schedule, doc_abstraction, doc_matters);
      }
    }
    <<output_shared_sqlite_db>>
  }
}
template outputHubOp() {
  <<output_imports>>
  void outputHubOp(E,O)(E env, O opt_action) {
    mixin DocReformOutputRgxInit;
    static auto rgx = Rgx();
    <<output_options_op>>
  }
}
#+END_SRC

** initialize / imports

#+name: output_imports
#+BEGIN_SRC d
import doc_reform.output,
  doc_reform.output.xmls,
  doc_reform.output.odt,
  doc_reform.output.create_zip_file,
  doc_reform.output.paths_output;
#+END_SRC

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

#+name: output_scheduled_task
#+BEGIN_SRC d
if (sched == outTask.pod) {
  msg.v("doc reform source processing... ");
  import doc_reform.output.source_pod;
  DocReformPod!()(doc_matters);
  msg.vv("doc reform source done");
}
#+END_SRC

**** epub                                                           :epub:

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

**** html                                                           :html:
***** scroll                                                     :scroll:

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

***** seg                                                           :seg:

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

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

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

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

#+name: output_scheduled_task
#+BEGIN_SRC d
if (sched == outTask.latex) {
  msg.v("latex processing... (available for downstream processing & pdf output");
  import doc_reform.output.latex;
  outputLaTeX!()(doc_abstraction, doc_matters);
  msg.vv("latex done");
}
#+END_SRC

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

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

**** sqlite discrete                                              :sqlite:

#+name: output_scheduled_task
#+BEGIN_SRC d
if (sched == outTask.sqlite) {
  msg.v("sqlite processing... ");
  import doc_reform.output.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.output.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.output.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
#+BEGIN_SRC d
if ((opt_action.sqlite_db_drop)) {
  if ((opt_action.verbose)) {
    writeln("sqlite drop db...");
  }
  import doc_reform.output.sqlite;
  SQLiteDbDrop!()(opt_action);
  if ((opt_action.very_verbose)) {
    writeln("sqlite drop db done");
  }
}
#+END_SRC

******  create                                                  :create:

#+name: output_options_op
#+BEGIN_SRC d
if ((opt_action.sqlite_db_create)) {
  if ((opt_action.verbose)) {
    writeln("sqlite create table...");
  }
  import doc_reform.output.sqlite;
  SQLiteTablesCreate!()(env, opt_action);
  if ((opt_action.very_verbose)) {
    writeln("sqlite create table done");
  }
}
#+END_SRC

* __END__