aboutsummaryrefslogtreecommitdiffhomepage
path: root/src/doc_reform/io_in
diff options
context:
space:
mode:
Diffstat (limited to 'src/doc_reform/io_in')
-rw-r--r--src/doc_reform/io_in/paths_source.d842
-rw-r--r--src/doc_reform/io_in/read_config_files.d155
-rw-r--r--src/doc_reform/io_in/read_source_files.d348
3 files changed, 1345 insertions, 0 deletions
diff --git a/src/doc_reform/io_in/paths_source.d b/src/doc_reform/io_in/paths_source.d
new file mode 100644
index 0000000..fbb6d76
--- /dev/null
+++ b/src/doc_reform/io_in/paths_source.d
@@ -0,0 +1,842 @@
+/++
+ read configuration files<BR>
+ - read config files<BR>
+ meta_config_files.d
++/
+module doc_reform.io_in.paths_source;
+import std.array,
+ std.file,
+ std.path,
+ std.regex,
+ std.stdio,
+ std.conv : to;
+import
+ doc_reform.meta.defaults,
+ doc_reform.meta.rgx;
+template PodManifest() {
+ mixin spineRgxInit;
+ static auto rgx = Rgx();
+ auto PodManifest(P)(
+ P _pth=""
+ ) {
+ struct ManifestFile_ {
+ string pod_manifest_filename() {
+ return "pod.manifest";
+ }
+ string pod_manifest_path() {
+ string _manifest_path;
+ if ((isValidPath(_pth) && exists(_pth)!=0 && _pth.isDir)
+ && (exists(_pth.chainPath(pod_manifest_filename).array)!=0
+ && (_pth.chainPath(pod_manifest_filename).array).isFile)) {
+ _manifest_path = _pth;
+ } else if (_pth.match(rgx.src_pth_contents)
+ && exists(_pth)!=0 && _pth.isFile) {
+ _manifest_path = _pth.dirName;
+ } else if (_pth.match(rgx.src_pth_pod_sst_or_ssm)
+ && exists(_pth)!=0 && (_pth.isFile)) {
+ if (auto m = _pth.match(rgx.src_pth_pod_sst_or_ssm)) {
+ _manifest_path = m.captures["podpath"];
+ }
+ } else {
+ writeln("WARNING, issue with manifest_path: ", _pth);
+ _manifest_path = null; // _manifest_path = "";
+ }
+ return _manifest_path;
+ }
+ string pods_collection_root_path() {
+ return (pod_manifest_path.length > 0) ? ((chainPath(pod_manifest_path, "..")).asNormalizedPath).array.to!string : "";
+ }
+ string pod_manifest_file_with_path() {
+ string _k;
+ if (exists(pod_manifest_path.chainPath(pod_manifest_filename).array)!=0) {
+ _k = pod_manifest_path.chainPath(pod_manifest_filename).array;
+ } else if (exists(pod_manifest_path)!=0) {
+ _k = pod_manifest_path;
+ }
+ if (exists(_k)==0) {
+ writeln("ERROR >> Processing Skipped! Manifest not found: ", _k);
+ _k = null;
+ }
+ return _k;
+ }
+ }
+ return ManifestFile_();
+ }
+}
+template PathMatters() {
+ mixin spineRgxInit;
+ mixin InternalMarkup;
+ static auto rgx = Rgx();
+ static auto mkup = InlineMarkup();
+ auto PathMatters(O,E)(
+ O _opt_actions,
+ E _env,
+ string _pth,
+ string _fns = "",
+ char[][] _manifest_fn_list = [[]],
+ ) {
+ auto _manifested = PodManifest!()(_pth);
+ struct ManifestMatters_ {
+ auto env() {
+ auto _env = _env;
+ struct Env_ {
+ auto pwd() {
+ return _env["pwd"];
+ }
+ auto home() {
+ return _env["home"];
+ }
+ }
+ return Env_();
+ }
+ auto opt() {
+ struct Opt_ {
+ auto action() {
+ return _opt_actions;
+ }
+ }
+ return Opt_();
+ }
+ bool src_is_pod() {
+ return (_manifested.pod_manifest_path.length > 0) ? true : false;
+ }
+ auto pod() {
+ struct Pod_ {
+ bool src_is_pod() {
+ return (_manifested.pod_manifest_path.length > 0) ? true : false;
+ }
+ string collection_root() {
+ return _manifested.pods_collection_root_path;
+ }
+ string manifest_filename() {
+ return _manifested.pod_manifest_filename;
+ }
+ string manifest_path() {
+ return _manifested.pod_manifest_path;
+ }
+ string pod_name_with_path() {
+ return _manifested.pod_manifest_path.baseName;
+ }
+ string manifest_file_with_path() {
+ return _manifested.pod_manifest_file_with_path;
+ }
+ string[] config_dr_document_make_dirs() {
+ string[] _config_dirs;
+ return _config_dirs;
+ }
+ string[] config_local_site_dirs() {
+ string[] _config_dirs;
+ return _config_dirs;
+ }
+ string[] image_dirs() {
+ string[] _image_dirs;
+ return _image_dirs;
+ }
+ auto manifest_list_of_filenames() {
+ return _manifest_fn_list;
+ }
+ string[] manifest_list_of_languages() {
+ string[] _lngs;
+ foreach (filename_; manifest_list_of_filenames) {
+ string _k = "en";
+ if (auto m = (filename_).match(rgx.language_code_and_filename)) {
+ _k = m.captures[1].to!string;
+ }
+ _lngs ~= _k; // all the languages from the manifest list of filenames with paths
+ }
+ return _lngs;
+ }
+ }
+ return Pod_();
+ }
+ auto src() {
+ string _fns = _fns; // required here by dmd & not by ldc (for D:2078)
+ auto _opt_actions = _opt_actions;
+ auto _env = _env;
+ struct SRC_ {
+ bool is_pod() {
+ return (_manifested.pod_manifest_path.length > 0) ? true : false;
+ }
+ string path_and_fn() {
+ return _fns;
+ }
+ string pod_name_with_path() {
+ return (is_pod) ? _manifested.pod_manifest_path : "";
+ }
+ string pods_collection_root_path() {
+ return (is_pod) ? _manifested.pods_collection_root_path : "";
+ }
+ string pod_name() {
+ return pod_name_with_path.baseName;
+ }
+ string filename() {
+ return path_and_fn.baseName;
+ }
+ string filename_base() {
+ return filename.stripExtension;
+ }
+ string filename_extension() {
+ return filename.match(rgx.src_pth_sst_or_ssm).captures["extension"];
+ }
+ string lng() {
+ string _k;
+ if (auto m = path_and_fn.match(rgx.language_code_and_filename)) {
+ _k = m.captures[1];
+ } else {_k = "en"; }
+ return _k;
+ }
+ string doc_uid() {
+ string _uid;
+ if (is_pod && !(pod_name_with_path.empty)) {
+ if (pod_name_with_path.baseName == filename_base) {
+ _uid = filename_base ~ "." ~ filename_extension ~ mkup.sep ~ lng;
+ } else {
+ _uid = pod_name_with_path.baseName ~ mkup.sep ~ filename_base ~ "." ~ filename_extension ~ mkup.sep ~ lng;
+ }
+ } else {
+ _uid = mkup.sep ~ filename_base ~ "." ~ filename_extension ~ mkup.sep ~ lng;
+ }
+ return _uid;
+ }
+ string doc_uid_out() {
+ string _uid;
+ if (is_pod && !(pod_name_with_path.empty)) {
+ if (pod_name_with_path.baseName == filename_base) {
+ _uid = filename_base ~ "." ~ lng;
+ } else {
+ _uid = pod_name_with_path.baseName ~ mkup.sep ~ filename_base ~ "." ~ lng;
+ }
+ } else {
+ _uid = "_" ~ filename_base ~ "." ~ lng;
+ }
+ return _uid;
+ }
+ string docname_composite_unique_per_src_doc() {
+ string _fn;
+ if (pod_name_with_path.baseName == filename_base) {
+ _fn = filename_base ~ mkup.sep ~ filename_extension ~ mkup.sep ~ lng;
+ } else if (!(pod_name_with_path.empty)) {
+ _fn = pod_name_with_path.baseName ~ mkup.sep ~ filename_base ~ mkup.sep ~ filename_extension ~ mkup.sep ~ lng;
+ } else {
+ _fn = "_" ~ mkup.sep ~ filename_base ~ mkup.sep ~ filename_extension ~ mkup.sep ~ lng;
+ }
+ return _fn;
+ }
+ string docname_composite_unique_per_src_pod() {
+ /+
+ z pod name if any + src filename (without lng code)
+ filename ~ mkup.sep ~ lng
+ * unique per src pod
+ used by
+ - pod (multilingual collection)
+ - sqlite discrete index (multilingual collection)
+ +/
+ string _fn;
+ if (pod_name_with_path.baseName == filename_base) {
+ _fn = filename_base ~ mkup.sep ~ filename_extension;
+ } else if (!(pod_name_with_path.empty)) {
+ _fn = pod_name_with_path.baseName ~ mkup.sep ~ filename_base ~ mkup.sep ~ filename_extension;
+ } else {
+ _fn = "_" ~ mkup.sep ~ filename_base ~ mkup.sep ~ filename_extension;
+ }
+ return _fn;
+ }
+ string language() {
+ return lng();
+ }
+ string file_with_absolute_path() {
+ return _env["pwd"].chainPath(path_and_fn).array;
+ }
+ string absolute_path_to_src() {
+ return (_env["pwd"].chainPath(path_and_fn)).dirName.array;
+ }
+ string path_to_doc_root_path_to_lang_and_filename() {
+ return _env["pwd"].chainPath(path_and_fn).array;
+ }
+ string base_dir() {
+ string _dir;
+ if (
+ auto m = (absolute_path_to_src)
+ .match(regex(r"[/](?P<dir>(?:[a-zA-Z0-9._-]+))/pod/" ~ filename.stripExtension))
+ ) {
+ _dir = ((path_and_fn.chainPath("../../")).asNormalizedPath).array;
+ assert(_dir == m.captures["dir"]);
+ } else {
+ _dir = ((path_and_fn.chainPath("../../../")).asNormalizedPath).array;
+ assert(_dir == absolute_path_to_src
+ .match(rgx.src_base_parent_dir_name).captures["dir"]);
+ }
+ if (_opt_actions.debug_do) {
+ writeln("--> (base_dir) ", _dir);
+ }
+ return _dir;
+ }
+ string base_parent_dir_path() {
+ string _dir;
+ if (
+ auto m = (absolute_path_to_src)
+ .match(regex(r"[/](?P<dir>(?:[a-zA-Z0-9._-]+))/pod/" ~ filename.stripExtension))
+ ) {
+ _dir = ((path_and_fn.chainPath("../../")).asNormalizedPath).array;
+ } else {
+ _dir = ((path_and_fn.chainPath("../../../")).asNormalizedPath).array;
+ }
+ return _dir;
+ }
+ string base_dir_path() {
+ string _dir;
+ if (
+ auto m = (absolute_path_to_src)
+ .match(rgx.src_formalised_file_path_parts)
+ ) {
+ _dir = ((m.captures["pth"]).asNormalizedPath).array;
+ } else if (
+ auto m = (absolute_path_to_src)
+ .match(regex(r"[/](?P<dir>(?:[a-zA-Z0-9._-]+))/pod/" ~ filename.stripExtension))
+ ) {
+ _dir = ((path_and_fn.chainPath("../")).asNormalizedPath).array;
+ } else {
+ _dir = ((path_and_fn.chainPath("../../")).asNormalizedPath).array;
+ }
+ if (_opt_actions.debug_do) {
+ writeln("--> (base_dir_path) ", _dir);
+ }
+ return _dir;
+ }
+ string media_dir_path() {
+ string _dir = ((base_dir_path.chainPath("media")).asNormalizedPath).array;
+ return _dir;
+ }
+ string image_dir_path() {
+ string _paths;
+ string[] _possible_img_pths = [ "./image", "../image", "../../image" ];
+ string _img_pth_found = "";
+ if (is_pod) {
+ _img_pth_found = ((file_with_absolute_path.dirName ~ "/../../image").asNormalizedPath).array;
+ } else {
+ string _img_pth(string _possible_img_pth) {
+ return ((file_with_absolute_path.dirName ~ "/" ~ _possible_img_pth).asNormalizedPath).array;
+ }
+ foreach(_possible_img_pth; _possible_img_pths) {
+ if (exists(_img_pth(_possible_img_pth))) {
+ _img_pth_found = _img_pth(_possible_img_pth);
+ break;
+ } else {
+ _paths ~= " " ~ _img_pth(_possible_img_pth);
+ }
+ }
+ }
+ if (_img_pth_found.empty) {
+ writeln("WARNING not image path found, searched: ", _paths);
+ }
+ return _img_pth_found;
+ }
+ auto conf_dir_path() {
+ return ((base_dir_path.chainPath("conf")).asNormalizedPath).array;
+ }
+ auto base_parent_dir() {
+ string _dir;
+ if (
+ auto m = (absolute_path_to_src)
+ .match(regex(r"[/](?P<dir>(?:[a-zA-Z0-9._-]+))/pod/" ~ filename.stripExtension))
+ ) {
+ _dir = m.captures["dir"];
+ } else {
+ _dir = (absolute_path_to_src).match(rgx.src_base_parent_dir_name).captures["dir"];
+ }
+ if (_opt_actions.debug_do) {
+ writeln("--> (base_parent_dir) ", _dir);
+ }
+ return _dir;
+ }
+ string[] config_dirs() {
+ string[] _config_dirs;
+ if (is_pod) {
+ } else {}
+ return _config_dirs;
+ }
+ string[] image_dirs() {
+ string[] _image_dirs;
+ if (is_pod) {
+ } else {}
+ return _image_dirs;
+ }
+ }
+ return SRC_();
+ }
+ auto output() {
+ /+
+ - command line if output path set
+ - config file if found and set set
+ - search for and if exists read config
+ - default paths to config related to:
+ - source markup path;
+ - current dir;
+ - home dir
+ - get output path if set
+ - (program) default within current directory?
+ +/
+ auto _env = _env;
+ struct Out_ {
+ auto path() {
+ auto _output_path = _env["pwd"];
+ if ((_opt_actions.output_dir_set.length > 0)
+ && isValidPath(_opt_actions.output_dir_set)
+ ) {
+ _output_path = ((_opt_actions.output_dir_set).asNormalizedPath).array;
+ if (!exists(_output_path)) {
+ try {
+ _output_path.mkdirRecurse;
+ // } catch (ErrnoException ex) {
+ } catch (Exception ex) {
+ // Handle error
+ }
+ }
+ assert(_output_path.isDir,
+ "not a directory: " ~ _output_path);
+ // TODO always test that is a directory and it is writable
+ }
+ return _output_path;
+ }
+ }
+ return Out_();
+ }
+ }
+ return ManifestMatters_();
+ }
+}
+template ConfigFilePaths() {
+ mixin spineRgxInit;
+ static auto rgx = Rgx();
+ auto ConfigFilePaths(M,E)(
+ M _manifested,
+ E _env,
+ string _cli_config_path_set = ""
+ ) {
+ struct ConfFilePaths {
+ string config_filename_document() {
+ return "dr_document_make";
+ }
+ string config_filename_site() {
+ return "config_local_site";
+ }
+ auto possible_config_path_locations() {
+ struct _ConfFilePaths {
+ string[] dr_document_make() {
+ /+ FIX clean up conf paths ↓ +/
+ /+ config local site (file system only, not in pod) +/
+ /+ return paths +/
+ string[] _possible_config_path_locations;
+ if (_cli_config_path_set.empty) {
+ if (_manifested.src.is_pod) {
+ /+ config document in pod +/
+ string _dr_doc_conf_pod;
+ string _dr_doc_conf_pod_text;
+ _dr_doc_conf_pod = asNormalizedPath(chainPath(
+ to!string(_env["pwd"]),
+ _manifested.pod.manifest_path ~ "/conf"
+ )).array;
+ _dr_doc_conf_pod_text = asNormalizedPath(chainPath(
+ to!string(_env["pwd"]),
+ _manifested.pod.manifest_path ~ "/media/text/" ~ _manifested.src.lng ~ "/conf"
+ )).array;
+ /+ return paths +/
+ _possible_config_path_locations = [
+ _dr_doc_conf_pod_text,
+ _dr_doc_conf_pod,
+ ];
+ } else {
+ /+ config document (& or local site) on filesystem +/
+ string _dr_doc_conf_pwd = ((chainPath(to!string(_env["pwd"]), "dr_doc/conf")).asNormalizedPath).array; // think about
+ string _dr_doc_conf_pwd_a = ((chainPath(to!string(_env["pwd"]), "conf")).asNormalizedPath).array;
+ string _dr_doc_conf_pwd_b = ((chainPath(to!string(_env["pwd"]), "../conf")).asNormalizedPath).array;
+ string _dr_doc_conf_pwd_c = ((chainPath(to!string(_env["pwd"]), "../../conf")).asNormalizedPath).array;
+ string _dr_doc_conf_pwd_d = ((chainPath(to!string(_env["pwd"]), "../../../conf")).asNormalizedPath).array;
+ /+ return paths +/
+ _possible_config_path_locations = [
+ _dr_doc_conf_pwd,
+ _dr_doc_conf_pwd_a,
+ _dr_doc_conf_pwd_b,
+ _dr_doc_conf_pwd_c,
+ _dr_doc_conf_pwd_d,
+ ];
+ }
+ } else {
+ _possible_config_path_locations = [
+ _cli_config_path_set
+ ];
+ }
+ /+ FIX clean up conf paths ↑
+ (compare pwd to doc path location, and build config path)
+ +/
+ return _possible_config_path_locations;
+ }
+ string[] config_local_site() {
+ /+ FIX clean up conf paths ↓ +/
+ /+ config local site (file system only, not in pod) +/
+ string[] _possible_config_path_locations;
+ if (_cli_config_path_set.empty) {
+ string _dot_pwd = ((chainPath(to!string(_env["pwd"]), ".dr")).asNormalizedPath).array;
+ string _underscore_pwd = ((chainPath(to!string(_env["pwd"]), "_dr")).asNormalizedPath).array;
+ string _dot_home = ((chainPath(to!string(_env["home"]), ".dr")).asNormalizedPath).array;
+ /+ return paths +/
+ if (_manifested.src.is_pod) {
+ string _collection_root_a = ((chainPath(to!string(_manifested.pod.collection_root.to!string), ".dr")).asNormalizedPath).array;
+ string _collection_root_b = ((chainPath(to!string(_manifested.pod.collection_root.to!string), "_dr")).asNormalizedPath).array;
+ _possible_config_path_locations = [
+ _dot_pwd,
+ _underscore_pwd,
+ _dot_home,
+ "/etc/dr",
+ _collection_root_a, // set priority higher?
+ _collection_root_b // set priority higher?
+ ];
+ } else {
+ /+ config document (& or local site) on filesystem +/
+ string _dr_doc_conf_pwd = ((chainPath(to!string(_env["pwd"]), "dr_doc/conf")).asNormalizedPath).array;
+ string _dr_doc_conf_pwd_a = ((chainPath(to!string(_env["pwd"]), "conf")).asNormalizedPath).array;
+ string _dr_doc_conf_pwd_b = ((chainPath(to!string(_env["pwd"]), "../conf")).asNormalizedPath).array;
+ string _dr_doc_conf_pwd_c = ((chainPath(to!string(_env["pwd"]), "../../conf")).asNormalizedPath).array;
+ string _dr_doc_conf_pwd_d = ((chainPath(to!string(_env["pwd"]), "../../../conf")).asNormalizedPath).array;
+ _possible_config_path_locations = [
+ _dr_doc_conf_pwd,
+ _dr_doc_conf_pwd_a,
+ _dr_doc_conf_pwd_b,
+ _dr_doc_conf_pwd_c,
+ _dr_doc_conf_pwd_d,
+ _dot_pwd,
+ _underscore_pwd,
+ _dot_home,
+ "/etc/dr"
+ ];
+ }
+ } else {
+ _possible_config_path_locations = [
+ _cli_config_path_set
+ ];
+ }
+ /+ FIX clean up conf paths ↑
+ (compare pwd to doc path location, and build config path)
+ +/
+ return _possible_config_path_locations;
+ }
+ }
+ return _ConfFilePaths();
+ }
+ }
+ return ConfFilePaths();
+ }
+}
+template spinePathsSRC() {
+ mixin spineRgxInit;
+ static auto rgx = Rgx();
+ auto spinePathsSRC(D,Fn)(
+ D _pwd,
+ Fn _fn_src_and_path,
+ ) {
+ struct drSrcPaths {
+ auto pwd() {
+ return _pwd;
+ }
+ string language() {
+ // use command line info as well?
+ string _k;
+ if (auto m = _fn_src_and_path.match(rgx.language_code_and_filename)) {
+ _k = m.captures[1];
+ } else { /+ unknown until doc_meta read, (could provide & use command line info?) +/
+ _k = "xx"; // original default was "en" but is not known
+ }
+ return _k;
+ }
+ string doc_root() {
+ return "dr_doc";
+ }
+ auto media_root() {
+ return ((doc_root.chainPath("media")).asNormalizedPath).array;
+ }
+ auto conf_root() {
+ return ((doc_root.chainPath("conf")).asNormalizedPath).array;
+ }
+ auto text_root() {
+ return ((media_root.chainPath("text")).asNormalizedPath).array;
+ }
+ auto image_root() {
+ return ((media_root.chainPath("image")).asNormalizedPath).array;
+ }
+ auto doc_src_fn_with_path_for_text_root_and_lng() {
+ return ((text_root.chainPath(language)).asNormalizedPath).array;
+ }
+ auto doc_src_fn() {
+ return ((_fn_src_and_path.baseName).asNormalizedPath).array;
+ }
+ auto doc_src_with_path() {
+ return ((pwd.chainPath(_fn_src_and_path)).asNormalizedPath).array;
+ }
+ }
+ return drSrcPaths();
+ }
+}
+
+
+template spinePathsPods() {
+ mixin spineRgxInit;
+ static auto rgx = Rgx();
+ string _suffix = ".zip";
+ auto spinePathsPods(M)(M doc_matters) {
+ string _base_dir_pod = (doc_matters.output_path.length > 0)
+ ? doc_matters.output_path ~ "/pod"
+ : "/pod";
+ string _base_dir_doc = "dr_doc";
+ struct _PodPaths {
+ string base_filename_(string fn_src) {
+ auto pth = fn_src.baseName.stripExtension;
+ return pth;
+ }
+ string pod_dir_() {
+ auto pth = _base_dir_pod;
+ return pth;
+ }
+ string dr_doc_dir_() {
+ auto pth = _base_dir_doc;
+ return pth;
+ }
+ string pod_filename_(string fn_src) {
+ string pth = _base_dir_pod.chainPath(base_filename_(fn_src) ~ _suffix).array;
+ return pth;
+ }
+ string base_filesystem_(string fn_src) {
+ string pth = _base_dir_pod.chainPath(base_filename_(fn_src)).array;
+ assert(pth == _base_dir_pod ~ "/" ~ base_filename_(fn_src),
+ pth ~ " == " ~ _base_dir_pod ~ "/" ~ base_filename_(fn_src) ~ "?");
+ return pth;
+ }
+ string output_pod_manifest_file(string fn_src) {
+ string pth = base_filesystem_(fn_src).chainPath("pod.manifest").array;
+ return pth;
+ }
+ string base_pod_(string fn_src) {
+ string pth = _base_dir_pod.chainPath(base_filename_(fn_src)).array; // change this
+ return pth;
+ }
+ auto base_filename(string fn_src) {
+ auto pth_1_ = base_filename_(fn_src);
+ auto pth_2_ = base_filename_(fn_src);
+ struct _pods {
+ auto zpod() {
+ return pth_1_;
+ }
+ auto filesystem_open_zpod() {
+ return pth_2_;
+ }
+ }
+ return _pods();
+ }
+ auto pod_filename(string fn_src) {
+ auto pth_1_ = pod_filename_(fn_src);
+ auto pth_2_ = pod_filename_(fn_src);
+ struct _pods {
+ auto zpod() {
+ return pth_1_;
+ }
+ auto filesystem_open_zpod() {
+ return pth_2_;
+ }
+ }
+ return _pods();
+ }
+ auto base(string fn_src) {
+ auto pth_1_ = "";
+ auto pth_2_ = base_filesystem_(fn_src);
+ struct _pods {
+ auto zpod() {
+ return pth_1_;
+ }
+ auto filesystem_open_zpod() {
+ return pth_2_;
+ }
+ }
+ return _pods();
+ }
+ auto pod_root(string fn_src) {
+ auto pth_1_ = "pod";
+ auto pth_2_ = ((base(fn_src).filesystem_open_zpod.chainPath("")).asNormalizedPath).array; // "dr_doc"
+ struct _pods {
+ auto zpod() {
+ return pth_1_;
+ }
+ auto filesystem_open_zpod() {
+ return pth_2_;
+ }
+ }
+ return _pods();
+ }
+ auto conf_root(string fn_src) {
+ auto pod_root_ = pod_root(fn_src);
+ auto pth_1_ = "conf";
+ auto pth_2_ = ((pod_root(fn_src).filesystem_open_zpod.chainPath("conf")).asNormalizedPath).array;
+ struct _pods {
+ auto zpod() {
+ return pth_1_;
+ }
+ auto filesystem_open_zpod() {
+ assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
+ return pth_2_;
+ }
+ }
+ return _pods();
+ }
+ auto css(string fn_src) {
+ auto pod_root_ = pod_root(fn_src);
+ auto pth_1_ = ((conf_root(fn_src).zpod.chainPath("css")).asNormalizedPath).array;
+ auto pth_2_ = ((conf_root(fn_src).filesystem_open_zpod.chainPath("css")).asNormalizedPath).array;
+ struct _pods {
+ auto zpod() {
+ return pth_1_;
+ }
+ auto filesystem_open_zpod() {
+ assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
+ return pth_2_;
+ }
+ }
+ return _pods();
+ }
+ auto pod_manifest(string fn_src) {
+ auto pod_root_ = pod_root(fn_src);
+ auto pth_1_ = ((pod_root(fn_src).zpod.chainPath("pod.manifest")).asNormalizedPath).array;
+ auto pth_2_ = ((pod_root(fn_src).filesystem_open_zpod.chainPath("pod.manifest")).asNormalizedPath).array;
+ struct _pods {
+ auto zpod() {
+ return pth_1_;
+ }
+ auto filesystem_open_zpod() {
+ assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
+ return pth_2_;
+ }
+ }
+ return _pods();
+ }
+ auto media_root(string fn_src) {
+ auto pod_root_ = pod_root(fn_src);
+ auto pth_1_ = ((pod_root(fn_src).zpod.chainPath("media")).asNormalizedPath).array;
+ auto pth_2_ = ((pod_root(fn_src).filesystem_open_zpod.chainPath("media")).asNormalizedPath).array;
+ struct _pods {
+ auto zpod() {
+ return pth_1_;
+ }
+ auto filesystem_open_zpod() {
+ assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
+ return pth_2_;
+ }
+ }
+ return _pods();
+ }
+ auto text_root(string fn_src) {
+ auto pod_root_ = pod_root(fn_src);
+ auto pth_1_ = ((media_root(fn_src).zpod.chainPath("text")).asNormalizedPath).array;
+ auto pth_2_ = ((media_root(fn_src).filesystem_open_zpod.chainPath("text")).asNormalizedPath).array;
+ struct _pods {
+ auto zpod() {
+ return pth_1_;
+ }
+ auto filesystem_open_zpod() {
+ assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
+ return pth_2_;
+ }
+ }
+ return _pods();
+ }
+ auto doc(string fn_src) {
+ auto pod_root_ = pod_root(fn_src);
+ auto pth_1_ = text_root(fn_src).zpod;
+ auto pth_2_ = text_root(fn_src).filesystem_open_zpod;
+ struct _pods {
+ auto zpod() {
+ return pth_1_;
+ }
+ auto filesystem_open_zpod() {
+ assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
+ return pth_2_;
+ }
+ }
+ return _pods();
+ }
+ auto doc_lng(string fn_src, string lng) {
+ auto pod_root_ = pod_root(fn_src);
+ auto pth_1_ = ((text_root(fn_src).zpod.chainPath(lng)).asNormalizedPath).array;
+ auto pth_2_ = ((text_root(fn_src).filesystem_open_zpod.chainPath(lng)).asNormalizedPath).array;
+ struct _pods {
+ auto zpod() {
+ return pth_1_;
+ }
+ auto filesystem_open_zpod() {
+ assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
+ return pth_2_;
+ }
+ }
+ return _pods();
+ }
+ auto image_root(string fn_src) {
+ auto pod_root_ = pod_root(fn_src);
+ auto pth_1_ = ((media_root(fn_src).zpod.chainPath("image")).asNormalizedPath).array;
+ auto pth_2_ = ((media_root(fn_src).filesystem_open_zpod.chainPath("image")).asNormalizedPath).array;
+ struct _pods {
+ auto zpod() {
+ return pth_1_;
+ }
+ auto filesystem_open_zpod() {
+ assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
+ return pth_2_;
+ }
+ }
+ return _pods();
+ }
+ auto fn_pod_filelist(string fn_src) {
+ auto pod_root_ = pod_root(fn_src);
+ auto _manifested = PodManifest!()(fn_src).pod_manifest_filename;
+ auto pth_1_ = _manifested;
+ auto pth_2_ = ((pod_root(fn_src).filesystem_open_zpod.chainPath(_manifested)).asNormalizedPath).array;
+ struct _pods {
+ auto zpod() {
+ return pth_1_;
+ }
+ auto filesystem_open_zpod() {
+ assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
+ return pth_2_;
+ }
+ }
+ return _pods();
+ }
+ auto fn_doc(string fn_src, string lng) {
+ auto pod_root_ = pod_root(fn_src);
+ auto pth_1_ = ((doc_lng(fn_src, lng).zpod.chainPath(fn_src.baseName)).asNormalizedPath).array;
+ auto pth_2_ = ((doc_lng(fn_src, lng).filesystem_open_zpod.chainPath(fn_src.baseName)).asNormalizedPath).array;
+ struct _pods {
+ auto zpod() {
+ return pth_1_;
+ }
+ auto filesystem_open_zpod() {
+ assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
+ return pth_2_;
+ }
+ }
+ return _pods();
+ }
+ auto fn_doc_insert(string fn_src, string fn_insert, string lng) {
+ auto pod_root_ = pod_root(fn_src);
+ auto pth_1_ = ((doc_lng(fn_src, lng).zpod.chainPath(fn_insert.baseName)).asNormalizedPath).array;
+ auto pth_2_ = ((doc_lng(fn_src, lng).filesystem_open_zpod.chainPath(fn_insert.baseName)).asNormalizedPath).array;
+ struct _pods {
+ auto zpod() {
+ return pth_1_;
+ }
+ auto filesystem_open_zpod() {
+ assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
+ return pth_2_;
+ }
+ }
+ return _pods();
+ }
+ }
+ return _PodPaths();
+ }
+}
diff --git a/src/doc_reform/io_in/read_config_files.d b/src/doc_reform/io_in/read_config_files.d
new file mode 100644
index 0000000..c0893de
--- /dev/null
+++ b/src/doc_reform/io_in/read_config_files.d
@@ -0,0 +1,155 @@
+/++
+ read configuration files<BR>
+ - read config files<BR>
+ meta_config_files.d
++/
+module doc_reform.io_in.read_config_files;
+
+static template readConfigSite() {
+ import
+ doc_reform.meta.rgx;
+ import
+ doc_reform.meta,
+ doc_reform.io_in.paths_source,
+ std.file,
+ std.path;
+ mixin spineRgxInit;
+ final auto readConfigSite(M,E)(
+ M _manifested,
+ E _env,
+ string _cli_config_path_set = ""
+ ) {
+ static auto rgx = Rgx();
+ string config_file_str;
+ string conf_filename = "NONE";
+ auto _conf_file_details = ConfigFilePaths!()(_manifested, _env, _cli_config_path_set);
+ string[] possible_config_path_locations = _conf_file_details.possible_config_path_locations.config_local_site;
+ foreach(conf_fn; [_conf_file_details.config_filename_site]) {
+ foreach(pth; possible_config_path_locations) {
+ char[] conf_file;
+ conf_filename = conf_fn;
+ if (exists(pth)) {
+ auto f_attrib = pth.getLinkAttributes;
+ if (
+ possible_config_path_locations.length == 1
+ && f_attrib.attrIsFile
+ ) {
+ conf_file = pth.to!(char[]);
+ conf_filename = pth.baseName;
+ } else if (f_attrib.attrIsDir) {
+ conf_file = ((chainPath(pth.to!string, conf_fn)).asNormalizedPath).array;
+ conf_filename = conf_fn;
+ }
+ try {
+ if (exists(conf_file)) {
+ if (conf_file.getLinkAttributes.attrIsFile) {
+ config_file_str = conf_file.readText;
+ break;
+ }
+ }
+ } catch (ErrnoException ex) {
+ } catch (FileException ex) {
+ }
+ }
+ }
+ if (config_file_str.length > 0) { break; }
+ }
+ struct _ConfContent {
+ string filename() {
+ return conf_filename;
+ }
+ string filetype() {
+ string _ft = "";
+ if (content.match(rgx.yaml_config)) {
+ _ft = "yaml";
+ }
+ return _ft;
+ }
+ string content() {
+ return config_file_str;
+ }
+ }
+ return _ConfContent();
+ }
+}
+static template readConfigDoc() {
+ import
+ doc_reform.meta.rgx;
+ import
+ doc_reform.meta,
+ doc_reform.io_in.paths_source,
+ std.file,
+ std.path;
+ mixin spineRgxInit;
+ final auto readConfigDoc(M,E)(M _manifested, E _env) {
+ static auto rgx = Rgx();
+ string config_file_str;
+ string conf_filename = "NONE";
+ auto _conf_file_details = ConfigFilePaths!()(_manifested, _env);
+ string[] possible_config_path_locations = _conf_file_details.possible_config_path_locations.dr_document_make;
+ foreach(conf_fn; [_conf_file_details.config_filename_document]) {
+ foreach(pth; possible_config_path_locations) {
+ auto conf_file = ((chainPath(pth.to!string, conf_fn)).asNormalizedPath).array;
+ conf_filename = conf_fn;
+ if (config_file_str.length > 0) {
+ break;
+ }
+ try {
+ if (exists(conf_file)) {
+ if (conf_file.getLinkAttributes.attrIsFile) {
+ config_file_str = conf_file.readText;
+ break;
+ }
+ }
+ } catch (ErrnoException ex) {
+ } catch (FileException ex) {
+ }
+ }
+ if (config_file_str.length > 0) { break; }
+ }
+ struct _ConfContent {
+ string filename() {
+ return conf_filename;
+ }
+ string content() {
+ return config_file_str;
+ }
+ string filetype() {
+ string _ft = "";
+ if (content.match(rgx.yaml_config)) {
+ _ft = "yaml";
+ }
+ return _ft;
+ }
+ }
+ return _ConfContent();
+ }
+}
+static template configReadSiteYAML() {
+ import
+ doc_reform.meta,
+ doc_reform.io_in.paths_source,
+ std.file,
+ std.path;
+ final YAMLDocument configReadSiteYAML(M,E)(M _manifested, E _env) {
+ string _configuration = configReadInSiteYAML!()(_manifested, _env);
+ auto _conf_file_details = ConfigFilePaths!()(_manifested, _env);
+ string _conf_yaml_fn = _conf_file_details.config_filename_site;
+ YAMLDocument _yaml_conf = configYAML!()(_configuration, _conf_yaml_fn);
+ return _yaml_conf;
+ }
+}
+static template configReadDocYAML() {
+ import
+ doc_reform.meta,
+ doc_reform.io_in.paths_source,
+ std.file,
+ std.path;
+ final YAMLDocument configReadDocYAML(M,E)(M _manifested, E _env) {
+ string _configuration = configReadInDocYAML!()(_manifested, _env);
+ auto _conf_file_details = ConfigFilePaths!()(_manifested, _env);
+ string _conf_yaml_fn = _conf_file_details.config_filename_document;
+ YAMLDocument _yaml_conf = configYAML!()(_configuration, _conf_yaml_fn);
+ return _yaml_conf;
+ }
+}
diff --git a/src/doc_reform/io_in/read_source_files.d b/src/doc_reform/io_in/read_source_files.d
new file mode 100644
index 0000000..e443b01
--- /dev/null
+++ b/src/doc_reform/io_in/read_source_files.d
@@ -0,0 +1,348 @@
+/++
+ module source_read_source_files;<BR>
+ - open markup files<BR>
+ - if master file scan for addional files to import/insert
++/
+module doc_reform.io_in.read_source_files;
+static template spineRawMarkupContent() {
+ import
+ doc_reform.meta.rgx;
+ import
+ doc_reform.meta,
+ doc_reform.io_in.paths_source,
+ std.file,
+ std.path;
+ mixin spineRgxInit;
+ static auto rgx = Rgx();
+ string[] _images=[];
+ auto _extract_images(S)(S content_block) {
+ string[] images_;
+ string _content_block = content_block.to!string;
+ if (auto m = _content_block.matchAll(rgx.image)) {
+ images_ ~= m.captures[1].to!string;
+ }
+ return images_;
+ }
+ auto rawsrc = RawMarkupContent();
+ auto spineRawMarkupContent(O,Fn)(O _opt_action, Fn fn_src) {
+ auto _0_header_1_body_content_2_insert_filelist_tuple
+ = rawsrc.sourceContentSplitIntoHeaderAndBody(_opt_action, rawsrc.sourceContent(fn_src), fn_src);
+ return _0_header_1_body_content_2_insert_filelist_tuple;
+ }
+ struct RawMarkupContent {
+ final sourceContent(in string fn_src) {
+ auto raw = MarkupRawUnit();
+ auto source_txt_str
+ = raw.markupSourceReadIn(fn_src);
+ return source_txt_str;
+ }
+ final auto sourceContentSplitIntoHeaderAndBody(O)(O _opt_action, in string source_txt_str, in string fn_src="") {
+ auto raw = MarkupRawUnit();
+ string[] insert_file_list;
+ string[] images_list;
+ auto t
+ = raw.markupSourceHeaderContentRawLineTupleArray(source_txt_str);
+ auto header_raw = t[0];
+ auto sourcefile_body_content = t[1];
+ if (fn_src.match(rgx.src_fn_master)) { // filename with path needed if master file (.ssm) not otherwise
+ auto ins = Inserts();
+ auto tu
+ = ins.scan_master_src_for_insert_files_and_import_content(_opt_action, sourcefile_body_content, fn_src);
+ static assert(!isTypeTuple!(tu));
+ sourcefile_body_content = tu[0];
+ insert_file_list = tu[1].dup;
+ images_list = tu[2].dup;
+ } else if (_opt_action.source || _opt_action.pod) {
+ auto ins = Inserts();
+ auto tu
+ = ins.scan_master_src_for_insert_files_and_import_content(_opt_action, sourcefile_body_content, fn_src);
+ static assert(!isTypeTuple!(tu));
+ images_list = tu[2].dup;
+ }
+ string header_type = "";
+ if (header_raw.match(rgx.yaml_config)) {
+ header_type = "yaml";
+ }
+ t = tuple(
+ header_raw,
+ sourcefile_body_content,
+ header_type,
+ insert_file_list,
+ images_list
+ );
+ static assert(t.length==5);
+ return t;
+ }
+ }
+ struct MarkupRawUnit {
+ import std.file;
+ final private string readInMarkupSource(in char[] fn_src) {
+ enforce(
+ exists(fn_src)!=0,
+ "file not found: «" ~
+ fn_src ~ "»"
+ );
+ string source_txt_str;
+ try {
+ if (exists(fn_src)) {
+ if (fn_src.getLinkAttributes.attrIsFile) {
+ source_txt_str = fn_src.readText;
+ } else {
+ }
+ }
+ } catch (ErrnoException ex) {
+ } catch (UTFException ex) {
+ // Handle validation errors
+ } catch (FileException ex) {
+ // Handle errors
+ }
+ std.utf.validate(source_txt_str);
+ return source_txt_str;
+ }
+ final private char[][] header0Content1(in string src_text) {
+ /+ split string on _first_ match of "^:?A~\s" into [header, content] array/tuple +/
+ char[][] header_and_content;
+ auto m = (cast(char[]) src_text).matchFirst(rgx.heading_a);
+ header_and_content ~= m.pre;
+ header_and_content ~= m.hit ~ m.post;
+ assert(header_and_content.length == 2,
+ "document markup is broken, header body split == "
+ ~ header_and_content.length.to!string
+ ~ "; (header / body array split should == 2 (split is on level A~))"
+ );
+ return header_and_content;
+ }
+ final private char[][] markupSourceLineArray(in char[] src_text) {
+ char[][] source_line_arr
+ = (cast(char[]) src_text).split(rgx.newline_eol_strip_preceding);
+ return source_line_arr;
+ }
+ auto markupSourceReadIn(in string fn_src) {
+ static auto rgx = Rgx();
+ enforce(
+ fn_src.match(rgx.src_pth_sst_or_ssm),
+ "not a dr markup filename: «" ~
+ fn_src ~ "»"
+ );
+ auto source_txt_str = readInMarkupSource(fn_src);
+ return source_txt_str;
+ }
+ auto markupSourceHeaderContentRawLineTupleArray(in string source_txt_str) {
+ string[] file_insert_list = [];
+ string[] images_list = [];
+ char[][] hc = header0Content1(source_txt_str);
+ char[] header = hc[0];
+ char[] source_txt = hc[1];
+ auto source_line_arr = markupSourceLineArray(source_txt);
+ string header_type = "";
+ if (header.match(rgx.yaml_config)) {
+ header_type = "yaml";
+ }
+ auto t = tuple(
+ header,
+ source_line_arr,
+ header_type,
+ file_insert_list,
+ images_list
+ );
+ return t;
+ }
+ final char[][] getInsertMarkupSourceContentRawLineArray(
+ in char[] fn_src_insert,
+ Regex!(char) rgx_file
+ ) {
+ enforce(
+ fn_src_insert.match(rgx_file),
+ "not a dr markup filename: «" ~
+ fn_src_insert ~ "»"
+ );
+ auto source_txt_str = readInMarkupSource(fn_src_insert);
+ auto source_line_arr = markupSourceLineArray(source_txt_str);
+ return source_line_arr;
+ }
+ }
+ struct Inserts {
+ auto scan_subdoc_source(O)(
+ O _opt_action,
+ char[][] markup_sourcefile_insert_content,
+ string fn_src
+ ) {
+ mixin spineRgxInitFlags;
+ char[][] contents_insert;
+ int[string] type1 = flags_type_init;
+ auto fn_pth_full = fn_src.match(rgx.src_pth_sst_or_ssm);
+ auto markup_src_file_path = fn_pth_full.captures[1];
+ foreach (line; markup_sourcefile_insert_content) {
+ if (type1["curly_code"] == 1) {
+ type1["header_make"] = 0;
+ type1["header_meta"] = 0;
+ if (line.matchFirst(rgx.block_curly_code_close)) {
+ type1["curly_code"] = 0;
+ }
+ contents_insert ~= line;
+ } else if (line.matchFirst(rgx.block_curly_code_open)) {
+ type1["curly_code"] = 1;
+ type1["header_make"] = 0;
+ type1["header_meta"] = 0;
+ contents_insert ~= line;
+ } else if (type1["tic_code"] == 1) {
+ type1["header_make"] = 0;
+ type1["header_meta"] = 0;
+ if (line.matchFirst(rgx.block_tic_close)) {
+ type1["tic_code"] = 0;
+ }
+ contents_insert ~= line;
+ } else if (line.matchFirst(rgx.block_tic_code_open)) {
+ type1["tic_code"] = 1;
+ type1["header_make"] = 0;
+ type1["header_meta"] = 0;
+ contents_insert ~= line;
+ } else if (auto m = line.match(rgx.insert_src_fn_ssi_or_sst)) {
+ type1["header_make"] = 0;
+ type1["header_meta"] = 0;
+ auto insert_fn = m.captures[2];
+ auto insert_sub_pth = m.captures[1];
+ auto fn_src_insert
+ = chainPath(markup_src_file_path, insert_sub_pth ~ insert_fn).array;
+ auto raw = MarkupRawUnit();
+ auto markup_sourcesubfile_insert_content
+ = raw.getInsertMarkupSourceContentRawLineArray(fn_src_insert, rgx.src_fn_find_inserts);
+ debug(insert_file) {
+ writeln(line);
+ writeln(fn_src_insert);
+ writeln(
+ " length contents insert array: ",
+ markup_sourcesubfile_insert_content.length
+ );
+ }
+ if (_opt_action.source || _opt_action.pod) {
+ _images ~= _extract_images(markup_sourcesubfile_insert_content);
+ }
+ auto ins = Inserts();
+ /+
+ - 1. load file
+ - 2. read lines
+ - 3. scan lines
+ - a. if filename insert, and insert filename
+ - repeat 1
+ - b. else
+ - add line to new array;
+ - build image list, search for any image files to add to image list
+ +/
+ } else {
+ type1["header_make"] = 0;
+ type1["header_meta"] = 0;
+ contents_insert ~= line; // images to extract for image list?
+ if (_opt_action.source || _opt_action.pod) {
+ auto _image_linelist = _extract_images(line);
+ if (_image_linelist.length > 0) {
+ _images ~= _image_linelist;
+ }
+ }
+ }
+ } // end src subdoc (inserts) loop
+ auto t = tuple(
+ contents_insert,
+ _images
+ );
+ return t;
+ }
+ auto scan_master_src_for_insert_files_and_import_content(O)(
+ O _opt_action,
+ char[][] sourcefile_body_content,
+ string fn_src
+ ) {
+ import std.algorithm;
+ mixin spineRgxInitFlags;
+ char[][] contents;
+ int[string] type = flags_type_init;
+ auto fn_pth_full = fn_src.match(rgx.src_pth_sst_or_ssm);
+ auto markup_src_file_path = fn_pth_full.captures[1];
+ char[][] contents_insert;
+ string[] _images =[];
+ string[] insert_file_list =[];
+ foreach (line; sourcefile_body_content) {
+ if (type["curly_code"] == 1) {
+ if (line.matchFirst(rgx.block_curly_code_close)) {
+ type["curly_code"] = 0;
+ }
+ contents ~= line;
+ } else if (line.matchFirst(rgx.block_curly_code_open)) {
+ type["curly_code"] = 1;
+ contents ~= line;
+ } else if (type["tic_code"] == 1) {
+ if (line.matchFirst(rgx.block_tic_close)) {
+ type["tic_code"] = 0;
+ }
+ contents ~= line;
+ } else if (line.matchFirst(rgx.block_tic_code_open)) {
+ type["tic_code"] = 1;
+ contents ~= line;
+ } else if (auto m = line.match(rgx.insert_src_fn_ssi_or_sst)) {
+ auto insert_fn = m.captures[2];
+ auto insert_sub_pth = m.captures[1];
+ auto fn_src_insert
+ = chainPath(markup_src_file_path, insert_sub_pth ~ insert_fn).array;
+ insert_file_list ~= fn_src_insert.to!string;
+ auto raw = MarkupRawUnit();
+ /+ TODO +/
+ auto markup_sourcefile_insert_content
+ = raw.getInsertMarkupSourceContentRawLineArray(fn_src_insert, rgx.src_fn_find_inserts);
+ debug(insert_file) {
+ writeln(line);
+ writeln(fn_src_insert);
+ writeln(
+ " length contents insert array: ",
+ markup_sourcefile_insert_content.length
+ );
+ }
+ auto ins = Inserts();
+ auto contents_insert_tu = ins.scan_subdoc_source(
+ _opt_action,
+ markup_sourcefile_insert_content,
+ fn_src_insert.to!string
+ );
+ contents ~= contents_insert_tu[0]; // images to extract for image list?
+ if (_opt_action.source || _opt_action.pod) {
+ auto _image_linelist = _extract_images(contents_insert_tu[0]);
+ if (_image_linelist.length > 0) {
+ _images ~= _image_linelist;
+ }
+ }
+ /+
+ - 1. load file
+ - 2. read lines
+ - 3. scan lines
+ - a. if filename insert, and insert filename
+ - repeat 1
+ - b. else
+ - add line to new array;
+ - build image list, search for any image files to add to image list
+ +/
+ } else {
+ contents ~= line;
+ if (_opt_action.source || _opt_action.pod) {
+ auto _image_linelist = _extract_images(line);
+ if (_image_linelist.length > 0) {
+ _images ~= _image_linelist;
+ }
+ }
+ }
+ } // end src doc loop
+ string[] images = [];
+ foreach(i; uniq(_images.sort())) {
+ images ~= i;
+ }
+ debug(insert_file) {
+ writeln(__LINE__);
+ writeln(contents.length);
+ }
+ auto t = tuple(
+ contents,
+ insert_file_list,
+ images
+ );
+ return t;
+ }
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-10 19:40:11 +0000