path: root/org/meta_conf_make_meta.org

#+TITLE:       sdp config & header (make & meta) extract
#+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:meta:
#+TAGS: assert(a) class(c) debug(d) mixin(m) sdp(s) tangle(T) template(t) WEB(W) noexport(n)

[[./sdp.org][sdp]]  [[./][org/]]
* 0. generic
** imports

#+name: meta_defaults_imports
#+BEGIN_SRC d
import
  std.algorithm,
  std.array,
  std.container,
  std.exception,
  std.file,
  std.getopt,
  std.json,
  std.path,
  std.process,
  std.range,
  std.regex,
  std.stdio,
  std.string,
  std.traits,
  std.typecons,
  std.uni,
  std.utf,
  std.conv : to;
import sdp.meta.conf_make_meta_structs;
#+END_SRC

** struct ConfComposite

#+BEGIN_SRC d :tangle ../src/sdp/meta/conf_make_meta_structs.d
module sdp.meta.conf_make_meta_structs;
import
  std.exception,
  std.json,
  std.regex,
  std.stdio,
  std.string,
  std.traits,
  std.typecons,
  std.utf,
  std.conv : to;
<<meta_defaults_template_structs>>
#+END_SRC

** struct Generic ConfComposite

#+name: meta_defaults_template_structs
#+BEGIN_SRC d
struct ConfCompositeMakeStr {
  string bold                           = "";
  string breaks                         = "";
  string cover_image                    = "";
  string css                            = "";
  string emphasis                       = "";
  string footer                         = "";
  string headings                       = "";
  string home_button_image              = "";
  string home_button_text               = "";
  string italics                        = "";
  string num_top                        = "";
  string num_depth                      = "";
  JSONValue substitute                  = JSONValue( ["", ""] );
  string texpdf_font                    = "";
}
struct confCompositeMakeBuild {
  auto bold_rgxmatch(string _mk) {
    auto _rgxtxt = (_mk.empty)
    ? `=NULL`
    : `(` ~ _mk.dup ~ `)`;
    return (cast(char[]) (_rgxtxt));
  }
  auto bold_substitute_abstract() {
    return "*{$1}*";
  }
  auto bold_substitute_sisu_markup() {
    return "*{$1}*";
  }
  auto bold_substitute_html() {
    return "<b>$1</b>";
  }
  auto breaks(string _mk) {
    return _mk;
  }
  auto cover_image(string _mk) {
    return _mk;
  }
  auto css(string _mk) {
    return _mk;
  }
  auto emphasis_rgxmatch(string _mk) {
    auto _rgxtxt = (_mk.empty)
    ? `=NULL`
    : `(` ~ _mk.dup ~ `)`;
    return (cast(char[]) (_rgxtxt));
  }
  auto emphasis_substitute_abstract() {
    return "!{$1}!";
  }
  auto emphasis_substitute_sisu_markup() {
    return "!{$1}!";
  }
  auto emphasis_substitute_html() {
    return "<em>$1</em>";
  }
  auto footer(string _mk) {
    return _mk;
  }
  auto headings(string _mk) {
    return _mk;
  }
  auto home_button_image(string _mk) {
    return _mk;
  }
  auto home_button_text(string _mk) {
    return _mk;
  }
  auto italics_rgxmatch(string _mk) {
    auto _rgxtxt = (_mk.empty)
    ? `=NULL`
    : `(` ~ _mk.dup ~ `)`;
    return (cast(char[]) (_rgxtxt));
  }
  auto italics_substitute_abstract() {
    return "/{$1}/";
  }
  auto italics_substitute_sisu_markup() {
    return "/{$1}/";
  }
  auto italics_substitute_html() {
    return "<i>$1</i>";
  }
  auto num_top(string _mk) {
    return _mk;
  }
  auto num_depth(string _mk) {
    return _mk;
  }
  auto substitute(JSONValue _mk) {
    return _mk;
  }
  auto texpdf_font(string _mk) {
    return _mk;
  }
}
#+END_SRC

** initialize make & meta
*** composite make

#+name: meta_defaults_template_structs
#+BEGIN_SRC d
struct ConfCompositeMakeInit {
  char[] bold_rgxmatch                  = `=NULL`.dup;
  auto bold_substitute_abstract         = "*{$1}*";
  auto bold_substitute_sisu_markup      = "*{$1}*";
  auto bold_substitute_html             = "<b>$1</b>";
  string breaks                         = "";
  string cover_image                    = "";
  string css                            = "";
  char[] emphasis_rgxmatch              = `=NULL`.dup;
  auto emphasis_substitute_abstract     = "!{$1}!";
  auto emphasis_substitute_sisu_markup  = "!{$1}!";
  auto emphasis_substitute_html         = "<em>$1</em>";
  string footer                         = "";
  string headings                       = "";
  string home_button_image              = "";
  string home_button_text               = "";
  char[] italics_rgxmatch               = `=NULL`.dup;
  auto italics_substitute_abstract      = "/{$1}/";
  auto italics_substitute_sisu_markup   = "/{$1}/";
  auto italics_substitute_html          = "<i>$1</i>";
  string num_top                        = "";
  string num_depth                      = "";
  auto substitute                       = JSONValue(["", ""]);
  string texpdf_font                    = "";
}
#+END_SRC

*** conf site local

#+name: meta_defaults_template_structs
#+BEGIN_SRC d
struct ConfCompositeSiteLocal {
  string webserv_url_root               = "";
  string webserv_path                   = "";
  string webserv_images                 = "";
  string webserv_cgi                    = "";
  string webserv_cgi_host               = "";
  string webserv_cgi_host_path          = "";
  string webserv_cgi_port               = "";
  string webserv_cgi_user               = "";
  string webserv_cgi_file_links         = "";
  string processing_path                = "";
  string processing_dir                 = "";
  string processing_concord_max         = "";
  string flag_act0                      = "";
  string flag_act1                      = "";
  string flag_act2                      = "";
  string flag_act3                      = "";
  string flag_act4                      = "";
  string flag_act5                      = "";
  string flag_act6                      = "";
  string flag_act7                      = "";
  string flag_act8                      = "";
  string flag_act9                      = "";
  string default_papersize              = "";
  string default_text_wrap              = "";
  string default_emphasis               = "";
  string default_language               = "";
  string default_digest                 = "";
  string permission_share_source        = "";
  string search_flag                    = "";
  string search_action                  = "";
  string search_db                      = "";
  string search_title                   = "";
}
#+END_SRC

*** composite meta

#+name: meta_defaults_template_structs
#+BEGIN_SRC d
struct MetaComposite {
  string classify_dewey                 = "";
  string classify_keywords              = "";
  string classify_loc                   = "";
  string classify_subject               = "";
  string classify_topic_register        = "";
  string creator_author                 = "";
  string creator_author_email           = "";
  string creator_illustrator            = "";
  string creator_translator             = "";
  string date_added_to_site             = "";
  string date_available                 = "";
  string date_created                   = "";
  string date_issued                    = "";
  string date_modified                  = "";
  string date_published                 = "";
  string date_valid                     = "";
  string identifier_isbn                = "";
  string identifier_oclc                = "";
  string identifier_pg                  = "";
  string language_document              = "";
  string language_document_char         = "";
  string links                          = "";
  string notes_abstract                 = "";
  string notes_description              = "";
  string original_language              = "";
  string original_language_char         = "";
  string original_publisher             = "";
  string original_source                = "";
  string original_title                 = "";
  string publisher                      = "";
  string rights_copyright               = "";
  string rights_copyright_audio         = "";
  string rights_copyright_cover         = "";
  string rights_copyright_illustrations = "";
  string rights_copyright_photographs   = "";
  string rights_copyright_text          = "";
  string rights_copyright_translation   = "";
  string rights_copyright_video         = "";
  string rights_license                 = "";
  string title_edition                  = "";
  string title_full                     = "";
  string title_language                 = "";
  string title_main                     = "";
  string title_note                     = "";
  string title_short                    = "";
  string title_sub                      = "";
  string title_subtitle                 = "";
}
#+END_SRC

