find-cli 0.0.3 → 1.4.4

package/bin/isIgnored/asynchronous.js

@@ -0,0 +1,59 @@
+"use strict";
+
+const rulePromptOperation = require("../operation/prompt/rule"),
+      updatePathRulesOperation = require("../operation/updatePatRules"),
+      ignoreOrPermitPathPromptOperation = require("../operation/prompt/ignoreOrPermitPath");
+
+const { executeOperations } = require("../utilities/operation"),
+      { stripRootDirectoryFromPath } = require("../utilities/path");
+
+function asynchronousIsFilePathIgnored(filePath, context, callback) {
+  filePath = stripRootDirectoryFromPath(filePath, context); ///
+
+  const path = filePath,  ///
+        directory = false;
+
+  asynchronousIsPathIgnored(path, directory, context, callback);
+}
+
+function asynchronousIsDirectoryPathIgnored(directoryPath, context, callback) {
+  directoryPath = stripRootDirectoryFromPath(directoryPath, context);  ///
+
+  const path = directoryPath,  ///
+        directory = true;
+
+  asynchronousIsPathIgnored(path, directory, context, callback);
+}
+
+module.exports = {
+  asynchronousIsFilePathIgnored,
+  asynchronousIsDirectoryPathIgnored
+};
+
+function asynchronousIsPathIgnored(path, directory, context, callback) {
+  const operations = [
+          ignoreOrPermitPathPromptOperation,
+          rulePromptOperation,
+          updatePathRulesOperation
+        ],
+        rule = null,
+        pathIgnored = null;
+
+  Object.assign(context, {
+    rule,
+    path,
+    directory,
+    pathIgnored
+  });
+
+  executeOperations(operations, (completed) => {
+    const { pathIgnored } = context;
+
+    delete context.rule;
+    delete context.path;
+    delete context.directory;
+    delete context.pathIgnored;
+
+    callback(pathIgnored);
+  }, context);
+}

package/bin/isIgnored/synchronous.js

@@ -0,0 +1,104 @@
+"use strict";
+
+const { EMPTY_STRING } = require("../constants"),
+      { addTrailingForwardSlash } = require("../utilities/string"),
+      { stripRootDirectoryFromPath } = require("../utilities/path");
+
+function synchronousIsFilePathIgnored(filePath, context) {
+  let filePathIgnored = null;
+
+  filePath = stripRootDirectoryFromPath(filePath, context);  ///
+
+  const { ignoredFilePathRules, permittedFilePathRules } = context,
+        string = filePath;  ///
+
+  ignoredFilePathRules.some((ignoredFilePathRule) => {
+    const matches = ignoredFilePathRule.match(string);
+
+    if (matches) {
+      const rule = ignoredFilePathRule, ///
+            ruleString = rule.asString();
+
+      Object.assign(context, {
+        ruleString
+      });
+
+      filePathIgnored = true;
+
+      return true;
+    }
+  });
+
+  permittedFilePathRules.some((permittedFilePathRule) => {
+    const matches = permittedFilePathRule.match(string);
+
+    if (matches) {
+      const rule = permittedFilePathRule, ///
+            ruleString = rule.asString();
+
+      Object.assign(context, {
+        ruleString
+      });
+
+      filePathIgnored = false;
+
+      return true;
+    }
+  });
+
+  return filePathIgnored;
+}
+
+function synchronousIsDirectoryPathIgnored(directoryPath, context) {
+  let directoryPathIgnored = null;
+
+  directoryPath = stripRootDirectoryFromPath(directoryPath, context);  ///
+
+  if (directoryPath === EMPTY_STRING) {
+    directoryPathIgnored = false;
+  } else {
+    const { ignoredDirectoryPathRules, permittedDirectoryPathRules } = context,
+          string = addTrailingForwardSlash(directoryPath);  ///
+
+    ignoredDirectoryPathRules.some((ignoredDirectoryPathRule) => {
+      const matches = ignoredDirectoryPathRule.match(string);
+
+      if (matches) {
+        const rule = ignoredDirectoryPathRule, ///
+              ruleString = rule.asString();
+
+        Object.assign(context, {
+          ruleString
+        });
+
+        directoryPathIgnored = true;
+
+        return true;
+      }
+    });
+
+    permittedDirectoryPathRules.some((permittedDirectoryPathRule) => {
+      const matches = permittedDirectoryPathRule.match(string);
+
+      if (matches) {
+        const rule = permittedDirectoryPathRule, ///
+              ruleString = rule.asString();
+
+        Object.assign(context, {
+          ruleString
+        });
+
+        directoryPathIgnored = false;
+
+        return true;
+      }
+    });
+  }
+
+  return directoryPathIgnored;
+}
+
+module.exports = {
+  synchronousIsFilePathIgnored,
+  synchronousIsDirectoryPathIgnored
+};

package/bin/line.js

