secrez 1.1.0 → 1.1.2

package/src/commands/Mv.js

@@ -1,211 +1,244 @@
-const _ = require('lodash')
-const {Node} = require('@secrez/fs')
-
-class Mv extends require('../Command') {
+const _ = require("lodash");
+const { Node } = require("@secrez/fs");
 
+class Mv extends require("../Command") {
   setHelpAndCompletion() {
     this.cliConfig.completion.mv = {
       _func: this.selfCompletion(this),
-      _self: this
-    }
-    this.cliConfig.completion.help.mv = true
+      _self: this,
+    };
+    this.cliConfig.completion.help.mv = true;
     this.optionDefinitions = [
       {
-        name: 'help',
-        alias: 'h',
-        type: Boolean
+        name: "help",
+        alias: "h",
+        type: Boolean,
       },
       {
-        name: 'path',
-        completionType: 'file',
-        alias: 'p',
+        name: "path",
+        completionType: "file",
+        alias: "p",
         defaultOption: true,
         multiple: true,
-        type: String
+        type: String,
       },
       {
-        name: 'find',
-        type: String
+        name: "find",
+        type: String,
       },
       {
-        name: 'destination',
-        alias: 'd',
-        type: String
+        name: "destination",
+        alias: "d",
+        type: String,
       },
       {
-        name: 'content-too',
-        type: Boolean
+        name: "content-too",
+        type: Boolean,
       },
       {
-        name: 'span',
-        type: Boolean
-      }
-    ]
+        name: "span",
+        type: Boolean,
+      },
+    ];
   }
 
   help() {
     return {
-      description: ['Moves and renames files or folders.',
-        'If a destination is not specified it tries to move to the current folder.'],
+      description: [
+        "Moves and renames files or folders.",
+        "If a destination is not specified it tries to move to the current folder.",
+      ],
       examples: [
-        'mv somefile someother',
-        'mv -p ../dir1/file -d ../dir1/file-renamed',
-        ['mv pass/email* emails', 'moves all the files starting from email contained in pass'],
-        ['mv pass/email* archive:/old/email',
-          'moves all the files starting from email contained in pass',
+        "mv somefile someother",
+        "mv -p ../dir1/file -d ../dir1/file-renamed",
+        [
+          "mv pass/email* emails",
+          "moves all the files starting from email contained in pass",
+        ],
+        [
+          "mv pass/email* archive:/old/email",
+          "moves all the files starting from email contained in pass",
           'to the folder "/old/email" in the "archive" dataset;',
-          'The autocomplete works only in the current dataset (for now)'
+          "The autocomplete works only in the current dataset (for now)",
         ],
-        ['mv archive:/old/email/* /old-email',
-          'moves all the files starting from email contained in /old/email',
-          'in the "archive" dataset to the folder "/old-email" in the current dataset'
+        [
+          "mv archive:/old/email/* /old-email",
+          "moves all the files starting from email contained in /old/email",
+          'in the "archive" dataset to the folder "/old-email" in the current dataset',
         ],
-        ['mv --find email -d /emails', 'moves all the files found searching email to /emails;'],
-        ['mv --find email -d /emails --content-too', 'moves all the files found searching email in paths and contents'],
-        ['mv --find email -d archive:/emails --span ', 'moves all the files flattening the results']
-      ]
-    }
+        [
+          "mv --find email -d /emails",
+          "moves all the files found searching email to /emails;",
+        ],
+        [
+          "mv --find email -d /emails --content-too",
+          "moves all the files found searching email in paths and contents",
+        ],
+        [
+          "mv --find email -d archive:/emails --span ",
+          "moves all the files flattening the results",
+        ],
+      ],
+    };
   }
 
   async mv(options, nodes) {
-    let dataFrom = await this.internalFs.getTreeIndexAndPath(options.path)
-    await this.internalFs.mountTree(dataFrom.index)
-    let dataTo = await this.internalFs.getTreeIndexAndPath(options.newPath)
+    let dataFrom = await this.internalFs.getTreeIndexAndPath(options.path);
+    await this.internalFs.mountTree(dataFrom.index);
+    let dataTo = await this.internalFs.getTreeIndexAndPath(options.newPath);
     if (dataFrom.index !== dataTo.index) {
-      await this.internalFs.mountTree(dataTo.index)
-    } else
-        /* istanbul ignore if  */
-    if (dataFrom.index === 1 && options.removing) {
+      await this.internalFs.mountTree(dataTo.index);
+    } else if (dataFrom.index === 1 && options.removing) {
+      /* istanbul ignore if  */
       let yes = await this.useConfirm({
-        message: 'Are you sure you want to definitely remove those file from Secrez?',
-        default: false
-      })
+        message:
+          "Are you sure you want to definitely remove those file from Secrez?",
+        default: false,
+      });
       if (!yes) {
-        throw new Error('Operation canceled')
+        throw new Error("Operation canceled");
       }
     }
     if (nodes) {
-      this.internalFs.trees[dataFrom.index].disableSave()
-      this.internalFs.trees[dataTo.index].disableSave()
+      this.internalFs.trees[dataFrom.index].disableSave();
+      this.internalFs.trees[dataTo.index].disableSave();
       for (let node of nodes) {
-        let opt = _.clone(options)
-        await this.internalFs.change(Object.assign(opt, {path: `${dataFrom.name}:${node.getPath()}`}))
+        let opt = _.clone(options);
+        await this.internalFs.change(
+          Object.assign(opt, { path: `${dataFrom.name}:${node.getPath()}` })
+        );
       }
-      this.internalFs.trees[dataFrom.index].enableSave()
-      await this.internalFs.trees[dataFrom.index].save()
+      this.internalFs.trees[dataFrom.index].enableSave();
+      await this.internalFs.trees[dataFrom.index].save();
       if (dataFrom.index !== dataTo.index) {
-        this.internalFs.trees[dataTo.index].enableSave()
-        await this.internalFs.trees[dataTo.index].save()
+        this.internalFs.trees[dataTo.index].enableSave();
+        await this.internalFs.trees[dataTo.index].save();
       }
     } else {
-      await this.internalFs.change(options)
+      await this.internalFs.change(options);
     }
   }
 
   async isNotDir(options = {}) {
-    let dir
+    let dir;
     try {
-      let data = await this.internalFs.getTreeIndexAndPath(options.newPath || '')
-      let to = data.name
-      let index = this.internalFs.tree.datasetIndex
+      let data = await this.internalFs.getTreeIndexAndPath(
+        options.newPath || ""
+      );
+      let to = data.name;
+      let index = this.internalFs.tree.datasetIndex;
       if (to) {
-        let datasetInfo = await this.internalFs.getDatasetInfo(to)
+        let datasetInfo = await this.internalFs.getDatasetInfo(to);
         if (!datasetInfo) {
-          throw new Error('Destination dataset does not exist')
+          throw new Error("Destination dataset does not exist");
         }
-        index = datasetInfo.index
-        await this.internalFs.mountTree(index)
+        index = datasetInfo.index;
+        await this.internalFs.mountTree(index);
       }
-      let p = this.internalFs.normalizePath(data.path, index)
-      dir = this.internalFs.trees[index].root.getChildFromPath(p)
-    } catch (e) {
-    }
-    return !(dir && Node.isDir(dir))
+      let p = this.internalFs.normalizePath(data.path, index);
+      dir = this.internalFs.trees[index].root.getChildFromPath(p);
+    } catch (e) {}
+    return !(dir && Node.isDir(dir));
   }
 
   async exec(options = {}) {
     if (options.help) {
-      return this.showHelp()
+      return this.showHelp();
     }
     try {
-      this.validate(options)
+      this.validate(options);
       if (options.find) {
-        options.newPath = options.destination
-        options.path = options.find
+        options.newPath = options.destination;
+        options.path = options.find;
       } else {
         if (options.destination) {
-          options.newPath = options.destination
-
+          options.newPath = options.destination;
         } else {
-          options.newPath = options.path[1]
+          options.newPath = options.path[1];
         }
-        options.path = options.path[0]
+        options.path = options.path[0];
       }
       if (!options.path && !options.find) {
-        throw new Error('An origin path is required.')
+        throw new Error("An origin path is required.");
       } else {
         if (!options.newPath) {
-          options.message = 'Destination not set.\nWould you like to move to the current active directory in the target dataset?'
-          options.default = false
-          let yes = await this.useConfirm(options)
+          options.message =
+            "Destination not set.\nWould you like to move to the current active directory in the target dataset?";
+          options.default = false;
+          let yes = await this.useConfirm(options);
           if (yes) {
-            options.newPath = '.'
+            options.newPath = ".";
           } else {
-            throw new Error('Operation canceled')
+            throw new Error("Operation canceled");
           }
         }
-        let dataFrom = await this.internalFs.getTreeIndexAndPath(options.path)
-        let mustBeFolder = options.find || /\?|\*/.test(options.path)
-        let nodes
+        let dataFrom = await this.internalFs.getTreeIndexAndPath(options.path);
+        let mustBeFolder = options.find || /\?|\*/.test(options.path);
+        let nodes;
         if (options.find) {
-          options.getNodes = true
-          options.name = options.find
-          options.content = options.contentToo
-          nodes = await this.prompt.commands.find.find(options)
+          options.getNodes = true;
+          options.name = options.find;
+          options.content = options.contentToo;
+          nodes = await this.prompt.commands.find.find(options);
           if (!options.span) {
             for (let i = 0; i < nodes.length; i++) {
               if (i > 0) {
                 if (Node.isAncestor(nodes[i - 1], nodes[i])) {
-                  nodes.splice(i, 1)
-                  i--
+                  nodes.splice(i, 1);
+                  i--;
                 }
               }
             }
           }
         } else {
-          nodes = await this.internalFs.fileList({
-            path: options.path,
-            asIs: true
-          }, null, true)
+          nodes = await this.internalFs.fileList(
+            {
+              path: options.path,
+              asIs: true,
+            },
+            null,
+            true
+          );
         }
         if (nodes.length) {
           if (mustBeFolder) {
             if (await this.isNotDir(options)) {
-              throw new Error('When using search results or wildcards, the target has to be a folder')
+              throw new Error(
+                "When using search results or wildcards, the target has to be a folder"
+              );
             }
           }
-          let paths = nodes.map(e => [e.getPath(), e.id])
-          await this.mv(Object.assign(options, {newPath: options.newPath}), nodes)
+          let paths = nodes.map((e) => [e.getPath(), e.id]);
+          await this.mv(
+            Object.assign(options, { newPath: options.newPath }),
+            nodes
+          );
           if (options.find) {
-            this.Logger.reset(`The results of searching for ${options.find} has been moved to ${options.newPath}`)
+            this.Logger.reset(
+              `The results of searching for ${options.find} has been moved to ${options.newPath}`
+            );
           } else {
-            this.Logger.reset('The following have been moved:')
-            let data = await this.internalFs.getTreeIndexAndPath(options.newPath || '')
+            this.Logger.reset("The following have been moved:");
+            let data = await this.internalFs.getTreeIndexAndPath(
+              options.newPath || ""
+            );
             for (let p of paths) {
-              this.Logger.reset(`${dataFrom.name}:${p[0]}  >  ${data.name}:${data.tree.root.findChildById(p[1]).getPath()}`)
+              this.Logger.reset(
+                `${dataFrom.name}:${p[0]}  >  ${data.name}:${data.tree.root
+                  .findChildById(p[1])
+                  .getPath()}`
+              );
             }
           }
         } else {
-          this.Logger.red('Path does not exist')
+          this.Logger.red("Path does not exist");
         }
       }
     } catch (e) {
-      this.Logger.red(e.message)
+      this.Logger.red(e.message);
     }
-    await this.prompt.run()
+    await this.prompt.run();
   }
 }
 