*** composite structs

#+name: meta_defaults_template_structs
#+BEGIN_SRC d
struct ConfComposite {
  MetaComposite               meta;
  ConfCompositeMakeInit       make;
  ConfCompositeSiteLocal      conf;
}
struct ConfCompositePlus {
  MetaComposite               meta;
  ConfCompositeMakeInit       make;
  ConfCompositeMakeStr        make_str;
  ConfCompositeSiteLocal      conf;
}
#+END_SRC

*** metadata associative array indexes                             :header:

#+name: meta_defaults_template_structs
#+BEGIN_SRC d
static auto ptr_head_main
  = [
    "classify",
    "creator",
    "date",
    "identifier",
    "links",
    "make",
    "original",
    "notes",
    "rights",
    "title"
  ];
static auto ptr_head_sub_classify
  = [
    "dewey",
    "keywords",
    "loc",
    "subject",
    "topic_register"
  ];
static auto ptr_head_sub_creator
  = [
    "author",
    "author_email",
    "cover",
    "illustrator",
    "translator"
  ];
static auto ptr_head_sub_date
  = [
    "added_to_site",
    "available",
    "created",
    "issued",
    "modified",
    "published",
    "valid"
  ];
static auto ptr_head_sub_identifier
  = [
    "isbn",
    "oclc",
    "pg"
  ];
/+ make +/
static auto ptr_head_sub_make
  = [
    "cover_image",
    "home_button_image",
    "home_button_text",
    "footer", "headings",
    "num_top", "num_depth",
    "breaks",
    "substitute",
    "bold",
    "italics",
    "emphasis",
    "texpdf_font",
    "css"
  ];
static auto ptr_head_sub_notes
  = [
    "abstract",
    "description"
  ];
static auto ptr_head_sub_original
  = [
    "language",
    "source",
    "title"
  ];
static auto ptr_head_sub_publisher
  = [ "name" ];
static auto ptr_head_sub_rights
  = [
    "copyright",
    "cover",
    "illustrations",
    "license"
  ];
static auto ptr_head_sub_title
  = [
    "edition",
    "full",
    "language",
    "main",
    "note",
    "sub"
  ];
auto config_jsonstr = `{
}`;
#+END_SRC

* 1. JSON to SiSUstruct
** 1. module json                      :module:sdp:meta_conf_make_meta_json:
*** 0. module template

#+BEGIN_SRC d :tangle ../src/sdp/meta/conf_make_meta_json.d
/++
  json headers<BR>
  extract json header return json
+/
module sdp.meta.conf_make_meta_json;
static template contentJSONtoSiSUstruct() {
  import
    std.exception,
    std.regex,
    std.stdio,
    std.string,
    std.traits,
    std.typecons,
    std.utf,
    std.conv : to;
  import
    sdp.meta.conf_make_meta_structs,
    sdp.meta.conf_make_meta_json,
    sdp.meta.rgx;
  ConfCompositePlus _struct_composite;
  auto contentJSONtoSiSUstruct(C, J)(C _struct_composite, J _json, string _identifier) {
    mixin SiSUrgxInit;
    static auto _rgx = Rgx();
    debug (json) {
      writeln(">> --------------------------- >>");
      foreach (tag0; _json.object.byKeyValue) {
        if (tag0.value.stringof == "string") {
          writeln(tag0.key, ": ", tag0.value);
        } else {
          // writeln(tag0.key, ":");
          foreach (tag1; tag0.value.object.byKeyValue) {
            writeln(tag0.key, ":", tag1.key, ": ", tag1.value);
          }
        }
      }
      writeln("<< --------------------------- <<");
    }
    confCompositeMakeBuild _mk;
    <<json_objects>>
    return _struct_composite;
  }
}
#+END_SRC

***  make

#+name: json_objects
#+BEGIN_SRC d
/+ make ------------------------------------------------------------------- +/
if ("make" in _json.object) {
  if ("bold" in _json.object["make"]) {
    _struct_composite.make_str.bold  = _json.object["make"]["bold"].str;
  }
  if ("breaks" in _json.object["make"]) {
    _struct_composite.make_str.breaks  = _json.object["make"]["breaks"].str;
  }
  if ("cover_image" in _json.object["make"]) {
    _struct_composite.make_str.cover_image  = _json.object["make"]["cover_image"].str;
  }
  if ("css" in _json.object["make"]) {
    _struct_composite.make_str.css  = _json.object["make"]["css"].str;
  }
  if ("emphasis" in _json.object["make"]) {
    _struct_composite.make_str.emphasis  = _json.object["make"]["emphasis"].str;
  }
  if ("footer" in _json.object["make"]) {
    _struct_composite.make_str.footer  = _json.object["make"]["footer"].str;
  }
  if ("headings" in _json.object["make"]) {
    _struct_composite.make_str.headings  = _json.object["make"]["headings"].str;
  }
  if ("home_button_image" in _json.object["make"]) {
    _struct_composite.make_str.home_button_image  = _json.object["make"]["home_button_image"].str;
  }
  if ("home_button_text" in _json.object["make"]) {
    _struct_composite.make_str.home_button_text  = _json.object["make"]["home_button_text"].str;
  }
  if ("italics" in _json.object["make"]) {
    _struct_composite.make_str.italics  = _json.object["make"]["italics"].str;
  }
  if ("num_top" in _json.object["make"]) {
    _struct_composite.make_str.num_top  = _json.object["make"]["num_top"].str;
  }
  if ("num_depth" in _json.object["make"]) {
    _struct_composite.make_str.num_depth  = _json.object["num_depth"][""].str;
  }
  if ("substitute" in _json.object["make"]) {
    _struct_composite.make_str.substitute  = _json.object["make"]["substitute"].arrayNoRef;
  }
  if ("texpdf_font" in _json.object["make"]) {
    _struct_composite.make_str.texpdf_font  = _json.object["make"]["texpdf_font"].str;
  }
  _struct_composite.make.bold_rgxmatch                  = _mk.bold_rgxmatch(_struct_composite.make_str.bold);
  _struct_composite.make.breaks                         = _mk.breaks(_struct_composite.make_str.breaks);
  _struct_composite.make.cover_image                    = _mk.cover_image(_struct_composite.make_str.cover_image);
  _struct_composite.make.css                            = _mk.css(_struct_composite.make_str.css);
  _struct_composite.make.emphasis_rgxmatch              = _mk.emphasis_rgxmatch(_struct_composite.make_str.emphasis);
  _struct_composite.make.footer                         = _mk.footer(_struct_composite.make_str.footer);
  _struct_composite.make.headings                       = _mk.headings(_struct_composite.make_str.headings);
  _struct_composite.make.home_button_image              = _mk.home_button_image(_struct_composite.make_str.home_button_image);
  _struct_composite.make.home_button_text               = _mk.home_button_text(_struct_composite.make_str.home_button_text);
  _struct_composite.make.italics_rgxmatch               = _mk.italics_rgxmatch(_struct_composite.make_str.italics);
  _struct_composite.make.num_top                        = _mk.num_top(_struct_composite.make_str.num_top);
  _struct_composite.make.num_depth                      = _mk.num_depth(_struct_composite.make_str.num_depth);
  _struct_composite.make.substitute                     = _mk.substitute(_struct_composite.make_str.substitute);
  _struct_composite.make.texpdf_font                    = _mk.texpdf_font(_struct_composite.make_str.texpdf_font);
}
#+END_SRC

***  conf

