node-automator 1.0.0

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2023, TsubasaYeung
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/commands/abort.js

@@ -0,0 +1,11 @@
+const { BaseCommand } = require("./base");
+
+class AbortCommand extends BaseCommand {
+    async execute() {
+        throw (this.selfData && this.selfData.prompt) || "任务中止";
+    }
+}
+
+module.exports = {
+    AbortCommand,
+};

package/commands/alert.js

@@ -0,0 +1,19 @@
+const { showAlert } = require("../utils/alert_tool");
+const { BaseCommand } = require("./base");
+
+class AlertCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        await showAlert(data.type, data.msg, data.title);
+    }
+
+    getRequiredParams() {
+        return [
+            "msg",
+        ];
+    }
+}
+
+module.exports = {
+    AlertCommand,
+};

package/commands/assemble.js

@@ -0,0 +1,56 @@
+const {
+    BaseCommand
+} = require("./base");
+
+/**
+ * 把数组(content)中的元素使用指定符号(delimiter)分割，组合得到指定属性名(props)的对象数组(ret)
+ * @example
+ * content = ["Key1,Key2,Key3", "Value1,Value2,Value3"];
+ * delimiter = ",";
+ * props = "k,v"
+ * // 得到结果
+ * ret = [ 
+ *   {k: "Key1", v: "Value1"}, 
+ *   {k: "Key2", v: "Value2"}, 
+ *   {k: "Key3", v: "Value3"}, 
+ * ]
+ */
+class AssembleCommand extends BaseCommand {
+    async execute() {
+        let delimiter = this.selfData.delimiter;
+        if (delimiter) {
+            delimiter = new RegExp(delimiter);
+        }
+        let props = this.selfData.props;
+        if (delimiter && typeof props === "string") {
+            props = props.split(delimiter);
+        }
+        let arrays = this.content.map(v => delimiter && typeof v === "string" ? v.split(delimiter) : v);
+        let num_item = arrays.reduce((prev, curr) => {
+            return Math.max(prev, curr.length);
+        }, 0);
+        let ret = [];
+        for (let idx_item = 0; idx_item < num_item; ++idx_item) {
+            let tmp = {};
+            props.forEach((v, prop_idx) => {
+                tmp[v] = arrays[prop_idx][idx_item];
+            });
+            ret.push(tmp);
+        }
+        return ret;
+    }
+
+    getRequiredParams() {
+        return [
+            'props'
+        ];
+    }
+
+    getRequireContent() {
+        return true;
+    }
+}
+
+module.exports = {
+    AssembleCommand,
+};

package/commands/assert.js

@@ -0,0 +1,18 @@
+const { toArray } = require('../utils/transform_tool');
+const { BaseCommand } = require("./base");
+
+class AssertCommand extends BaseCommand {
+    async execute() {
+        let missingKeys = [];
+        toArray(this.selfData.key).forEach((key) => {
+            if (!this.getDataByKey(key)) missingKeys.push(key);
+        });
+        if (missingKeys.length) {
+            throw `${missingKeys.map(v => `"${v}"`).join(",")} 参数不存在(${missingKeys.length})`;
+        }
+    }
+}
+
+module.exports = {
+    AssertCommand,
+};

package/commands/base.js

