find-cli 1.6.3 → 1.7.1

package/bin/operation/prompt/previousRule.js

@@ -0,0 +1,52 @@
+"use strict";
+
+const { selectPreviousRule } = require("../../utilities/prompt"),
+      { retrievePreviousRules } = require("../../configuration"),
+      { NO_PREVIOUS_RULES_MESSAGE } = require("../../messages");
+
+function previousRulePromptOperation(proceed, abort, context) {
+  const { dryRun } = context;
+
+  if (dryRun) {
+    proceed();
+
+    return;
+  }
+
+  const { previous } = context;
+
+  if (!previous) {
+    proceed();
+
+    return;
+  }
+
+  const previousRules = retrievePreviousRules(),
+        previousRulesLength = previousRules.length;
+
+  if (previousRulesLength === 0) {
+    console.log(NO_PREVIOUS_RULES_MESSAGE);
+
+    abort();
+
+    return;
+  }
+
+  selectPreviousRule(previousRules, (previousRule) => {
+    if (previousRule === null) {
+      abort();
+
+      return;
+    }
+
+    const rule = previousRule;  ///
+
+    Object.assign(context, {
+      rule
+    });
+
+    proceed();
+  });
+}
+
+module.exports = previousRulePromptOperation;

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

@@ -4,19 +4,24 @@ const Occurrence = require("../occurrence");
 
 const { STRING_TYPE } = require("../types"),
       { isStringStringLiteral } = require("../utilities/literal"),
-      { addDoubleQuotes, removeDoubleQuotes, addTrailingForwardSlash, removeTrailingForwardSlash } = require("../utilities/string");
+      { 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,
@@ -32,10 +37,11 @@ class StringRule {
 
     let offset = 0,
         string = content, ///
-        index = string.indexOf(this.string);
+        index = string.indexOf(this.string),
+        length = this.string.length;
 
     while (index !== -1) {
-      const occurrence = Occurrence.fromIndexStringAndOffset(index, string, offset),
+      const occurrence = Occurrence.fromIndexLengthAndOffset(index, length, offset),
             end = occurrence.getEnd(),
             start = end;  ///
 
@@ -45,24 +51,38 @@ class StringRule {
 
       occurrences.push(occurrence);
 
-      index = string.match(this.regExp);
+      index = string.indexOf(this.string);
     }
 
     return occurrences;
   }
 
   match(string) {
-    this.string = removeDoubleQuotes(this.string);  ///
-
     const matches = (this.string === string);
 
-    this.string = addDoubleQuotes(this.string); ///
-
     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) {
@@ -73,7 +93,7 @@ class StringRule {
     if (type === STRING_TYPE) {
       const { string } = json;
 
-      stringRule = new StringRule(string);
+      stringRule = new StringRule(type, string);
     }
 
     return stringRule;
@@ -85,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;
@@ -107,8 +129,6 @@ function stringFromStringAndDirectory(string, directory) {
     if (directory) {
       string = addTrailingForwardSlash(string); ///
     }
-
-    string = addDoubleQuotes(string); ///
   } else {
     string = null;
   }

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;
+}