#+name: json_objects
#+BEGIN_SRC d
/+ conf ------------------------------------------------------------------- +/
if ("webserv" in _json.object) {
  if ("url_root" in _json.object["webserv"]) {
    _struct_composite.conf.webserv_url_root = _json.object["webserv"]["url_root"].str;
  }
  if ("path" in _json.object["webserv"]) {
    _struct_composite.conf.webserv_path = _json.object["webserv"]["path"].str;
  }
  if ("images" in _json.object["webserv"]) {
    _struct_composite.conf.webserv_images = _json.object["webserv"]["images"].str;
  }
  if ("cgi" in _json.object["webserv"]) {
    _struct_composite.conf.webserv_cgi = _json.object["webserv"]["cgi"].str;
  }
  if ("cgi_host" in _json.object["webserv"]) {
    _struct_composite.conf.webserv_cgi_host = _json.object["webserv"]["cgi_host"].str;
  }
  if ("cgi_host_path" in _json.object["webserv"]) {
    _struct_composite.conf.webserv_cgi_host_path = _json.object["webserv"]["cgi_host_path"].str;
  }
  if ("cgi_port" in _json.object["webserv"]) {
    _struct_composite.conf.webserv_cgi_port = _json.object["webserv"]["cgi_port"].str;
  }
  if ("cgi_user" in _json.object["webserv"]) {
    _struct_composite.conf.webserv_cgi_user = _json.object["webserv"]["cgi_user"].str;
  }
  if ("cgi_file_links" in _json.object["webserv"]) {
    _struct_composite.conf.webserv_cgi_file_links = _json.object["webserv"]["cgi_file_links"].str;
  }
}
if ("processing" in _json.object) { // TODO check & match logic with sdlang
  if ("path" in _json.object["processing"]) {
    _struct_composite.conf.processing_path = _json.object["processing"]["path"].str;
  }
  if ("dir" in _json.object["processing"]) {
    _struct_composite.conf.processing_dir = _json.object["processing"]["dir"].str;
  }
  if ("concord_max" in _json.object["processing"]) {
    _struct_composite.conf.processing_concord_max = _json.object["processing"]["concord_max"].str;
  }
}
if ("flag" in _json.object) {
  if ("act0" in _json.object["flag"]) {
    _struct_composite.conf.flag_act0 = _json.object["flag"]["act0"].str;
  }
  if ("act1" in _json.object["flag"]) {
    _struct_composite.conf.flag_act1 = _json.object["flag"]["act1"].str;
  }
  if ("act2" in _json.object["flag"]) {
    _struct_composite.conf.flag_act2 = _json.object["flag"]["act2"].str;
  }
  if ("act3" in _json.object["flag"]) {
    _struct_composite.conf.flag_act3 = _json.object["flag"]["act3"].str;
  }
  if ("act4" in _json.object["flag"]) {
    _struct_composite.conf.flag_act4 = _json.object["flag"]["act4"].str;
  }
  if ("act5" in _json.object["flag"]) {
    _struct_composite.conf.flag_act5 = _json.object["flag"]["act5"].str;
  }
  if ("act6" in _json.object["flag"]) {
    _struct_composite.conf.flag_act6 = _json.object["flag"]["act6"].str;
  }
  if ("act7" in _json.object["flag"]) {
    _struct_composite.conf.flag_act7 = _json.object["flag"]["act7"].str;
  }
  if ("act8" in _json.object["flag"]) {
    _struct_composite.conf.flag_act8 = _json.object["flag"]["act8"].str;
  }
  if ("act9" in _json.object["flag"]) {
    _struct_composite.conf.flag_act9 = _json.object["flag"]["act9"].str;
  }
}
if ("default" in _json.object) {
  if ("papersize" in _json.object["default"]) {
    _struct_composite.conf.default_papersize = _json.object["default"]["papersize"].str;
  }
  if ("text_wrap" in _json.object["default"]) {
    _struct_composite.conf.default_text_wrap = _json.object["default"]["text_wrap"].str;
  }
  if ("emphasis" in _json.object["default"]) {
    _struct_composite.conf.default_emphasis = _json.object["default"]["emphasis"].str;
  }
  if ("language" in _json.object["default"]) {
    _struct_composite.conf.default_language = _json.object["default"]["language"].str;
  }
  if ("digest" in _json.object["default"]) {
    _struct_composite.conf.default_digest = _json.object["default"]["digest"].str;
  }
}
if ("search" in _json.object) {
  if ("flag" in _json.object["search"]) {
    _struct_composite.conf.search_flag = _json.object["search"]["flag"].str;
  }
  if ("action" in _json.object["search"]) {
    _struct_composite.conf.search_action = _json.object["search"]["action"].str;
  }
  if ("db" in _json.object["search"]) {
    _struct_composite.conf.search_db = _json.object["search"]["db"].str;
  }
  if ("title" in _json.object["search"]) {
    _struct_composite.conf.search_title = _json.object["search"]["title"].str;
  }
}
#+END_SRC

***  meta

