find-cli 1.6.4 → 1.7.2

package/bin/operation/prompt/rule.js

@@ -2,7 +2,8 @@
 
 const { shellUtilities } = require("necessary");
 
-const { validateGlobStringOrPattern } = require("../../utilities/validate"),
+const { EMPTY_STRING } = require("../../constants"),
+      { validateGlobStringOrPattern } = require("../../utilities/validate"),
       { GLOB_STRING_OR_REGEX_DESCRIPTION } = require("../../descriptions"),
       { ruleFromStringAnchoredAndDirectory } = require("../../utilities/rule"),
       { INVALID_GLOB_REGEX_OR_STRING_MESSAGE } = require("../../messages");
@@ -26,22 +27,33 @@ function rulePromptOperation(proceed, abort, context) {
     return;
   }
 
-  const { path, anchored, directory } = context,
+  const { rule, anchored, directory } = context,
         description = GLOB_STRING_OR_REGEX_DESCRIPTION,
         errorMessage = INVALID_GLOB_REGEX_OR_STRING_MESSAGE,
-        initialAnswer = path,  ///
         validationFunction = (answer) => {
-          const valid = validateGlobStringOrPattern(answer, anchored, directory);
+          let valid = false;
+
+          if (answer !== EMPTY_STRING) {
+            valid = validateGlobStringOrPattern(answer, anchored, directory);
+          }
 
           return valid;
         },
         options = {
           description,
           errorMessage,
-          initialAnswer,
           validationFunction
         };
 