@@ -0,0 +1,181 @@
+"use strict";
+
+const { arrayUtilities } = require("necessary");
+
+const { grey, blue, yellow } = require("./utilities/log"),
+      { EMPTY_STRING, SINGLE_SPACE } = require("./constants");
+
+const { backwardsForEach } = arrayUtilities;
+
+class Line {
+  constructor(index, content, filePath, occurrences) {
+    this.index = index;
+    this.content = content;
+    this.filePath = filePath;
+    this.occurences = occurrences;
+  }
+
+  getIndex() {
+    return this.index;
+  }
+
+  getContent() {
+    return this.content;
+  }
+
+  getFilePath() {
+    return this.filePath;
+  }
+
+  getOccurrences() {
+    return this.occurences;
+  }
+
+  setIndex(index) {
+    this.index = index;
+  }
+
+  setContent(content) {
+    this.content = content;
+  }
+
+  setFilePath(filePath) {
+    this.filePath = filePath;
+  }
+
+  setOccurrences(occurrences) {
+    this.occurrences = occurrences;
+  }
+
+  getIndexLength() {
+    const indexLength = this.index.length;
+
+    return indexLength;
+  }
+
+  getFilePathLength() {
+    const filePathLength = this.filePath.length;
+
+    return filePathLength;
+  }
+
+  addOccurrences(occurrences) {
+
+  }
+
+  getFormattedIndex(requiredIndexLength) {
+    let index;
+
+    const indexLength = this.getIndexLength(),
+          paddingLength = requiredIndexLength - indexLength,
+          padding = paddingFromPaddingLength(paddingLength);
+
+    index = `${padding}${this.index}`;
+
+    const formattedIndex = yellow(index);
+
+    return formattedIndex;
+  }
+
+  getFormattedContent() {
+    const gaps = [],
+          matches = [];
+
+    let end,
+        start,
+        string = this.content;  ///
+
+    backwardsForEach(this.occurrences, (occurrence) => {
+      end = occurrence.getEnd();
+
+      start = end;  ///
+
+      end = Infinity;
+
+      const gap = string.substring(start, end);
+
+      gaps.unshift(gap);
+
+      end = occurrence.getEnd();
+
+      start = 0;
+
+      string = string.substring(start, end);
+
+      start = occurrence.getStart();
+
+      end = Infinity;
+
+      const match = string.substring(start, end);
+
+      matches.unshift(match);
+
+      end = start;  ///
+
+      start = 0;
+
+      string = string.substring(start, end);  ///
+    });
+
+    let gap = string; ///
+
+    gap = grey(gap);  ///
+
+    string = gap; ///
+
+    gaps.forEach((gap, index) => {
+      let match = matches[index];
+
+      gap = grey(gap);  ///
+
+      match = blue(match);  ///
+
+      string = `${string}${match}${gap}`;
+    });
+
+    const formattedContent = string;  ///
+
+    return formattedContent;
+  }
+
+  getFormattedFilePath(requiredFilePathLength) {
+    const filePathLength = this.getFilePathLength(),
+          paddingLength = requiredFilePathLength - filePathLength,
+          padding = paddingFromPaddingLength(paddingLength),
+          formattedFilePath =  `${this.filePath}${padding}`;
+
+    return formattedFilePath;
+  }
+
+  asMessage(requiredIndexLength, requiredFilePathLength) {
+    const formattedIndex = this.getFormattedIndex(requiredIndexLength),
+          formattedContent = this.getFormattedContent(),
+          formattedFilePath = this.getFormattedFilePath(requiredFilePathLength),
+          message = `|${formattedFilePath}  ${formattedIndex}|${formattedContent}`;
+
+    return message;
+  }
+
+  static fromIndexContentAndFilePath(index, content, filePath) {
+    index = `${index}`; ///
+
+    content = content.replace(/(\r\n|\r|\n)$/, EMPTY_STRING); ///
+
+    const occurrences = [],
+          line = new Line(index, content, filePath, occurrences);
+
+    return line;
+  }
+}
+
+module.exports = Line;
+
+function paddingFromPaddingLength(paddingLength) {
+  let padding = EMPTY_STRING;
+
+  for (let count = 0; count < paddingLength; count++) {
+    padding += SINGLE_SPACE;
+  }
+
+  return padding;
+}

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) && !dryRun) {
+        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,40 @@
+"use strict";
+
+const { ZERO } = require("./constants");
+
+class Occurrence {
+  constructor(start, end) {
+    this.start = start;
+    this.end = end;
+  }
+
+  getStart() {
+    return this.start;
+  }
+
+  getEnd() {
+    return this.end;
+  }
+
+  static fromResultAndOffset(result, offset) {
+    const { index } = result,
+          match = result[ZERO],
+          length = match.length,
+          start = index + offset,
+          end = start + length,
+          occurrence = new Occurrence(start, end);
+
+    return occurrence;
+  }
+
+  static fromIndexStringAndOffset(index, string, offset) {
+    const length = string.length,
+          start = index + offset,
+          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;