From 22cea68385b57a1593f5751e49cfdd41d8067997 Mon Sep 17 00:00:00 2001 From: Ralph Amissah Date: Thu, 13 Jul 2017 07:44:03 -0400 Subject: 0.18.0 rename meta from ao (considered adr) --- src/sdp/meta/conf_make_meta_native.d | 330 +++++++++++++++++++++++++++++++++++ 1 file changed, 330 insertions(+) create mode 100644 src/sdp/meta/conf_make_meta_native.d (limited to 'src/sdp/meta/conf_make_meta_native.d') diff --git a/src/sdp/meta/conf_make_meta_native.d b/src/sdp/meta/conf_make_meta_native.d new file mode 100644 index 0000000..fc7912f --- /dev/null +++ b/src/sdp/meta/conf_make_meta_native.d @@ -0,0 +1,330 @@ +/++ + native headers using
@title:
:subtitle:
type tags
+ extract native/orig header return associative array ++/ +module sdp.meta.conf_make_meta_native; +template SiSUheaderExtractNative() { + import + std.exception, + std.regex, + std.stdio, + std.string, + std.traits, + std.typecons, + std.utf, + std.conv : to; + import + sdp.meta.defaults, + sdp.meta.rgx; + struct HeaderDocMetadataAndMakeNativeToAA { + mixin SiSUregisters; + mixin SiSUrgxInitFlags; + mixin SiSUrgxInit; + auto rgx = Rgx(); + enum State { off, on } + string hm, hs; + auto header_metadata_and_make_aa(H,Me,Ma)( + H header, + Me dochead_meta, + Ma dochead_make + ) + in { + debug(asserts){ + static assert(is(typeof(header) == string)); + static assert(is(typeof(dochead_meta) == string[string][string])); + static assert(is(typeof(dochead_make) == string[string][string])); + } + } + body { + scope(exit) { + destroy(header); + destroy(dochead_meta); + destroy(dochead_make); + } + if (auto t = header.match(rgx.native_header_main)) { + char[][] header_obj_spl = + (cast(char[]) header).split(rgx.line_delimiter_ws_strip); + auto hm = to!string(t.captures[1]); + if (hm.match(rgx.main_headers)) { + foreach (line; header_obj_spl) { + if (auto m = line.match(rgx.native_header_main)) { + if (!empty(m.captures[2])) { + if (hm == "creator") { + dochead_meta[hm]["author"] = + to!string(m.captures[2]); + } else if (hm == "title") { + dochead_meta[hm]["main"] = + to!string(m.captures[2]); + } else if (hm == "publisher") { + dochead_meta[hm]["name"] = + to!string(m.captures[2]); + } + } + } else if (auto s = match(line, rgx.native_header_sub)) { + if (!empty(s.captures[2])) { + auto hs = to!string(s.captures[1]); + if ((hm == "make" ) + && (dochead_make[hm])) { + switch (hm) { + case "make": + if (hs.match(rgx.native_subhead_make)) { + if (dochead_make[hm][hs]) { + dochead_make[hm][hs] = to!string(s.captures[2]); + } + } else { + writeln("not a valid header type:", hm, ":", hs); + destroy(hm); + destroy(hs); + } + break; + default: + break; + } + } else if (dochead_meta[hm]) { + switch (hm) { + case "creator": + if (hs.match(rgx.native_subhead_creator)) { + if (dochead_meta[hm][hs]) { + dochead_meta[hm][hs] = + to!string(s.captures[2]); + } + } else { + writeln("not a valid header type:", hm, ":", hs); + destroy(hm); + destroy(hs); + } + break; + case "title": + if (hs.match(rgx.native_subhead_title)) { + if ((hs == "subtitle") + && (dochead_meta[hm]["sub"])) { + dochead_meta[hm]["sub"] = + to!string(s.captures[2]); + } else if (dochead_meta[hm][hs]) { + dochead_meta[hm][hs] = + to!string(s.captures[2]); + } + } else { + writeln("not a valid header type:", hm, ":", hs); + destroy(hm); + destroy(hs); + } + break; + case "rights": + if (hs.match(rgx.native_subhead_rights)) { + if (dochead_meta[hm][hs]) { + dochead_meta[hm][hs] = + to!string(s.captures[2]); + } + } else { + writeln("not a valid header type:", hm, ":", hs); + destroy(hm); + destroy(hs); + } + break; + case "date": + if (hs.match(rgx.native_subhead_date)) { + if (dochead_meta[hm][hs]) { + dochead_meta[hm][hs] = + to!string(s.captures[2]); + } + } else { + writeln("not a valid header type:", hm, ":", hs); + destroy(hm); + destroy(hs); + } + break; + case "original": + if (hs.match(rgx.native_subhead_original)) { + if (dochead_meta[hm][hs]) { + dochead_meta[hm][hs] = + to!string(s.captures[2]); + } + } else { + writeln("not a valid header type:", hm, ":", hs); + destroy(hm); + destroy(hs); + } + break; + case "classify": + if (hs.match(rgx.native_subhead_classify)) { + if (dochead_meta[hm][hs]) { + dochead_meta[hm][hs] = + to!string(s.captures[2]); + } + } else { + writeln("not a valid header type:", hm, ":", hs); + destroy(hm); + destroy(hs); + } + break; + case "identifier": + if (hs.match(rgx.native_subhead_identifier)) { + if (dochead_meta[hm][hs]) { + dochead_meta[hm][hs] = + to!string(s.captures[2]); + } + } else { + writeln("not a valid header type:", hm, ":", hs); + destroy(hm); + destroy(hs); + } + break; + case "notes": + if (hs.match(rgx.native_subhead_notes)) { + if (dochead_meta[hm][hs]) { + dochead_meta[hm][hs] = + to!string(s.captures[2]); + } + } else { + writeln("not a valid header type:", hm, ":", hs); + destroy(hm); + destroy(hs); + } + break; + case "publisher": + if (hs.match(rgx.native_subhead_publisher)) { + if (dochead_meta[hm][hs]) { + dochead_meta[hm][hs] = + to!string(s.captures[2]); + } + } else { + writeln("not a valid header type:", hm, ":", hs); + destroy(hm); + destroy(hs); + } + break; + case "links": + destroy(hm); + destroy(hs); + break; + default: + break; + } + } + } + } + } + } else { + writeln("not a valid header type:", hm); + } + } + auto t = tuple(dochead_meta, dochead_make); + static assert(t.length==2); + return t; + } + private auto native_header_extract(L,Lo,O,T)( + L line, + return ref Lo line_occur, + return ref O an_object, + return ref T type + ) { + debug(asserts){ + static assert(is(typeof(line) == char[])); + static assert(is(typeof(line_occur) == int[string])); + static assert(is(typeof(an_object) == string[string])); + static assert(is(typeof(type) == int[string])); + } + if (line.matchFirst(rgx.native_header_make)) { /+ matched header_make +/ + debug(header1) { /+ writeln(line); +/ } + type["header"] = State.on; + type["header_make"] = State.on; + type["header_meta"] = State.off; + ++line_occur["header_make"]; + an_object["body_nugget"] ~= line ~= "\n"; + } else if (line.matchFirst(rgx.native_header)) { /+ matched header_metadata +/ + /+ (generic header match and not previously caught by header_make) +/ + debug(header1) { /+ writeln(line); +/ } + type["header"] = State.on; + type["header_make"] = State.off; + type["header_meta"] = State.on; + ++line_occur["header_meta"]; + an_object["body_nugget"] ~= line ~= "\n"; + } else if (type["header_make"] == State.on + && (line_occur["header_make"] > State.off)) { /+ header_make flag set +/ + if (line.matchFirst(rgx.native_header_sub)) { /+ sub-header +/ + debug(header1) { /+ writeln(line); +/ } + ++line_occur["header_make"]; + an_object["body_nugget"] ~= line ~= "\n"; + } + } else if (type["header_meta"] == State.on + && (line_occur["header_meta"] > State.off)) { /+ header_metadata flag set +/ + if (line.matchFirst(rgx.native_header_sub)) { /+ sub-header +/ + debug(header1) { /+ writeln(line); +/ } + ++line_occur["header_meta"]; + an_object["body_nugget"] ~= line ~= "\n"; + } + } + return an_object; + } + auto header_reset_states_common(Lo,O,T)( + return ref Lo line_occur, + return ref O an_object, + return ref T type + ) { + debug(asserts){ + static assert(is(typeof(line_occur) == int[string])); + static assert(is(typeof(an_object) == string[string])); + static assert(is(typeof(type) == int[string])); + } + line_occur["header_make"] = State.off; + line_occur["header_meta"] = State.off; + type["header"] = State.off; + an_object.remove("body_nugget"); + an_object.remove("is"); + an_object.remove("attrib"); + } + private auto headerNativeToAA(Hn)(Hn src_header) { + debug(asserts){ + static assert(is(typeof(src_header) == char[])); + } + auto type = flags_type_init; + type = [ + "header" : State.off, + "header_make" : State.off, + "header_meta" : State.off, + ]; + string[string] an_object; + int[string] line_occur; + auto dochead_make = conf_aa_empty; + auto dochead_meta = meta_aa_empty; + auto set_header = HeaderDocMetadataAndMakeNativeToAA(); + char[][] source_header_arr = + (cast(char[]) src_header).split(rgx.newline_eol_delimiter); + foreach(header_line; source_header_arr) { + if (auto m = header_line.matchFirst(rgx.comment)) { + /+ matched comment +/ + debug(comment) { + } + header_reset_states_common(line_occur, an_object, type); + } else if ((header_line.matchFirst(rgx.native_header)) + || (type["header_make"] == State.on + && (line_occur["header_make"] > State.off)) + || (type["header_meta"] == State.on + && (line_occur["header_meta"] > State.off))) { + if (header_line.length == 0) { + /+ header_make instructions (current line empty) +/ + auto dochead_metadata_and_make = + set_header.header_metadata_and_make_aa(strip(an_object["body_nugget"]), dochead_meta, dochead_make); + static assert(!isTypeTuple!(dochead_metadata_and_make)); + dochead_meta = dochead_metadata_and_make[0]; + dochead_make = dochead_metadata_and_make[1]; + header_reset_states_common(line_occur, an_object, type); + type["header_make"] = State.off; + type["header_meta"] = State.off; + debug(headersdlang) { + writeln(dochead_metadata_and_make); + } + } else { + an_object = native_header_extract(header_line, line_occur, an_object, type); + } + } + } + auto t = tuple( + dochead_make, + dochead_meta, + ); + return t; + } + } +} -- cgit v1.2.3