roll-right 0.0.1 → 0.0.2

package/lib/phase1.js

@@ -0,0 +1,441 @@
+
+const fs = require('fs-extra')
+const path = require('path')
+const untildify = require('untildify')
+const {translate_marker} = require('../lib/utils')
+
+//$$files::header.html<<
+const g_inserts_match = /\$\$files\:\:(\w|_|-|\+)+\/*(\w|_|-|\+)+\.(\w|_|-\+)+\<\</g 
+const g_names_inserts_match = /\$\$files\:\:name\:\:(\w|_|-|\+)+\/*(\w|_|-|\+)+\<\</g
+
+// ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
+//
+
+function subst(fdata,key,value) {
+    while ( fdata.indexOf(key) >= 0 ) {
+        fdata = fdata.replace(key,value)
+    }
+    return fdata
+}
+
+
+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 the_map
+}
+
+
+function find_map(part_form,the_map) {
+
+    let key = part_form.substr(0,part_form.indexOf("<<")).trim()
+    if ( key.length === 0 ) {
+        //console.log(part_form)
+    }
+
+    let data = the_map[key]
+
+    return[key,data]
+}
+
+
+
+function key_map_sub(file_data,key_values,vars) {
+    let fdata = '' + file_data
+    for ( let key in key_values ) {
+        let value = key_values[key]
+        if ( value[0] === '>' ) {
+            let varname = value.substr(1)
+            let i = vars.indexOf(varname)
+            if ( i >= 0 ) {
+                value = vars.substr(i + varname.length + '::'.length)
+                if ( value.indexOf('::') > 0 ) {
+                    value = value.substr(0,value.indexOf('::'))
+                }
+                value = value.trim()
+            }
+        }
+        fdata = subst(fdata,`$$${key}`,value)
+    }
+    //
+    return fdata
+}
+
+
+
+function windows_module(file_data) {
+    let lines = file_data.split('\n')
+    lines = lines.map(line => {
+        if ( /\/\/\s+MODULE\:/.test(line) ) {
+            return line.replace('(modularized)','(windowized)')
+        } else if ( /import\s+\{/.test(line) ) {
+            return ""
+        } else if ( /^import\s+\* as\s+.+\s+from/.test(line) ) {
+            return ""
+        } else if ( /^export\s+function/.test(line) ) {
+            return line.replace('export',"").trim()
+        } else if ( /^export\s+async\s+function/.test(line) ) {
+            return line.replace('export',"").trim()
+        } else if ( /\/\/windowize>>/.test(line) ) {
+            return line.replace('//windowize>>','')
+        }
+        return line
+    })
+
+    return lines.join('\n')
+}
+
+
+
+function file_transformations(transforms,file_data) {
+    if ( Array.isArray(transforms) ) {
+        for ( let trans of transforms ) {
+            file_data = file_transformations(trans,file_data)
+        }
+    } else if ( typeof transforms === "string" ) {
+        switch ( transforms ) {
+            case "windowize" : {
+                file_data = windows_module(file_data)
+                break;
+            }
+            default : {
+                break;
+            }
+        }
+    }
+
+    return file_data
+}
+
+
+function alphas_file_paths(clean_key,conf) {
+    console.log("alphas_file_paths: " + clean_key)
+    //
+    let the_file = ""
+    if ( (clean_key.indexOf('/') > 0) && (clean_key[0] !== '[') ) {
+        let top_dir = clean_key.substr(0,clean_key.indexOf('/'))
+        let tdir = conf.top_dir_location[top_dir]
+        tdir = tdir === undefined ? `./top_dir` : tdir
+        the_file = clean_key.replace(top_dir,tdir)
+        the_file = translate_marker(the_file,conf)
+    } else if ( (clean_key.indexOf('/') > 0) && (clean_key[0] === '[') ) {
+        // 
+        the_file = translate_marker(clean_key,conf)
+    } else {
+        let ext = path.extname(clean_key)
+        let src_dir = conf.ext_default_dir[ext]
+        the_file = src_dir + '/' + clean_key
+        the_file = translate_marker(the_file,conf)
+    }
+    return the_file
+}
+
+
+function sub_file_replace(file_data,defs,conf) {
+    for ( let file in defs ) {
+        try {
+            let the_file = alphas_file_paths(file,conf)
+            let sub_file = fs.readFileSync(the_file).toString()
+            let marker = `$$file::${file}<<`
+            file_data = file_data.replace(marker,sub_file)
+        } catch(e) {
+        }
+    }
+    return file_data
+}
+
+
+
+function sub_file_processing(clean_key,file_def,conf) {
+    let the_file = alphas_file_paths(clean_key,conf)
+    try {
+        let file_data = fs.readFileSync(the_file).toString()
+        if ( typeof file_def === 'object' ) {
+            file_data = sub_file_replace(file_data,file_def,conf)
+        }
+        return file_data    
+    } catch (e) {
+        console.log(e)
+    }
+    return ""
+}
+
+
+function file_replacement(key_string,conf,file_key) {
+    let file_map = conf.files
+    let file_defs = file_map[file_key]
+    let clean_key = key_string.replace("$$files::","")
+    clean_key = clean_key.replace("<<",'')
+    return sub_file_processing(clean_key,file_defs[clean_key],conf)
+}
+
+
+function named_replacer_replacement(key_string,conf,file_key) {
+    let file_map = conf.files
+    let file_defs = file_map[file_key]
+
+    let clean_key = key_string.replace("$$files::","")
+    clean_key = clean_key.replace("<<",'')
+    let named_file_def = file_defs[clean_key]
+    let ext = path.extname(named_file_def.file)
+    let src_dir = conf.ext_default_dir[ext]
+    let the_file = src_dir + '/' + named_file_def.file
+    //
+    console.log(the_file)
+    if ( the_file[0] === '[' ) {
+        the_file = translate_marker(the_file,conf)
+    }
+    try {
+        let file_data = fs.readFileSync(the_file).toString()
+        //
+        if ( typeof named_file_def.key_values === 'object' ) {
+            file_data = key_map_sub(file_data,named_file_def.key_values,clean_key)
+        }
+        //
+        return file_data    
+    } catch (e) {
+        console.log(e)
+    }
+    return ""
+}
+
+
+
+function filter_file_data(file_data,script_filters) {
+    let exclusions = script_filters.exclude
+    let inclusions = script_filters.include
+    let transforms = script_filters.transforms
+
+    if ( transforms ) {
+        file_data = file_transformations(transforms,file_data)
+    }
+
+    let file_data_update = ""
+
+    let exportations = file_data.split('$$EXPORTABLE::')[1]
+    if ( exportations ) {
+        //
+        exportations = exportations.trim()
+        exportations = exportations.replace('/*','').replace('*/','').trim()
+        exportations = exportations.split('\n')
+        exportations = exportations.map(line => { return line.trim() })
+
+        //
+        if ( exclusions === '*' ) return ""
+        if ( inclusions === '*' ) return file_data
+        if ( exclusions ) {
+            exportations = exportations.filter((exprt) => { return (exclusions.indexOf(exprt) < 0) })
+        }
+        if ( inclusions ) {
+            exportations = exportations.filter((exprt) => { return (inclusions.indexOf(exprt) >= 0) })
+        }
+        //
+
+        let file_parts = file_data.split('//$>>')
+        file_data_update = file_parts.shift()
+        let file_parts_map = {}
+        for ( let part of file_parts ) {
+            let key = part.substr(0,part.indexOf('\n'))
+            key = key.trim()
+            file_parts_map[key] = '//$>>' + part
+        }
+
+        for ( let ky of exportations ) {
+            file_data_update += file_parts_map[ky]
+        }
+        //
+    } else {
+        file_data_update = file_data
+    }
+
+    return file_data_update
+}
+
+
+
+function oneof_absolutes(conf,the_key) {
+    if ( the_key[0] === '<' )  {
+        let abss = conf.absolutes
+        for ( let abKy in abss ) {
+            if ( the_key.indexOf(abKy) === 0 ) {
+                return abss[abKy]
+            }
+        }
+    }
+    return false
+}
+
+
+function load_scripts(conf,file_key) {
+    //
+    let file_map = conf.files
+    let file_defs = file_map[file_key]
+    let script_list = file_defs.script
+    //
+    // script_list
+    let the_file = ""
+    let the_map = {}
+    for ( let clean_key in script_list ) {
+        let fkeys = oneof_absolutes(conf,clean_key)
+        if ( fkeys ) {      // check for a kind of absolute path spec
+            the_file = fkeys.root + '/'  + fkeys.offset
+        } else {
+            if ( clean_key.indexOf('/') > 0 ) {     // assume a selected directory by offset from call location
+                the_file = alphas_file_paths(clean_key,conf)
+            } else {        // get a default location for types of files...
+                let ext = path.extname(clean_key)
+                let src_dir = conf.ext_default_dir[ext]
+                the_file = src_dir + '/' + clean_key
+                the_file = translate_marker(the_file,conf)
+            }
+        }
+        let replacers = script_list[clean_key]
+        if ( typeof replacers === "object" ) {
+            if ( typeof replacers.replace === "string" ) {
+                let repl = clean_key.substring(clean_key.lastIndexOf('/')+1)
+                the_file = the_file.replace(repl,replacers.replace)
+            }
+        }
+        //
+        console.log(the_file)
+        if ( the_file[0] === '[' ) {
+            the_file = translate_marker(the_file,conf)
+        }
+        try {
+            let file_data = fs.readFileSync(the_file).toString()
+            let m_file_key = `script::${clean_key}`
+            //
+            let script_filters = script_list[clean_key]
+            if ( typeof script_filters === "object" ) {
+                file_data = filter_file_data(file_data,script_filters)
+            }
+            //
+            the_map[m_file_key] = file_data
+        } catch (e) {
+            console.log(e)
+        }
+    }
+    //
+    return the_map
+}
+
+// ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
+
+
+class Phase1 {
+
+    constructor(target,target_conf) {
+        this.tconf = target_conf
+        this._target = target
+    }
+
+    ensure_directory(out_dir,target) {
+        fs.ensureDirSync(`${out_dir}/${target}`)
+    }
+
+
+    config(conf,current_file_key) {
+        console.log(conf.business_url)
+        console.log(conf.pre_template)
+    
+        let tmpl_file = conf.pre_template 
+        if ( tmpl_file[0] === '[' ) {
+            tmpl_file = translate_marker(tmpl_file,conf)
+        }
+        try {
+            let html_def = fs.readFileSync(tmpl_file,'utf8').toString()
+            //
+            let replacers = html_def.match(g_inserts_match)
+            let named_replacers = html_def.match(g_names_inserts_match)
+    
+            //
+            console.log("FILES file_replacement")
+            let key_map_replacers = {}
+            if ( !!replacers ) {
+                let replacers_content = replacers.map((key_string) => {
+                    let repl = file_replacement(key_string,conf,current_file_key)
+                    if ( repl === undefined ) {
+                        return ""
+                    }
+                    return repl
+                })
+        
+                key_map_replacers = mapify(replacers,replacers_content,(key) => { return key.replace('$$','').replace('<<','') } )    
+            }
+
+
+            let key_map_named_replacers = {}
+            if ( !!named_replacers ) {
+                console.log("NAMED FILES named_replacer_replacement")
+                let named_replacers_content = named_replacers.map((key_string) => {
+                    return named_replacer_replacement(key_string,conf,current_file_key)
+                })
+                key_map_named_replacers = mapify(named_replacers,named_replacers_content,(key) => { return key.replace('$$','').replace('<<','')} )    
+            }
+    
+            console.log("SCRIPTS load_scripts")
+            let script_map = load_scripts(conf,current_file_key)
+    
+            let key_map_all = Object.assign({},key_map_replacers,key_map_named_replacers,script_map)
+    
+            //console.dir(key_map_all)
+            console.dir(Object.keys(key_map_all))
+            //
+            let results = []
+            let leaders = html_def.split('$$')
+            results.push(leaders.shift())
+            //
+            //
+            for ( let nextL of leaders ) {
+                let [key,found_sub] = find_map(nextL,key_map_all)
+                console.log(key)
+                if ( typeof found_sub === "object" ) {
+console.dir(found_sub)
+                }
+                let matcher = `${key}<<`
+                if ( found_sub !== undefined ) {
+                    let sub_file = nextL.replace(matcher,found_sub)
+                    results.push(sub_file)
+                }
+            }
+            //
+            let sdata = results.join('\n')
+    
+            let output_file = conf.out_dir + '/' + this._target + '/' + current_file_key
+            console.log("WRITING OUTPUT: ",output_file)
+            //
+            fs.writeFileSync(output_file,sdata)
+            //
+        } catch(e) {
+            console.log("TEMPLATE: " + tmpl_file + " does not exists or does not have permissions or is not formatted correctly")
+            console.log(e)
+        }
+    }
+    
+    
+
+    run() {
+        //
+        console.log("ENSURE: ",this.tconf.out_dir)
+        console.log("TARGET:",this._target)
+        //
+        this.ensure_directory(this.tconf.out_dir,this._target)
+        for ( let file in this.tconf.files ) {
+            this.config(this.tconf,file)
+        }
+    }
+
+
+}
+
+module.exports = Phase1