+  if (rule !== null) {
+    const ruleString = rule.asString(),
+          initialAnswer = ruleString; ///
+
+    Object.assign(options, {
+      initialAnswer
+    });
+  }
+
   prompt(options, (answer) => {
     const valid = (answer !== null);
 

package/bin/operation/rule.js

@@ -11,9 +11,9 @@ function ruleOperation(proceed, abort, context) {
     return;
   }
 
-  const { interactive } = context;
+  const { previous, interactive } = context;
 
-  if (interactive) {
+  if (previous || interactive) {
     proceed();
 
     return;

package/bin/options.js

@@ -8,6 +8,7 @@ const HELP_OPTION = "help",
       VERSION_OPTION = "version",
       QUIETLY_OPTION = "quietly",
       DRY_RUN_OPTION = "dry-run",
+      PREVIOUS_OPTION = "previous",
       INTERACTIVE_OPTION = "interactive";
 
 module.exports = {
@@ -19,5 +20,6 @@ module.exports = {
   VERSION_OPTION,
   QUIETLY_OPTION,
   DRY_RUN_OPTION,
+  PREVIOUS_OPTION,
   INTERACTIVE_OPTION
 };

package/bin/rule/glob.js

@@ -9,12 +9,17 @@ const { GLOB_TYPE } = require("../types"),
       { addAnchors, addTrailingForwardSlash, removeTrailingForwardSlash } = require("../utilities/string");
 
 class GlobRule {
-  constructor(glob, pattern, regExp) {
+  constructor(type, glob, pattern, regExp) {
+    this.type = type;
     this.glob = glob;
     this.pattern = pattern;
     this.regExp = regExp;
   }
 
+  getType() {
+    return this.type;
+  }
+
   getGlob() {
     return this.glob;
   }
@@ -28,7 +33,7 @@ class GlobRule {
   }
 
   toJSON() {
-    const type = GLOB_TYPE,
+    const type = this.type,
           glob = this.glob,
           pattern = this.pattern,
           json = {
@@ -71,6 +76,22 @@ class GlobRule {
     return matches;
   }
 
+  isEqualTo(rule) {
+    let equalTo = false;
+
+    const ruleType = rule.getType();
+
+    if (ruleType === this.type) {
+      const ruleGlob = rule.getGlob();
+
+      if (ruleGlob === this.glob) {
+        equalTo = true;
+      }
+    }
+
+    return equalTo;
+  }
+
   asString() {
     const string = this.glob; ///
 
@@ -86,7 +107,7 @@ class GlobRule {
       const { glob, pattern } = json,
             regExp = new RegExp(pattern);
 
-      globRule = new GlobRule(glob, pattern, regExp);
+      globRule = new GlobRule(type, glob, pattern, regExp);
     }
 
     return globRule;
@@ -98,10 +119,11 @@ class GlobRule {
     const glob = globFromStringAndDirectory(string, directory);
 
     if (glob !== null) {
-      const pattern = patternFromGlobAndAnchored(glob, anchored),
+      const type = GLOB_TYPE,
+            pattern = patternFromGlobAndAnchored(glob, anchored),
             regExp = new RegExp(pattern);
 
-      globRule = new GlobRule(glob, pattern, regExp);
+      globRule = new GlobRule(type, glob, pattern, regExp);
     }
 
     return globRule;

package/bin/rule/regex.js

@@ -12,11 +12,16 @@ const { REGEX_TYPE } = require("../types"),
         removeTrailingEscapedForwardSlash } = require("../utilities/string");
 
 class RegexRule {
-  constructor(pattern, regExp) {
+  constructor(type, pattern, regExp) {
+    this.type = type;
     this.pattern = pattern;
     this.regExp = regExp;
   }
 
+  getType() {
+    return this.type;
+  }
+
   getPattern() {
     return this.pattern;
   }
@@ -26,7 +31,7 @@ class RegexRule {
   }
 
   toJSON() {
-    const type = REGEX_TYPE,
+    const type = this.type,
           pattern = this.pattern,
           json = {
             type,
@@ -67,6 +72,22 @@ class RegexRule {
     return matches;
   }
 
+  isEqualTo(rule) {
+    let equalTo = false;
+
+    const ruleType = rule.getType();
+
+    if (ruleType === this.type) {
+      const rulePattern = rule.getPattern();
+
+      if (rulePattern === this.pattern) {
+        equalTo = true;
+      }
+    }
+
+    return equalTo;
+  }
+
   asString() {
     const string = addForwardSlashes(this.pattern);  ///
 
@@ -82,7 +103,7 @@ class RegexRule {
       const { pattern } = json,
             regExp = new RegExp(pattern);
 
-      regexRule = new RegexRule(pattern, regExp);
+      regexRule = new RegexRule(type, pattern, regExp);
     }
 
     return regexRule;
@@ -94,9 +115,10 @@ class RegexRule {
     const pattern = patternFromStringAndDirectory(string, anchored, directory);
 
     if (pattern !== null) {
-      const regExp = new RegExp(pattern);
+      const type = REGEX_TYPE,
+            regExp = new RegExp(pattern);
 
-      regexRule = new RegexRule(pattern, regExp);
+      regexRule = new RegexRule(type, pattern, regExp);
     }
 
     return regexRule;

package/bin/rule/string.js

@@ -7,16 +7,21 @@ const { STRING_TYPE } = require("../types"),
       { removeDoubleQuotes, addTrailingForwardSlash, removeTrailingForwardSlash } = require("../utilities/string");
 
 class StringRule {
-  constructor(string) {
+  constructor(type, string) {
+    this.type = type;
     this.string = string;
   }
 
+  getType() {
+    return this.type;
+  }
+
   getString() {
     return this.string;
   }
 
   toJSON() {
-    const type = STRING_TYPE,
+    const type = this.type,
           string = this.string,
           json = {
             type,
@@ -58,8 +63,26 @@ class StringRule {
     return matches;
   }
 
+  isEqualTo(rule) {
+    let equalTo = false;
+
+    const ruleType = rule.getType();
+
+    if (ruleType === this.type) {
+      const ruleString = rule.getString();
+
+      if (ruleString === this.string) {
+        equalTo = true;
+      }
+    }
+
+    return equalTo;
+  }
+
   asString() {
-    return this.string;
+    const string = `"${this.string}"`;
+
+    return string;
   }
 
   static fromJSON(json) {
@@ -70,7 +93,7 @@ class StringRule {
     if (type === STRING_TYPE) {
       const { string } = json;
 
-      stringRule = new StringRule(string);
+      stringRule = new StringRule(type, string);
     }
 
     return stringRule;
@@ -82,7 +105,9 @@ class StringRule {
     string = stringFromStringAndDirectory(string, directory); ///
 
     if (string !== null) {
-      stringRule = new StringRule(string);
+      const type = STRING_TYPE; ///
+
+      stringRule = new StringRule(type, string);
     }
 
     return stringRule;

package/bin/utilities/find.js

@@ -0,0 +1,203 @@
+"use strict";
+
+const { fileSystemUtilities } = require("necessary");
+
+const find = require("../find");
+
+const { red, green } = require("../utilities/log"),
+      { synchronousIsFilePathIgnored, synchronousIsDirectoryPathIgnored } = require("../isIgnored/synchronous"),
+      { asynchronousIsFilePathIgnored, asynchronousIsDirectoryPathIgnored } = require("../isIgnored/asynchronous"),
+      { isDirectoryPathRootDirectoryPath, entryPathsFromEntryNamesAndDirectoryPath } = require("../utilities/path");
+
+const { readDirectory, isEntryDirectory } = fileSystemUtilities;
+
+function findInEntries(entryPaths, callback, context) {
+  let synchronous = true;
+
+  let entryNamesLength;
+
+  entryNamesLength = entryPaths.length;
+
+  while (entryNamesLength > 0) {
+    const entryPath = entryPaths.shift();
+
+    synchronous = findInEntry(entryPath, entryPaths, callback, context);
+
+    if (!synchronous) {
+      break;
+    }
+
+    entryNamesLength = entryPaths.length;
+  }
+
+  return synchronous;
+}
+
+module.exports = {
+  findInEntries
+};
+
+function findInEntry(entryPath, entryPaths, callback, context) {
+  let synchronous;
+
+  const path = entryPath,
+        directory = isEntryDirectory(path);
+
+  if (directory) {
+    const directoryPath = entryPath; ///
+
+    synchronous = findInDirectory(directoryPath, (pathIgnored) => {
+      const synchronous = (pathIgnored !== null) ?
+                            findInEntries(entryPaths, callback, context) :
+                              true;
+
+      if (synchronous) {
+        callback(pathIgnored);
+      }
+    }, context);
+  } else {
+    const filePath = entryPath;  ///
+
+    synchronous = findInFile(filePath, (pathIgnored) => {
+      const synchronous = (pathIgnored !== null) ?
+                            findInEntries(entryPaths, callback, context) :
+                              true;
+      if (synchronous) {
+        callback(pathIgnored);
+      }
+    }, context);
+  }
+
+  if (synchronous) {
+    synchronous = findInEntries(entryPaths, callback, context);
+  }
+
+  return synchronous;
+}
+
+function findInFile(filePath, callback, context) {
+  let synchronous;
+
+  const filePathIgnored = synchronousIsFilePathIgnored(filePath, context);
+
+  if (filePathIgnored !== null) {
+    synchronous = true;
+
+    const { quietly } = context;
+
+    if (!quietly) {
+      let message;
+
+      const { format, ruleString } = context;
+
+      message = filePathIgnored ?
+                  `Ignore ${filePath}`:
+                    `Permit ${filePath}`;
+
+      if (format) {
+        message = filePathIgnored ?
+                    red(message) :
+                      green(message);
+      }
+
+      message = `${message} ${ruleString}`;
+
+      console.log(message);
+    }
+
+    if (!filePathIgnored) {
+      let { filesTotal } = context;
+
+      filesTotal++;
+
+      Object.assign(context, {
+        filesTotal
+      });
+
+      const { dryRun } = context;
+
+      if (!dryRun) {
+        find(filePath, context);
+      }
+    }
+  } else {
+    synchronous = false;
+
+    asynchronousIsFilePathIgnored(filePath, context, (pathIgnored) => {
+      const synchronous = (pathIgnored !== null) ?
+                            findInFile(filePath, callback, context) :
+                              true;
+
+      if (synchronous) {
+        callback(pathIgnored);
+      }
+    });
+  }
+
+  return synchronous;
+}
+
+function findInDirectory(directoryPath, callback, context) {
+  let synchronous;
+
+  const directoryPathIgnored = synchronousIsDirectoryPathIgnored(directoryPath, context);
+
+  if (directoryPathIgnored !== null) {
+    synchronous = true;
+
+    const directoryPathRootDirectoryPath = isDirectoryPathRootDirectoryPath(directoryPath, context);
+
+    if (!directoryPathRootDirectoryPath) {
+      const { quietly } = context;
+
+      if (!quietly) {
+        let message;
+
+        const { format, ruleString } = context;
+
+        message = directoryPathIgnored ?
+                   `Ignore ${directoryPath}/` :
+                     `Permit ${directoryPath}/`;
+
+        if (format) {
+          message = directoryPathIgnored ?
+                      red(message) :
+                        green(message);
+        }
+
+        message = `${message} ${ruleString}`;
+
+        console.log(message);
+      }
+    }
+
+    if (!directoryPathIgnored) {
+      let { directoriesTotal } = context;
+
+      directoriesTotal++;
+
+      Object.assign(context, {
+        directoriesTotal
+      });
+
+      const entryNames = readDirectory(directoryPath),
+            entryPaths = entryPathsFromEntryNamesAndDirectoryPath(entryNames, directoryPath);
+
+      synchronous = findInEntries(entryPaths, callback, context);
+    }
+  } else {
+    synchronous = false;
+
+    asynchronousIsDirectoryPathIgnored(directoryPath, context, (pathIgnored) => {
+      const synchronous = (pathIgnored !== null) ?
+                            findInDirectory(directoryPath, callback, context) :
+                              true;
+
+      if (synchronous) {
+        callback(pathIgnored);
+      }
+    });
+  }
+
+  return synchronous;
+}

package/bin/utilities/prompt.js

@@ -1,7 +1,129 @@
 "use strict";
 
-function isAnswerIgnore(answer) { return /^(?:ignore|i)$/i.test(answer); }
+const { encodings, characters } = require("necessary");
+
+const { DATA } = require("../constants"),
+      { PREVIOUS_GLOB_STRING_OR_REGEX_DESCRIPTION } = require("../descriptions");
+
+const { UTF8_ENCODING } = encodings,
+      { UP_CHARACTER,
+        ETX_CHARACTER,
+        DOWN_CHARACTER,
+        ESCAPE_CHARACTER,
+        CTRL_C_CHARACTER,
+        NEW_LINE_CHARACTER,
+        CARRIAGE_RETURN_CHARACTER } = characters;
+
+function selectPreviousRule(previousRules, callback) {
+  let index = 0,
+      previousRule = previousRules[index];
+
+  writePreviousRule(previousRule);
+
+  const rawMode = true,
+        encoding = UTF8_ENCODING,
+        previousRulesLength = previousRules.length;
+
+  process.stdin.setRawMode(rawMode);
+
+  process.stdin.setEncoding(encoding);
+
+  process.stdin.addListener(DATA, listener);
+
+  process.stdin.resume();
+
+  function listener(data) {
+    const character = data.toString(encoding);
+
+    switch (character) {
+      case UP_CHARACTER: {
+        const firstIndex = 0;
+
+        if (index > firstIndex) {
+          index--;
+
+          previousRule = previousRules[index];
+
+          writePreviousRule(previousRule);
+        }
+
+        break;
+      }
+
+      case DOWN_CHARACTER: {
+        const lastIndex = previousRulesLength - 1;
+
+        if (index < lastIndex) {
+          index++;
+
+          previousRule = previousRules[index];
+
+          writePreviousRule(previousRule);
+        }
+
+        break;
+      }
+
+      case ESCAPE_CHARACTER: {
+        previousRule = null;
+
+        console.log(CARRIAGE_RETURN_CHARACTER);
+
+        process.stdin.removeListener(DATA, listener);
+
+        process.stdin.pause();
+
+        callback(previousRule);
+
+        break;
+      }
+
+      case NEW_LINE_CHARACTER:
+      case CARRIAGE_RETURN_CHARACTER: {
+        process.stdout.clearLine();
+
+        process.stdout.cursorTo(0);
+
+        process.stdin.removeListener(DATA, listener);
+
+        process.stdin.pause();
+
+        callback(previousRule);
+
+        break;
+      }
+
+      case ETX_CHARACTER: {
+        console.log(CTRL_C_CHARACTER);
+
+        process.exit();
+
+        break;
+      }
+
+      default: {
+        ///
+
+        break;
+      }
+    }
+  }
+}
 
 module.exports = {
-  isAnswerIgnore
+  selectPreviousRule
 };
+
+function writePreviousRule(previousRule) {
+  const description = PREVIOUS_GLOB_STRING_OR_REGEX_DESCRIPTION,  ///
+        previousRuleString = previousRule.asString();
+
+  process.stdout.clearLine();
+
+  process.stdout.cursorTo(0);
+
+  process.stdout.write(description);
+
+  process.stdout.write(previousRuleString);
+}
+

package/bin/versions.js

@@ -4,12 +4,14 @@ 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";
+      VERSION_1_4 = "1.4",
+      VERSION_1_7 = "1.7";
 
 module.exports = {
   VERSION_1_0,
   VERSION_1_1,
   VERSION_1_2,
   VERSION_1_3,
-  VERSION_1_4
+  VERSION_1_4,
+  VERSION_1_7
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "find-cli",
   "author": "James Smith",
-  "version": "1.6.4",
+  "version": "1.7.2",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/find-cli",
   "description": "An alternative to grep.",
@@ -14,7 +14,7 @@
   },
   "dependencies": {
     "argumentative": "^2.0.32",
-    "necessary": "^14.2.3"
+    "necessary": "^14.3.2"
   },
   "scripts": {}
 }

package/bin/operation/readConfiguration.js

@@ -1,27 +0,0 @@
-"use strict";
-
-const { retrieveRootDirectoryPaths,
-        retrieveIgnoredFilePathRules,
-        retrievePermittedFilePathRules,
-        retrieveIgnoredDirectoryPathRules,
-        retrievePermittedDirectoryPathRules } = require("../configuration");
-
-function readConfigurationOperation(proceed, abort, context) {
-  const rootDirectoryPaths = retrieveRootDirectoryPaths(),
-        ignoredFilePathRules = retrieveIgnoredFilePathRules(),
-        permittedFilePathRules = retrievePermittedFilePathRules(),
-        ignoredDirectoryPathRules = retrieveIgnoredDirectoryPathRules(),
-        permittedDirectoryPathRules = retrievePermittedDirectoryPathRules();
-
-  Object.assign(context, {
-    rootDirectoryPaths,
-    ignoredFilePathRules,
-    permittedFilePathRules,
-    ignoredDirectoryPathRules,
-    permittedDirectoryPathRules
-  });
-
-  proceed();
-}
-
-module.exports = readConfigurationOperation;