secrez 1.1.1 → 1.1.2

package/src/commands/Find.js

@@ -1,210 +1,215 @@
-const chalk = require('chalk')
-const {Node} = require('@secrez/fs')
-
-class Find extends require('../Command') {
+const chalk = require("chalk");
+const { Node } = require("@secrez/fs");
 
+class Find extends require("../Command") {
   setHelpAndCompletion() {
     this.cliConfig.completion.find = {
       _func: this.selfCompletion(this),
-      _self: this
-    }
-    this.cliConfig.completion.help.find = true
+      _self: this,
+    };
+    this.cliConfig.completion.help.find = true;
     this.optionDefinitions = [
       {
-        name: 'help',
-        alias: 'h',
-        type: Boolean
+        name: "help",
+        alias: "h",
+        type: Boolean,
       },
       {
-        name: 'keywords',
-        alias: 'k',
+        name: "keywords",
+        alias: "k",
         defaultOption: true,
-        type: String
+        type: String,
       },
       {
-        name: 'content',
-        alias: 'c',
+        name: "content",
+        alias: "c",
         type: Boolean,
-        hint: 'Search also in contents'
+        hint: "Search also in contents",
       },
       {
-        name: 'all',
-        alias: 'a',
+        name: "all",
+        alias: "a",
         type: Boolean,
-        hint: 'Search all the versions'
+        hint: "Search all the versions",
       },
       {
-        name: 'sensitive',
-        alias: 's',
+        name: "sensitive",
+        alias: "s",
         type: Boolean,
-        hint: 'Make the search case-sensitive'
+        hint: "Make the search case-sensitive",
       },
       {
-        name: 'root',
-        alias: 'r',
+        name: "root",
+        alias: "r",
         type: Boolean,
-        hint: 'Search starting from the root'
+        hint: "Search starting from the root",
       },
       {
-        name: 'global',
-        alias: 'g',
+        name: "global",
+        alias: "g",
         type: Boolean,
-        hint: 'Search in all the datasets'
+        hint: "Search in all the datasets",
       },
       {
-        name: 'trash-too',
-        alias: 't',
+        name: "trash-too",
+        alias: "t",
         type: Boolean,
-        hint: 'If global, search also in trash'
-      }
-    ]
+        hint: "If global, search also in trash",
+      },
+    ];
   }
 
   help() {
     return {
       description: [
-        'Find a secret.',
-        'By default the search is case-unsensitive.'
+        "Find a secret.",
+        "By default the search is case-unsensitive.",
       ],
       examples: [
-        ['find Ethereum', 'Search for entries with ethereum or Ethereum in the name'],
-        ['find -c 0xAB', 'Search for files with the string "0xAB" in their content'],
-        ['find -sn Wallet', 'Search for names containings "Wallet" from the current dir'],
-        ['find Wallet -ag', 'Search scanning all the versions in all the datasets'],
-        ['find archive:allet', 'Search allet in the archive dataset']
-      ]
-    }
+        [
+          "find Ethereum",
+          "Search for entries with ethereum or Ethereum in the name",
+        ],
+        [
+          "find -c 0xAB",
+          'Search for files with the string "0xAB" in their content',
+        ],
+        [
+          "find -sn Wallet",
+          'Search for names containings "Wallet" from the current dir',
+        ],
+        [
+          "find Wallet -ag",
+          "Search scanning all the versions in all the datasets",
+        ],
+        ["find archive:allet", "Search allet in the archive dataset"],
+      ],
+    };
   }
 
   async find(options) {
     if (!options.name && options.keywords) {
-      options.name = options.keywords
+      options.name = options.keywords;
     }
-    let splitted = options.name.split(':')
-    let withDataset = splitted.length > 1
+    let splitted = options.name.split(":");
+    let withDataset = splitted.length > 1;
     if (options.global || (splitted[1] && !splitted[0])) {
       if (withDataset) {
-        options.name = splitted[1]
+        options.name = splitted[1];
       }
       if (!options.name) {
-        throw new Error('Keywords required')
+        throw new Error("Keywords required");
       }
-      let datasetInfo = await this.internalFs.getDatasetsInfo()
-      let results = []
+      let datasetInfo = await this.internalFs.getDatasetsInfo();
+      let results = [];
       for (let dataset of datasetInfo) {
         if (options.global && !options.trashToo && dataset.index === 1) {
-          continue
+          continue;
         }
-        await this.internalFs.mountTree(dataset.index)
-        options.tree = this.internalFs.trees[dataset.index]
-        options.dataset = dataset.name
-        results = results.concat(await this._find(options))
+        await this.internalFs.mountTree(dataset.index);
+        options.tree = this.internalFs.trees[dataset.index];
+        options.dataset = dataset.name;
+        results = results.concat(await this._find(options));
       }
-      return results
+      return results;
     } else {
-      let data = await this.internalFs.getTreeIndexAndPath(options.name)
+      let data = await this.internalFs.getTreeIndexAndPath(options.name);
       if (withDataset) {
-        options.dataset = data.name
+        options.dataset = data.name;
       }
-      options.name = data.path
-      options.tree = data.tree
-      return await this._find(options)
+      options.name = data.path;
+      options.tree = data.tree;
+      return await this._find(options);
     }
   }
 
   async _find(options) {
-    let start = options.tree[options.root ? 'root' : 'workingNode']
-    return (await start.find(options)).map(e => {
+    let start = options.tree[options.root ? "root" : "workingNode"];
+    return (await start.find(options)).map((e) => {
       if (options.dataset) {
-        e[1] = options.dataset + ':' + e[1]
+        e[1] = options.dataset + ":" + e[1];
       }
-      return e
-    })
+      return e;
+    });
   }
 
   formatResult(result, re) {
     if (re.test(result)) {
-      return result.replace(re, a => chalk.bold(a))
+      return result.replace(re, (a) => chalk.bold(a));
     } else {
-      return result
+      return result;
     }
   }
 
   formatIndex(len, i) {
-    return ' '.repeat(len.toString().length - i.toString().length) + i
+    return " ".repeat(len.toString().length - i.toString().length) + i;
   }
 
   formatList(list, options) {
-    let re = Node.getFindRe(options)
-    let i = 0
+    let re = Node.getFindRe(options);
+    let i = 0;
     const setCache = (i, e) => {
-      this.prompt.setCache('findResult', i, e)
-    }
-    return list.map(e => {
-      i++
-      let k = this.formatIndex(list.length, i)
+      this.prompt.setCache("findResult", i, e);
+    };
+    return list.map((e) => {
+      i++;
+      let k = this.formatIndex(list.length, i);
       if (options.all) {
-        let p = e[1].split('/')
-        let l = p.length
-        let c = p[l - 1] ? p[l - 1] : p[l - 2]
+        let p = e[1].split("/");
+        let l = p.length;
+        let c = p[l - 1] ? p[l - 1] : p[l - 2];
         if (e[2] && e[2] !== c) {
-          e[2] = this.formatResult(e[2], re, options.name)
+          e[2] = this.formatResult(e[2], re, options.name);
         } else {
-          e[2] = undefined
+          e[2] = undefined;
         }
-        setCache(i, e)
+        setCache(i, e);
         return [
           k,
-          '  ',
+          "  ",
           chalk.yellow(e[0]),
-          '  ',
+          "  ",
           this.formatResult(e[1], re, options.name),
-          '  ',
-          e[2]
-        ].join('')
-
+          "  ",
+          e[2],
+        ].join("");
       } else {
-        setCache(i, e)
-        return [
-          k,
-          '  ',
-          this.formatResult(e[1], re, options.name)
-        ].join('')
+        setCache(i, e);
+        return [k, "  ", this.formatResult(e[1], re, options.name)].join("");
       }
-    })
+    });
   }
 
   async exec(options = {}) {
     if (options.help) {
-      return this.showHelp()
+      return this.showHelp();
     }
     try {
-      this.validate(options)
-      options.name = options.keywords
+      this.validate(options);
+      options.name = options.keywords;
       if (options.name) {
         try {
-          this.lastResult = await this.find(options)
-          let list = this.formatList(this.lastResult, options)
+          this.lastResult = await this.find(options);
+          let list = this.formatList(this.lastResult, options);
           if (list && list.length) {
-            this.Logger.grey(`${list.length} result${list.length > 1 ? 's' : ''} found:`)
-            for (let l of list) this.Logger.reset(l)
+            this.Logger.grey(
+              `${list.length} result${list.length > 1 ? "s" : ""} found:`
+            );
+            for (let l of list) this.Logger.reset(l);
           } else {
-            this.Logger.grey('No results.')
+            this.Logger.grey("No results.");
           }
-
         } catch (e) {
-          this.Logger.red(e.message)
+          this.Logger.red(e.message);
         }
       } else {
-        this.Logger.grey('Missing parameters')
+        this.Logger.grey("Missing parameters");
       }
     } catch (e) {
-      this.Logger.red(e.message)
+      this.Logger.red(e.message);
     }
-    await this.prompt.run()
+    await this.prompt.run();
   }
 }
 
