find-cli 0.0.3 → 1.4.3

package/bin/main.js

@@ -0,0 +1,85 @@
+"use strict";
+
+const findAction = require("./action/find"),
+      helpAction = require("./action/help"),
+      versionAction = require("./action/version"),
+      initialiseAction = require("./action/initialise"),
+      addRootDirectoryPathAction = require("./action/addRootDirectoryPath"),
+      listRootDirectoryPathsAction = require("./action/listRootDirectoryPaths"),
+      removeRootDirectoryPathAction = require("./action/removeRootDirectoryPath");
+
+const { NO_ARGUMENT_GIVEN_MESSAGE, COMMAND_NOT_RECOGNISED_MESSAGE } = require("./messages"),
+      { DEFAULT_DRY_RUN, DEFAULT_QUIETLY } = require("./defaults"),
+      { FIND_COMMAND,
+        HELP_COMMAND,
+        VERSION_COMMAND,
+        INITIALISE_COMMAND,
+        ADD_ROOT_DIRECTORY_PATH_COMMAND,
+        LIST_ROOT_DIRECTORY_PATHS_COMMAND,
+        REMOVE_ROOT_DIRECTORY_PATH_COMMAND } = require("./commands");
+
+function main(command, argument, options) {
+  const { dryRun = DEFAULT_DRY_RUN, quietly = DEFAULT_QUIETLY } = options;
+
+  switch (command) {
+    case HELP_COMMAND: {
+      helpAction();
+
+      break;
+    }
+
+    case VERSION_COMMAND: {
+      versionAction();
+
+      break;
+    }
+
+    case INITIALISE_COMMAND: {
+      initialiseAction();
+
+      break;
+    }
+
+    case ADD_ROOT_DIRECTORY_PATH_COMMAND: {
+      const rootDirectoryPath = argument; ///
+
+      addRootDirectoryPathAction(rootDirectoryPath);
+
+      break;
+    }
+
+    case LIST_ROOT_DIRECTORY_PATHS_COMMAND: {
+      listRootDirectoryPathsAction();
+
+      break;
+    }
+
+    case REMOVE_ROOT_DIRECTORY_PATH_COMMAND: {
+      const rootDirectoryPath = argument; ///
+
+      removeRootDirectoryPathAction(rootDirectoryPath);
+
+      break;
+    }
+
+    case FIND_COMMAND: {
+      if (argument === null) {
+        console.log(NO_ARGUMENT_GIVEN_MESSAGE);
+      } else {
+        const string = argument;  ///
+
+        findAction(string, dryRun, quietly);
+      }
+
+      break;
+    }
+
+    default: {
+      console.log(COMMAND_NOT_RECOGNISED_MESSAGE);
+
+      break;
+    }
+  }
+}
+
+module.exports = main;

package/bin/messages.js

@@ -0,0 +1,37 @@
+"use strict";
+
+const NO_ARGUMENT_GIVEN_MESSAGE = "No argument has been given.",
+      COMMAND_NOT_RECOGNISED_MESSAGE = "The command is not recognised.",
+      NO_ROOT_DIRECTORY_PATHS_MESSAGE = "There are no root directory paths bar the default one.",
+      CONFIGURATION_FILE_DOES_NOT_EXIST_MESSAGE = "The action cannot be performed because the configuration file is missing. Run 'find initialise' to create one.",
+      INVALID_IGNORE_OR_PERMIT_MESSAGE = "You must answer (i)gnore or (p)ermit.",
+      INVALID_ROOT_DIRECTORY_PATH_MESSAGE = "Additional root directories must be globs of the form '../**/'.",
+      INVALID_GLOB_REGEX_OR_STRING_MESSAGE = "The glob, regex or string is invalid.",
+      INVALID_ROOT_DIRECTORY_PATH_INDEX_MESSAGE = "The index is either not a number or not within range.",
+      FAILED_FIND_MESSAGE = "Failed to search everything.",
+      FAILED_INITIALISE_MESSAGE = "Failed to create a configuration file because one is already present.",
+      FAILED_ADD_ROOT_DIRECTORY_MESSAGE = "Failed to add the root directory.",
+      FAILED_REMOVE_ROOT_DIRECTORY_MESSAGE = "Failed to remove the root directory.",
+      SUCCESSFUL_FIND_MESSAGE = "Searched everything successfully.",
+      SUCCESSFUL_INITIALISE_MESSAGE = "The configuration file has been created successfully.",
+      SUCCESSFUL_ADD_ROOT_DIRECTORY_MESSAGE = "Added the root directory successfully.",
+      SUCCESSFUL_REMOVE_ROOT_DIRECTORY_MESSAGE = "Removed the root directory successfully.";
+
+module.exports = {
+  NO_ARGUMENT_GIVEN_MESSAGE,
+  COMMAND_NOT_RECOGNISED_MESSAGE,
+  NO_ROOT_DIRECTORY_PATHS_MESSAGE,
+  CONFIGURATION_FILE_DOES_NOT_EXIST_MESSAGE,
+  INVALID_IGNORE_OR_PERMIT_MESSAGE,
+  INVALID_ROOT_DIRECTORY_PATH_MESSAGE,
+  INVALID_GLOB_REGEX_OR_STRING_MESSAGE,
+  INVALID_ROOT_DIRECTORY_PATH_INDEX_MESSAGE,
+  FAILED_FIND_MESSAGE,
+  FAILED_INITIALISE_MESSAGE,
+  FAILED_ADD_ROOT_DIRECTORY_MESSAGE,
+  FAILED_REMOVE_ROOT_DIRECTORY_MESSAGE,
+  SUCCESSFUL_FIND_MESSAGE,
+  SUCCESSFUL_INITIALISE_MESSAGE,
+  SUCCESSFUL_ADD_ROOT_DIRECTORY_MESSAGE,
+  SUCCESSFUL_REMOVE_ROOT_DIRECTORY_MESSAGE
+};

package/bin/occurrence.js

@@ -0,0 +1,38 @@
+"use strict";
+
+class Occurrence {
+  constructor(start, end) {
+    this.start = start;
+    this.end = end;
+  }
+
+  getStart() {
+    return this.start;
+  }
+
+  getEnd() {
+    return this.end;
+  }
+
+  static fromResult(result) {
+    const { index } = result,
+          match = result[0],  ///
+          length = match.length,
+          start = index,  ///
+          end = start + length,
+          occurrence = new Occurrence(start, end);
+
+    return occurrence;
+  }
+
+  static fromIndexAndString(index, string) {
+    const length = string.length,
+          start = index,  ///
+          end = start + length,
+          occurrence = new Occurrence(start, end);
+
+    return occurrence;
+  }
+}
+
+module.exports = Occurrence;

package/bin/operation/addRootDirectoryPath.js

@@ -0,0 +1,16 @@
+"use strict";
+
+const { retrieveRootDirectoryPaths, updateRootDirectoryPaths } = require("../configuration");
+
+function addRootDirectoryPathOperation(proceed, abort, context) {
+  const { rootDirectoryPath } = context,
+        rootDirectoryPaths = retrieveRootDirectoryPaths();
+
+  rootDirectoryPaths.push(rootDirectoryPath);
+
+  updateRootDirectoryPaths(rootDirectoryPaths);
+
+  proceed();
+}
+
+module.exports = addRootDirectoryPathOperation;

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 { totalFiles } = context;
+
+      totalFiles++;
+
+      Object.assign(context, {
+        totalFiles
+      });
+
+      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 { totalDirectories } = context;
+
+      totalDirectories++;
+
+      Object.assign(context, {
+        totalDirectories
+      });
+
+      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;