roll-right 0.1.4 → 0.2.1

package/lib/phase2.js

@@ -1,6 +1,10 @@
-const fs = require('fs-extra')
+
 const {spawn} = require('child_process')
-const {translate_marker,gsubst} = require('../lib/utils')
+
+const {gsubst} = require('../lib/utils')
+
+const {PathManager} = require('extra-file-class')
+const fos = require('extra-file-class')()
 
 
 // node genpage.js ${top_level}/${dir}/static/${dir}.subst ../templates/index.html ${top_level}/${dir}/index.html
@@ -10,32 +14,30 @@ class Phase2 {
     constructor(target,target_conf) {
         this.tconf = target_conf
         this._target = target
+        this.pm = new PathManager(conf)
     }
 
-    ensure_directory(out_dir,target) {
-        fs.ensureDirSync(`${out_dir}/${target}`)
-    }
 
     config(tconf,target) {
         let static_artifacts = tconf.static_artifacts
         let where_is_subst_file = `${static_artifacts}/${target}.subst`
         where_is_subst_file = gsubst(where_is_subst_file,'$$target',target)
-        where_is_subst_file = translate_marker(where_is_subst_file,tconf)
+        where_is_subst_file = this.pm.translate_marker(where_is_subst_file,tconf)
         //
         let where_is_template_file = tconf.template
         where_is_template_file = gsubst(where_is_template_file,'$$target',target)
-        where_is_template_file = translate_marker(where_is_template_file,tconf)
+        where_is_template_file = this.pm.translate_marker(where_is_template_file,tconf)
         //
         let derived_output_file_name = tconf.template.substr(tconf.template.lastIndexOf('/'))
         //
         let where_does_output_go = tconf.out_dir
         where_does_output_go = gsubst(where_does_output_go,'$$target',target)
-        where_does_output_go = translate_marker(where_does_output_go,tconf)
+        where_does_output_go = this.pm.translate_marker(where_does_output_go,tconf)
         where_does_output_go += derived_output_file_name
         //
         let where_are_scripts = tconf.scripts_dir
         where_are_scripts = gsubst(where_are_scripts,'$$target',target)
-        where_are_scripts = translate_marker(where_are_scripts,tconf) + '/tools'
+        where_are_scripts = this.pm.translate_marker(where_are_scripts,tconf) + '/tools'
 
             console.log("----------------")
             console.log("subst: " + where_is_subst_file)
@@ -63,8 +65,8 @@ class Phase2 {
     }
 
     run() {
-        let out_dir = translate_marker(this.tconf.out_dir,this.tconf)
-        this.ensure_directory(out_dir,this._target)
+        let out_dir = this.pm.translate_marker(this.tconf.out_dir,this.tconf)
+        fos.ensure_directory(out_dir,this._target)
         this.config(this.tconf,this._target,this.tconf.template)
     }
 

package/lib/rr_utils.js

@@ -1,19 +1,11 @@
 
 const fs = require('fs')
 const path = require('path')
-const {load_json_file,array_flatten} = require('../lib/utils')
+const fos = require('extra-file-class')()
 
 
-// from stack oveflow
-function isDir(path) {
-    try {
-        let stat = fs.lstatSync(path);
-        return stat.isDirectory();
-    } catch (e) {
-        // lstatSync throws an error if path doesn't exist
-        return false;
-    }
-}
+const {array_flatten} = require('../lib/utils')
+
 
 function load_package_json(pars) {
     let file_path = `${pars}/package.json`
@@ -36,7 +28,7 @@ const _browser_code_access = (pars,subdirs,topdir) => {
             let file_content = dirlist.map(file_name => {
                 let file_path = client_code_path + '/' + file_name
                 let content = ""
-                if ( !(isDir(file_path)) ) {
+                if ( !(fsoc.is_dirSync(file_path)) ) {
                     if ( path.extname(file_path) in g_permit_paths ) {
                         content = fs.readFileSync(file_path).toString()
                         return { file_path, content }    
@@ -83,7 +75,7 @@ function check_sub_deps(dep,dependencies) {
 
 
 // // transfer_node_module_browser_version
-module.exports.transfer_node_module_browser_version = (source_spec) => {
+module.exports.transfer_node_module_browser_version = async (source_spec) => {
     let check_file = source_spec.file
     let out_dir = source_spec.out_dir
     let missing_dependencies = []
@@ -91,7 +83,7 @@ module.exports.transfer_node_module_browser_version = (source_spec) => {
         // need to do this... node does not look at the current working directory
         module.paths.unshift(`${process.cwd()}/node_modules`)
         //
-        let package_file = load_json_file(check_file)
+        let package_file = fos.load_json_data_at_path(check_file)
         for ( let dep of source_spec.dependencies ) {
             if ( ((typeof dep === 'string') && package_file.dependencies[dep]) || (dep = check_sub_deps(dep,package_file.dependencies))  ) {
                 console.log(dep + " :: " + package_file.dependencies[dep])
@@ -107,7 +99,7 @@ module.exports.transfer_node_module_browser_version = (source_spec) => {
                                 for ( let codes of code_list ) {
                                     let { file_path, content } = codes
                                     if ( file_path.indexOf("package.json") >= 0 ) {
-                                        let mod_pack = load_json_file(file_path)
+                                        let mod_pack = await fos.load_json_data_at_path(file_path)
                                         let deps = mod_pack.dependencies
                                         package_file.dependencies = Object.assign({},package_file.dependencies,deps)
                                     } else {

package/lib/sys_utils.js

@@ -0,0 +1,36 @@
+
+const {spawn} = require('child_process')
+
+
+
+class SysUtils {
+
+    constructor(conf) {
+        let where_are_scripts = conf.tools_directory
+        this.generator_program =   `${where_are_scripts}/genpage.js`
+    }
+
+
+    spawn_generator(where_is_subst_file, where_is_template_file, where_does_output_go,where_is_static_dir) {
+        //
+        let spawner = spawn("node",[this.generator_program, where_is_subst_file, where_is_template_file, where_does_output_go, where_is_static_dir])
+    
+        spawner.stdout.on('data', (data) => {
+            console.log(`stdout: ${data}`);
+        });
+        
+        spawner.stderr.on('data', (data) => {
+            console.error(`stderr: ${data}`);
+        });
+        
+        spawner.on('close', (code) => {
+            console.log(`child process exited with code ${code}`);
+        });
+        //
+    }
+
+}
+
+
+
+module.exports = SysUtils

package/lib/utils.js

@@ -1,20 +1,19 @@
 const fs = require('fs')
-const untildify = require('untildify')
 
-
-// // 
-module.exports.load_json_file = (src) => {
-    try {
-        let contents = JSON.parse(fs.readFileSync(src).toString())
-        return contents
-    } catch (e) {
-        console.log(e)
-    }
-}
-
-
-
-module.exports.gsubst = (str,pattern,value) => {
+/**
+ * subst
+ * 
+ * Calls String.replace sequentially until no instances of the pattern are left.
+ * Puts the value in place of the pattern.
+ * 
+ * Returns the string 
+ * 
+ * @param {string} str 
+ * @param {string} pattern 
+ * @param {string} value 
+ * @returns string
+ */
+function subst(str,pattern,value) {
     let i = str.indexOf(pattern)
     let j = 0
     while ( i >= 0 ) {
@@ -26,7 +25,17 @@ module.exports.gsubst = (str,pattern,value) => {
 }
 
 
-// recursive_flat
+
+/**
+ * recursive_flat
+ * 
+ * Takes in an array whose elements are either atoms or arrays.
+ * The structure is assumed to be recursive and have some max depth
+ * not checked by this method.
+ * 
+ * @param {Array} ary 
+ * @returns Array
+ */
 function recursive_flat(ary) {
     if ( Array.isArray(ary) ) {
         let outary = []
@@ -44,7 +53,16 @@ function recursive_flat(ary) {
 }
 
 
-module.exports.array_flatten = (items_array) => {
+
+/**
+ * array_flatten
+ * 
+ * A top level call for `recursive_flat`
+ * 
+ * @param {Array} items_array 
+ * @returns Array
+ */
+function array_flatten(items_array) {
     let final_array = []
     for ( let item of items_array ) {
         if ( !Array.isArray(item) ) {
@@ -57,41 +75,331 @@ module.exports.array_flatten = (items_array) => {
     return final_array
 }
 
-function pop_dir(where_am_i) {
-    let last_dir = where_am_i.lastIndexOf('/')
-    if ( last_dir > 0 ) {
-        where_am_i = where_am_i.substr(0,last_dir)
+
+/**
+ * mapify
+ * 
+ * Given two arrays creates an object whose keys are the to be found in the first array and the values in the second.
+ * 
+ * The method uses all the keys and as many values found at the front of the array. 
+ * It is possible that the value array will be longer than the keys. If the value array is short, 
+ * then key will map to 'undefined'.
+ * 
+ * 
+ * 
+ * @param {Array} a1 
+ * @param {Array} a2 
+ * @param {Function} key_edit
+ * 
+ * @returns Object
+ */
+function mapify(a1,a2,key_edit) {
+    let the_map = {}
+    let n = a1.length
+    if ( typeof key_edit === 'function' ) {
+        for ( let i = 0; i < n; i++ ) {
+            let ky = key_edit(a1[i])
+            the_map[ky] = a2[i]
+        }
+    } else {
+        for ( let i = 0; i < n; i++ ) {
+            the_map[a1[i]] = a2[i]
+        }    
     }
-    return where_am_i
+    return the_map
 }
 
-function default_realtive_asset_dir() {
-    let where_am_i = __dirname
-    let default_dir = pop_dir(where_am_i)
-    return default_dir
+
+/**
+ * find_map
+ * 
+ * This is for an application that takes in a string that is expected to have 
+ * a delimeter marking the end of the prefix (or first part) of the string.
+ * 
+ * It pulls of the prefix and uses it as a key into the map to get stored data. 
+ * 
+ * This returns key and data as a pair.
+ * 
+ * default "<<"
+ * 
+ * @param {string} part_form 
+ * @param {object} the_map 
+ * @param {string}
+ * @returns pair<key,data>  -- this is an array with a key in position 0, and data in position 1
+ */
+function find_map(part_form,the_map,section_key) {
+    
+    if ( section_key === undefined ) {
+        section_key = "<<"
+    }
+
+    let key = part_form.substring(0,part_form.indexOf(section_key)).trim()
+    if ( key.length === 0 ) {
+        //console.log(part_form)
+    }
+
+    let data = the_map[key]
+
+    return[key,data]
 }
 
 
-function translate_marker(clean_key,conf) {
-    if ( clean_key === "default" ) {
-        clean_key = default_realtive_asset_dir()
-    } else {
-        let syntax_boundary = clean_key.indexOf(']')
-        if ( syntax_boundary > 0 ) {
-            let location_marker = clean_key.substr(0,syntax_boundary+1)
-            let findable = conf.path_abreviations[location_marker]
-            if ( findable ) {
-                clean_key = clean_key.replace(location_marker,findable).trim()
-                if ( clean_key[0] === '[' ) {
-                    clean_key = translate_marker(clean_key,conf)
-                } else if ( clean_key[0] === '~' ) {
-                    clean_key = untildify(clean_key)
+/**
+ * key_map_sub
+ * 
+ * Takes in a string `source_str`, which may be formatted with substitution forms.
+ * The form '$${key}' is similar to the JavaScript substitution directive '${subsitution expre}'.
+ * There is one extra '$' up front. The object contains key-value pairs.
+ * 
+ * In some cases, a value from the object may be a stored variable.
+ * In this application, the value as variable is indicated by a character prefix. (default '>')
+ * The vars parameter includes variable-value pairs allowing for substitutions specifically for a string 
+ * outside the use of the key-value object. This provides override for globally set values.
+ * 
+ * 
+ * @param {string} source_str 
+ * @param {object} key_values 
+ * @param {string} vars - a string of variable,value pairs delimited by the var_delimiter
+ * @param {string} value_var_prefix (optional)
+ * @param {string} var_delimiter 
+ * @returns string
+ */
+function key_map_sub(source_str,key_values,vars,value_var_prefix,var_delimiter) {
+    if ( value_var_prefix === undefined ) {
+        value_var_prefix = '>'
+    }
+    if ( var_delimiter === undefined ) {
+        var_delimiter = "::"
+    }
+    let fdata = '' + source_str
+    for ( let key in key_values ) {
+        let value = key_values[key]
+        if ( value[0] === value_var_prefix ) {
+            let varname = value.substr(1)
+            let i = vars.indexOf(varname)
+            if ( i >= 0 ) {
+                value = vars.substring(i + varname.length + var_delimiter.length)  // take in the full variable and including the delimiter, value follows
+                if ( value.indexOf(var_delimiter) > 0 ) {  // just clear of the delimiter
+                    value = value.substr(0,value.indexOf(var_delimiter))
                 }
+                value = value.trim()
             }
         }
+        fdata = subst(fdata,`$$${key}`,value)
     }
-    return clean_key
+    //
+    return fdata
 }
 
 
-module.exports.translate_marker = translate_marker
+class ParseUtils {
+
+    constructor() {}
+
+    clear_block_comments(str) {
+        let output = ""
+        let n = str.length - 1
+        let prev_c = str[0]
+        let i = 1
+        for ( ; i < n; i++ ) {
+            let c = str[i]
+            if ( "/*" === (`${prev_c}${c}`) )  {
+                while ( i < n ) {
+                    c = str[i++]
+                    if ( (c === '*') && (str[i++] === '/') ) {
+                        prev_c = str[i]
+                        break
+                    }
+                }
+            } else {
+                output += prev_c
+                prev_c = c
+            }
+        }
+        n = str.length
+        if ( i < n ) {
+            output += str.substring(i-1)
+        }
+        
+        return output
+    }
+
+    clear_comments(str) {
+        if ( str.indexOf("verbatim::") === 0 ) {
+            let check_end = str.lastIndexOf('}')
+            //
+            if ( check_end > 0 ) {
+                let front = str.substring(0,check_end+1)
+                return front
+            }
+        } else {
+            if ( str.indexOf("//") >= 0 ) {
+                let lines = str.split('\n')
+                let n = lines.length
+                for ( let i = 0; i < n; i++ ) {
+                    let line = lines[i]
+                    line = line.trim()
+                    if ( line.length && (line.indexOf('//') === 0) ) {
+                        lines[i] = ""
+                    } else if ( line.length && (line.indexOf('//') > 0) ) {
+                        line = line.substring(0,(line.indexOf('//'))).trim()
+                        lines[i] = line
+                    }
+                }
+                lines = lines.filter((line)  => {
+                    return line.length > 0
+                })
+                return lines.join("\n")
+            }
+        }
+        return str.trim()
+    }
+    remove_spaces(str) {
+        let strs = str.split(' ')
+        strs = strs.filter((sub) => {
+            return sub.length > 0
+        })
+        return strs.join('')
+    }
+    remove_white(str) {
+        str = str.replace(/\s+/g,'')
+        return str
+    }
+
+    flatten(data_parts) {
+        let flattened = []
+        for ( let part of data_parts ) {
+            if ( typeof part === "string" ) {
+                flattened.push(part)
+            } else {
+                let parted = this.flatten(part)
+                for ( let p of parted ) {
+                    flattened.push(p)
+                }
+            }
+        }
+        return flattened
+    }
+
+
+    capitalize(str) {
+        let rest = str.substring(1)
+        str = str.substring(0,1).toUpperCase() + rest
+        return str
+    }
+
+
+    subst(str,ky,val) {
+        while ( str.indexOf(ky) >= 0 ) {
+            str = str.replace(ky,val)
+        }
+        return str
+    }
+
+
+    extract_var(str) {
+        let var_up = str.substring(str.indexOf('@{') + 2)
+        let vname = var_up.substring(0,var_up.indexOf('}'))
+        return vname
+    }
+
+    has_parameter_block(data) {
+        return data.indexOf("@params<{") >= 0
+    }
+
+    remove_parameter_block(data) {
+        data = data.trim()
+        let front_split = data.split("@params<{")
+        let front = front_split[0]
+        let rest = front_split[1]
+
+        let end_block = rest.indexOf("}>")
+        rest = rest.substring(end_block+2).trim()
+        data = front + rest
+        return data.trim()
+    }
+
+
+    /**
+     * Revers a map... take into consideration that the original mapping might not be one to one
+     * @param {object} skeletons 
+     * @returns {object}
+     */
+    reverse_map(skeletons) {
+        let robj = {}
+        for ( let [ky,val] of Object.entries(skeletons) ) {
+            let obj = robj[val]   // robj maps from value to object (a map)
+            if ( !obj ) {   // create object (new value as key)
+                obj = {}
+                robj[val] = obj
+            }
+            obj[ky] = ""    // collect keys that mapped to value (may be one or more)
+        }
+        return robj
+    }
+
+    copy_keys(dst,src,type) {
+        if ( type === "array" ) {
+            for ( let ky in src ) {
+                dst[ky] = []
+            }
+        } else if ( type === "object" ) {
+            for ( let ky in src ) {
+                dst[ky] = {}
+            }
+        } else {
+            for ( let ky in src ) {
+                dst[ky] = ""
+            }
+        }
+    }
+
+
+    /**
+     * 
+     * @param {object} obj 
+     * @param {Function} fn 
+     */
+    key_sort(obj,fn) {
+        let sobj = {}
+        let keys = Object.keys(obj)
+        if ( typeof fn === "function" ) {
+            keys.sort((el1,el2) => {
+                let ky1 = fn(el1)
+                let ky2 = fn(el2)
+                if ( ky1 < ky2 ) {
+                    return -1
+                } else if ( ky1 < ky2 ) {
+                    return 1
+                } else {
+                    return 0
+                }
+            })
+        } else {
+            keys.sort()
+        }
+        for ( let ky of keys ) {
+            sobj[ky] = obj[ky]
+        }
+        return sobj
+    }
+
+
+
+    next_char(achar) {
+        let b = achar.charCodeAt(0)
+        b++
+        let c = String.fromCharCode(b)
+        return c
+    }
+}
+
+
+module.exports = ParseUtils
+
+module.exports.gsubst = subst
+module.exports.array_flatten = array_flatten
+module.exports.recursive_flat = recursive_flat
+module.exports.find_map = find_map
+module.exports.mapify = mapify
+module.exports.key_map_sub = key_map_sub

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "roll-right",
-  "version": "0.1.4",
-  "description": "A helper utilty for gather browser artifacts from node modules, code repositories, etc.",
+  "version": "0.2.1",
+  "description": "A utilty for generating template files, e.g. HTML templates, in one phase, and then generating final output files, e.g. HTML, in another phase.",
   "main": "index.js",
   "directories": {
     "example": "examples"
@@ -11,14 +11,16 @@
     "roll-right-breakup": "./bin/breakup.js"
   },
   "scripts": {
-    "test": "node tests/index.js"
+    "test": "node tests/index.js",
+    "prepare" : "node bin/index.js --phase prepare --sources ../websites/template-configs/  --generator generate.json --structure parsed.json",
+    "templates" : "node bin/index.js --phase template --sources ../websites/template-configs/ --generator generate.json --structure parsed.json",
+    "page" : "node bin/index.js --phase page --sources ../websites/template-configs/ --values assignments.json"
   },
   "dependencies": {
     "byte-base64": "^1.1.0",
-    "extra-file-class": "^0.9.12",
-    "fs-extra": "^10.0.1",
+    "extra-file-class": "^1.0.1",
     "handlebars": "^4.7.7",
-    "minimist": "^1.2.5",
+    "minimist": "^1.2.8",
     "untildify": "^4.0.0"
   },
   "repository": {
@@ -28,7 +30,8 @@
   "keywords": [
     "browserify",
     "rollup",
-    "publisher"
+    "publisher",
+    "HTML-generation"
   ],
   "author": "R. Leddy",
   "license": "GPL-3.0-or-later",

package/test/index.js

@@ -1,5 +1,33 @@
-const papa = require('../index.js')
+// const papa = require('../index.js')
 
 
 
-papa.browser_code()
+// papa.browser_code()
+
+
+let ParseUtils = require('../lib/utils')
+
+
+let putils = new ParseUtils()
+
+putils.clear_block_comments("")
+
+
+let commented = 
+`----/* ****
+
+This is a test and it shoul be something you can't see.
+
+*
+
+*/
+I like living in my house.
+-------------------------
+/* ****
+This is a test and it shoul be something you can't see.
+*
+*/1234`
+
+let oput = putils.clear_block_comments(commented)
+
+console.log(oput)