path: root/src/sdp.d

#!/usr/bin/env rdmd
/+
  sdp
  sdp.d
+/
/+ sdp  sisu document parser http://sisudoc.org +/
import
  compile_time_info,          // sdp/compile_time_info.d
  ao_abstract_doc_source,     // sdp/ao_abstract_doc_source.d
  ao_defaults,                // sdp/ao_defaults.d
  ao_read_source_files,       // sdp/ao_read_source_files.d
  ao_output_debugs,           // sdp/ao_output_debugs.d
  output_hub,                 // output_hub.d
  ao_rgx,                     // sdp/ao_rgx.d
  ao_ansi_colors;             // sdp/ao_ansi_colors.d
  // std.conv;
/+ sdp  sisu document parser +/
private import
  std.getopt,
  std.process,
  std.stdio,
  std.algorithm,
  std.array,
  std.container,
  std.exception,
  std.file,
  std.json,
  // std.path,
  std.range,
  std.regex,
  // std.stdio,
  std.string,
  std.traits,
  std.typecons,
  std.utf,
  // std.variant,
  std.conv : to;
mixin(import("version.txt"));
mixin CompileTimeInfo;
mixin RgxInit;
void main(string[] args) {
  
  mixin SiSUheader;
  mixin SiSUbiblio;
  mixin SiSUrgxInitFlags;
  mixin SiSUmarkupRaw;
  mixin SiSUdocAbstraction;
  mixin SiSUoutputDebugs;
  mixin SiSUoutputHub;
  mixin ScreenTxtColors;
  struct SDPoutput {
    auto hub(S)(
      auto ref const S         contents,
      string[][string][string] bookindex_unordered_hashes,
      JSONValue[]              biblio,
      JSONValue[string]        dochead_make,
      JSONValue[string]        dochead_meta,
      string                   fn_src,
      bool[string]             opt_action_bool
    ) {
      mixin ScreenTxtColors;
      mixin RgxInit;
      mixin SiSUoutputHub;
      // mixin SiSUoutput;
      auto rgx = Rgx();
      uint return_ = 0;
      if (opt_action_bool["source"]) {
        writeln("sisupod source");
      }
      if (opt_action_bool["sisupod"]) {
        writeln("sisupod source");
      }
      if (opt_action_bool["text"]) {
        writeln("text processing");
        // auto text=SDPoutput_text();
        // text.scroll(contents, bookindex_unordered_hashes, biblio, fn_src, opt_action_bool);
        // // text.scroll(contents, bookindex_unordered_hashes, biblio, dochead_make, dochead_meta, fn_src, opt_action_bool);
      }
      if (opt_action_bool["html"]) {
        auto html=SDPoutputHTML();
        html.css_write;
        // html.scroll(contents, bookindex_unordered_hashes, biblio, fn_src, opt_action_bool);
        html.scroll(contents, bookindex_unordered_hashes, biblio, dochead_make, dochead_meta, fn_src, opt_action_bool);
      }
      if (opt_action_bool["epub"]) {
        writeln("epub processing");
      }
      if (opt_action_bool["pdf"]) {
        writeln("pdf processing");
      }
      if (opt_action_bool["odt"]) {
        writeln("odt processing");
      }
      if (opt_action_bool["sqlite"]) {
        writeln("sqlite processing");
      }
      if (opt_action_bool["postgresql"]) {
        writeln("pgsql processing");
      }
      return return_;
    }
  }
  auto raw = MarkupRaw();
  auto abs = Abstraction();
  auto dbg = SDPoutputDebugs();
  auto output = SDPoutput();
  /+
  struct DocumentParts {
    string[string][] contents;
    JSONValue[string] metadata_json;
    JSONValue[string] make_json;
    string[][string][string] bookindex_unordered_hashes;
    JSONValue[] biblio;
  }
  +/
  string[] fns_src;
  string flag_action;
  string arg_unrecognized;
  auto rgx = Rgx();
  scope(success) {
    debug(checkdoc) {
      writefln(
        "%s~ run complete, ok ~ %s (sdp-%s.%s.%s, %s v%s, %s %s)",
        scr_txt_color["cyan"], scr_txt_color["off"],
        ver.major, ver.minor, ver.patch,
        __VENDOR__, __VERSION__,
        bits, os,
      );
    }
    // stderr.writeln("0");
  }
  scope(failure) {
    debug(checkdoc) {
      stderr.writefln(
        "%s~ run failure ~%s",
         scr_txt_color["fuchsia"], scr_txt_color["off"],
      );
    }
  }
  
  bool[string] opt_action_bool = [
    "assertions"      : false,
    "concordance"     : false,
    "digest"          : false,
    "docbook"         : false,
    "epub"            : false,
    "html"            : false,
    "manifest"        : false,
    "no_ocn"          : false,
    "odt"             : false,
    "pdf"             : false,
    "postgresql"      : false,
    "qrcode"          : false,
    "sisupod"         : false,
    "source"          : false,
    "sqlite"          : false,
    "text"            : false,
    "verbose"         : false,
    "xhtml"           : false,
    "xml_dom"         : false,
    "xml_sax"         : false,
  ];
  auto helpInfo = getopt(args,
    std.getopt.config.passThrough,
    "assert",         "--assert set optional assertions on",       &opt_action_bool["assertions"],
    "concordance",    "--concordance file for document",           &opt_action_bool["concordance"],
    "digest",         "--digest hash digest for each object",      &opt_action_bool["digest"],
    "docbook",        "--docbook process docbook output",          &opt_action_bool["docbook"],
    "epub",           "--epub process epub output",                &opt_action_bool["epub"],
    "html",           "--html process html output",                &opt_action_bool["html"],
    "manifest",       "--manifest process manifest output",        &opt_action_bool["manifest"],
    "no-ocn",         "--no-ocn suppress object cite numbers",     &opt_action_bool["no_ocn"],
    "odf",            "--odf process odf:odt output",              &opt_action_bool["odt"],
    "odt",            "--odt process odf:odt output",              &opt_action_bool["odt"],
    "pdf",            "--pdf process pdf output",                  &opt_action_bool["pdf"],
    "pg",             "--pg process postgresql output",            &opt_action_bool["postgresql"],
    "postgresql",     "--postgresql process postgresql output",    &opt_action_bool["postgresql"],
    "qrcode",         "--qrcode with document metadata",           &opt_action_bool["qrcode"],
    "sisupod",        "--sisupod sisupod source content bundled",  &opt_action_bool["sisupod"],
    "source",         "--source markup source text content",       &opt_action_bool["source"],
    "sqlite",         "--sqlite process sqlite output",            &opt_action_bool["sqlite"],
    "text",           "--text process text output",                &opt_action_bool["text"],
    "txt",            "--txt process text output",                 &opt_action_bool["text"],
    "verbose|v",      "--verbose output to terminal",              &opt_action_bool["verbose"],
    "xhtml",          "--xhtml process xhtml output",              &opt_action_bool["xhtml"],
    "xml-dom",        "--xml-dom process xml dom output",          &opt_action_bool["xml_dom"],
    "xml-sax",        "--xml-sax process xml sax output",          &opt_action_bool["xml_sax"],
  );
  if (helpInfo.helpWanted) {
    defaultGetoptPrinter("Some information about the program.", helpInfo.options);
  }
  foreach(arg; args) {
    if (match(arg, rgx.flag_action)) {
      flag_action ~= " " ~ arg;   // flags not taken by getopt
    } else if (match(arg, rgx.src_pth)) {
      fns_src ~= arg;             // gather input markup source file names for processing
    } else {                      // anything remaining, unused
      arg_unrecognized ~= " " ~ arg;
    }
  }
  foreach(fn_src; fns_src) {
  // foreach(fn_src; fns_src) {
    if (!empty(fn_src)) {
      scope(success) {
        debug(checkdoc) {
          writefln(
            "%s~ document complete, ok ~%s",
            scr_txt_color["green"], scr_txt_color["off"],
          );
        }
        // stderr.writeln("0");
      }
      scope(failure) {
        debug(checkdoc) {
          stderr.writefln(
            "%s~ document run failure ~%s (%s  v%s)\n\t%s",
            scr_txt_color["red"], scr_txt_color["off"],
            __VENDOR__, __VERSION__,
            fn_src
          );
        }
        // stderr.writeln("1");
      }
      enforce(
        match(fn_src, rgx.src_pth),
        "not a sisu markup filename"
      );
      /+ ↓ read file +/
      auto sourcefile_content =
        raw.sourceContent(fn_src);
      /+ ↓ porcess document, return abstraction as tuple +/
      auto t = abs.abstract_doc_source(sourcefile_content);
      static assert(!isTypeTuple!(t));
      auto doc_ao_contents = t[0]; // contents ~ endnotes ~ bookindex;
      // static assert(!isIterable!(doc_ao_contents));
      auto doc_ao_metadata_json = t[1];
      auto doc_ao_make_json = t[2];
      auto doc_ao_bookindex_unordered_hashes = t[3];
      auto doc_ao_biblio = t[4];
      // destroy(t);
      /+ ↓ document parts +/
      debug(checkdoc) { // checkbook & dumpdoc
        dbg.abstract_doc_source_debugs(
          doc_ao_contents,
          doc_ao_bookindex_unordered_hashes,
          doc_ao_biblio,
          doc_ao_make_json,
          doc_ao_metadata_json,
          fn_src,
          opt_action_bool
        );
      }
      /+ ↓ output hub +/
      output.hub(
        doc_ao_contents,
        doc_ao_bookindex_unordered_hashes,
        doc_ao_biblio,
        doc_ao_make_json,
        doc_ao_metadata_json,
        fn_src,
        opt_action_bool
      );
      scope(exit) {
        debug(checkdoc) {
          writefln(
            "processed file: %s",
            fn_src
          );
        }
        destroy(sourcefile_content);
        destroy(t);
        destroy(doc_ao_contents);
        destroy(doc_ao_make_json);
        destroy(doc_ao_metadata_json);
        destroy(doc_ao_bookindex_unordered_hashes);
        destroy(doc_ao_biblio);
        destroy(fn_src);
      }
    } else {
      /+ no recognized filename provided +/
      writeln("no recognized filename");
      break;
      // terminate, stop
    }
  }
}