secrez 1.1.1 → 1.1.2

package/src/prompts/CommandPrompt.js

@@ -1,184 +1,192 @@
-const chalk = require('chalk')
-const _ = require('lodash')
-const fs = require('fs-extra')
-const inquirer = require('inquirer')
+const chalk = require("chalk");
+const _ = require("lodash");
+const fs = require("fs-extra");
+const inquirer = require("inquirer");
 
 // eslint-disable-next-line node/no-unpublished-require
 // const inquirerCommandPrompt = require('../../../../../inquirer-command-prompt')
-const inquirerCommandPrompt = require('inquirer-command-prompt')
-const multiEditorPrompt = require('./MultiEditorPrompt')
-inquirer.registerPrompt('command', inquirerCommandPrompt)
-inquirer.registerPrompt('multiEditor', multiEditorPrompt)
+const inquirerCommandPrompt = require("inquirer-command-prompt");
+const multiEditorPrompt = require("./MultiEditorPrompt");
+inquirer.registerPrompt("command", inquirerCommandPrompt);
+inquirer.registerPrompt("multiEditor", multiEditorPrompt);
 
-const {sleep, getKeyValue} = require('@secrez/utils')
-const Completion = require('./Completion')
-const {FsUtils} = require('@secrez/fs')
-const Logger = require('../utils/Logger')
-const cliConfig = require('../cliConfig')
-const sigintManager = require('./SigintManager')
+const { sleep, getKeyValue } = require("@secrez/utils");
+const Completion = require("./Completion");
+const { FsUtils } = require("@secrez/fs");
+const Logger = require("../utils/Logger");
+const cliConfig = require("../cliConfig");
+const sigintManager = require("./SigintManager");
 