#+name: json_objects
#+BEGIN_SRC d
/+ meta ------------------------------------------------------------------- +/
if ("classify" in _json.object) {
  if ("dewey" in _json.object["classify"]) {
    _struct_composite.meta.classify_dewey = _json.object["classify"]["dewey"].str;
  }
  if ("keywords" in _json.object["classify"]) {
    _struct_composite.meta.classify_keywords = _json.object["classify"]["keywords"].str;
  }
  if ("loc" in _json.object["classify"]) {
    _struct_composite.meta.classify_loc = _json.object["classify"]["loc"].str;
  }
  if ("subject" in _json.object["classify"]) {
    _struct_composite.meta.classify_subject = _json.object["classify"]["subject"].str;
  }
  if ("topic_register" in _json.object["classify"]) {
    _struct_composite.meta.classify_topic_register = _json.object["classify"]["topic_register"].str;
  }
}
if ("date" in _json.object) {
  if ("added_to_site" in _json.object["date"]) {
    _struct_composite.meta.date_added_to_site = _json.object["date"]["added_to_site"].str;
  }
  if ("available" in _json.object["date"]) {
    _struct_composite.meta.date_available = _json.object["date"]["available"].str;
  }
  if ("created" in _json.object["date"]) {
    _struct_composite.meta.date_created = _json.object["date"]["created"].str;
  }
  if ("issued" in _json.object["date"]) {
    _struct_composite.meta.date_issued = _json.object["date"]["issued"].str;
  }
  if ("modified" in _json.object["date"]) {
    _struct_composite.meta.date_modified = _json.object["date"]["modified"].str;
  }
  if ("published" in _json.object["date"]) {
    _struct_composite.meta.date_published = _json.object["date"]["published"].str;
  }
  if ("valid" in _json.object["date"]) {
    _struct_composite.meta.date_valid = _json.object["date"]["valid"].str;
  }
}
if ("links" in _json.object) {
  // if ("" in _json.object["links"]) {
  //   _struct_composite.meta.links_ = _json.object["links"][""].str;
  // }
}
if ("notes" in _json.object) {
  if ("abstract" in _json.object["notes"]) {
    _struct_composite.meta.notes_abstract = _json.object["notes"]["abstract"].str;
  }
  if ("description" in _json.object["notes"]) {
    _struct_composite.meta.notes_description = _json.object["notes"]["description"].str;
  }
}
if ("original" in _json.object) {
  if ("language" in _json.object["original"]) {
    _struct_composite.meta.original_language = _json.object["original"]["language"].str;
  }
  if ("language_char" in _json.object["original"]) {
    _struct_composite.meta.original_language_char = _json.object["original"]["language_char"].str;
  }
  if ("source" in _json.object["original"]) {
    _struct_composite.meta.original_source = _json.object["original"]["source"].str;
  }
  if ("title" in _json.object["original"]) {
    _struct_composite.meta.original_title = _json.object["original"]["title"].str;
  }
}
if ("publisher" in _json.object) {
  // if ("" in _json.object["publisher"]) {
  //   _struct_composite.meta.publisher = _json.object["publisher"][""].str;
  // }
}
if ("rights" in _json.object) {
  if ("copyright" in _json.object["rights"]) {
    _struct_composite.meta.rights_copyright = _json.object["rights"]["copyright"].str;
  }
  if ("copyright_text" in _json.object["rights"]) {
    _struct_composite.meta.rights_copyright_text = _json.object["rights"]["copyright_text"].str;
  }
  if ("copyright_audio" in _json.object["rights"]) {
    _struct_composite.meta.rights_copyright_audio = _json.object["rights"]["copyright_audio"].str;
  }
  if ("copyright_cover" in _json.object["rights"]) {
    _struct_composite.meta.rights_copyright_cover = _json.object["rights"]["copyright_cover"].str;
  }
  if ("copyright_illustrations" in _json.object["rights"]) {
    _struct_composite.meta.rights_copyright_illustrations = _json.object["rights"]["copyright_illustrations"].str;
  }
  if ("copyright_photographs" in _json.object["rights"]) {
    _struct_composite.meta.rights_copyright_photographs = _json.object["rights"]["copyright_photographs"].str;
  }
  if ("copyright_translation" in _json.object["rights"]) {
    _struct_composite.meta.rights_copyright_translation = _json.object["rights"]["copyright_translation"].str;
  }
  if ("copyright_video" in _json.object["rights"]) {
    _struct_composite.meta.rights_copyright_video = _json.object["rights"]["copyright_video"].str;
  }
  if ("license" in _json.object["rights"]) {
    _struct_composite.meta.rights_license = _json.object["rights"]["license"].str;
  }
}
if (_struct_composite.meta.creator_author.empty) {
  if ("creator" in _json.object) {
    if ("author" in _json.object["creator"]) {
      _struct_composite.meta.creator_author = _json.object["creator"]["author"].str;
    }
    if ("email" in _json.object["creator"]) {
      _struct_composite.meta.creator_author_email = _json.object["creator"]["email"].str;
    }
    if ("illustrator" in _json.object["creator"]) {
      _struct_composite.meta.creator_illustrator = _json.object["creator"]["illustrator"].str;
    }
    if ("translator" in _json.object["creator"]) {
      _struct_composite.meta.creator_translator = _json.object["creator"]["translator"].str;
    }
  }
  // dochead_meta["creator"]["author_raw"] = dochead_meta["creator"]["author"];
  string[] authors_arr;
  auto authors_raw_arr = _struct_composite.meta.creator_author.split(_rgx.arr_delimiter);
  foreach (author_raw; authors_raw_arr) {
    authors_arr ~= author_raw.replace(_rgx.raw_author_munge, "$2 $1");
  }
  _struct_composite.meta.creator_author = join(authors_arr, ", ").chomp.chomp;
}
if (_struct_composite.meta.title_main.empty) {
  if ("title" in _json.object) {
    if ((_json.object["title"].type().to!string) == "STRING") {
      _struct_composite.meta.title_main                     = _json.object["title"].str;
    } else {
      if ("edition" in _json.object["title"]) {
        _struct_composite.meta.title_edition                = _json.object["title"]["edition"].str;
      }
      if ("full" in _json.object["title"]) {
        // _struct_composite.meta.title_full                  = _json.object["title"]["full"].str;
      }
      if ("language" in _json.object["title"]) {
        _struct_composite.meta.title_language               = _json.object["title"]["language"].str;
      }
      if ("main" in _json.object["title"]) {
        _struct_composite.meta.title_main                   = _json.object["title"]["main"].str;
      }
      if ("note" in _json.object["title"]) {
        _struct_composite.meta.title_note                   = _json.object["title"]["note"].str;
      }
      if ("sub" in _json.object["title"]) {
        _struct_composite.meta.title_sub                    = _json.object["title"]["sub"].str;
      }
      if ("subtitle" in _json.object["title"]) {
        _struct_composite.meta.title_subtitle               = _json.object["title"]["subtitle"].str;
      }
    }
  }
  if ((!(_struct_composite.meta.title_subtitle.empty))
  && (_struct_composite.meta.title_sub.empty)) {
    _struct_composite.meta.title_sub = _struct_composite.meta.title_subtitle;
  }
  _struct_composite.meta.title_full = (_struct_composite.meta.title_sub.empty)
  ? _struct_composite.meta.title_main
  : format(
      "%s - %s",
      _struct_composite.meta.title_main,
      _struct_composite.meta.title_sub,
    );
}
#+END_SRC

* 2. TOML returns SiSUstruct (via JSON)      :module:sdp:meta_conf_make_meta:
** 0. parse TOML config return JSON

#+BEGIN_SRC d :tangle ../src/sdp/meta/conf_make_meta_toml.d
/++
  extract native/orig header return associative array<BR>

  the header is passed as text (lopped off top of a sisu markup file until the
  required first heading ^A~), determine whether is a native header or sdlang one
  with a regex check if whether it contains the "native header" required tag/field
  @title: then process accordingly as a "native header" or "sdlang header"
  converting the metadata and make instructions to a common json format used by
  program internally. Moved to associative array.
+/
module sdp.meta.conf_make_meta_toml;
static template configParseTOMLreturnJSON() {
  import
    toml,
    toml.json;
  auto configParseTOMLreturnJSON(T)(
    T _text
  ){
    TOMLDocument _doc;
    _doc = parseTOML(cast(string)(_text.content));
    auto _doc_json = toJSON(_doc);
    return _doc_json;
  }
}
#+END_SRC

** 1. parse TOML config to JSON return SiSUstruct

#+BEGIN_SRC d :tangle ../src/sdp/meta/conf_make_meta_toml.d
static template configParseTOMLreturnSiSUstruct() {
  import
    toml,
    toml.json;
  import
    sdp.meta.conf_make_meta_structs,
    sdp.meta.conf_make_meta_json;
  mixin contentJSONtoSiSUstruct;
  auto configParseTOMLreturnSiSUstruct(CCm, T)(
    CCm     _make_and_meta_struct,
    T       _document_struct
  ){
    TOMLDocument _doc = parseTOML(cast(string)(_document_struct.content));
    auto _doc_json = toJSON(_doc);
    _make_and_meta_struct = contentJSONtoSiSUstruct!()(_make_and_meta_struct, _doc_json, _document_struct.filename); // struct from json
    return _make_and_meta_struct;
  }
}
#+END_SRC

** 2. parse TOML header to JSON then Struct

#+BEGIN_SRC d :tangle ../src/sdp/meta/conf_make_meta_toml.d
static template docHeaderMakeAndMetaTupTomlExtractAndConvertToStruct() {
  import
    std.exception,
    std.regex,
    std.stdio,
    std.traits,
    std.typecons,
    std.utf,
    std.conv : to;
  import
    toml,
    toml.json;
  import
    sdp.meta.conf_make_meta_structs,
    sdp.meta.conf_make_meta_json,
    sdp.meta.rgx;
  mixin SiSUrgxInit;
  mixin contentJSONtoSiSUstruct;
  static auto rgx = Rgx();
  auto docHeaderMakeAndMetaTupTomlExtractAndConvertToStruct(CCm, Src)(
    CCm     _make_and_meta_struct,
    Src     header_src,
  ) {
    TOMLDocument _doc;
    if (header_src.match(rgx.sdlang_header_meta_title)) {
      writeln("WARNING >>> document header is sdlang (in wrong location JSON)");
    } else if (header_src.match(rgx.toml_header_meta_title)) {
      debug (json) {
        writeln(">>> document header is toml, convert to JSON");
      }
      _doc = parseTOML(cast(string)(header_src));
    }
    auto _doc_json = toJSON(_doc);
    auto _header_and_make_and_meta_struct = contentJSONtoSiSUstruct!()(_make_and_meta_struct, _doc_json, "header");
    return _header_and_make_and_meta_struct;
  }
}
#+END_SRC

* 3. SDLang to SiSUstruct
** 1. header extract (sdlang) to Struct     :module:sdp:meta_conf_make_meta:

