momo-ai 1.0.0 → 1.0.1

package/src/epic/history/ai.export.impl.fn.parse.js

@@ -0,0 +1,345 @@
+const fs = require('fs');
+const Immutable = require('immutable');
+const U = require('underscore');
+const __CX = require('./ai.under.fn.cx.evaluate');
+const __FX = require('./ai.under.fn.fx.terminal');
+const __IT = require('./ai.uncork.fn.it.feature');
+const __IO = require('./ai.export.interface.io');
+const __LOG = require('../momo.fn.log');
+const __STR = require('./ai.export.interface.fn.string');
+
+const _parseButtons = (value) => {
+    if (value.startsWith('(') && value.endsWith(')')) {
+        // 分组的情况
+    } else {
+        value = value.split('-');
+        const buttons = [];
+        value.forEach((eachVal) => {
+            const button = {};
+            const eachVals = eachVal.split(':');
+            button.text = eachVals[0];
+            if (eachVals[1]) {
+                button.key = `btn${__STR.strFirstUpper(eachVals[1])}`;
+            }
+            if (eachVals[2]) {
+                button.type = eachVals[2];
+            }
+            buttons.push(button);
+        });
+        return buttons;
+    }
+};
+const _parseTopbar = (key, value = "") => {
+    const textes = value.split(',');
+    const ret = {};
+    const config = {};
+    textes.forEach(text => {
+        if (0 <= text.indexOf('=')) {
+            const kv = text.split('=');
+            const key = kv[0].trim();
+            let value = kv[1].trim();
+            if ("buttons" === key) {
+                value = _parseButtons(value);
+            }
+            config[key] = value;
+        }
+    });
+    ret[`_${key}`] = config;
+    return ret;
+};
+const _parseTabs = (key, value = "") => {
+    const textes = value.split(',');
+    const ret = {};
+    const items = [];
+    textes.forEach((each, index) => {
+        const item = {};
+        item.tab = each;
+        item.key = `tabItem${index}`;
+        items.push(item);
+    });
+    ret[`_${key}`] = {items};
+    return ret;
+};
+const _parseNav = (key, value = "") => {
+    const textes = value.split(',');
+    const ret = {};
+    const items = [];
+    textes.forEach(each => {
+        const item = {};
+        if (0 <= each.indexOf('-')) {
+            const meta = each.split('-');
+            item.text = meta[0];
+            item.uri = meta[1];
+        } else {
+            item.text = each;
+        }
+        items.push(item);
+    });
+    if (0 < items.length && items[0]) {
+        items[0].uri = '$MAIN$';
+    }
+    if (1 < items.length && items[items.length - 1]) {
+        items[items.length - 1].uri = '$SELF$';
+    }
+    items.forEach((item, index) => {
+        item.key = `lnkNav${index}`;
+    });
+    ret[`_${key}`] = items;
+    return ret;
+};
+const _parser = {
+    NAV: _parseNav,
+    TOPBAR: _parseTopbar,
+    TABS: _parseTabs
+};
+const _parseLine = (line = "") => {
+    // 以#号为配置项
+    if (0 <= line.indexOf('#')) {
+        const kv = line.split('#');
+        const prefix = kv[0];
+        const value = kv[1];
+        const type = prefix.toUpperCase();
+        if (_parser[type]) {
+            return _parser[type](prefix, value);
+        }
+    } else {
+        __LOG.warn(`不合法格式（不包含#）跳过配置行${line}`)
+    }
+    return {};
+};
+const parseUi = (lines = []) => {
+    const result = {};
+    lines.forEach(line => {
+        const kv = _parseLine(line);
+        Object.assign(result, kv);
+    });
+    return result;
+};
+
+const _parseValue = (value = "") => {
+    // 是否数值
+    if (value) {
+        if ("true" === value.toString().toLowerCase()
+            || "false" === value.toString().toLowerCase()) {
+            value = "true" === value.toString().toLowerCase();
+        } else if (value.startsWith("[")) {
+            value = JSON.parse(value);
+        } else {
+            const reg = /^([1-9]\d*|-[1-9]\d*)$/;
+            if (reg.test(value)) {
+                value = parseInt(value, 10);
+            }
+        }
+    }
+    return value;
+};
+const _parseExpr = (item = "") => {
+    let ret = item;
+    if (item) {
+        item = item.toString().trim();
+        if (0 < item.indexOf('=')) {
+            const kv = item.split('=');
+            kv[1] = _parseValue(kv[1]);
+            ret = [kv[0], kv[1]];
+        } else {
+            ret = [item, item];
+        }
+    }
+    return ret;
+};
+
+const _parseRel = (lines = []) => {
+    const array = [];
+    lines.forEach(line => {
+        const parsed = _parseExpr(line.trim());
+        array.push(parsed);
+    });
+    return array;
+};
+
+const _parseOption = (item = "", name = "option") => {
+    const root = __IO.ioRoot();
+    const prop = parseZero(root + "/commander/" + name + ".zero", ["P;"]);
+    const kv = _parseExpr(item);
+    const pair = {};
+    pair[kv[0]] = kv[1];
+    if (prop[kv[0]]) pair[prop[kv[0]]] = kv[1];
+    delete pair[undefined];
+    return pair;
+};
+
+const _parseArray = (lines = []) => {
+    const fields = lines.shift();
+    const fieldArr = fields.split(',');
+    const result = [];
+    lines.forEach(line => {
+        const valueArr = line.toString().trim().split(',');
+        const entity = {};
+        __IT.itPair(fieldArr, valueArr, (first, second) => {
+            first = first ? first.trim() : first;
+            second = second ? second.trim() : second;
+            if (first.startsWith('option')) {
+                const optionValue = _parseOption(second);
+                if (0 < Object.keys(optionValue).length) {
+                    entity[first] = optionValue;
+                }
+            } else {
+                entity[first] = second;
+            }
+        });
+        result.push(entity);
+    });
+    return result;
+};
+
+const _parseProp = (lines) => {
+    const data = {};
+    lines.forEach(line => {
+        const parsed = _parseExpr(line.trim());
+        data[parsed[0]] = parsed[1];
+    });
+    return data;
+};
+const _parseKv = (lines = []) => {
+    let content = "";
+    lines.forEach(line => content += line);
+    const pairs = content.split(',');
+    const result = {};
+    pairs.forEach(pair => {
+        const input = pair.trim();
+        const kv = _parseExpr(input);
+        result[kv[0].trim()] = kv[1];
+    });
+    return result;
+};
+
+const PARSER = {
+    "P;": _parseProp, "P": _parseProp,
+    "A;": _parseArray, "A": _parseArray,
+    "KV;": _parseKv, "KV": _parseKv,
+    "UI;": parseUi, "UI": parseUi,
+    "R;": _parseRel, "R": _parseRel
+};
+/**
+ * ## `Ec.parseZero`
+ *
+ * ### 1. 基本介绍
+ *
+ * 解析路径中的特殊文件，文件后缀使用`.zero`，作为当前工具的核心配置数据，文件内容通常如下（`UTF-8`方式读取内容）：
+ *
+ * ```shell
+ * PREFIX;
+ * <Content>
+ * ```
+ *
+ * 此处`PREFIX`则是第二参数，表示不同的文件类型，不同文件类型的解析方式有所区别。
+ *
+ * ### 2. 文件类型
+ *
+ * |前缀|含义|
+ * |:---|:---|
+ * |`P;`|属性文件专用集，用于描述基础属性文件内容。|
+ * |`KV;`|`P;`的不换行模式，直接以`,`为每一个键值对的匹配项，去`\n`换行符过后统一解析，不支持`ENUM`枚举信息。|
+ * |`R;`|关系专用解析文件，可解析关系数据文件（后期可增强）。|
+ * |`A;`|命令解析专用，表格解析器，解析以`\t`为分隔符的表格，然后解析尾部`optionX`部分为配置选项。|
+ * |`UI;`|Jsx文件专用解析器，根据文件模板解析数据。|
+ * |`J;`|Java文件专用解析器，解析Java源代码文件数据专用。|
+ *
+ * @memberOf module:_epic
+ * @param {String} path 解析文件的路径
+ * @param {Array} fileTypes 文件前缀类型
+ * @returns {Any} 最终解析出来的数据内容
+ */
+const parseZero = (path, fileTypes = ['J;', 'P;', 'A;', 'KV;', "UI;", 'R;']) => {
+    if (fs.existsSync(path)) {
+        const content = fs.readFileSync(path, "utf-8").trim();
+        const lines = content.split(/\r?\n/g); //for darwin, it is \n; for win32, it is \r\n.
+        const fileType = lines.shift();
+        __CX.cxEnum(fileType, fileTypes);
+        const parser = PARSER[fileType];
+        __FX.fxError(!U.isFunction(parser), 10003, fileType);
+        return parser(lines);
+    } else {
+        __FX.fxError(10009, path);
+    }
+};
+/**
+ * ## `Ec.parseArgs`
+ *
+ * @memberOf module:_epic
+ * @param {Number} ensure 参数允许的长度解析，如果长度不合法，则直接退出
+ * @returns {Object} 解析成功后的数据信息
+ */
+const parseArgs = (ensure) => {
+    const inputArgs = process.argv.splice(3);
+    if (ensure === inputArgs.length) {
+        const config = {};
+        let key = undefined;
+        let value = undefined;
+        for (let idx = 0; idx <= inputArgs.length; idx++) {
+            if (0 === idx % 2) {
+                key = inputArgs[idx];
+            } else {
+                value = inputArgs[idx];
+            }
+            if (key && value) {
+                config[key] = value;
+                key = undefined;
+                value = undefined;
+            }
+        }
+        return config;
+    } else {
+        __LOG.error(`参数丢失，期望参数: ${ensure / 2} 个.`);
+        process.exit();
+    }
+};
+
+const parseInput = (required = []) => {
+    const inputArgs = process.argv.splice(3);
+    const config = {};
+    let key = undefined;
+    let value = undefined;
+    for (let idx = 0; idx <= inputArgs.length; idx++) {
+        if (0 === idx % 2) {
+            key = inputArgs[idx];
+        } else {
+            value = inputArgs[idx];
+        }
+        if (key && value) {
+            config[key] = value;
+            key = undefined;
+            value = undefined;
+        }
+    }
+    const $keys = Immutable.fromJS(Object.keys(config));
+    __IT.itArray(required, (each) => {
+        const checked = 1 < each.length && (!($keys.contains(each[0]) || $keys.contains(each[1])));
+        __FX.fxError(checked, 10006, each);
+    });
+    return config;
+};
+const parseFormat = (args = {}, pairs = []) => {
+    const actual = {};
+    pairs.forEach(item => __FX.fxContinue(U.isArray(item), () => {
+        const arg0 = item[0];
+        const arg1 = item[1];
+        let finalKey = arg0.length > arg1.length ? arg0 : arg1;
+        finalKey = finalKey.toString().replace(/-/g, '');
+        const dft = item[2];
+        __IT.itObject(args, (key, value) => __FX.fxContinue(arg0 === key || arg1 === key, () => {
+            actual[finalKey] = value;
+        }));
+        __FX.fxContinue(!args.hasOwnProperty(arg0) && !args.hasOwnProperty(arg1) && undefined !== dft, () => {
+            actual[finalKey] = dft;
+        });
+    }));
+    __LOG.info(`Zero AI 加载输入参数：\n${JSON.stringify(actual, null, 4).blue}`);
+    return actual;
+};
+module.exports = {
+    parseInput,
+    parseFormat,
+    parseArgs,
+    parseZero,
+};