@@ -0,0 +1,363 @@
+const keypress = require("keypress");
+const { warn, getPrint, stdout, setLastError } = require("../utils/log_tool");
+const { convert, flatten, removeDuplicate } = require("../utils/transform_tool");
+const { parse, get_full_path, write_with_type } = require("../utils/file_tool");
+
+const { eval_code } = require("./share_data");
+
+
+keypress(process.stdin);
+
+const { shareData, getDataByKey } = require("./share_data");
+
+const PROCESS_STATE = {
+    NONE: 0,
+    CONTINUE: 1,
+    BREAK: 2,
+};
+
+class BaseCommand {
+    constructor(type, globalData, execSingle, exec) {
+        this.type = type;
+        this.selfData = null;
+        this.shareData = shareData;
+        this.globalData = globalData;
+        this.execSingle = execSingle;
+        this.exec = exec;
+    }
+
+    async willExecute() {
+        return true;
+    }
+
+    async didExecute() {
+        
+    }
+
+    async checkValid(commandCfg) {
+        let conditionCode = commandCfg.when;
+        let when_tip = commandCfg.when_tip;
+        let cfgData = commandCfg.data;
+        if (conditionCode) {
+            let willExec = eval_code(conditionCode);
+            if (!willExec) {
+                when_tip && warn(`[${when_tip}]`);
+                return;
+            }
+        }
+        // 如果可选， 则要判断是否store_key是否已经有值
+        let if_false = commandCfg.if_false;
+        if (if_false) {
+            let checkKey = typeof if_false === "string" ? if_false : cfgData && cfgData.store_key;
+            if (checkKey && this.getDataByKey(checkKey)) {
+                // warn(`${checkKey} 不为空， 跳过执行`)
+                return;
+            }
+        }
+        let if_true = commandCfg.if_true;
+        if (if_true) {
+            let checkKey = typeof if_true === "string" ? if_true : cfgData && cfgData.store_key;
+            if (checkKey && !this.getDataByKey(checkKey)) {
+                // warn(`${checkKey} 为空， 跳过执行`)
+                return;
+            }
+        }
+        let optional = commandCfg.optional;
+        if (optional) {
+            let options = ["Yes", "No"];
+            warn(`\n是否执行 ${commandCfg.title || commandCfg.type}?`);
+            await this.forward("select", { content: options, store_key: "$checkValidOptional"});
+            if (options.indexOf(shareData.$checkValidOptional) == 1) {
+                return;
+            }
+        }
+        return true;
+    }
+
+    async handle(commandCfg, content, depth = 0) {
+        /** @type {{type: string, title?: string, when:?: string, data: any, ignore_error: boolean, data_print: boolean, data_confirm: boolean}} */
+        this.selfCfg = commandCfg;
+        this.selfData = commandCfg.data;
+        /** @type {string} */
+        this.content = content;
+        this.depth = depth || 0;
+
+        // 判断参数是否存在
+        let requiredParams = this.getRequiredParams();
+        let failed = false;
+        for (let index = 0; index < requiredParams.length; index++) {
+            const key = requiredParams[index];
+            let ret = getDataByKey(key, this.selfData);
+            if (ret == null) {
+                failed = true;
+                warn(`\n缺少 ${key}`);
+            }
+        }
+        if (failed) {
+            throw (`参数校验失败，请检查所有缺少的参数 ${getPrint(this.selfCfg, true)}`);
+        }
+
+        let ret;
+        let data = this.selfData;
+        let willExec = await this.willExecute();
+        if (!willExec) {
+            warn("\n不执行");
+            return;
+        }
+        // 打印完整 data
+        if (this.selfCfg.data_print) {
+            await this.forward("print", { content: data, mode: "content", level: 3 });
+        }
+        // 确认完整 data
+        if (this.selfCfg.data_confirm) {
+            await this.forward("confirm", { content: data, mode: "content" });
+        }
+        if (data) {
+            // 内容打印
+            if (data.content_print) {
+                await this.forward("print", { content: this.content, mode: "content", level: 3 });
+            }
+            // 内容确认
+            if (data.content_confirm) {
+                await this.forward("confirm", { content: this.content, mode: "content" });
+            }
+        }
+
+        ret = await this.execute();
+        await this.didExecute();
+        if (data) {
+            ////// 数据预处理 BEG
+            // 对结果进行语法解析
+            if (data.parse_type) {
+                try {
+                    ret = await parse(ret, data.parse_type, data.parse_options);
+                } catch (err) {
+                    setLastError(`parse ${ret} ${data.parse_type} error ${err.message}`);
+                    ret = null;
+                }
+            }
+            // 类型转换
+            if (data && data.value_type) {
+                ret = convert(ret, data.value_type);
+            }
+            // 数组处理
+            if (ret instanceof Array) {
+                // 扁平处理
+                if (data.flatten) {
+                    ret = flatten(ret);
+                }
+                // 数据除重
+                if (data.remove_duplicate) {
+                    ret = removeDuplicate(ret, data);
+                }
+                // 数据排序
+                if (data.store_sort) {
+                    ret.sort();
+                }
+            }
+            // 字符串类型处理
+            if (typeof ret  === "string") {
+                if (data.store_trim) {
+                    ret = ret.trim();
+                }
+            }
+            ////// 数据预处理 END
+            
+            // 默认值
+            if (!ret && data.default_value != null) {
+                ret = data.default_value;
+            }
+            // 保存到共享数据
+            if (data.store_key) {
+                let keys = data.store_key instanceof Array ? data.store_key : data.store_key.split(".");
+                let dst = this.shareData;
+                let len = keys.length;
+                let key;
+                let store_key_type = data.store_key_type;
+                for (let i = 0; i < len - 1; i++) {
+                    key = keys[i];
+                    // 键转换
+                    switch (store_key_type && store_key_type[i]) {
+                        case "eval":
+                            key = eval_code(key);
+                            break;
+                    }
+                    if (!dst[key]) {
+                        dst[key] = {};
+                    }
+                    dst = dst[key];
+                }
+                key = keys[len - 1];
+                let store_mode = data.store_mode || "default";
+                switch (store_mode) {
+                    case "push": {
+                        if (!dst[key]) {
+                            dst[key] = [];
+                        }
+                        dst = dst[key];
+                        dst.push(ret);
+                        break;
+                    }
+                    case "unshift": {
+                        if (!dst[key]) {
+                            dst[key] = [];
+                        }
+                        dst = dst[key];
+                        dst.unshift(ret);
+                        break;
+                    }
+                    case "append": {
+                        if (dst[key] == null) {
+                            dst[key] = "";
+                        }
+                        dst[key] += ret;
+                        break;
+                    }
+                    case "merge": {
+                        dst[key] = Object.assign({}, dst[key], ret);
+                        break;
+                    }
+                    case "concat": {
+                        if (!dst[key]) {
+                            dst[key] = [];
+                        }
+                        dst[key] = dst[key].concat(ret);
+                        break;
+                    }
+                    case "default": {
+                        dst[key] = ret;
+                        break;
+                    }
+                    default: {
+                        throw (`未实现的store_mode ${store_mode}`);
+                        break;
+                    }
+                }
+            }
+            // 保存到store_dst目标
+            if (data.store_dst) {
+                let store_dst = get_full_path(data.store_dst);
+                let store_dst_type = data.store_dst_type;
+                await write_with_type(ret, store_dst, store_dst_type);
+                if (data.reveal_dst) {
+                    await this.forward("reveal", { src: store_dst });
+                }
+                if (data.open_dst) {
+                    await this.forward("open", { src: store_dst });
+                }
+            }
+            // if (data.key && !data.store_key && !data.store_dst && ret != undefined) {
+            //     warn(`返回值未存储 ${getPrint(this.selfCfg, true)}`);
+            // }
+            // 数据映射
+            if (data.mapping) {
+                if (typeof data.mapping === "boolean") {
+                    for (let k in ret) {
+                        this.shareData[k] = ret[k];
+                    }
+                } else {
+                    for (let i = 0; i < data.mapping.length; i++) {
+                        const k = data.mapping[i];
+                        this.shareData[k] = ret[i];
+                    }
+                }
+            }
+            // 参数打印
+            if (data.store_print) {
+                await this.forward("print", { content: ret, mode: "content", level: data.store_print_level ?? 3 });
+            }
+            // 参数确认
+            if (data.store_confirm) {
+                await this.forward("confirm", { content: ret, mode: "content" });
+            }
+            // 参数写入标准输出stdout，需要配合参数 --LOG_LEVEL 99
+            if (data.store_stdout) {
+                stdout(ret);
+            }
+            // 写入剪切板
+            if (data.store_clipboard) {
+                await this.forward("write_clipboard", { content: ret });
+            }
+            // 数据校验
+            if (data.store_validator) {
+                let [ok, errmsg] = eval_code(data.store_validator)(ret);
+                if (!ok) {
+                    setLastError(errmsg || "校验失败");
+                }
+            }
+        }
+        // 写日志
+        if (this.selfCfg.log != undefined) {
+            await this.forward("log", { content: this.selfCfg.log });
+        }
+        if (this.selfCfg.required && ret == null) {
+            throw (`执行结果不能为空`);
+        }
+        return ret;
+    }
+
+    async execute() {
+        
+    }
+
+    /**
+     * 转交给另外一个类型的命令处理
+     * @param {*} type 
+     */
+    async forward(type, data = this.selfData) {
+        return await this.execSingle({
+            type: type, 
+            // 传递 ignore_error
+            ignore_error: this.selfCfg.ignore_error,
+            data: data,
+        },  this.depth);
+    }
+
+    /**
+     * 是否需要传入content
+     */
+    getRequireContent() {
+        return false;
+    }
+
+    getDataByKey() {
+        return getDataByKey.apply(this, arguments);
+    }
+
+    /**
+     * 需要提供的参数
+     */
+    getRequiredParams() {
+        return [
+
+        ];
+    }
+
+    /**
+     * 设置执行状态
+     * @param {*} state 
+     */
+    setProcessState(state) {
+        this.globalData.process_state = state;
+    }
+
+    /**
+     * 重置执行状态
+     */
+    resetProcessState() {
+        this.globalData.process_state = PROCESS_STATE.NONE;
+    }
+
+    /**
+     * 是否为全自动
+     * @returns 
+     */
+    isFullAutomatic() {
+        return this.shareData.FULL_AUTOMATIC;
+    }
+}
+
+module.exports = {
+    BaseCommand,
+    PROCESS_STATE,
+};

