find-cli 0.0.3 → 1.4.3

package/bin/utilities/operation.js

@@ -0,0 +1,38 @@
+"use strict";
+
+const { asynchronousUtilities } = require("necessary");
+
+const { whilst } = asynchronousUtilities;
+
+function executeOperations(operations, callback, context) {
+  let completed = true;
+
+  const operationsLength = operations.length,
+        lastIndex = operationsLength - 1;
+
+  whilst((next, done, context, index) => {
+    if (index > lastIndex) {
+      done();
+
+      return;
+    }
+
+    const operation = operations[index],
+          proceed = next, ///
+          abort = () => {
+            completed = false;
+
+            done();
+          };
+
+    operation(proceed, abort, context);
+  }, done, context);
+
+  function done() {
+    callback(completed);
+  }
+}
+
+module.exports = {
+	executeOperations
+};

package/bin/utilities/path.js

@@ -0,0 +1,58 @@
+"use strict";
+
+const { pathUtilities } = require("necessary");
+
+const { CURRENT_DIRECTORY_PATH } = require("../constants");
+
+const { concatenatePaths } = pathUtilities;
+
+function stripRootDirectoryFromPath(path, context) {
+  const { rootDirectoryPaths } = context;
+
+  rootDirectoryPaths.some((rootDirectoryPath) => {
+    const pathStartsWithRootDirectoryPath = path.startsWith(rootDirectoryPath);
+
+    if (pathStartsWithRootDirectoryPath) {
+      const length = rootDirectoryPath.length,
+            start = length;
+
+      path = path.substring(start);  ///
+
+      return true;
+    }
+  });
+
+  return path;
+}
+
+function isDirectoryPathRootDirectoryPath(directoryPath, context) {
+  const { rootDirectoryPaths } = context,
+        rootDirectoryPathsIncludesDirectoryPath = rootDirectoryPaths.includes(directoryPath),
+        directoryPathRootDirectoryPath = rootDirectoryPathsIncludesDirectoryPath; ///
+
+  return directoryPathRootDirectoryPath;
+}
+
+function entryPathsFromEntryNamesAndDirectoryPath(entryNames, directoryPath) {
+  const entryPaths = entryNames.map((entryName) => {
+    const entryPath = entryPathFromEntryNameAndDirectoryPath(entryName, directoryPath);
+
+    return entryPath
+  });
+
+  return entryPaths;
+}
+
+module.exports = {
+  stripRootDirectoryFromPath,
+  isDirectoryPathRootDirectoryPath,
+  entryPathsFromEntryNamesAndDirectoryPath
+};
+
+function entryPathFromEntryNameAndDirectoryPath(entryName, directoryPath) {
+  const entryPath = (directoryPath === CURRENT_DIRECTORY_PATH) ?
+                         entryName : ///
+                           concatenatePaths(directoryPath, entryName);
+
+  return entryPath;
+}

package/bin/utilities/prompt.js

@@ -0,0 +1,7 @@
+"use strict";
+
+function isAnswerIgnore(answer) { return /^(?:ignore|i)$/i.test(answer); }
+
+module.exports = {
+  isAnswerIgnore
+};

package/bin/utilities/rule.js

@@ -0,0 +1,18 @@
+"use strict";
+
+const GlobRule = require("../rule/glob"),
+      RegexRule = require("../rule/regex"),
+      StringRule = require("../rule/string");
+
+function ruleFromStringAnchoredAndDirectory(string, anchored, directory) {
+  const globRule = GlobRule.fromStringAnchoredAndDirectory(string, anchored, directory),
+        regexRule = RegexRule.fromStringAnchoredAndDirectory(string, anchored, directory),
+        stringRule = StringRule.fromStringAnchoredAndDirectory(string, anchored, directory),
+        rule = (globRule || regexRule || stringRule);
+
+  return rule;
+}
+
+module.exports = {
+  ruleFromStringAnchoredAndDirectory
+};

package/bin/utilities/string.js