#+BEGIN_SRC d :tangle ../src/sdp/meta/conf_make_meta_sdlang.d
/++
  extract native/orig header return associative array<BR>

  the header is passed as text (lopped off top of a sisu markup file until the
  required first heading ^A~), determine whether is a native header or sdlang one
  with a regex check if whether it contains the "native header" required tag/field
  @title: then process accordingly as a "native header" or "sdlang header"
  converting the metadata and make instructions to a common json format used by
  program internally. Moved to associative array.
+/
module sdp.meta.conf_make_meta_sdlang;
static template docHeaderMakeAndMetaTupSDLangExtractAndConvertToStruct() {
  import
    std.exception,
    std.regex,
    std.stdio,
    std.traits,
    std.typecons,
    std.utf,
    std.conv : to;
  import sdlang;
  import
    sdp.meta.conf_make_meta_sdlang,
    sdp.meta.rgx;
  mixin SiSUrgxInit;
  mixin SiSUextractSDLang;
  static auto rgx = Rgx();
  auto docHeaderMakeAndMetaTupSDLangExtractAndConvertToStruct(CCm, Src)(
    CCm     conf_composite_make,
    Src     header_src,
  ) {
    auto header_sdlang_tag = (header_src.match(rgx.sdlang_header_meta_title))
    ? extractSDL().docHeaderSDLtagGet(header_src) // sdlang.ast.Tag
    : null;
    auto header_make_and_meta_struct = extractSDL().docSDLtoStruct(conf_composite_make, header_sdlang_tag);
    return header_make_and_meta_struct;
  }
}
#+END_SRC

** 2. module sdlang                  :module:sdp:meta_conf_make_meta_sdlang:
*** 0. module template
**** 1. extract sdlang
#+BEGIN_SRC d :tangle ../src/sdp/meta/conf_make_meta_sdlang.d
/++
  sdlang headers<BR>
  extract sdlang header return sdlang
+/
static template SiSUextractSDLang() {
  import
    std.exception,
    std.regex,
    std.stdio,
    std.string,
    std.traits,
    std.typecons,
    std.utf,
    std.conv : to;
  import
    sdp.meta.conf_make_meta_structs,
    sdp.meta.rgx;
  struct extractSDL {
    mixin SiSUmakeMetaStructsSDLang;
    mixin SiSUrgxInit;
    static auto rgx = Rgx();
    <<meta_conf_make_meta_sdl_extract>>
    private auto docSDLtoStruct(C,Tag)(C _conf_composite, Tag header_sdlang) { // work on
      <<meta_conf_make_meta_sdl>>
      return _conf_composite;
    }
  }
}
#+END_SRC

**** 2. extract sdlang

#+BEGIN_SRC d :tangle ../src/sdp/meta/conf_make_meta_sdlang.d
static template parseSDLangConfig() {
  import
    std.exception,
    std.regex,
    std.stdio,
    std.string,
    std.traits,
    std.typecons,
    std.utf,
    std.conv : to;
  import sdlang;
  <<meta_config_file_sdlang_test>>
}
#+END_SRC

*** 1. sdlang root tag _extract root Tag_                   :sdlang:root:tag:
**** 1. header

#+name: meta_conf_make_meta_sdl_extract
#+BEGIN_SRC d
private auto docHeaderSDLtagGet(Hs)(Hs src_header) {
  debug(asserts){
    static assert(is(typeof(src_header) == char[]));
  }
  char[][] source_header_arr
    = (cast(char[]) src_header).split(rgx.newline_eol_delimiter);
  char[] _src_header;
  foreach(header_line; source_header_arr) {
    if (!match(header_line, rgx.comments)) {
      _src_header ~= header_line ~ "\n";
    }
  }
  scope(failure) {
    stderr.writefln(
      "%s\n%s\n%s:%s failed here:\n  _src_header: %s",
      __MODULE__, __FUNCTION__,
      __FILE__, __LINE__,
      _src_header,
    );
  }
  Tag sdl_root_header;
  try {
    sdl_root_header = parseSource(_src_header.to!string);
  }
  catch(ParseException e) {
    stderr.writeln("SDLang problem with this document header:");
    stderr.writeln(_src_header);
    // Error messages of the form:
    // myFile.sdl(5:28): Error: Invalid integer suffix.
    stderr.writeln(e.msg);
  }
  debug(sdlang) {
    writeln("header SDL:");
    writeln(__LINE__, ": ",  sdl_root_header.toSDLDocument());
    writeln(__LINE__, ": ",  sdl_root_header.maybe.namespaces);
    writeln("header make sdlang: ", sdl_root_header.toSDLDocument());
    writeln(__LINE__, ": ", sdl_root_header.getTagValues("title"));
    writeln(__LINE__, ": ", sdl_root_header.getTagValues("creator"));
    Tag creator = sdl_root_header.getTag("creator");
    if (creator !is null) {
      if ("author" in creator.maybe.tags) {
        writeln(__LINE__, ": ", creator.getTagValues("author"));
      } else if ("author" in creator.maybe.attributes) {
        writeln(__LINE__, ": ", creator.maybe.attributes["author"][0].value);
      }
    }
  }
  return sdl_root_header; // sdlang.ast.Tag
}
#+END_SRC

**** 2. conf & make

#+name: meta_config_file_sdlang_test
#+BEGIN_SRC d
auto parseSDLangConfig(string configuration, string conf_sdl_filename) {
  Tag sdl_root_conf;
  try {
    sdl_root_conf = parseSource(configuration);
  }
  catch(ParseException e) {
    stderr.writeln("SDLang problem with content for ", conf_sdl_filename);
    stderr.writeln(e.msg);
  }
  return sdl_root_conf;
}
#+END_SRC

*** 2. _sdlang to struct_
****  make

#+name: meta_conf_make_meta_sdl
#+BEGIN_SRC d
/+ make ------------------------------------------------------------------- +/
if ("make" in header_sdlang.maybe.tags) {
  confCompositeMakeBuild _mk;
  _conf_composite.make_str.bold                       = extractSDLangTabOrAttrib(header_sdlang, "make", "bold"); // TODO
  _conf_composite.make_str.breaks                     = extractSDLangTabOrAttrib(header_sdlang, "make", "breaks");
  _conf_composite.make_str.cover_image                = extractSDLangTabOrAttrib(header_sdlang, "make", "cover_image");
  _conf_composite.make_str.css                        = extractSDLangTabOrAttrib(header_sdlang, "make", "css");
  _conf_composite.make_str.emphasis                   = extractSDLangTabOrAttrib(header_sdlang, "make", "emphasis"); // TODO
  _conf_composite.make_str.footer                     = extractSDLangTabOrAttrib(header_sdlang, "make", "footer");
  _conf_composite.make_str.headings                   = extractSDLangTabOrAttrib(header_sdlang, "make", "headings");
  _conf_composite.make_str.home_button_image          = extractSDLangTabOrAttrib(header_sdlang, "make", "home_button_image");
  _conf_composite.make_str.home_button_text           = extractSDLangTabOrAttrib(header_sdlang, "make", "home_button_text");
  _conf_composite.make_str.italics                    = extractSDLangTabOrAttrib(header_sdlang, "make", "italics"); // TODO
  _conf_composite.make_str.num_top                    = extractSDLangTabOrAttrib(header_sdlang, "make", "num_top");
  _conf_composite.make_str.num_depth                  = extractSDLangTabOrAttrib(header_sdlang, "make", "num_depth");
  _conf_composite.make_str.substitute                 = extractSDLangTabOrAttrib(header_sdlang, "make", "substitute"); // TODO
  _conf_composite.make_str.texpdf_font                = extractSDLangTabOrAttrib(header_sdlang, "make", "texpdf_font");
  _conf_composite.make.bold_rgxmatch                  = _mk.bold_rgxmatch(_conf_composite.make_str.bold);
  _conf_composite.make.breaks                         = _mk.breaks(_conf_composite.make_str.breaks);
  _conf_composite.make.cover_image                    = _mk.cover_image(_conf_composite.make_str.cover_image);
  _conf_composite.make.css                            = _mk.css(_conf_composite.make_str.css);
  _conf_composite.make.emphasis_rgxmatch              = _mk.emphasis_rgxmatch(_conf_composite.make_str.emphasis);
  _conf_composite.make.footer                         = _mk.footer(_conf_composite.make_str.footer);
  _conf_composite.make.headings                       = _mk.headings(_conf_composite.make_str.headings);
  _conf_composite.make.home_button_image              = _mk.home_button_image(_conf_composite.make_str.home_button_image);
  _conf_composite.make.home_button_text               = _mk.home_button_text(_conf_composite.make_str.home_button_text);
  _conf_composite.make.italics_rgxmatch               = _mk.italics_rgxmatch(_conf_composite.make_str.italics);
  _conf_composite.make.num_top                        = _mk.num_top(_conf_composite.make_str.num_top);
  _conf_composite.make.num_depth                      = _mk.num_depth(_conf_composite.make_str.num_depth);
  _conf_composite.make.substitute                     = _mk.substitute(_conf_composite.make_str.substitute);
  _conf_composite.make.texpdf_font                    = _mk.texpdf_font(_conf_composite.make_str.texpdf_font);
}
#+END_SRC