package/src/epic/history/ai.export.impl.fn.seek.js

@@ -0,0 +1,42 @@
+const __IO = require('./ai.export.interface.io');
+const Ec = require("../index");
+
+const seekResource = (path = ".") => {
+    const parent = __IO.dirTree(path, folder => __IO.isExist(folder + "/pom.xml"));
+    // 查找最近的项目目录资源信息
+    let found;
+    parent.forEach(item => {
+        if (found) {
+            if (item.length > found.length) {
+                found = item;
+            }
+        } else {
+            found = item;
+        }
+    });
+    // 追加 src/main/resources/
+    return `${found}/src/main/resources`;
+}
+
+const seekChildren = (path = ".", filterFn) => {
+    const children = __IO.dirChildren(path, true);
+    const fileArray = [];
+    children.forEach(child => {
+        const files = __IO.ioFiles(child);
+        files.forEach(file => {
+            if (__IO.isFunction(filterFn)) {
+                if (filterFn(file.file)) {
+                    fileArray.push(file.path.replace(path, ""));
+                }
+            } else {
+                fileArray.push(file.path.replace(path, ""));
+            }
+        })
+    })
+    return fileArray;
+}
+
+module.exports = {
+    seekResource,
+    seekChildren,
+}

package/src/epic/history/ai.export.interface.fn.string.js