-module.exports = Mv
-
-
+module.exports = Mv;

package/src/commands/Paste.js

@@ -1,132 +1,135 @@
-const clipboardy = require('clipboardy')
-const {isYaml, yamlParse, yamlStringify} = require('@secrez/utils')
+const clipboardy = require("clipboardy");
+const { isYaml, yamlParse, yamlStringify } = require("@secrez/utils");
 
-const {Node} = require('@secrez/fs')
-
-class Paste extends require('../Command') {
+const { Node } = require("@secrez/fs");
 
+class Paste extends require("../Command") {
   setHelpAndCompletion() {
     this.cliConfig.completion.paste = {
       _func: this.selfCompletion(this),
-      _self: this
-    }
-    this.cliConfig.completion.help.paste = true
+      _self: this,
+    };
+    this.cliConfig.completion.help.paste = true;
     this.optionDefinitions = [
       {
-        name: 'help',
-        alias: 'h',
-        type: Boolean
+        name: "help",
+        alias: "h",
+        type: Boolean,
       },
       {
-        name: 'path',
-        completionType: 'file',
-        alias: 'p',
+        name: "path",
+        completionType: "file",
+        alias: "p",
         defaultOption: true,
-        type: String
+        type: String,
       },
       {
-        name: 'append',
-        alias: 'a',
-        type: Boolean
+        name: "append",
+        alias: "a",
+        type: Boolean,
       },
       {
-        name: 'field',
-        alias: 'f',
-        type: String
-      }
-    ]
+        name: "field",
+        alias: "f",
+        type: String,
+      },
+    ];
   }
 
   help() {
     return {
       description: [
-        'Paste whatever is in the clipboard in an encrypted entries.'
+        "Paste whatever is in the clipboard in an encrypted entries.",
       ],
       examples: [
-        ['paste ethKeys.json', 'pastes in ethKeys.json even if it exists'],
-        ['paste -a -p google.txt', 'pastes appending the content to the existent content in google.txt'],
-        ['paste yahoo.yml -f password', 'pastes the field password in the card']
-      ]
-    }
+        ["paste ethKeys.json", "pastes in ethKeys.json even if it exists"],
+        [
+          "paste -a -p google.txt",
+          "pastes appending the content to the existent content in google.txt",
+        ],
+        [
+          "paste yahoo.yml -f password",
+          "pastes the field password in the card",
+        ],
+      ],
+    };
   }
 
   async paste(options = {}) {
-    let ifs = this.internalFs
-    let cat = this.prompt.commands.cat
-    let p = this.internalFs.tree.getNormalizedPath(options.path)
-    let file
-    let existingContent
+    let ifs = this.internalFs;
+    let cat = this.prompt.commands.cat;
+    let p = this.internalFs.tree.getNormalizedPath(options.path);
+    let file;
+    let existingContent;
     try {
-      file = ifs.tree.root.getChildFromPath(p)
-      existingContent = (await cat.cat({path: p, unformatted: true}))[0].content
+      file = ifs.tree.root.getChildFromPath(p);
+      existingContent = (await cat.cat({ path: p, unformatted: true }))[0]
+        .content;
     } catch (e) {
       //
     }
     if (file && !Node.isFile(file)) {
-      throw new Error('Cannot paste to a folder or a binary file')
+      throw new Error("Cannot paste to a folder or a binary file");
     }
-    let content
+    let content;
     try {
-      content = await clipboardy.read()
+      content = await clipboardy.read();
     } catch (e) {
-      throw new Error(e.message)
+      throw new Error(e.message);
     }
     if (!content) {
-      throw new Error('The clipboard does not contain any text')
+      throw new Error("The clipboard does not contain any text");
     }
     if (isYaml(p) && options.field) {
-      let parsed = {}
+      let parsed = {};
       if (existingContent) {
         try {
-          parsed = yamlParse(existingContent)
+          parsed = yamlParse(existingContent);
         } catch (e) {
-          throw new Error('The yaml file exists but it is malformed.')
+          throw new Error("The yaml file exists but it is malformed.");
         }
       }
-      parsed[options.field] = content
-      content = yamlStringify(parsed)
+      parsed[options.field] = content;
+      content = yamlStringify(parsed);
     }
     if (file) {
       if (options.append) {
-        content = existingContent + '\n' + content
+        content = existingContent + "\n" + content;
       }
       await ifs.change({
         path: p,
-        content
-      })
+        content,
+      });
     } else {
       await ifs.make({
         path: p,
         type: this.cliConfig.types.TEXT,
-        content
-      })
+        content,
+      });
     }
     try {
-      await clipboardy.write('')
+      await clipboardy.write("");
     } catch (e) {
-      throw new Error(e.message)
+      throw new Error(e.message);
     }
 