****  conf

#+name: meta_conf_make_meta_sdl
#+BEGIN_SRC d
/+ conf ------------------------------------------------------------------- +/
if ("webserv" in header_sdlang.maybe.tags) {
  _conf_composite.conf.webserv_url_root               = extractSDLangTabOrAttrib(header_sdlang, "webserv", "url_root");
  _conf_composite.conf.webserv_path                   = extractSDLangTabOrAttrib(header_sdlang, "webserv", "path");
  _conf_composite.conf.webserv_images                 = extractSDLangTabOrAttrib(header_sdlang, "webserv", "images");
  _conf_composite.conf.webserv_cgi                    = extractSDLangTabOrAttrib(header_sdlang, "webserv", "cgi");
  _conf_composite.conf.webserv_cgi_host               = extractSDLangTabOrAttrib(header_sdlang, "webserv", "cgi_host");
  _conf_composite.conf.webserv_cgi_host_path          = extractSDLangTabOrAttrib(header_sdlang, "webserv", "cgi_host_path");
  _conf_composite.conf.webserv_cgi_port               = extractSDLangTabOrAttrib(header_sdlang, "webserv", "cgi_port");
  _conf_composite.conf.webserv_cgi_user               = extractSDLangTabOrAttrib(header_sdlang, "webserv", "cgi_user");
  _conf_composite.conf.webserv_cgi_file_links         = extractSDLangTabOrAttrib(header_sdlang, "webserv", "cgi_file_links");
}
if ("processing" in header_sdlang.maybe.tags) {
  _conf_composite.conf.processing_path                = extractSDLangTabOrAttrib(header_sdlang, "webserv", "processing_path");
  _conf_composite.conf.processing_dir                 = extractSDLangTabOrAttrib(header_sdlang, "webserv", "processing_dir");
  _conf_composite.conf.processing_concord_max         = extractSDLangTabOrAttrib(header_sdlang, "webserv", "processing_concord_max");
}
if ("flag" in header_sdlang.maybe.tags) {
  _conf_composite.conf.flag_act0                      = extractSDLangTabOrAttrib(header_sdlang, "flag", "act0");
  _conf_composite.conf.flag_act1                      = extractSDLangTabOrAttrib(header_sdlang, "flag", "act1");
  _conf_composite.conf.flag_act2                      = extractSDLangTabOrAttrib(header_sdlang, "flag", "act2");
  _conf_composite.conf.flag_act3                      = extractSDLangTabOrAttrib(header_sdlang, "flag", "act3");
  _conf_composite.conf.flag_act4                      = extractSDLangTabOrAttrib(header_sdlang, "flag", "act4");
  _conf_composite.conf.flag_act5                      = extractSDLangTabOrAttrib(header_sdlang, "flag", "act5");
  _conf_composite.conf.flag_act6                      = extractSDLangTabOrAttrib(header_sdlang, "flag", "act6");
  _conf_composite.conf.flag_act7                      = extractSDLangTabOrAttrib(header_sdlang, "flag", "act7");
  _conf_composite.conf.flag_act8                      = extractSDLangTabOrAttrib(header_sdlang, "flag", "act8");
  _conf_composite.conf.flag_act9                      = extractSDLangTabOrAttrib(header_sdlang, "flag", "act9");
}
if ("default" in header_sdlang.maybe.tags) {
  _conf_composite.conf.default_papersize              = extractSDLangTabOrAttrib(header_sdlang, "default", "papersize");
  _conf_composite.conf.default_text_wrap              = extractSDLangTabOrAttrib(header_sdlang, "default", "text_wrap");
  _conf_composite.conf.default_emphasis               = extractSDLangTabOrAttrib(header_sdlang, "default", "emphasis");
  _conf_composite.conf.default_language               = extractSDLangTabOrAttrib(header_sdlang, "default", "language");
  _conf_composite.conf.default_digest                 = extractSDLangTabOrAttrib(header_sdlang, "default", "digest");
}
if ("search" in header_sdlang.maybe.tags) {
  _conf_composite.conf.search_flag                    = extractSDLangTabOrAttrib(header_sdlang, "search", "flag");
  _conf_composite.conf.search_action                  = extractSDLangTabOrAttrib(header_sdlang, "search", "action");
  _conf_composite.conf.search_db                      = extractSDLangTabOrAttrib(header_sdlang, "search", "db");
  _conf_composite.conf.search_title                   = extractSDLangTabOrAttrib(header_sdlang, "search", "title");
}
#+END_SRC

****  meta