-let thiz
+let thiz;
 
 class CommandPrompt {
-
   async getReady(options) {
-    thiz = this
-    this.inquirer = inquirer
-    this.commandPrompt = inquirerCommandPrompt
-    this.historyPath = options.historyPath
+    thiz = this;
+    this.inquirer = inquirer;
+    this.commandPrompt = inquirerCommandPrompt;
+    this.historyPath = options.historyPath;
     inquirerCommandPrompt.setConfig({
       history: {
         save: false,
-        limit: 100
+        limit: 100,
       },
-      onCtrlEnd: thiz.reorderCommandLineWithDefaultAtEnd
-    })
-    this.completion = cliConfig[options.completion]
-    this.commands = options.commands
-    this.environment = options.environment
-    this.context = options.context || 0
-    await this.setSigintPosition()
+      onCtrlEnd: thiz.reorderCommandLineWithDefaultAtEnd,
+    });
+    this.completion = cliConfig[options.completion];
+    this.commands = options.commands;
+    this.environment = options.environment;
+    this.context = options.context || 0;
+    await this.setSigintPosition();
   }
 
   async setSigintPosition() {
-    const {position, runNow} = await sigintManager.setPosition(this)
-    this.sigintPosition = position
+    const { position, runNow } = await sigintManager.setPosition(this);
+    this.sigintPosition = position;
     if (runNow) {
-      await this.run()
+      await this.run();
     }
   }
 
   startSigintManager() {
-    sigintManager.start()
+    sigintManager.start();
   }
 
   async firstRun() {
     if (!this.getCommands) {
-      this.getCommands = Completion(this.completion)
-      this.basicCommands = await this.getCommands()
-      this.getCommands.bind(this)
+      this.getCommands = Completion(this.completion);
+      this.basicCommands = await this.getCommands();
+      this.getCommands.bind(this);
     }
   }
 
   reorderCommandLineWithDefaultAtEnd(line) {
     // reorder the line to put autocompletable words at the end of the line
-    let previousLine = line
-    line = _.trim(line).split(' ')
-    let cmd = line[0]
+    let previousLine = line;
+    line = _.trim(line).split(" ");
+    let cmd = line[0];
     if (cmd && thiz.commands[cmd]) {
-      let definitions = thiz.commands[cmd].optionDefinitions
-      let def = {}
-      let selfCompletables = 0
+      let definitions = thiz.commands[cmd].optionDefinitions;
+      let def = {};
+      let selfCompletables = 0;
       for (let d of definitions) {
-        def[d.name] = d
-        if (d.defaultOption || d.isCompletable) selfCompletables++
+        def[d.name] = d;
+        if (d.defaultOption || d.isCompletable) selfCompletables++;
       }
-      let params = FsUtils.parseCommandLine(definitions, line.slice(1).join(' '))
-      let result = []
+      let params = FsUtils.parseCommandLine(
+        definitions,
+        line.slice(1).join(" ")
+      );
+      let result = [];
       for (let key in params) {
-        if (key !== '_unknown') {
-          result.push(getKeyValue(params, key))
+        if (key !== "_unknown") {
+          result.push(getKeyValue(params, key));
         }
       }
       result.sort((a, b) => {
-        let A = def[a.key]
-        let B = def[b.key]
-        return (
-            A.defaultOption ? 1
-                : B.defaultOption ? -1
-                : A.isCompletable ? 1
-                    : B.isCompletable ? -1
-                        : 0
-        )
-      })
-      let ret = [cmd]
+        let A = def[a.key];
+        let B = def[b.key];
+        return A.defaultOption
+          ? 1
+          : B.defaultOption
+          ? -1
+          : A.isCompletable
+          ? 1
+          : B.isCompletable
+          ? -1
+          : 0;
+      });
+      let ret = [cmd];
       for (let c of result) {
         if (!def[c.key].defaultOption) {
           if (ret.length && /^-/.test(ret[ret.length - 1])) {
-            ret[ret.length - 1] += def[c.key].alias
+            ret[ret.length - 1] += def[c.key].alias;
           } else {
-            ret.push('-' + def[c.key].alias)
+            ret.push("-" + def[c.key].alias);
           }
         }
         if (def[c.key].type !== Boolean) {
-          ret.push(c.value)
+          ret.push(c.value);
         }
       }
-      if (selfCompletables === 2 && previousLine === ret.join(' ')) {
-        let len = ret.length
+      if (selfCompletables === 2 && previousLine === ret.join(" ")) {
+        let len = ret.length;
         if (len > 3) {
-          ret = ret.slice(0, len - 3)
-              .concat(ret.slice(len - 1, len))
-              .concat(ret.slice(len - 3, len - 1))
+          ret = ret
+            .slice(0, len - 3)
+            .concat(ret.slice(len - 1, len))
+            .concat(ret.slice(len - 3, len - 1));
         }
       }
-      return ret.join(' ')
+      return ret.join(" ");
     } else {
-      return ''
+      return "";
     }
   }
 
   async saveHistory() {
-    let histories = JSON.stringify(inquirerCommandPrompt.getHistories(true))
-    let encryptedHistory = this.secrez.encryptData(histories)
-    await fs.writeFile(this.historyPath, encryptedHistory)
+    let histories = JSON.stringify(inquirerCommandPrompt.getHistories(true));
+    let encryptedHistory = this.secrez.encryptData(histories);
+    await fs.writeFile(this.historyPath, encryptedHistory);
   }
 
   async loadSavedHistory() {
-    let previousHistories
+    let previousHistories;
     if (await fs.pathExists(this.historyPath)) {
-      let encryptedHistory = await fs.readFile(this.historyPath, 'utf8')
-      previousHistories = JSON.parse(this.secrez.decryptData(encryptedHistory))
-      inquirerCommandPrompt.setHistoryFromPreviousSavedHistories(previousHistories)
+      let encryptedHistory = await fs.readFile(this.historyPath, "utf8");
+      previousHistories = JSON.parse(this.secrez.decryptData(encryptedHistory));
+      inquirerCommandPrompt.setHistoryFromPreviousSavedHistories(
+        previousHistories
+      );
     }
   }
 
   async loading() {
-    this.loadingIndex = 0
-    this.showLoading = true
-    await sleep(100)
+    this.loadingIndex = 0;
+    this.showLoading = true;
+    await sleep(100);
     while (this.showLoading) {
-      const loader = ['\\', '|', '/', '-']
-      this.loadingIndex = (this.loadingIndex + 1) % 4
-      process.stdout.write(loader[this.loadingIndex] + ' ' + this.loadingMessage)
-      await sleep(100)
-      process.stdout.clearLine()
-      process.stdout.cursorTo(0)
+      const loader = ["\\", "|", "/", "-"];
+      this.loadingIndex = (this.loadingIndex + 1) % 4;
+      process.stdout.write(
+        loader[this.loadingIndex] + " " + this.loadingMessage
+      );
+      await sleep(100);
+      process.stdout.clearLine();
+      process.stdout.cursorTo(0);
     }
   }
 
   short(l, m) {
-    let res = []
+    let res = [];
     if (l) {
-      l = _.trim(l)
-      let r = l.split('/')
+      l = _.trim(l);
+      let r = l.split("/");
       if (r.length !== 1) {
-        r.pop()
-        r = r.join('/') + '/'
+        r.pop();
+        r = r.join("/") + "/";
       } else {
-        r = l.split(' ')
+        r = l.split(" ");
         if (r.length !== 1) {
-          r.pop()
-          r = r.join(' ') + ' '
+          r.pop();
+          r = r.join(" ") + " ";
         } else {
-          r = l
+          r = l;
         }
       }
       for (let i = 0; i < m.length; i++) {
         try {
           if (m[i] !== l) {
             if (r !== l) {
-              m[i] = m[i].replace(RegExp('^' + r), '')
+              m[i] = m[i].replace(RegExp("^" + r), "");
             }
             if (m[i]) {
-              res.push(m[i].replace(/^(-[a-zA-Z]{1} |--\w+(=| ))/, ''))
+              res.push(m[i].replace(/^(-[a-zA-Z]{1} |--\w+(=| ))/, ""));
             }
           }
-        } catch (e) {
-        }
+        } catch (e) {}
       }
     }