@@ -0,0 +1,5 @@
+const __STR = require("./ai.string.fn.str.util");
+
+module.exports = {
+    ...__STR,
+};

package/src/epic/history/ai.export.interface.io.js

@@ -0,0 +1,69 @@
+const __IS = require('./ai.unified.fn.is.decision');
+const __TO = require('./ai.uncork.fn.to.typed');
+const __OUT = require("./ai.path.fn.out.content");
+
+const __IO_CMD = require("./ai.path.fn.io.command");
+const __IO_SPEC = require('./ai.path.fn.io.specification');
+const __IO_TYPED = require('./ai.path.fn.io.typed');
+
+const __DIR = require("./ai.path.fn.dir.operation");
+
+const __IO = {
+    ...__IO_CMD,
+    ...__IO_TYPED,
+    ...__IO_SPEC,
+}
+module.exports = {
+
+    // interface.
+    /*
+       dirChildren,
+       dirParent,
+       dirTree,
+       dirCreate,
+       dirResolve,
+     */
+    ...__DIR,
+    // interface.
+    /*
+       ioCopy,
+       ioDelete,
+
+       ioJArray,
+       ioJObject,
+       ioString,
+       ioStream,
+       ioCsv,
+       ioProp,
+       ioFiles,
+
+       ioName,
+       ioRoot,
+       ioDataA,
+       ioSwitch,
+     */
+    ...__IO,
+
+    // interface.
+    /*
+       outJson,
+       outString,
+       outCopy,
+     */
+    ...__OUT,
+    // interface.
+    /*
+       toTable,
+       toJObject,
+       toJArray,
+       toCsv,
+     */
+    ...__TO,
+    // interface.
+    /*
+       isFile,
+       isDirectory,
+       isExist
+     */
+    ...__IS,
+};