package/commands/break.js

@@ -0,0 +1,11 @@
+const { BaseCommand, PROCESS_STATE } = require("./base");
+
+class BreakCommand extends BaseCommand {
+    async execute() {
+        this.setProcessState(PROCESS_STATE.BREAK);
+    }
+}
+
+module.exports = {
+    BreakCommand,
+};

package/commands/change_filter.js

@@ -0,0 +1,34 @@
+
+const { setCache, getCache } = require("../utils/cache_tool");
+const { BaseCommand } = require("./base");
+
+class ChangeFilterCommand extends BaseCommand {
+    async execute() {
+        let key_name = this.selfData.key_name;
+        let status_name = this.selfData.status_name;
+        let default_status = this.selfData.default_status;
+        let cache_key = "[ChangeFilterCommand]:" + this.selfData.cache_key;
+        let cacheType = this.selfData.cache_type;
+        let cacheParam = this.selfData.cache_param;
+        let cached = await getCache(cache_key, cacheType, cacheParam) || {};
+        let ret = this.content.filter(v => {
+            let key = this.getDataByKey(key_name, v);
+            let status = this.getDataByKey(status_name, v);
+            let cached_status = cached[key];
+            cached[key] = status;
+            if (default_status != null && status != default_status) return true;
+            if (cached_status != null && cached_status != status) return true;
+            return false;
+        });
+        await setCache(cache_key, cached, cacheType, cacheParam);
+        return ret;
+    }
+
+    getRequireContent() {
+        return true;
+    }
+}
+
+module.exports = {
+    ChangeFilterCommand,
+};