-    return options.path
-
+    return options.path;
   }
 
   async exec(options = {}) {
     if (options.help) {
-      return this.showHelp()
+      return this.showHelp();
     }
     try {
-      this.validate(options)
-      let name = await this.paste(options)
-      this.Logger.grey('Pasted the clipboard to:')
-      this.Logger.reset(name)
+      this.validate(options);
+      let name = await this.paste(options);
+      this.Logger.grey("Pasted the clipboard to:");
+      this.Logger.reset(name);
     } catch (e) {
-      this.Logger.red(e.message)
+      this.Logger.red(e.message);
     }
-    await this.prompt.run()
+    await this.prompt.run();
   }
 }
 
-module.exports = Paste
-
-
+module.exports = Paste;

package/src/commands/Pwd.js

@@ -1,44 +1,39 @@
-class Pwd extends require('../Command') {
-
+class Pwd extends require("../Command") {
   setHelpAndCompletion() {
-    this.cliConfig.completion.pwd = {}
-    this.cliConfig.completion.help.pwd = true
+    this.cliConfig.completion.pwd = {};
+    this.cliConfig.completion.help.pwd = true;
     this.optionDefinitions = [
       {
-        name: 'help',
-        alias: 'h',
-        type: Boolean
-      }
-    ]
+        name: "help",
+        alias: "h",
+        type: Boolean,
+      },
+    ];
   }
 
   help() {
     return {
-      description: ['Shows the path of the working directory.'],
-      examples: [
-        'pwd'
-      ]
-    }
+      description: ["Shows the path of the working directory."],
+      examples: ["pwd"],
+    };
   }
 
   async pwd() {
-    return this.internalFs.tree.workingNode.getPath()
+    return this.internalFs.tree.workingNode.getPath();
   }
 
   async exec(options = {}) {
     if (options.help) {
-      return this.showHelp()
+      return this.showHelp();
     }
     try {
-      this.validate(options)
-      this.Logger.reset(await this.pwd())
+      this.validate(options);
+      this.Logger.reset(await this.pwd());
     } catch (e) {
-      this.Logger.red(e.message)
+      this.Logger.red(e.message);
     }
-    await this.prompt.run()
+    await this.prompt.run();
   }
 }
 
-module.exports = Pwd
-
-
+module.exports = Pwd;