-    return res
+    return res;
   }
 
   async preRun(options) {
@@ -190,44 +198,44 @@ class CommandPrompt {
   }
 
   prePromptMessage() {
-    return 'MainPrompt'
+    return "MainPrompt";
   }
 
   promptMessage() {
-    return '$'
+    return "$";
   }
 
   availableOptionsMessage(options) {
-    return chalk.grey('Available options:')
+    return chalk.grey("Available options:");
   }
 
   noColorOnAnswered() {
-    return false
+    return false;
   }
 
   colorOnAnswered() {
-    return 'grey'
+    return "grey";
   }
 
   onBeforeRewrite(line) {
     if (/ (#|£)\d+(\w+:|)\/[\w/]+/.test(line)) {
-      line = line.replace(/ (#|£)\d+((\w+:|)\/[\w/]+)/,' $2')
+      line = line.replace(/ (#|£)\d+((\w+:|)\/[\w/]+)/, " $2");
     }
-    return line
+    return line;
   }
 
   async run(options = {}) {
-    await this.firstRun()
-    await this.preRun(options)
+    await this.firstRun();
+    await this.preRun(options);
     if (this.disableRun) {
-      return
+      return;
     }
     try {
-      let prefix = this.lastPrefix = this.prePromptMessage(options)
-      let {cmd} = await inquirer.prompt([
+      let prefix = (this.lastPrefix = this.prePromptMessage(options));
+      let { cmd } = await inquirer.prompt([
         {
-          type: 'command',
-          name: 'cmd',
+          type: "command",
+          name: "cmd",
           autoCompletion: this.getCommands,
           short: this.short,
           prefix,
@@ -240,57 +248,57 @@ class CommandPrompt {
           onBeforeRewrite: this.onBeforeRewrite,
           context: this.context,
           onClose: () => {
-            fs.emptyDirSync(this.secrez.config.tmpPath)
+            fs.emptyDirSync(this.secrez.config.tmpPath);
           },
-          validate: val => {
-            return val
-                ? true
-                : chalk.grey('Press TAB for suggestions.')
-          }
-        }
-      ])
-      options.cmd = _.trim(cmd)
-      await this.postRun(options)
+          validate: (val) => {
+            return val ? true : chalk.grey("Press TAB for suggestions.");
+          },
+        },
+      ]);
+      options.cmd = _.trim(cmd);
+      await this.postRun(options);
     } catch (e) {
-      console.error(e)
-      Logger.red(e.message)
+      console.error(e);
+      Logger.red(e.message);
     }
   }
 
   getRl() {
-    return inquirerCommandPrompt.getRl()
+    return inquirerCommandPrompt.getRl();
   }
 
   async exec(cmds, noRun) {
     for (let cmd of cmds) {
       if (cmd) {
-        cmd = cmd.split(' ')
-        const command = cmd[0]
+        cmd = cmd.split(" ");
+        const command = cmd[0];
         if (this.basicCommands.includes(command)) {
-          let commandLine = cmd.slice(1).join(' ')
+          let commandLine = cmd.slice(1).join(" ");
           if (!commandLine) {
             // prevent command-line-args from parsing process.argv
-            commandLine = ' '
+            commandLine = " ";
           }
           try {
-            const options = FsUtils.parseCommandLine(this.commands[command].optionDefinitions, commandLine, true)
-            await this.commands[command].exec(options)
+            const options = FsUtils.parseCommandLine(
+              this.commands[command].optionDefinitions,
+              commandLine,
+              true
+            );
+            await this.commands[command].exec(options);
           } catch (e) {
             // console.error(e)
-            Logger.red(e.message)
-            await this.run()
+            Logger.red(e.message);
+            await this.run();
           }
         } else {
-          Logger.red('Command not found')
+          Logger.red("Command not found");
           if (!noRun) {
-            await this.run()
+            await this.run();
           }
         }
       }
     }
   }
-
 }
 
-module.exports = CommandPrompt
-
+module.exports = CommandPrompt;

package/src/prompts/Completion.js

@@ -1,112 +1,107 @@
-const _ = require('lodash')
-const {FsUtils} = require('@secrez/fs')
+const _ = require("lodash");
+const { FsUtils } = require("@secrez/fs");
 
 class _Completion {
-
   constructor(completion) {
-    this.completion = completion
+    this.completion = completion;
   }
 
   basicCommands() {
     if (!this.commands) {
-      this.commands = []
+      this.commands = [];
       for (let c in this.completion) {
-        this.commands.push(c)
+        this.commands.push(c);
       }
-      this.commands.sort()
+      this.commands.sort();
     }
-    return this.commands
+    return this.commands;
   }
 
-  async subCommands(line = '', forceCommand) {
-    const originalLine = line
-    const params = line.split(' ')
-    const normalizedParams = params.map(e => e.split('=')[0])
-    const command = params[0]
-    let c = this.completion[command]
+  async subCommands(line = "", forceCommand) {
+    const originalLine = line;
+    const params = line.split(" ");
+    const normalizedParams = params.map((e) => e.split("=")[0]);
+    const command = params[0];
+    let c = this.completion[command];
     if (!c && forceCommand) {
-      c = this.completion[forceCommand]
-      line = forceCommand + ' ' + line
+      c = this.completion[forceCommand];
+      line = forceCommand + " " + line;
     }
-    if (typeof c === 'object') {
-      let commands = []
-      let options = {}
+    if (typeof c === "object") {
+      let commands = [];
+      let options = {};
       if (c._func) {
-        let commandLine = _.trim(line).split(' ').slice(1).join(' ')
-        const definitions = c._self.optionDefinitions
-        options = FsUtils.parseCommandLine(definitions, commandLine)
+        let commandLine = _.trim(line).split(" ").slice(1).join(" ");
+        const definitions = c._self.optionDefinitions;
+        options = FsUtils.parseCommandLine(definitions, commandLine);
         if (options._unknown) {
-          options = {}
+          options = {};
         }
-        let optionsKeys = Object.keys(options)
-        let currentOption = optionsKeys.pop()
+        let optionsKeys = Object.keys(options);
+        let currentOption = optionsKeys.pop();
         if (currentOption === undefined) {
-          let defaultOption = definitions.filter(e => e.defaultOption === true)[0]
+          let defaultOption = definitions.filter(
+            (e) => e.defaultOption === true
+          )[0];
           if (defaultOption) {
-            defaultOption = defaultOption.name
+            defaultOption = defaultOption.name;
           }
-          currentOption = defaultOption
+          currentOption = defaultOption;
         }
-        let files = await c._func(options, originalLine, currentOption)
-        commands = files
+        let files = await c._func(options, originalLine, currentOption);
+        commands = files;
       } else {
-        commands = _.filter(
-            Object.keys(c),
-            o => {
-              return !normalizedParams.includes(o)
-            }
-        )
-        if (commands.length === 1 && commands[0] === '_self') {
-          commands = []
+        commands = _.filter(Object.keys(c), (o) => {
+          return !normalizedParams.includes(o);
+        });
+        if (commands.length === 1 && commands[0] === "_self") {
+          commands = [];
         }
       }
       if (commands.length) {
-        let l = line
-        let lastSpace = l.lastIndexOf(' ')
+        let l = line;
+        let lastSpace = l.lastIndexOf(" ");
         for (;;) {
-          if (l[lastSpace - 1] !== '\\') {
-            break
+          if (l[lastSpace - 1] !== "\\") {
+            break;
           }
-          l = l.substring(0, lastSpace)
-          lastSpace = l.lastIndexOf(' ')
+          l = l.substring(0, lastSpace);
+          lastSpace = l.lastIndexOf(" ");
         }
         let lasts = [
-          {n: '/', l: line.lastIndexOf('/')},
-          {n: '=', l: line.lastIndexOf('=')},
-          {n: ' ', l: lastSpace}
-        ]
+          { n: "/", l: line.lastIndexOf("/") },
+          { n: "=", l: line.lastIndexOf("=") },
+          { n: " ", l: lastSpace },
+        ];
         lasts.sort((a, b) => {
-          let A = a.l
-          let B = b.l
-          return A > B ? -1 : A < B ? 1 : 0
-        })
-        let v = lasts[0].l
-        let prefix = v !== -1 ? line.substring(0, v) + lasts[0].n : line
+          let A = a.l;
+          let B = b.l;
+          return A > B ? -1 : A < B ? 1 : 0;
+        });
+        let v = lasts[0].l;
+        let prefix = v !== -1 ? line.substring(0, v) + lasts[0].n : line;
         if (c._self && !!c._self.prompt.commands[prefix]) {
-          prefix += ' '
+          prefix += " ";
         }
-        commands = commands.map(e => `${prefix}${
-            e
-                ? e.replace(/ /g, '\\ ')
-                : ' '
-        }`)
-        return commands
+        commands = commands.map(
+          (e) => `${prefix}${e ? e.replace(/ /g, "\\ ") : " "}`
+        );
+        return commands;
       }
     }
   }
 }
 
 function Completion(completion, forceCommand) {
-  const instance = new _Completion(completion)
+  const instance = new _Completion(completion);
 
-  return async line => {
-    let subCommands = await instance.subCommands(line, forceCommand)
+  return async (line) => {
+    let subCommands = await instance.subCommands(line, forceCommand);
     if (subCommands) {
-      return subCommands
+      return subCommands;
     }
-    return instance.basicCommands()
-  }
+    return instance.basicCommands();
+  };
 }
 
-
-module.exports = Completion
+module.exports = Completion;