-module.exports = Find
-
-
+module.exports = Find;

package/src/commands/Help.js

@@ -1,50 +1,47 @@
-const HelpProto = require('../utils/HelpProto')
-
-class Help extends require('../Command') {
+const HelpProto = require("../utils/HelpProto");
 
+class Help extends require("../Command") {
   constructor(prompt) {
-    super(prompt)
+    super(prompt);
     this.proto = new HelpProto({
       prompt: this.prompt,
       cliConfig: this.cliConfig,
       helpDescription: this.helpDescription,
-      completions: this.completion
-    })
+      completions: this.completion,
+    });
   }
 
   setHelpAndCompletion() {
     this.optionDefinitions = [
       {
-        name: 'command',
-        alias: 'c',
+        name: "command",
+        alias: "c",
         defaultOption: true,
-        type: String
-      }
-    ]
+        type: String,
+      },
+    ];
   }
 
   help() {
-    return this.proto.help()
+    return this.proto.help();
   }
 
   async exec(options = {}) {
-    let help
-    let command = options.command
+    let help;
+    let command = options.command;
     if (command) {
       if (this.prompt.commands[command]) {
-        help = this.prompt.commands[command].help()
+        help = this.prompt.commands[command].help();
       } else {
-        this.Logger.red('Invalid command.')
-        return await this.prompt.run()
+        this.Logger.red("Invalid command.");
+        return await this.prompt.run();
       }
     } else {
-      help = this.help()
+      help = this.help();
     }
-    this.proto.format(help, command)
-    await this.prompt.run()
+    this.proto.format(help, command);
+    await this.prompt.run();
   }
 }
 
-module.exports = Help
-
-
+module.exports = Help;