package/src/epic/history/ai.export.interface.util.js

@@ -0,0 +1,17 @@
+const func_uncork_element_feature = require('./ai.uncork.fn.element.feature');
+const func_unbind_it_feature = require('./ai.uncork.fn.it.feature');
+const func_under_cx_evaluate = require('./ai.under.fn.cx.evaluate');
+const func_under_fx_terminal = require('./ai.under.fn.fx.terminal');
+const func_under___logging = require('../momo.fn.log');
+const func_unified_sorter_element = require("./ai.unified.fn.sorter.element");
+const Immutable = require("immutable");
+module.exports = {
+    ...func_uncork_element_feature,
+    ...func_unbind_it_feature,
+    ...func_under_cx_evaluate,
+    ...func_under_fx_terminal,
+    ...func_under___logging,
+    ...func_unified_sorter_element,
+    // clone method
+    clone: input => Immutable.fromJS(input).toJS(),
+}

package/src/epic/history/ai.parse.metadata.js

@@ -0,0 +1,94 @@
+const IoR = require("./ai.path.fn.io.specification");
+const IoT = require("./ai.path.fn.io.typed");
+const parseMetadata = () => {
+    const commandMeta = IoR.ioRoot() + "/commander";
+    const commandFiles = IoT.ioFiles(commandMeta);
+    const commandList = [];
+    commandFiles.forEach(fileObj => {
+        const filename = fileObj.file.toString();
+        if (filename.endsWith(".json")) {
+            const command = filename.substring(0, filename.indexOf("."));
+            const commandPath = IoR.ioRoot() + "/commander/" + command + ".json";
+            const commandJ = IoT.ioJObject(commandPath);
+            commandList.push(commandJ);
+        }
+    });
+    return commandList;
+}
+
+const parseArgument = (options = []) => {
+    const args = process.argv.splice(3);
+    const result = {};
+    const argsLength = args.length;
+
+    // 将 options 转换为 map 以便快速查找
+    const optionsMap = new Map();
+    const aliasesMap = new Map();
+
+    options.forEach(option => {
+        optionsMap.set(option.name, option);
+        if (option.alias) {
+            aliasesMap.set(option.alias, option);
+        }
+    });
+
+    // 解析参数
+    for (let i = 0; i < argsLength; i += 2) {
+        const key = args[i];
+        const value = args[i + 1];
+
+        if (!key || !value) {
+            // 如果参数不成对，报错
+            if (key && !value) {
+                throw new Error(`[ ZERO ] 缺少参数 ${key} 的值`);
+            }
+            break;
+        }
+
+        // 移除前缀（- 或 --）
+        let cleanKey = key;
+        if (key.startsWith('--')) {
+            cleanKey = key.substring(2);
+        } else if (key.startsWith('-')) {
+            cleanKey = key.substring(1);
+        }
+
+        // 查找对应的选项
+        const option = optionsMap.get(cleanKey) || aliasesMap.get(cleanKey);
+
+        if (!option) {
+            throw new Error(`[ ZERO ] 未知的参数: ${key}`);
+        }
+
+        // 转换值的类型
+        let parsedValue = value;
+        if (option.type === 'number') {
+            parsedValue = Number(value);
+            if (isNaN(parsedValue)) {
+                throw new Error(`[ ZERO ] 参数 ${key} 的值 ${value} 不是有效的数字`);
+            }
+        } else if (option.type === 'boolean') {
+            parsedValue = value.toLowerCase() === 'true';
+        }
+
+        result[option.name] = parsedValue;
+    }
+
+    // 处理默认值和必需参数
+    options.forEach(option => {
+        const key = option.name;
+        if (!(key in result)) {
+            if ('default' in option) {
+                result[key] = option.default;
+            } else if (option.required) {
+                throw new Error(`[ ZERO ] 必需的参数缺失: ${key}`);
+            }
+        }
+    });
+
+    return result;
+}
+module.exports = {
+    parseMetadata,
+    parseArgument,
+}

