node-automator 1.0.0

package/utils/cache/local_cache.js

@@ -0,0 +1,79 @@
+// const LocalStorage = require("node-localstorage").LocalStorage;
+
+const { writeFileSync, readFileSync, existsSync, mkdirSync } = require('fs');
+const { error, warn } = require("../log_tool");
+const path = require("path");
+const { shareData } = require('../../commands/share_data');
+module.exports = class LocalCache {
+    constructor(location) {
+        this.location = location || path.resolve(shareData.AUTOMATOR_APPDATA, ".local_cache");
+        this.StorageCache = {};
+    }
+    
+    async setCache(key, val) {
+        key += ".yml";
+        this.StorageCache[key] = val;
+        try {
+            var resStr = require("yaml").stringify(val);
+            this.getLocalStorage().setItem(key, resStr);
+        } catch (e) {
+            warn(e);   
+        }
+    }
+
+    async getCache(key) {
+        key += ".yml";
+        var res = null;
+        res = this.StorageCache[key];
+        if (!res) {
+            try {
+                res = this.getLocalStorage().getItem(key);
+                if (res) {
+                    res = require("yaml").parse(res);
+                }
+            } catch (e) {
+                warn(e);  
+            }
+            if (res) {
+                this.StorageCache[key] = res;
+            }
+        }
+        return res;
+    }
+
+    getLocalStorage() {
+        if (!this.localStorage) {
+            this.localStorage = new LocalStorage(this.location);
+        }
+        return this.localStorage;
+    }
+};
+
+class LocalStorage {
+    constructor(location) {
+        this.location = location;
+        if (!existsSync(location)) {
+            mkdirSync(location, {
+                recursive: true
+            });
+        }
+    }
+
+    parseKey(key) {
+        return path.join(this.location, key.replace(/[\\\/\:\*\?"<>\|]/g, (substring) => encodeURIComponent(substring)));
+    }
+
+    setItem(key, val) {
+        let file = this.parseKey(key);
+        writeFileSync(file, val, "utf-8");
+    }
+
+    getItem(key) {
+        let file = this.parseKey(key);
+        try {
+            return readFileSync(file, "utf-8");
+        } catch (err) {
+            return null;
+        }
+    }
+}

package/utils/cache/raw_cache.js

@@ -0,0 +1,47 @@
+const { error, warn } = require("../log_tool");
+const path = require("path");
+const fs = require("fs");
+const { shareData } = require('../../commands/share_data');
+module.exports = class RawCache {
+    constructor(location) {
+        this.location = location || path.resolve(shareData.AUTOMATOR_APPDATA, ".raw_cache");
+        if (!fs.existsSync(this.location)) {
+            fs.mkdirSync(this.location, {
+                recursive: true
+            });
+        }
+        this.StorageCache = {};
+    }
+    
+    async setCache(key, val) {
+        this.StorageCache[key] = val;
+        try {
+            fs.writeFileSync(path.resolve(this.location, key), val);
+        } catch (e) {
+            warn(e);   
+        }
+    }
+
+    async getCache(key) {
+        var res = null;
+        res = this.StorageCache[key];
+        if (!res) {
+            try {
+                res = fs.readFileSync(path.resolve(this.location, key));
+            } catch (e) {
+                // warn(e);
+            }
+            if (res) {
+                this.StorageCache[key] = res;
+            }
+        }
+        return res;
+    }
+
+    getLocalStorage() {
+        if (!this.localStorage) {
+            this.localStorage = new LocalStorage(this.location);
+        }
+        return this.localStorage;
+    }
+};

package/utils/cache/simple_local_cache.js

@@ -0,0 +1,33 @@
+const LocalStorage = require("node-localstorage").LocalStorage;
+
+const { error, warn } = require("../log_tool");
+const path = require("path");
+const fs = require("fs");
+const { shareData } = require('../../commands/share_data');
+module.exports = class SimpleLocalCache {
+    constructor(location) {
+        this.location = location || path.resolve(shareData.AUTOMATOR_APPDATA, `.simple_local_cache.yml`);
+        if (fs.existsSync(this.location)) {
+            this.StorageCache = require("yaml").parse(fs.readFileSync(this.location, "utf-8"));
+        } else {
+            this.StorageCache = {};
+        }
+    }
+    
+    async setCache(key, val) {
+        this.StorageCache[key] = val;
+        try {
+            fs.writeFileSync(this.location, require("yaml").stringify(this.StorageCache), "utf-8");
+        } catch (e) {
+            warn(e);   
+        }
+    }
+
+    async getCache(key) {
+        return this.StorageCache[key];
+    }
+    
+    async getSize() {
+        return Object.keys(this.StorageCache).length;
+    }
+};

package/utils/cache/simple_sqlite_cache.js

@@ -0,0 +1,43 @@
+const path = require("path");
+
+
+const sqlite3 = require("sqlite3");
+const {
+    open
+} = require("sqlite");
+const { shareData } = require('../../commands/share_data');
+
+module.exports = class SimpleSqliteCache {
+    constructor(location) {
+        this.location = location || path.resolve(shareData.AUTOMATOR_APPDATA, ".simple_sqlite_cache.db");
+    }
+
+    async setCache(key, val) {
+        // await (await this.getDB()).exec(`INSERT INTO tbl VALUES ("${encodeURIComponent(key)}", "${encodeURIComponent(val)}")`);
+        await (await this.getDB()).exec(`REPLACE INTO tbl VALUES ("${encodeURIComponent(key)}", "${encodeURIComponent(val)}")`);
+    }
+
+    async getCache(key) {
+        let ret = await (await this.getDB()).get('SELECT value FROM tbl WHERE key = ?', encodeURIComponent(key));
+        return ret && decodeURIComponent(ret.value);
+    }
+
+    async getDB() {
+        if (!this.db) {
+            this.db = await open({
+                filename: this.location,
+                driver: sqlite3.cached.Database,
+            });
+            await this.db.exec('CREATE TABLE IF NOT EXISTS tbl (\
+                key TEXT,\
+                value TEXT,\
+                PRIMARY KEY (key)\
+                )');
+        }
+        return this.db;
+    }
+
+    async getSize() {
+        return (await (await this.getDB()).get('SELECT count(key) FROM tbl'))['count(key)'];
+    }
+};

package/utils/cache/simple_svn_cache.js

@@ -0,0 +1,49 @@
+const {read_cfg, write_with_type} = require("../file_tool");
+const {exec_shell} = require("../shell_tool");
+
+const path = require("path");
+const fs = require("fs");
+const { error, warn } = require("../log_tool");
+module.exports = class SimpleSVNCache {
+    constructor(location) {
+        this.location = location;
+        this.basename = path.basename(this.location);
+        this.cwd = path.dirname(this.location);
+    }
+    
+    async setCache(key, val) {
+        await this.updateCache();
+        this.StorageCache[key] = val;
+        try {
+            fs.writeFileSync(this.location, require("yaml").stringify(this.StorageCache), "utf-8");
+            await exec_shell({
+                cmd: `svn add ${this.basename} --force`,
+                cwd: this.cwd,
+            });
+            await exec_shell({
+                cmd: `svn commit ${this.basename} -m "AutoSet ${key}=${JSON.stringify(val).replace(/"/g, "'").substring(0, 50)}"`,
+                cwd: this.cwd,
+            });
+        } catch (e) {
+            warn(e);   
+        }
+    }
+
+    async getCache(key) {
+        await this.updateCache();
+        return this.StorageCache[key];
+    }
+
+    async updateCache() {
+        await exec_shell({
+            cmd: `svn update ${this.basename}`,
+            cwd: this.location,
+        });
+        this.StorageCache = require("yaml").parse(fs.readFileSync(this.location, "utf-8"));
+    }
+
+    async getSize() {
+        this.updateCache();
+        return Object.keys(this.StorageCache).length;
+    }
+};

package/utils/cache/svn_cache.js

@@ -0,0 +1,40 @@
+const {read_cfg, write_with_type} = require("../file_tool");
+const {exec_shell} = require("../shell_tool");
+
+const path = require("path");
+const { error, warn } = require("../log_tool");
+module.exports = class SVNCache {
+    constructor(location) {
+        this.location = location;
+    }
+    
+    async setCache(key, val) {
+        key = encodeURIComponent(key);
+        let basename = key + ".yml";
+        let fullpath = path.join(this.location, basename);
+        try {
+            await write_with_type(val, fullpath);
+            await exec_shell({
+                cmd: `svn add ${basename} --force`,
+                cwd: this.location,
+            });
+            await exec_shell({
+                cmd: `svn commit ${basename} -m "AutoSet ${basename}=${JSON.stringify(val).replace(/"/g, "'").substring(0, 50)}"`,
+                cwd: this.location,
+            });
+        } catch (e) {
+            warn(e);   
+        }
+    }
+
+    async getCache(key) {
+        key = encodeURIComponent(key);
+        let basename = key + ".yml";
+        let fullpath = path.join(this.location, basename);
+        await exec_shell({
+            cmd: `svn update ${basename}`,
+            cwd: this.location,
+        });
+        return await read_cfg(fullpath);
+    }
+};

package/utils/cache_tool.js

@@ -0,0 +1,53 @@
+const LocalCache = require("./cache/local_cache");
+const RawCache = require("./cache/raw_cache");
+const SVNCache = require("./cache/svn_cache");
+const SimpleLocalCache = require("./cache/simple_local_cache");
+const SimpleSVNCache = require("./cache/simple_svn_cache");
+// const SimpleSqliteCache = require("./cache/simple_sqlite_cache");
+
+
+const type2param2mgr = {};
+const type2mgrcls = {
+    "raw": RawCache,
+    "local": LocalCache,
+    "svn": SVNCache,
+    "simple_local": SimpleLocalCache,
+    "simple_svn": SimpleSVNCache,
+    // "simple_sqlite": SimpleSqliteCache,
+};
+
+function getCacheMgr(type, param) {
+    let param2mgr = type2param2mgr[type] || (type2param2mgr[type] = {});
+    let mgr = param2mgr[param] || (param2mgr[param] = new (type2mgrcls[type])(param));
+    return mgr;
+}
+
+// const defaultCache = new LocalCache();
+// const defaultCache = new SVNFileCache();
+
+async function setCache(key, val, type, param) {
+    if (!type) {
+        type = "local";
+    }
+    const cacheMgr = getCacheMgr(type, param);
+    return await cacheMgr.setCache(key, val);
+}
+
+async function getCache(key, type, param) {
+    if (!type) {
+        type = "local";
+    }
+    const cacheMgr = getCacheMgr(type, param);
+    return await cacheMgr.getCache(key);
+}
+
+async function getSize(type, param) {
+    const cacheMgr = getCacheMgr(type, param);
+    return await cacheMgr.getSize();
+}
+
+module.exports = {
+    setCache,
+    getCache,
+    getSize,
+};

package/utils/display_tool.js

@@ -0,0 +1,85 @@
+const process = require("process");
+const { stdout_columns, clear_line_end, shareData } = require("../commands/share_data");
+const { clearLine } = require("./interaction_tool");
+const { omit, omit_offset, write } = require("./log_tool");
+const { alignNumber, formatByteSize, alignStr, Alignment } = require("./transform_tool");
+
+const color_cfg = [
+    "cyan",
+    "green",
+    "white",
+];
+
+
+/**
+ * 
+ * @param {*} cur 
+ * @param {*} total 
+ * @param {{
+ *  char_count?: number,
+ *  char1?: string,
+ *  char2?: string,
+ *  desc?: string,
+ *  show_progress_txt?: boolean,
+ *  color?: string = "reset",
+ *  depth?: number = 0,
+ *  align?: boolean = false,
+ * }} options 
+ */
+function progress(cur, total, options, important) {
+    if (shareData.FULL_AUTOMATIC && !important) {
+        write(".");
+        return;
+    }
+    let depth = options && options.depth || 0;
+    depth = Math.min(depth, 5);
+    let color = options.color || color_cfg[Math.min(color_cfg.length - 1, depth)];
+    let padding = 4;
+    options = Object.assign({}, {
+        char_count: 30,
+        char1: "━"[color],
+        char2: "━"["gray"],
+        desc: "",
+        show_progress_txt: true,
+    }, options);
+    // options.color = "gray";
+    let { char_count, char1, char2, desc, show_progress_txt, format_bytes } = options;
+    char_count -= depth * padding;
+    if (char_count <= 0)
+        char_count = 10;
+    percent = cur >= total ? 100 : alignNumber(Math.floor(100 * cur / total), 100);
+    char_num = cur >= total ? char_count : Math.floor(char_count * cur / total);
+    if (!format_bytes) {
+        curr_total = `(${alignNumber(cur, total > 0 ? total : cur)}/${total > 0 ? total : "∞"})`;
+    } else {
+        cur = formatByteSize(cur);
+        total = formatByteSize(total);
+        curr_total = `(${alignNumber(cur, total)}/${total})`;
+    }
+    chars1 = char1.repeat(char_num);
+    chars2 = char2.repeat(char_count - char_num);
+
+    
+    let progressChars;
+    if (show_progress_txt)
+        progressChars = `${chars1}${chars2} ${percent}% ${curr_total} ${desc}`;
+    else
+        progressChars = `${chars1}${chars2} ${desc}`;
+    if (!shareData.FULL_AUTOMATIC) {
+        progressChars = "\r" + progressChars[color] + clear_line_end;
+    } else {
+        progressChars = progressChars + "\n";
+    }
+    if (options.align) {
+        // progressChars = `${alignStr(progressChars, stdout_columns, {alignment: Alignment.LEFT})}`;
+    } else {
+        //     // 清空本行
+        // clearLine();
+        //     write(`${progressChars}`)
+    }
+    write(progressChars);
+}
+
+module.exports = {
+    progress,
+};