find-cli 0.0.3 → 1.4.4

package/bin/operation/find.js

@@ -0,0 +1,201 @@
+"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 findOperation(proceed, abort, context) {
+  const { rootDirectoryPaths } = context,
+        entryPaths = [  ///
+          ...rootDirectoryPaths
+        ],
+        synchronous = findInEntries(entryPaths, (pathIgnored) => {
+          if (pathIgnored === null) {
+            abort();
+          }
+        }, context);
+
+  if (synchronous) {
+    proceed();
+  }
+}
+
+module.exports = findOperation;
+
+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;
+}
+
+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) {
+      const { ruleString } = context;
+
+      let message = filePathIgnored ?
+                      red(`Ignore ${filePath}`) :
+                        green(`Permit ${filePath}`);
+
+      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) {
+        const { ruleString } = context;
+
+        let message = directoryPathIgnored ?
+                        red(`Ignore ${directoryPath}/`) :
+                          green(`Permit ${directoryPath}/`);
+
+        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/operation/listRootDirectoryPaths.js

@@ -0,0 +1,34 @@
+"use strict";
+
+const { retrieveRootDirectoryPaths } = require("../configuration"),
+      { NO_ROOT_DIRECTORY_PATHS_MESSAGE } = require("../messages");
+
+function listRootDirectoryPathsOperation(proceed, abort, context) {
+  listRootDirectoryPaths()
+
+  proceed();
+}
+
+function listRootDirectoryPaths() {
+  const rootDirectoryPaths = retrieveRootDirectoryPaths(),
+        rootDirectoryPathsLength = rootDirectoryPaths.length,
+        lastIndex = rootDirectoryPathsLength - 1;
+
+  if (lastIndex === 0) {
+    console.log(NO_ROOT_DIRECTORY_PATHS_MESSAGE);
+  }
+
+  rootDirectoryPaths.forEach((rootDirectoryPath, index) => {
+    if (index > 0) {
+      console.log(index, rootDirectoryPath);
+    }
+  });
+
+  return lastIndex;
+}
+
+module.exports = listRootDirectoryPathsOperation;
+
+Object.assign(module.exports, {
+  listRootDirectoryPaths
+});

package/bin/operation/prompt/addRootDirectoryPath.js

@@ -0,0 +1,48 @@
+"use strict";
+
+const { shellUtilities } = require("necessary");
+
+const { validateRootDirectoryPath } = require("../../utilities/validate"),
+      { INVALID_ROOT_DIRECTORY_PATH_MESSAGE } = require("../../messages"),
+      { ADD_ROOT_DIRECTORY_PATH_DESCRIPTION } = require("../../descriptions");
+
+const { prompt } = shellUtilities;
+
+function addRootDirectoryPathPromptOperation(proceed, abort, context) {
+  const { rootDirectoryPath } = context;
+
+  if (rootDirectoryPath !== null) {
+    proceed();
+
+    return;
+  }
+
+  const description = ADD_ROOT_DIRECTORY_PATH_DESCRIPTION,
+        errorMessage = INVALID_ROOT_DIRECTORY_PATH_MESSAGE,
+        validationFunction = validateRootDirectoryPath, ///
+        options = {
+          description,
+          errorMessage,
+          validationFunction
+        };
+
+  prompt(options, (answer) => {
+    const valid = (answer !== null);
+
+    if(!valid) {
+      abort();
+
+      return;
+    }
+
+    const rootDirectoryPath = answer; ///
+
+    Object.assign(context, {
+      rootDirectoryPath
+    });
+
+    proceed();
+  });
+}
+
+module.exports = addRootDirectoryPathPromptOperation;

package/bin/operation/prompt/ignoreOrPermitPath.js

@@ -0,0 +1,46 @@
+"use strict";
+
+const { shellUtilities } = require("necessary");
+
+const { isAnswerIgnore } = require("../../utilities/prompt"),
+      { FILE, DIRECTORY } = require("../../constants"),
+      { validateIgnoreOrPermit } = require("../../utilities/validate"),
+      { INVALID_IGNORE_OR_PERMIT_MESSAGE } = require("../../messages");
+
+const { prompt } = shellUtilities;
+
+function ignoreOrPermitPathPromptOperation(proceed, abort, context) {
+  const { path, directory } = context,
+        fileOrDirectory = directory ?
+                            DIRECTORY :
+                              FILE,
+        description = `Ignore or permit the '${path}' ${fileOrDirectory}? (i)gnore (p)ermit: `,
+        errorMessage = INVALID_IGNORE_OR_PERMIT_MESSAGE,
+        validationFunction = validateIgnoreOrPermit,  ///
+        options = {
+          description,
+          errorMessage,
+          validationFunction
+        };
+
+  prompt(options, (answer) => {
+    const valid = (answer !== null);
+
+    if(!valid) {
+      abort();
+
+      return;
+    }
+
+    const ignore = isAnswerIgnore(answer),
+          pathIgnored = ignore; ///
+
+    Object.assign(context, {
+      pathIgnored
+    });
+
+    proceed();
+  });
+}
+
+module.exports = ignoreOrPermitPathPromptOperation;

package/bin/operation/prompt/removeRootDirectoryPath.js

@@ -0,0 +1,61 @@
+"use strict";
+
+const { shellUtilities } = require("necessary");
+
+const { validateIndex } = require("../../utilities/validate"),
+      { listRootDirectoryPaths } = require("../../operation/listRootDirectoryPaths"),
+      { REMOVE_ROOT_DIRECTORY_PATH_DESCRIPTION } = require("../../descriptions"),
+      { INVALID_ROOT_DIRECTORY_PATH_INDEX_MESSAGE } = require("../../messages");
+
+const { prompt } = shellUtilities;
+
+function removeRootDirectoryPathPromptOperation(proceed, abort, context) {
+  const { rootDirectoryPath } = context;
+
+  if (rootDirectoryPath !== null) {
+    proceed();
+
+    return;
+  }
+
+  const lastIndex = listRootDirectoryPaths();
+
+  if (lastIndex === 0) {
+    abort();
+
+    return;
+  }
+
+  const description = REMOVE_ROOT_DIRECTORY_PATH_DESCRIPTION,
+        errorMessage = INVALID_ROOT_DIRECTORY_PATH_INDEX_MESSAGE,
+        validationFunction = (answer) => {
+          const valid = validateIndex(answer, lastIndex);
+
+          return valid;
+        }, ///
+        options = {
+          description,
+          errorMessage,
+          validationFunction
+        };
+
+  prompt(options, (answer) => {
+    const valid = (answer !== null);
+
+    if(!valid) {
+      abort();
+
+      return;
+    }
+
+    const index = answer; ///
+
+    Object.assign(context, {
+      index
+    });
+
+    proceed();
+  });
+}
+
+module.exports = removeRootDirectoryPathPromptOperation;

package/bin/operation/prompt/rule.js

@@ -0,0 +1,50 @@
+"use strict";
+
+const { shellUtilities } = require("necessary");
+
+const { ruleFromStringAnchoredAndDirectory } = require("../../utilities/rule"),
+      { validateGlobStringOrPattern } = require("../../utilities/validate"),
+      { GLOB_STRING_OR_REGEX_DESCRIPTION } = require("../../descriptions"),
+      { INVALID_GLOB_REGEX_OR_STRING_MESSAGE } = require("../../messages");
+
+const { prompt } = shellUtilities;
+
+function rulePromptOperation(proceed, abort, context) {
+  const { path, directory } = context,
+        description = GLOB_STRING_OR_REGEX_DESCRIPTION,
+        errorMessage = INVALID_GLOB_REGEX_OR_STRING_MESSAGE,
+        initialAnswer = path,  ///
+        validationFunction = (answer) => {
+          const valid = validateGlobStringOrPattern(answer, directory);
+
+          return valid;
+        },
+        options = {
+          description,
+          errorMessage,
+          initialAnswer,
+          validationFunction
+        };
+
+  prompt(options, (answer) => {
+    const valid = (answer !== null);
+
+    if(!valid) {
+      abort();
+
+      return;
+    }
+
+    const string = answer,  ///
+          anchored = true,
+          rule = ruleFromStringAnchoredAndDirectory(string, anchored, directory);
+
+    Object.assign(context, {
+      rule
+    });
+
+    proceed();
+  });
+}
+
+module.exports = rulePromptOperation;

package/bin/operation/readConfiguration.js

@@ -0,0 +1,27 @@
+"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;

package/bin/operation/removeRootDirectoryPath.js

@@ -0,0 +1,29 @@
+"use strict";
+
+const { retrieveRootDirectoryPaths } = require("../configuration"),
+      { removeRootDirectoryPathByIndex } = require("./removeRootDirectoryPathByIndex");
+
+function removeRootDirectoryPathOperation(proceed, abort, context) {
+  const { rootDirectoryPath } = context;
+
+  if (rootDirectoryPath === null) {
+    proceed();
+
+    return;
+  }
+
+  const rootDirectoryPaths = retrieveRootDirectoryPaths(),
+        index = rootDirectoryPaths.indexOf(rootDirectoryPath);
+
+  if (index === -1) {
+    abort();
+
+    return;
+  }
+
+  removeRootDirectoryPathByIndex(index);
+
+  proceed();
+}
+
+module.exports = removeRootDirectoryPathOperation;

package/bin/operation/removeRootDirectoryPathByIndex.js

@@ -0,0 +1,34 @@
+"use strict";
+
+const { retrieveRootDirectoryPaths, updateRootDirectoryPaths } = require("../configuration");
+
+function removeRootDirectoryPathByIndexOperation(proceed, abort, context) {
+  const { index } = context;
+
+  if (index === null) {
+    proceed();
+
+    return;
+  }
+
+  removeRootDirectoryPathByIndex(index);
+
+  proceed();
+}
+
+function removeRootDirectoryPathByIndex(index) {
+  const start = index,  ///
+        deleteCount = 1,
+        rootDirectoryPaths = retrieveRootDirectoryPaths()
+
+  rootDirectoryPaths.splice(start, deleteCount);
+
+  updateRootDirectoryPaths(rootDirectoryPaths);
+
+}
+
+module.exports = removeRootDirectoryPathByIndexOperation;
+
+Object.assign(module.exports, {
+  removeRootDirectoryPathByIndex
+});

package/bin/operation/rule.js

@@ -0,0 +1,32 @@
+"use strict";
+
+const { ruleFromStringAnchoredAndDirectory } = require("../utilities/rule");
+
+function ruleOperation(proceed, abort, context) {
+  const { dryRun } = context;
+
+  if (dryRun) {
+    proceed();
+
+    return;
+  }
+
+  const { string } = context,
+        directory = false,
+        anchored = false,
+        rule = ruleFromStringAnchoredAndDirectory(string, anchored, directory);
+
+  if (rule === null) {
+    abort();
+
+    return;
+  }
+
+  Object.assign(context, {
+    rule
+  });
+
+  proceed();
+}
+
+module.exports = ruleOperation;

package/bin/operation/updatePatRules.js

@@ -0,0 +1,54 @@
+"use strict";
+
+const { updateIgnoredFilePathRules,
+        updatePermittedFilePathRules,
+        updateIgnoredDirectoryPathRules,
+        updatePermittedDirectoryPathRules } = require("../configuration");
+
+function updatePathRulesOperation(proceed, abort, context) {
+  const { rule, directory, pathIgnored } = context;
+
+  pathIgnored ?
+    addIgnoreRule(rule, directory, context) :
+      addPermitRule(rule, directory, context);
+
+  proceed();
+}
+
+module.exports = updatePathRulesOperation;
+
+function addIgnoreRule(rule, directory, context) {
+  if (directory) {
+    const { ignoredDirectoryPathRules } = context,
+          ignoredDirectoryPathRule = rule;  ///
+
+    ignoredDirectoryPathRules.push(ignoredDirectoryPathRule);
+
+    updateIgnoredDirectoryPathRules(ignoredDirectoryPathRules);
+  } else {
+    const { ignoredFilePathRules } = context,
+          ignoredFilePathRule = rule;  ///
+
+    ignoredFilePathRules.push(ignoredFilePathRule);
+
+    updateIgnoredFilePathRules(ignoredFilePathRules);
+  }
+}
+
+function addPermitRule(rule, directory, context) {
+  if (directory) {
+    const { permittedDirectoryPathRules } = context,
+          permittedDirectoryPathRule = rule;  ///
+
+    permittedDirectoryPathRules.push(permittedDirectoryPathRule);
+
+    updatePermittedDirectoryPathRules(permittedDirectoryPathRules);
+  } else {
+    const { permittedFilePathRules } = context,
+          permittedFilePathRule = rule;  ///
+
+    permittedFilePathRules.push(permittedFilePathRule);
+
+    updatePermittedFilePathRules(permittedFilePathRules);
+  }
+}

package/bin/operation/validateRootDirectoryPath.js

@@ -0,0 +1,30 @@
+"use strict";
+
+const { validateRootDirectoryPath } = require("../utilities/validate"),
+      { INVALID_ROOT_DIRECTORY_PATH_MESSAGE } = require("../messages");
+
+function validateRootDirectoryPathOperation(proceed, abort, context) {
+  const { rootDirectoryPath } = context;
+
+  if (rootDirectoryPath === null) {
+    proceed();
+
+    return;
+  }
+
+  const valid = validateRootDirectoryPath(rootDirectoryPath);
+
+  if (!valid) {
+    console.log(INVALID_ROOT_DIRECTORY_PATH_MESSAGE);
+
+    const rootDirectoryPath = null;
+
+    Object.assign(context, {
+      rootDirectoryPath
+    });
+  }
+
+  proceed();
+}
+
+module.exports = validateRootDirectoryPathOperation;

package/bin/options.js

@@ -0,0 +1,13 @@
+"use strict";
+
+const HELP_OPTION = "help",
+      VERSION_OPTION = "version",
+      QUIETLY_OPTION = "quietly",
+      DRY_RUN_OPTION = "dry-run";
+
+module.exports = {
+  HELP_OPTION,
+  VERSION_OPTION,
+  QUIETLY_OPTION,
+  DRY_RUN_OPTION
+};