package/commands/cheerio.js

@@ -0,0 +1,15 @@
+const { BaseCommand, PROCESS_STATE } = require("./base");
+
+class CheerioCommand extends BaseCommand {
+    async execute() {
+        return require("cheerio").load(this.content)
+    }
+
+    getRequireContent() {
+        return true;
+    }
+}
+
+module.exports = {
+    CheerioCommand,
+};

package/commands/clear_screen.js

@@ -0,0 +1,14 @@
+const { write } = require("../utils/log_tool");
+const { BaseCommand } = require("./base");
+const { clear_screen } = require("./share_data");
+
+class ClearScreenCommand extends BaseCommand {
+    async execute() {
+        write(clear_screen + "\n");
+        write(`\x1B[${99}A`);
+    }
+}
+
+module.exports = {
+    ClearScreenCommand,
+};

package/commands/commit.js

@@ -0,0 +1,31 @@
+const { vital } = require("../utils/log_tool");
+const { BaseCommand } = require("./base");
+
+class CommitCommand extends BaseCommand {
+    async execute() {
+        switch (this.selfData.type) {
+            case 'svn': {
+                return await this.forward('svn_commit');
+                break;
+            }
+            case 'git': {
+                return await this.forward('git_commit');
+                break;
+            }
+            default: {
+                throw (`不支持的类型 ${this.selfData.type}`);
+                break;
+            }
+        }
+    }
+
+    getRequiredParams() {
+        return [
+            "type",
+        ];
+    }
+}
+
+module.exports = {
+    CommitCommand,
+};

package/commands/compare.js

@@ -0,0 +1,23 @@
+const { BaseCommand } = require("./base");
+
+class CompareCommand extends BaseCommand {
+    async execute() {
+        let lhs = this.selfData.lhs;
+        let rhs = this.selfData.rhs;
+        let ret = {};
+        if (!lhs) {
+            ret = rhs;
+        } else {
+            for (let key in rhs) {
+                if (rhs[key] !== lhs[key]) {
+                    ret[key] = rhs[key];
+                }
+            }
+        }
+        return ret;
+    }
+}
+
+module.exports = {
+    CompareCommand,
+};

package/commands/confirm.js

@@ -0,0 +1,16 @@
+const { pause } = require("../utils/interaction_tool");
+const { BaseCommand } = require("./base");
+
+class ConfirmCommand extends BaseCommand {
+    async execute() {
+        await this.forward("print");
+        await this.forward("pause", {
+            prompt: this.selfData.prompt || "请确认以上参数",
+            countdown: this.selfData.countdown,
+        });
+    }
+}
+
+module.exports = {
+    ConfirmCommand,
+};

package/commands/continue.js

@@ -0,0 +1,11 @@
+const { BaseCommand, PROCESS_STATE } = require("./base");
+
+class ContinueCommand extends BaseCommand {
+    async execute() {
+        this.setProcessState(PROCESS_STATE.CONTINUE);
+    }
+}
+
+module.exports = {
+    ContinueCommand,
+};

package/commands/copy.js

@@ -0,0 +1,14 @@
+const { copy } = require("../utils/file_tool");
+const { log } = require("../utils/log_tool");
+const { BaseCommand } = require("./base");
+
+class CopyCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        await copy(data.src, data.dst, data.base, data.options);
+    }
+}
+
+module.exports = {
+    CopyCommand,
+};

package/commands/cursor_up.js

@@ -0,0 +1,12 @@
+const { moveCursorLineUp } = require('../utils/interaction_tool');
+const { BaseCommand } = require("./base");
+
+class CursorUpCommand extends BaseCommand {
+    async execute() {
+        moveCursorLineUp(this.selfData.line);
+    }
+}
+
+module.exports = {
+    CursorUpCommand,
+};