file-obj-queue 1.0.23 → 2.0.0

package/app.js

@@ -3,132 +3,63 @@
 * Main processing app
 */
 
-let colors = require('node-console-colors'),
-    fs = require('fs'),
-    validPath = require('valid-path')
-
-class file_obj {
-    constructor(props) {
-        let t = this
-        t.id = props.id
-        t.log = props.log
-        t.name = props.name
-        t.path = props.path
-        t.absolute_path = props.absolute_path
-        t.status = 'init'
-        t.errors = false
-        t.error_msg = 'none'
-
-        t.process = t.process.bind(t)
-        t.do_checks = t.do_checks.bind(t)
-
-        if (props.check) {
-            t.do_checks()
-        }
-
-        return t
-    }
-
-    do_checks() {
-        let t = this, path_to_check,
-            last_item = t.absolute_path.split("\\").pop(),
-            check_file = t.absolute_path.split(last_item)[0], check_path = t.path.split('/')
-
-        check_file = check_file.replace(/\\/g, "/");
-        path_to_check = validPath(t.path);
-
-        if (!path_to_check.valid) {
-            t.errors = true
-            t.error_msg = `id = ${t.id} name(${t.name}) Error in ${path_to_check.data.input}: ${path_to_check.error})`
-        }
-
-        check_path.map((dat, i) => {
-            if (/^[a-zA-Z._]+$/.test(dat)) {
-                if (dat != '.')
-                    check_file += dat + '/'
-            }
-        })
-        check_file = check_file.slice(0, -1)
-        try {
-            if (!fs.existsSync(check_file)) {
-                t.errors = true
-                t.error_msg = `id = ${t.id} name(${t.name}) file (${check_file} does not exist)`
-            }
-        } catch (e) {
-            e.message = "file_obj do_checks error: " + e.message
-            throw (e)
-        }
-    }
-
-    process(callback) {
-        let t = this
-        if (t.errors)
-            callback({ error: { msg: t.error_msg } })
-        else
-            callback({ success: { msg: `id = ${t.id} name(${t.name})` } })
-    }
-}
+let colors = require('colors'),
+    base_queue = require("./base_queue/app")
+
+colors.setTheme({
+    silly: 'rainbow',
+    input: 'grey',
+    verbose: 'cyan',
+    prompt: 'grey',
+    info: 'green',
+    data: 'grey',
+    help: 'cyan',
+    warn: 'yellow',
+    debug: 'blue',
+    error: 'red',
+    success: 'green'
+});
 
 exports = module.exports = class FilesQueue {
     constructor() {
         try {
             var t = this
+            t.app_resolve = null
+            t.app_reject = null
+            t.successMsg = ''
+
             t.logMsg = t.logMsg.bind(t)
-            t.init = t.init.bind(t)
+            t.process = t.process.bind(t)
             t.getFileObject = t.getFileObject.bind(t)
-            t.json_queue = require("queuejson")
-            t.qJson = null
 
-            t.logMsg(`FilesQueue.constructor`)
+            t.logMsg(`FilesQueue.constructor`.debug)
 
             return t
         } catch (e) {
-            e.message = "FilesQueue app.js constructor error: " + e.message
+            e.message = `FilesQueue app.js constructor error: ${e.message}`.error
             throw (e)
         }
     }
 
-    init(props = {}) {
+    process(props = {}) {
         let t = this
-        try {
-            if (t.qJson == null) {
-                if (typeof props.input_data == 'undefined')
-                    throw new Error('props.input_data is not defined')
-                try {
-                    t.logMsg(`jrm debug 1/29 8800`)
-                    t.qJson = new t.json_queue({
-                        class_obj: file_obj,
-                        appender: 'all',
-                        stats: true,
-                        debug: true,
-                        file_obj_queue: t.getFileObj   //jrm debug 1/31
-                    })
-                    t.logMsg(`jrm debug 1/29 8801`)
-                } catch (e) {
-                    e.message = "queuejson error: " + e.message
-                    t.logMsg(e.message)
-                    throw (e)
-                }
-                try {
-                    t.qJson.init({ input_data: props.input_data })
-                    t.qJson.process()
-                } catch (e) {
-                    e.message = "queuejson.init error: " + e.message
-                    t.logMsg(e.message)
-                    throw (e)
-                }
 
-            }
-            return t
-        } catch (e) {
-            e.message = "FilesQueue app.js init error: " + e.message
-            t.logMsg(e.message)
-            throw (e)
-        }
-    }
+        return new Promise((resolve, reject) => {
+            t.app_resolve = resolve
+            t.app_reject = reject
 
-    getFileObj(){
-        return this
+            if (typeof props.data_to_process_array == 'undefined')
+                t.app_reject('base_queue no props.data_to_process_array')
+
+            if (typeof props.appender == 'undefined')
+                t.app_reject('base_queue no props.appender')
+
+            if (typeof props.process_objects == 'undefined')
+                t.app_reject(`props.process_objects not defined`)
+
+            props.parent = t
+            t.base_queue = new base_queue().load(props).process()
+        })
     }
 
     getFileObject() {

package/base_queue/app.js

@@ -0,0 +1,146 @@
+
+/*
+* @author Jim Manton: jrman@risebroadband.net
+* @since 2023-02-02
+* apps.js
+*/
+
+let cc = require("colors"),
+    file_requre_data = [
+        { props: { id: 100, name: "all", path: "./lib/appenders/all.js", absolute_path: __filename, check: true } }
+    ]
+
+cc.setTheme({
+    silly: 'rainbow',
+    input: 'grey',
+    verbose: 'cyan',
+    prompt: 'grey',
+    info: 'green',
+    data: 'grey',
+    help: 'cyan',
+    warn: 'yellow',
+    debug: 'blue',
+    error: 'red'
+});
+
+
+class process_object {
+    constructor(props) {
+        let t = this
+        t.parent = props.parent
+        t.status = 'process'
+        t.objs = t.parent.getParent().getObjs()
+    }
+
+    process() {
+        let t = this
+    }
+
+    continueProcessing() {
+        let t = this
+    }
+
+    getStatus() {
+        return this.status
+    }
+
+    setStatus(v) {
+        this.status = v
+    }
+}
+
+exports = module.exports = class BaseQueue {
+    constructor(props = {}) {
+        let t = this, fname = `BaseQueue app constructor`
+        try {
+            t.parent = null
+            t.appenders_dir = './appenders/'
+            t.appender = null
+
+            t.logMsg = t.logMsg.bind(t)
+            t.init = t.init.bind(t)
+            t.load = t.load.bind(t)
+            t.process = t.process.bind(t)
+            t.set_base_promise = t.set_base_promise.bind(t)
+            t.base_promise = null
+            t.base_resolve = null
+            t.base_reject = null
+
+            t.set_base_promise()
+
+            return t
+        } catch (e) {
+            t.logMsg(`${fname}: ${e.message}`.error)
+        }
+    }
+
+    set_base_promise() {
+        let t = this, fname = `BaseQueue set_base_promise`
+
+        t.base_promise = new Promise((resolve, reject) => {
+            t.base_resolve = resolve
+            t.base_reject = reject
+        })
+
+        t.base_promise.then(function (success) {
+            t.parent.app_resolve(success)
+        }).catch(function (err) {
+            t.parent.app_reject(err)
+        })
+
+    }
+
+    init(props = {}) {
+        let t = this, fname = `BaseQueue init`
+    }
+
+    load(props = {}) {
+        let t = this, fname = `BaseQueue load`, a, app, req
+
+        if (typeof props.parent == 'undefined')
+            t.base_reject(`${fname}: props.parent not defined`)
+
+        t.parent = props.parent
+        props.parent = t
+        app = props.appender
+        a = t.appenders_dir + app + '.js'
+        req = require(a)
+        t.parent.logMsg(`${fname} loading appender(${a})`.debug)
+        t.appender = new req(props)
+        return t
+    }
+
+    process() {
+        let t = this, fname = `BaseQueue process`, res, error_count = 0
+        try {
+            t.logMsg(`${fname}`.debug)
+
+            res = t.appender.init().process().get_results_array()
+            res.map((json, i) => {
+                if (typeof json.success != "undefined")
+                    t.logMsg(`${JSON.stringify(json)}`.success)
+                if (typeof json.error != "undefined") {
+                    t.logMsg(`${JSON.stringify(json)}`.error)
+                    error_count++
+                }
+            })
+            if (error_count) {
+                res.error_count = error_count
+                t.base_reject(res)
+            } else
+                t.base_resolve(res)
+        } catch (e) {
+            t.base_reject(`${fname}: ${e.message}.`)
+        }
+    }
+
+    logMsg(msg, props = {}) {
+        let t = this
+        try {
+            console.log(msg)
+            return t
+        } catch (e) {
+            t.base_reject(`BaseQueue log: ${e.message} for message (${msg})`)
+        }
+    }
+}

package/base_queue/appenders/base.js

@@ -0,0 +1,77 @@
+/*
+* @author Jim Manton: jrman@risebroadband.net
+* @since 2023-02-03
+* base.js
+*/
+
+exports = module.exports = class base {
+    constructor(props) {
+        let t = this, fname = `base appenders constructor`
+        try {
+            t.parent = props.parent
+            t.parent.logMsg(`${fname}`.debug)
+            t.class_obj_array = []
+            t.data_to_process_array = []
+            t.objects_to_process = []
+            t.results_array = []
+            t.base_name_appender = ''
+
+            if (typeof props.data_to_process_array == 'undefined')
+                throw new Error(`props.data_to_process_array not defined`)
+
+            if (typeof props.process_objects == 'undefined')
+                throw new Error(`props.process_objects not defined`)
+
+            if (typeof props.appender == 'undefined')
+                throw new Error(`appender not defined)`)
+
+            t.base_name_appender = props.appender
+            t.data_to_process_array = props.data_to_process_array
+            t.objects_to_process = props.process_objects
+
+            t.init = t.init.bind(t)
+            t.get_objects_to_process = t.get_objects_to_process.bind(t)
+            t.get_data_to_process_array = t.get_data_to_process_array.bind(t)
+            t.process = t.process.bind(t)
+            t.get_results_array = t.get_results_array.bind(t)
+
+            return t
+        } catch (e) {
+            t.parent.base_reject(`${fname} error: ${e.message})`)
+        }
+    }
+	
+	process (props = {}) {
+		var t = this, fname = `base.process`
+		try {
+			t.parent.logMsg(`${fname}`.debug)
+
+			return t
+		} catch (e) {
+            t.parent.base_reject(`${fname} error: ${e.message})`)
+		}
+	}
+
+    get_results_array () {
+        return this.results_array
+    }
+
+    get_data_to_process_array () {
+        return this.data_to_process_array
+    }
+
+    get_objects_to_process () {
+        return this.objects_to_process
+    }
+    
+	init (props = {}) {
+		var t = this, fname = `base.init`
+		try {
+
+			t.parent.logMsg(`${fname}`.debug)
+			return t
+		} catch (e) {
+            t.parent.base_reject(`${fname} error: ${e.message})`)
+		}
+	}
+}

package/base_queue/appenders/json_all.js

@@ -0,0 +1,70 @@
+/*
+* @author Jim Manton: jrman@risebroadband.net
+* @since 2022-12-11
+* all.ts
+*/
+
+var base = require('./base.js')
+
+exports = module.exports = class json_all extends base {
+	constructor(props) {
+		super(props)
+		var t = this, fname = 'json_all.constructor'
+		try {
+			t.aname = 'json_all'
+			t.main_process_objects = []
+			
+            if (t.base_name_appender != t.aname)
+                throw new Error(`(${t.base_name_appender}) does not equal the appender name (${t.aname}))`)
+
+			t.parent.logMsg(`${fname}`.debug)
+			
+            t.init = t.init.bind(t)
+            t.process = t.process.bind(t)
+
+			return t
+		} catch (e) {
+            t.parent.base_reject(`${fname} error: ${e.message})`)
+		}
+	}
+
+	init (props = {}) {
+		var t = this, fname = `json_all.init`, gotp, gdtpa, obj
+		try {
+			t.parent.logMsg(`${fname}`.debug)
+
+			if (typeof t.get_objects_to_process()[0] == "undefined")
+				throw new Error(`get_objects_to_process[0] has no data`)
+
+			t.get_data_to_process_array().map((dat, i)=>{
+				dat.props.log = t.parent.logMsg
+				obj = t.get_objects_to_process()[0]
+				t.main_process_objects.push(new obj(dat.props))
+			})
+
+			super.init(props)
+			return t
+		} catch (e) {
+            t.parent.base_reject(`${fname} error: ${e.message})`)
+		}
+	}
+	
+	process (props = {}) {
+		var t = this, fname = `json_all.process`
+		try {
+			t.parent.logMsg(`${fname} length(${t.main_process_objects.length})`.debug)
+
+			t.main_process_objects.map((obj, i)=>{
+				obj.process((res)=>{
+					// t.parent.logMsg(`${fname}${JSON.stringify(res)})`.debug)
+					t.results_array.push(res)
+				})
+			})
+
+			super.process(props)
+			return t
+		} catch (e) {
+            t.parent.base_reject(`${fname} error: ${e.message})`)
+		}
+	}
+}

package/package.json

@@ -2,15 +2,15 @@
   "author": {
     "name": "Jim Manton"
   },
-  "version": "1.0.23",
+  "version": "2.0.0",
   "bundleDependencies": [],
   "dependencies": {
     "chai": "^4.3.7",
+    "colors": "^1.4.0",
     "diffler": "^2.0.4",
     "fs": "^0.0.1-security",
     "mocha": "^10.2.0",
-    "node-console-colors": "^1.1.4",
-    "queuejson": "^9.0.9",
+    "queuejson": "^9.0.11",
     "valid-path": "^2.1.0"
   },
   "scripts": {

package/test/app.js

@@ -7,10 +7,6 @@ describe('app', function () {
         application = require('../app.js')
         assert(app = new application())
     })
-
-    it('app.init is a function', function () {
-        assert(typeof app.init == 'function')
-    })
     
     it('app.logMsg is a function', function () {
         assert(typeof app.logMsg == 'function')
@@ -23,12 +19,12 @@ describe('app', function () {
 
 describe('require', function () {
 
-    it('node-console-colors', function () {
-        assert(require('node-console-colors'))
+    it('colors', function () {
+        assert(require('colors'))
     })
 
-    it('queuejson', function () {
-        assert(require('queuejson'))
+    it('base_queue', function () {
+        assert(require('../base_queue/app'))
     })
 
     it('fs', function () {

package/test/package.js

@@ -6,15 +6,15 @@ const packageMock = {
   "author": {
     "name": "Jim Manton"
   },
-  "version": "1.0.23",
+  "version": "2.0.0",
   "bundleDependencies": [],
   "dependencies": {
     "chai": "^4.3.7",
+    "colors": "^1.4.0",
     "diffler": "^2.0.4",
     "fs": "^0.0.1-security",
     "mocha": "^10.2.0",
-    "node-console-colors": "^1.1.4",
-    "queuejson": "^9.0.9",
+    "queuejson": "^9.0.11",
     "valid-path": "^2.1.0"
   },
   "scripts": {

package/tests/appenders/base.js

@@ -4,9 +4,9 @@
 * lib/appenders/base.js
 */
 
-var colors = require('node-console-colors')
+var colors = require('colors')
 
-class process_all_obj {
+class process_object {
     constructor(props) {
         let t = this
         t.parent = props.parent
@@ -82,7 +82,7 @@ class process_all_obj {
                 throw e
             }
         } catch (e) {
-            e.message = `process_all_obj error: ${e.message} `
+            e.message = `process_object error: ${e.message} `
             throw e
         }
     }
@@ -113,7 +113,7 @@ exports = module.exports = class base {
         t.getParent = props.getParent
         t.dt_start = null
         t.dt_end = null
-        t.process_all_obj = null
+        t.process_object = null
         t.pro_props = []
 
         t.process = t.process.bind(this)
@@ -155,15 +155,15 @@ exports = module.exports = class base {
 
     process_all = () => {
         let t = this, _continue
-        if (t.process_all_obj == null) {
-            t.process_all_obj = new process_all_obj({ parent: t })
+        if (t.process_object == null) {
+            t.process_object = new process_object({ parent: t })
         }
 
         _continue = false
         try {
-            switch (t.process_all_obj.getStatus()) {
+            switch (t.process_object.getStatus()) {
                 case 'process':
-                    t.process_all_obj.process()
+                    t.process_object.process()
                     _continue = true
                     break
                 case 'finish with errors':
@@ -175,7 +175,7 @@ exports = module.exports = class base {
                 case 'wait':
                     return
                 default:
-                    throw new Error(`status(${t.process_all_obj.getStatus()}) does not exist`)
+                    throw new Error(`status(${t.process_object.getStatus()}) does not exist`)
             }
 
             if (_continue)

package/tests/files.js

@@ -1,5 +1,7 @@
-var colors = require('node-console-colors'),
-    file_queue = require("../app.js")
+var colors = require('colors'),
+    file_queue = require("../app.js"),
+    fs = require('fs'),
+    validPath = require('valid-path')
 
 var file_data = [
     { props: { id: 100, name: "all", path: "./appenders/all.js", absolute_path: __filename, check: true } },
@@ -12,9 +14,77 @@ var file_data = [
     { props: { id: 107, name: "version", path: "./appenders/version.js", absolute_path: __filename, check: true } }
 ]
 
-console.log(`jrm debug 1/29 2200`)
-var qRequire = new file_queue().init({ input_data: file_data })  
-console.log(`jrm debug 1/29 2201`)
 
-console.log(`test complete`)
+var file_object = class file_obj {
+    constructor(props) {
+        let t = this
+        t.id = props.id
+        t.log = props.log
+        t.name = props.name
+        t.path = props.path
+        t.absolute_path = props.absolute_path
+        t.status = 'init'
+        t.errors = false
+        t.error_msg = 'none'
+
+        t.process = t.process.bind(t)
+        t.do_checks = t.do_checks.bind(t)
+
+        if (props.check) {
+            t.do_checks()
+        }
+
+        return t
+    }
+
+    do_checks() {
+        let t = this, path_to_check,
+            last_item = t.absolute_path.split("\\").pop(),
+            check_file = t.absolute_path.split(last_item)[0], check_path = t.path.split('/')
+
+        check_file = check_file.replace(/\\/g, "/");
+        path_to_check = validPath(t.path);
+
+        if (!path_to_check.valid) {
+            t.errors = true
+            t.error_msg = `id = ${t.id} name(${t.name}) Error in ${path_to_check.data.input}: ${path_to_check.error})`
+        }
+
+        check_path.map((dat, i) => {
+            if (/^[a-zA-Z._]+$/.test(dat)) {
+                if (dat != '.')
+                    check_file += dat + '/'
+            }
+        })
+        check_file = check_file.slice(0, -1)
+        try {
+            if (!fs.existsSync(check_file)) {
+                t.errors = true
+                t.error_msg = `id = ${t.id} name(${t.name}) file (${check_file} does not exist)`
+            }
+        } catch (e) {
+            e.message = "file_obj do_checks error: " + e.message
+            throw (e)
+        }
+    }
+
+    process(callback) {
+        let t = this
+        if (t.errors)
+            callback({ error: { msg: t.error_msg } })
+        else
+            callback({ success: { msg: `id = ${t.id} name(${t.name})` } })
+    }
+}
+
+var qRequire = new file_queue()
+
+qRequire.process({ appender: "json_all", 
+                    process_objects: [file_object], 
+                    data_to_process_array: file_data }).then((success)=>{
+    qRequire.logMsg(`test success: all file objects processed with no errors`.success)
+},(error)=>{
+    let add_s = (error.error_count > 1) ? 's' : ''
+    qRequire.logMsg(`${error.error_count} error${add_s} detected`.error)
+})