#+name: meta_conf_make_meta_sdl
#+BEGIN_SRC d
/+ meta ------------------------------------------------------------------- +/
if ("classify" in header_sdlang.maybe.tags) {
  _conf_composite.meta.classify_dewey                 = extractSDLangTabOrAttrib(header_sdlang, "classify", "dewey");
  _conf_composite.meta.classify_keywords              = extractSDLangTabOrAttrib(header_sdlang, "classify", "keywords");
  _conf_composite.meta.classify_loc                   = extractSDLangTabOrAttrib(header_sdlang, "classify", "loc");
  _conf_composite.meta.classify_subject               = extractSDLangTabOrAttrib(header_sdlang, "classify", "subject");
  _conf_composite.meta.classify_topic_register        = extractSDLangTabOrAttrib(header_sdlang, "classify", "topic_register");
}
if ("date" in header_sdlang.maybe.tags) {
  _conf_composite.meta.date_added_to_site             = extractSDLangTabOrAttrib(header_sdlang, "date", "added_to_site");
  _conf_composite.meta.date_available                 = extractSDLangTabOrAttrib(header_sdlang, "date", "available");
  _conf_composite.meta.date_created                   = extractSDLangTabOrAttrib(header_sdlang, "date", "created");
  _conf_composite.meta.date_issued                    = extractSDLangTabOrAttrib(header_sdlang, "date", "issued");
  _conf_composite.meta.date_modified                  = extractSDLangTabOrAttrib(header_sdlang, "date", "modified");
  _conf_composite.meta.date_published                 = extractSDLangTabOrAttrib(header_sdlang, "date", "published");
  _conf_composite.meta.date_valid                     = extractSDLangTabOrAttrib(header_sdlang, "date", "valid");
}
if ("identifier" in header_sdlang.maybe.tags) {
  _conf_composite.meta.identifier_isbn                = extractSDLangTabOrAttrib(header_sdlang, "identifier", "isbn");
  _conf_composite.meta.identifier_oclc                = extractSDLangTabOrAttrib(header_sdlang, "identifier", "oclc");
  _conf_composite.meta.identifier_pg                  = extractSDLangTabOrAttrib(header_sdlang, "identifier", "pg");
}
if ("links" in header_sdlang.maybe.tags) {
  // _conf_composite.meta.links                         = extractSDLangTabOrAttrib(header_sdlang, "links", "");
}
if ("notes" in header_sdlang.maybe.tags) {
  _conf_composite.meta.notes_abstract                 = extractSDLangTabOrAttrib(header_sdlang, "notes", "abstract");
  _conf_composite.meta.notes_description              = extractSDLangTabOrAttrib(header_sdlang, "notes", "description");
}
if ("original" in header_sdlang.maybe.tags) {
  _conf_composite.meta.original_language              = extractSDLangTabOrAttrib(header_sdlang, "original", "language");
  _conf_composite.meta.original_language_char         = extractSDLangTabOrAttrib(header_sdlang, "original", "language_char");
  _conf_composite.meta.original_source                = extractSDLangTabOrAttrib(header_sdlang, "original", "source");
  _conf_composite.meta.original_title                 = extractSDLangTabOrAttrib(header_sdlang, "original", "title");
}
if ("publisher" in header_sdlang.maybe.tags) {
  // _conf_composite.meta.publisher                     = extractSDLangTabOrAttrib(header_sdlang, "publisher", "");
}
if ("rights" in header_sdlang.maybe.tags) {
  _conf_composite.meta.rights_copyright               = extractSDLangTabOrAttrib(header_sdlang, "rights", "copyright");
  _conf_composite.meta.rights_copyright_text          = extractSDLangTabOrAttrib(header_sdlang, "rights", "copyright_text");
  _conf_composite.meta.rights_copyright_audio         = extractSDLangTabOrAttrib(header_sdlang, "rights", "copyright_audio");
  _conf_composite.meta.rights_copyright_cover         = extractSDLangTabOrAttrib(header_sdlang, "rights", "copyright_cover");
  _conf_composite.meta.rights_copyright_illustrations = extractSDLangTabOrAttrib(header_sdlang, "rights", "copyright_illustrations");
  _conf_composite.meta.rights_copyright_photographs   = extractSDLangTabOrAttrib(header_sdlang, "rights", "copyright_photographs");
  _conf_composite.meta.rights_copyright_translation   = extractSDLangTabOrAttrib(header_sdlang, "rights", "copyright_translation");
  _conf_composite.meta.rights_copyright_video         = extractSDLangTabOrAttrib(header_sdlang, "rights", "copyright_video");
  _conf_composite.meta.rights_license                 = extractSDLangTabOrAttrib(header_sdlang, "rights", "license");
}
if (_conf_composite.meta.creator_author.empty) {
  if ("creator" in header_sdlang.maybe.tags) {
    _conf_composite.meta.creator_author               = extractSDLangTabOrAttrib(header_sdlang, "creator", "author");
    _conf_composite.meta.creator_author_email         = extractSDLangTabOrAttrib(header_sdlang, "creator", "author_email");
    _conf_composite.meta.creator_illustrator          = extractSDLangTabOrAttrib(header_sdlang, "creator", "illustrator");
    _conf_composite.meta.creator_translator           = extractSDLangTabOrAttrib(header_sdlang, "creator", "translator");
  }
  // dochead_meta["creator"]["author_raw"] = dochead_meta["creator"]["author"];
  string[] authors_arr;
  auto authors_raw_arr = _conf_composite.meta.creator_author.split(rgx.arr_delimiter);
  foreach (author_raw; authors_raw_arr) {
    authors_arr ~= author_raw.replace(rgx.raw_author_munge, "$2 $1");
  }
  _conf_composite.meta.creator_author = join(authors_arr, ", ").chomp.chomp;
}
if (_conf_composite.meta.title_main.empty) {
  if ("title" in header_sdlang.maybe.tags) {
    _conf_composite.meta.title_edition                = extractSDLangTabOrAttrib(header_sdlang, "title", "edition");
    // _conf_composite.meta.title_full                  = extractSDLangTabOrAttrib(header_sdlang, "title", "full");
    _conf_composite.meta.title_language               = extractSDLangTabOrAttrib(header_sdlang, "title", "language");
    _conf_composite.meta.title_main                   = extractSDLangTabOrAttrib(header_sdlang, "title", "main");
    _conf_composite.meta.title_note                   = extractSDLangTabOrAttrib(header_sdlang, "title", "note");
    _conf_composite.meta.title_sub                    = extractSDLangTabOrAttrib(header_sdlang, "title", "sub");
    _conf_composite.meta.title_subtitle               = extractSDLangTabOrAttrib(header_sdlang, "title", "subtitle");
  }
  if (_conf_composite.meta.title_main.empty) {
    Tag _maintag = header_sdlang.getTag("title");
    if (_maintag !is null) {
      if ("main" in _maintag.maybe.tags) {
        _conf_composite.meta.title_main
          = to!string(_maintag.getTagValues("main"));
      } else if ("main" !in _maintag.maybe.attributes) {
        _conf_composite.meta.title_main
          = (_maintag.values[0]).to!string; // test that this exists
      }
    }
  }
  if ((!(_conf_composite.meta.title_subtitle.empty))
  && (_conf_composite.meta.title_sub.empty)) {
    _conf_composite.meta.title_sub = _conf_composite.meta.title_subtitle;
  }
  _conf_composite.meta.title_full = (_conf_composite.meta.title_sub.empty)
  ? _conf_composite.meta.title_main
  : format(
      "%s - %s",
      _conf_composite.meta.title_main,
      _conf_composite.meta.title_sub,
    );
}
#+END_SRC

** 3. module conf files make composite
*** TODO 0. module template

#+BEGIN_SRC d :tangle ../src/sdp/meta/conf_make_meta_sdlang.d
/++
  return composite make from config files
+/
<<meta_conf_make_meta_sdl_to_composite_struct>>
template confFilesSDLtoStruct() {
  import
    std.exception,
    std.regex,
    std.stdio,
    std.string,
    std.traits,
    std.typecons,
    std.utf,
    std.conv : to;
  import
    sdp.meta.conf_make_meta_structs,
    sdp.meta.rgx;
  <<meta_conf_make_meta_sdl_to_composite>>
}
#+END_SRC

*** _sdlang to parse_ composite make

#+name: meta_conf_make_meta_sdl_to_composite
#+BEGIN_SRC d
auto configParseSDL(T)(
  T _text
){
  Tag sdl_root;
  try {
    sdl_root = parseSource(_text.to!string);
  }
  catch(ParseException e) {
    stderr.writeln("SDLang problem with this document header:");
    stderr.writeln(_src_header);
    // Error messages of the form:
    // myFile.sdl(5:28): Error: Invalid integer suffix.
    stderr.writeln(e.msg);
  }
  debug(sdlang) {
    writeln("header SDL:");
    writeln(__LINE__, ": ",  sdl_root.toSDLDocument());
    writeln(__LINE__, ": ",  sdl_root.maybe.namespaces);
    writeln("header make sdlang: ", sdl_root.toSDLDocument());
    writeln(__LINE__, ": ", sdl_root.getTagValues("title"));
    writeln(__LINE__, ": ", sdl_root.getTagValues("creator"));
    Tag creator = sdl_root.getTag("creator");
    if (creator !is null) {
      if ("author" in creator.maybe.tags) {
        writeln(__LINE__, ": ", creator.getTagValues("author"));
      } else if ("author" in creator.maybe.attributes) {
        writeln(__LINE__, ": ", creator.maybe.attributes["author"][0].value);
      }
    }
  }
  return sdl_root; // sdlang.ast.Tag
}
#+END_SRC

*** _sdlang to struct_ composite make