package/src/epic/history/ai.path.fn.dir.operation.js

@@ -0,0 +1,87 @@
+const __FX = require("./ai.under.fn.fx.terminal");
+const fs = require("fs");
+const U = require("underscore");
+const __LOG = require("../momo.fn.log");
+const __V = require("./zero.__.v.constant");
+const __U = require("./zero.__.fn.find.util");
+const __IS = require("./ai.unified.fn.is.decision");
+const __IO = require("./ai.path.fn.io.specification");
+const dirResolve = (path = "") => {
+    let result = path.trim();
+    if (result.endsWith(__V.FILE_DELIMITER)) {
+        result = result.substring(0, result.length - 1);
+    }
+    return result;
+};
+const dirTree = (pathDir = ".", pathFilterFn) => {
+    // 截取当前运行目录
+    const pathStart = __IO.ioSwitch(pathDir);
+    // 往上查找项目根目录
+    const pathArr = pathStart.split(__V.FILE_DELIMITER);
+    const pathIt = [];
+    while (0 < pathArr.length) {
+        const folder = pathArr.join("/");
+        if ('' !== folder) {
+            if (U.isFunction(pathFilterFn)) {
+                if (pathFilterFn(folder)) {
+                    pathIt.push(folder);
+                }
+            } else {
+                pathIt.push(folder);
+            }
+        }
+        pathArr.pop();
+    }
+    return pathIt;
+}
+const dirParent = (path, includeCurrent = false) => {
+    let result = [];
+    if (includeCurrent) {
+        result.push(path);
+    }
+    __FX.fxContinue(fs.existsSync(path), () => {
+        let parent = dirResolve(path);
+        parent = parent.substring(0, parent.lastIndexOf(__V.FILE_DELIMITER));
+        result.push(parent);
+        result = result.concat(dirParent(parent, false));
+    });
+    return result;
+};
+
+const dirChildren = (path, includeCurrent = true) => {
+    let result = [];
+    if (includeCurrent) {
+        result.push(path);
+    }
+    __FX.fxContinue(fs.existsSync(path), () => {
+        const folders = fs.readdirSync(path);
+        const directory = dirResolve(path) + __V.FILE_DELIMITER;
+        folders.forEach(item => __FX.fxContinue(!item.startsWith('.'), () => {
+            const absolute = directory + item;
+            if (__IS.isDirectory(absolute)) {
+                result.push(absolute);
+                result = result.concat(dirChildren(absolute, false));
+            }
+        }));
+    });
+    return result;
+};
+
+const dirCreate = (path = "") => {
+    // TODO: Path专用
+    const folderInfo = __U.findTrace(path);
+    // 查找第一个存在的目录
+    const lefts = folderInfo.filter(item => !__IS.isExist(item)).sort((left, right) => left.length - right.length);
+    lefts.filter(item => '' !== item).forEach(left => {
+        __LOG.info("创建目录：" + left.yellow);
+        fs.mkdirSync(left);
+    });
+    return true;
+};
+module.exports = {
+    dirCreate,
+    dirChildren,
+    dirParent,
+    dirResolve,
+    dirTree,
+}