package/lib/phase2.js

@@ -0,0 +1,77 @@
+const fs = require('fs-extra')
+const {spawn} = require('child_process')
+const {translate_marker,gsubst} = require('../lib/utils')
+
+
+// node genpage.js ${top_level}/${dir}/static/${dir}.subst ../templates/index.html ${top_level}/${dir}/index.html
+
+class Phase2 {
+    // ----
+    constructor(target,target_conf) {
+        this.tconf = target_conf
+        this._target = target
+    }
+
+    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)
+        //
+        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)
+        //
+        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 += 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'
+
+            console.log("----------------")
+            console.log("subst: " + where_is_subst_file)
+            console.log("template: " + where_is_template_file)
+            console.log("output: " + where_does_output_go)
+            console.log("tools: " + where_are_scripts)
+
+        let generator_program =   `${where_are_scripts}/genpage.js`
+        //
+
+        let spawner = spawn("node",[generator_program, where_is_subst_file, where_is_template_file, where_does_output_go])
+    
+        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}`);
+        });
+
+    }
+
+    run() {
+        let out_dir = translate_marker(this.tconf.out_dir,this.tconf)
+        this.ensure_directory(out_dir,this._target)
+        this.config(this.tconf,this._target,this.tconf.template)
+    }
+
+
+
+}
+
+
+
+module.exports = Phase2

package/lib/rr_utils.js

@@ -1,27 +1,147 @@
 
-const { dir } = require('console')
 const fs = require('fs')
+const path = require('path')
+const {load_json_file,array_flatten} = require('../lib/utils')
 
 
+// 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;
+    }
+}
+
+function load_package_json(pars) {
+    let file_path = `${pars}/package.json`
+    try {
+        let content = fs.readFileSync(file_path).toString()
+        return { file_path, content }
+    } catch(e) {
+    }
+    return { file_path, "content" : false }
+}
 
+const g_permit_paths = {'.js' : true, '.mjs' : true, '.json' : true }
 
-module.exports.browser_code_access = (pars) => {
-    if ( pars === undefined ) {
+const _browser_code_access = (pars,subdirs,topdir) => {
+    if ( typeof pars === "string" ) {
         try {
-            let client_code_path = './client'
+            let client_code_path = (topdir === undefined) ? `${pars}/client` : `${pars}/${topdir}`
             let dirlist = fs.readdirSync(client_code_path)
             console.dir(dirlist)
             let file_content = dirlist.map(file_name => {
                 let file_path = client_code_path + '/' + file_name
-                let content = fs.readFileSync(file_path).toString()
-                return content
+                let content = ""
+                if ( !(isDir(file_path)) ) {
+                    if ( path.extname(file_path) in g_permit_paths ) {
+                        content = fs.readFileSync(file_path).toString()
+                        return { file_path, content }    
+                    }
+                } else if ( subdirs !== undefined ) {
+                    if ( subdirs.indexOf(file_name) >= 0 ) {
+                        return _browser_code_access(client_code_path,subdirs,file_name)
+                    }
+                }
+                return { file_path, content }
             })
-            return file_content
+            file_content = array_flatten(file_content)
+            let package_item = load_package_json(pars)
+            if ( package_item.content ) file_content.unshift(package_item)
+            return file_content.filter(data => (data.content.length > 0))
         } catch(e) {
             console.log(e)
         }
     }
-    console.log("no files " + __dirname  + " "  + __filename )
+    console.log("_browser_code_access :: no files " + __dirname  + " "  + __filename )
     return []
 }
 
+
+module.exports.browser_code_access = _browser_code_access
+
+
+
+
+function check_sub_deps(dep,dependencies) {
+    console.log(dep)
+    console.log(dependencies)
+    if ( Array.isArray(dep) ) {
+        let ret_val = dep.shift()
+        for ( let subdep of dep ) {
+            if ( subdep in dependencies ) {
+                return ret_val
+            }
+        }
+    }
+    return false
+}
+
+
+
+// // transfer_node_module_browser_version
+module.exports.transfer_node_module_browser_version = (source_spec) => {
+    let check_file = source_spec.file
+    let out_dir = source_spec.out_dir
+    let missing_dependencies = []
+    try {
+        // 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)
+        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])
+                //
+                let depCheck = require(dep)             // require ... ... ... ... ...
+                //
+                for ( let depKy in depCheck ) {
+                    console.log(depKy  + " ::: " + typeof depCheck[depKy] )
+                    if ( typeof depCheck[depKy] === "function" ) {
+                        if (depKy === "browser_code") {
+                            try {
+                                let code_list = depCheck.browser_code()
+                                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 deps = mod_pack.dependencies
+                                        package_file.dependencies = Object.assign({},package_file.dependencies,deps)
+                                    } else {
+                                        console.log(" -------> " + file_path)
+                                        //console.log(content)
+                                        let out_file = `${out_dir}/${dep}.js`
+                                        fs.writeFileSync(out_file,content)    
+                                    }
+                                }    
+                            } catch (e) {
+                                console.log(e)
+                            }
+                        }
+                    }
+                }
+            } else {
+                missing_dependencies.push(dep)
+            }
+        }
+        //
+        //
+    } catch (e) {
+        console.log(e)
+    }
+}
+
+
+
+// // transfer_github_browser_version
+module.exports.transfer_github_browser_version  = (source_spec) => {
+    
+}
+
+// // transfer_local_directory_browser_version
+module.exports.transfer_local_directory_browser_version = (source_spec) => {
+    
+}