#+name: meta_conf_make_meta_sdl_to_composite
#+BEGIN_SRC d
auto confFilesSDLtoStruct(S,L)(
  S sdl_root_config_share,
  L sdl_root_config_local,
){
  mixin SiSUmakeMetaStructsSDLang;
  ConfCompositePlus _conf_composite;
  foreach (conf_sdlang; [sdl_root_config_share, sdl_root_config_local]) {
    if ("make" in conf_sdlang.maybe.tags) {
      confCompositeMakeBuild _mk;
      _conf_composite.make_str.bold               = extractSDLangTabOrAttrib(conf_sdlang, "make", "bold"); // TODO
      _conf_composite.make_str.breaks             = extractSDLangTabOrAttrib(conf_sdlang, "make", "breaks");
      _conf_composite.make_str.cover_image        = extractSDLangTabOrAttrib(conf_sdlang, "make", "cover_image");
      _conf_composite.make_str.css                = extractSDLangTabOrAttrib(conf_sdlang, "make", "css");
      _conf_composite.make_str.emphasis           = extractSDLangTabOrAttrib(conf_sdlang, "make", "emphasis"); // TODO
      _conf_composite.make_str.footer             = extractSDLangTabOrAttrib(conf_sdlang, "make", "footer");
      _conf_composite.make_str.headings           = extractSDLangTabOrAttrib(conf_sdlang, "make", "headings");
      _conf_composite.make_str.home_button_image  = extractSDLangTabOrAttrib(conf_sdlang, "make", "home_button_image");
      _conf_composite.make_str.home_button_text   = extractSDLangTabOrAttrib(conf_sdlang, "make", "home_button_text");
      _conf_composite.make_str.italics            = extractSDLangTabOrAttrib(conf_sdlang, "make", "italics"); // TODO
      _conf_composite.make_str.num_top            = extractSDLangTabOrAttrib(conf_sdlang, "make", "num_top");
      _conf_composite.make_str.num_depth          = extractSDLangTabOrAttrib(conf_sdlang, "make", "num_depth");
      _conf_composite.make_str.substitute         = extractSDLangTabOrAttrib(conf_sdlang, "make", "substitute"); // TODO
      _conf_composite.make_str.texpdf_font        = extractSDLangTabOrAttrib(conf_sdlang, "make", "texpdf_font");
      _conf_composite.make.bold_rgxmatch          = _mk.bold_rgxmatch(_conf_composite.make_str.bold); //
      _conf_composite.make.breaks                 = _mk.breaks(_conf_composite.make_str.breaks);
      _conf_composite.make.cover_image            = _mk.cover_image(_conf_composite.make_str.cover_image);
      _conf_composite.make.css                    = _mk.css(_conf_composite.make_str.css);
      _conf_composite.make.emphasis_rgxmatch      = _mk.emphasis_rgxmatch(_conf_composite.make_str.emphasis);
      _conf_composite.make.footer                 = _mk.footer(_conf_composite.make_str.footer);
      _conf_composite.make.headings               = _mk.headings(_conf_composite.make_str.headings);
      _conf_composite.make.home_button_image      = _mk.home_button_image(_conf_composite.make_str.home_button_image);
      _conf_composite.make.home_button_text       = _mk.home_button_text(_conf_composite.make_str.home_button_text);
      _conf_composite.make.italics_rgxmatch       = _mk.italics_rgxmatch(_conf_composite.make_str.italics);
      _conf_composite.make.num_top                = _mk.num_top(_conf_composite.make_str.num_top);
      _conf_composite.make.num_depth              = _mk.num_depth(_conf_composite.make_str.num_depth);
      _conf_composite.make.substitute             = _mk.substitute(_conf_composite.make_str.substitute); // TODO
      _conf_composite.make.texpdf_font            = _mk.texpdf_font(_conf_composite.make_str.texpdf_font);
    }
  }
  return _conf_composite;
}
#+END_SRC

** 4. SDLang default make meta structs            :module:sdp:meta_defaults:

#+name: tangle_defaults
#+BEGIN_SRC d :tangle ../src/sdp/meta/conf_make_meta_sdlang.d
/++
  default settings
+/
template SiSUmakeMetaStructsSDLang() {
  <<meta_defaults_imports>>
  string extractSDLangTabOrAttrib(S)(
    S conf_sdlang,
    string maintab,
    string atab
  ) {
    string _conf_composite_string = "";
    if (maintab in conf_sdlang.maybe.tags) {
      auto _maintag = conf_sdlang.getTag(maintab);
      if (
        (atab in _maintag.maybe.tags)
        && (_maintag.getTagValues(atab).length > 0)
      ) {
        debug(configsdlang) {
          writeln(
            "  ", __LINE__,
            ": sdl tag, ",
            maintab, ":", atab, ": ",
            _maintag.getTagValues(atab)[0]
          );
        }
        if (_maintag.getTagValues(atab).length == 1) {
          writeln((_maintag.getTagValues(atab)[0]).to!string);
          _conf_composite_string
            = (_maintag.getTagValues(atab)[0]).to!string;
        } else if (_maintag.getTagValues(atab).length > 1) {
          string _tmp = "";
          foreach (st; _maintag.getTagValues(atab)) {
            writeln(st.to!string, ";");
            _tmp ~= st.to!string ~ ";";
          }
          _conf_composite_string = _tmp;
        }
      } else if (
        (atab in _maintag.maybe.attributes)
        && (_maintag.attributes[atab][0].value.length > 0)
      ) {
        debug(configsdlang) {
          writeln(
            "  ", __LINE__,
            ": sdl attrib, ",
            maintab, ":", atab, ": ",
            _maintag.attributes[atab][0].value
          );
        }
        _conf_composite_string
          = (_maintag.attributes[atab][0].value).to!string;
      }
    }
    return _conf_composite_string;
  }
}
#+END_SRC

* __END__
** notes headers

#+BEGIN_SRC d
/+
  /+
    unify internal representation of header info for native & sdlang document headers
    represent either using struct, hashes or possibly json
    sdp internal representation should be identical for native & sdlang variants
  +/
header.
  ├── make                         // make instructions
  │   ├── bold
  │   ├── breaks
  │   ├── cover_image
  │   ├── css
  │   ├── emphasis
  │   ├── footer
  │   ├── headings
  │   ├── home_button_image
  │   ├── home_button_text
  │   ├── italics
  │   ├── num_top
  │   ├── substitute
  │   └── texpdf_font
  └── meta                         // metadata
     ├── author                    // move author to creator:author
     ├── classify
     │   ├── dewey
     │   ├── keyword
     │   ├── loc
     │   ├── subject
     │   └── topic_register
     ├── creator
     │   ├── author
     │   │     ├── [ [first_name: x0, last_name: y0], [first_name: x1, last_name: y1] ]
     │   │     └── [ full_name0, full_name1 ]
     │   ├── author_email
     │   ├── illustrator
     │   └── translator
     ├── date
     │   ├── added_to_site
     │   ├── available
     │   ├── created
     │   ├── issued
     │   ├── modified
     │   ├── published
     │   └── valid
     ├── identifier
     │   ├── isbn
     │   ├── oclc
     │   └── pg
     ├── links
     ├── notes
     │   ├── abstract
     │   └── description
     ├── original
     │   ├── language
     │   ├── source
     │   └── title
     ├── publisher
     │   └── name
     ├── rights
     │   ├── copyright
     │   ├── cover
     │   ├── illustrations
     │   └── license
     └── title                    // move title: to title:main
         ├── edition
         ├── [ full (main + sub) ]
         ├── language
         ├── main
         ├── note
         ├── sub
         └── subtitle              // move title:subtitle to title:sub

61 leaves
+/
#+END_SRC

** dlang rgx example

#+BEGIN_SRC d
import std.conv, std.regex, std.range, std.file, std.stdio;
import std.string : format;
void main(string[] argv) {
  immutable ratio = 1.5824;  // UK pounds to US dollar as of this writing
  auto toDollars(Captures!string price) {
    real value = to!real(price["integer"]);
    if (!price["fraction"].empty)
      value += 0.01*to!real(price["fraction"]);
    return format("$%.2f",value * ratio);
  }
  string text = std.file.readText(argv[1]);
  auto converted = replaceAll!toDollars(text,
    regex(r"£\s*(?P<integer>[0-9]+)(\.(?P<fraction>[0-9]{2}))?","g"));
  write(converted);
}
#+END_SRC