@@ -0,0 +1,36 @@
+"use strict";
+
+const { EMPTY_STRING } = require("../constants");
+
+function addAnchors(string) { return `^${string}$`; }
+
+function removeAnchors(string) { return string.replace(/(^\^|\$$)/g, EMPTY_STRING); }
+
+function addDoubleQuotes(string) { return `"${string}"`; }
+
+function addForwardSlashes(string) { return `/${string}/`; }
+
+function removeDoubleQuotes(string) { return string.replace(/(^"|"$)/g, EMPTY_STRING); }
+
+function removeForwardSlashes(string) { return string.replace(/(^\/|\/$)/g, EMPTY_STRING); }
+
+function addTrailingForwardSlash(string) { return `${string}\/`; }
+
+function removeTrailingForwardSlash(string) { return string.replace(/(\/$)/, EMPTY_STRING); }
+
+function addTrailingEscapedForwardSlash(string) { return `${string}\\\/`; }
+
+function removeTrailingEscapedForwardSlash(string) { return string.replace(/(\\\/$)/, EMPTY_STRING); }
+
+module.exports = {
+  addAnchors,
+  removeAnchors,
+  addDoubleQuotes,
+  addForwardSlashes,
+  removeDoubleQuotes,
+  removeForwardSlashes,
+  addTrailingForwardSlash,
+  removeTrailingForwardSlash,
+  addTrailingEscapedForwardSlash,
+  removeTrailingEscapedForwardSlash
+};

package/bin/utilities/validate.js

@@ -0,0 +1,56 @@
+"use strict";
+
+const { ruleFromStringAnchoredAndDirectory } = require("../utilities/rule");
+
+function validateIndex(answer, lastIndex) {
+  let valid = true;
+
+  if (valid) {
+    valid = /^[1-9][0-9]*$/.test(answer);
+  }
+
+  if (valid) {
+    const index = Number(answer);
+
+    valid = (index <= lastIndex);
+  }
+
+  return valid;
+}
+
+function validateIgnoreOrPermit(answer) { return /^(:?ignore|permit|i|p)$/i.test(answer); }
+
+function validateRootDirectoryPath(answer) {
+  let valid = true;
+
+  if (valid) {
+    valid = /^\.\.\/(?:[^/]*\/)+$/i.test(answer);
+  }
+
+  if (valid) {
+    const directory = true,
+          glob = globFromAnswerAndDirectory(answer, directory);
+
+    if (glob === null) {
+      valid = false;
+    }
+  }
+
+  return valid;
+}
+
+function validateGlobStringOrPattern(answer, directory) {
+  const string = answer,  ///
+        anchored = false,
+        rule = ruleFromStringAnchoredAndDirectory(string, anchored, directory),
+        valid = (rule !== null)
+
+  return valid;
+}
+
+module.exports = {
+  validateIndex,
+  validateIgnoreOrPermit,
+  validateRootDirectoryPath,
+  validateGlobStringOrPattern
+};

package/bin/versions.js

@@ -0,0 +1,15 @@
+"use strict";
+
+const VERSION_1_0 = "1.0",
+      VERSION_1_1 = "1.1",
+      VERSION_1_2 = "1.2",
+      VERSION_1_3 = "1.3",
+      VERSION_1_4 = "1.4";
+
+module.exports = {
+  VERSION_1_0,
+  VERSION_1_1,
+  VERSION_1_2,
+  VERSION_1_3,
+  VERSION_1_4
+};

package/find.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+const { parseArgv } = require("argumentative"),
+      { arrayUtilities } = require("necessary");
+
+const main = require("./bin/main"),
+      prepare = require("./bin/prepare"),
+      abbreviations = require("./bin/abbreviations");
+
+const { first, second } = arrayUtilities;
+
+const { commands, options } = parseArgv(process.argv, abbreviations),
+      firstCommand = first(commands),
+      secondCommand = second(commands),
+      command = firstCommand || null, ///
+      argument = secondCommand || null; ///
+
+prepare(command, argument, options, main);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "find-cli",
   "author": "James Smith",
-  "version": "0.0.3",
+  "version": "1.4.3",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/find-cli",
   "description": "An alternative to grep.",
@@ -9,9 +9,12 @@
     "type": "git",
     "url": "https://github.com/djalbat/find-cli"
   },
+  "bin": {
+    "find": "./find.js"
+  },
   "dependencies": {
     "argumentative": "^2.0.32",
-    "necessary": "^14.2.1"
+    "necessary": "^14.2.3"
   },
   "scripts": {}
 }