package/src/epic/history/ai.path.fn.io.command.js

@@ -0,0 +1,43 @@
+const fs = require("fs");
+const __LOG = require("../momo.fn.log");
+const __FX = require("./ai.under.fn.fx.terminal");
+const __IO = require('./ai.path.fn.io.typed');
+const __IS = require("./ai.unified.fn.is.decision");
+const __OUT = require("./ai.path.fn.out.content");
+const __V = require("./zero.__.v.constant");
+
+const __ioDeleteDir = (path) => {
+    if (fs.existsSync(path)) {
+        const etat = fs.statSync(path);
+        if (etat.isDirectory()) {
+            const children = fs.readdirSync(path);
+            if (0 === children.length) {
+                fs.rmdirSync(path);
+            } else {
+                children.forEach(item => {
+                    const hitted = path + __V.FILE_DELIMITER + item;
+                    __ioDeleteDir(hitted);
+                });
+            }
+        } else {
+            __LOG.info(`删除文件：${path}`);
+            fs.unlinkSync(path);
+        }
+    }
+};
+
+const ioCopy = (from, to) => {
+    __FX.fxContinue(__IS.isExist(from) && !__IS.isExist(to) && __IS.isFile(from), () => {
+        const content = __IO.ioString(from);
+        __OUT.outString(to, content);
+    });
+};
+
+const ioDelete = (path) => {
+    __FX.fxError(__V.FILE_DELIMITER === path.trim(), 10024, path);
+    __ioDeleteDir(path);
+};
+module.exports = {
+    ioCopy,
+    ioDelete,
+}