find-cli 0.0.3 → 1.4.4

package/bin/prepare.js

@@ -0,0 +1,51 @@
+"use strict";
+
+const { migrateConfigurationFile } = require("./configuration"),
+      { DEFAULT_HELP, DEFAULT_VERSION } = 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 prepare(command, argument, options, main) {
+  const { help = DEFAULT_HELP, version = DEFAULT_VERSION } = options;
+
+  if (false) {
+    ///
+  } else if (help) {
+    command = HELP_COMMAND;
+  } else if (version) {
+    command = VERSION_COMMAND;
+  }
+
+  if ((command === HELP_COMMAND) ||
+      (command === VERSION_COMMAND) ||
+      (command === INITIALISE_COMMAND)) {
+
+    main(command, argument, options);
+
+    return;
+  }
+
+  migrateConfigurationFile();
+
+  if ((command === ADD_ROOT_DIRECTORY_PATH_COMMAND) ||
+      (command === LIST_ROOT_DIRECTORY_PATHS_COMMAND) ||
+      (command === REMOVE_ROOT_DIRECTORY_PATH_COMMAND)) {
+
+    main(command, argument, options);
+
+    return;
+  }
+
+  argument = command; ///
+
+  command = FIND_COMMAND;
+
+  main(command, argument, options);
+}
+
+module.exports = prepare;

package/bin/rule/glob.js

@@ -0,0 +1,170 @@
+"use strict";
+
+const converters = require("../converters"),
+      Occurrence = require("../occurrence");
+
+const { GLOB_TYPE } = require("../types"),
+      { EMPTY_STRING } = require("../constants"),
+      { isStringGlobLiteral } = require("../utilities/literal"),
+      { addAnchors, addTrailingForwardSlash, removeTrailingForwardSlash } = require("../utilities/string");
+
+class GlobRule {
+  constructor(glob, pattern, regExp) {
+    this.glob = glob;
+    this.pattern = pattern;
+    this.regExp = regExp;
+  }
+
+  getGlob() {
+    return this.glob;
+  }
+
+  getPattern() {
+    return this.pattern;
+  }
+
+  getRegExp() {
+    return this.regExp;
+  }
+
+  toJSON() {
+    const type = GLOB_TYPE,
+          glob = this.glob,
+          pattern = this.pattern,
+          json = {
+            type,
+            glob,
+            pattern
+          };
+
+    return json;
+  }
+
+  find(line) {
+    const occurrences = [],
+          content = line.getContent();
+
+    let offset = 0,
+        string = content, ///
+        result = string.match(this.regExp);
+
+    while (result !== null) {
+      const occurrence = Occurrence.fromResultAndOffset(result, offset),
+            end = occurrence.getEnd(),
+            start = end;  ///
+
+      string = string.substring(start); ///
+
+      offset += start;
+
+      occurrences.push(occurrence);
+
+      result = string.match(this.regExp);
+    }
+
+    return occurrences;
+  }
+
+  match(string) {
+    const matches = this.regExp.test(string);
+
+    return matches;
+  }
+
+  asString() {
+    const string = this.glob; ///
+
+    return string;
+  }
+
+  static fromJSON(json) {
+    let globRule = null;
+
+    const { type } = json;
+
+    if (type === GLOB_TYPE) {
+      const { glob, pattern } = json,
+            regExp = new RegExp(pattern);
+
+      globRule = new GlobRule(glob, pattern, regExp);
+    }
+
+    return globRule;
+  }
+
+  static fromStringAnchoredAndDirectory(string, anchored, directory) {
+    let globRule = null;
+
+    const glob = globFromStringAndDirectory(string, directory);
+
+    if (glob !== null) {
+      const pattern = patternFromGlobAndAnchored(glob, anchored),
+            regExp = new RegExp(pattern);
+
+      globRule = new GlobRule(glob, pattern, regExp);
+    }
+
+    return globRule;
+  }
+}
+
+module.exports = GlobRule;
+
+function patternFromGlobAndAnchored(glob, anchored) {
+  let pattern = EMPTY_STRING;
+
+  const characters = [ ...glob ];
+
+  for (;;) {
+    const converted = converters.some((converter) => {
+      const result = converter.match(characters);
+
+      if (result !== null) {
+        pattern = `${pattern}${result}`;
+
+        return true;
+      }
+    });
+
+    if (!converted) {
+      break;
+    }
+  }
+
+  if (anchored) {
+    pattern = addAnchors(pattern);
+  }
+
+  return pattern;
+}
+
+function globFromStringAndDirectory(string, directory) {
+  let glob;
+
+  const stringGlobLiteral = isStringGlobLiteral(string);
+
+  if (stringGlobLiteral) {
+    const globLiteral = string; ///
+
+    glob = globLiteral;  ///
+
+    glob = removeTrailingForwardSlash(glob);  ///
+
+    if (directory) {
+      glob = addTrailingForwardSlash(glob); ///
+    }
+
+    try {
+      const anchored = false,
+            pattern = patternFromGlobAndAnchored(glob, anchored);
+
+      new RegExp(pattern);
+    } catch (error) {
+      glob = null;
+    }
+  } else {
+    glob = null;
+  }
+
+  return glob;
+}

package/bin/rule/regex.js

@@ -0,0 +1,141 @@
+"use strict";
+
+const Occurrence = require("../occurrence");
+
+const { REGEX_TYPE } = require("../types"),
+      { isStringRegexLiteral } = require("../utilities/literal"),
+      { addAnchors,
+        removeAnchors,
+        addForwardSlashes,
+        removeForwardSlashes,
+        addTrailingEscapedForwardSlash,
+        removeTrailingEscapedForwardSlash } = require("../utilities/string");
+
+class RegexRule {
+  constructor(pattern, regExp) {
+    this.pattern = pattern;
+    this.regExp = regExp;
+  }
+
+  getPattern() {
+    return this.pattern;
+  }
+
+  getRegExp() {
+    return this.regExp;
+  }
+
+  toJSON() {
+    const type = REGEX_TYPE,
+          pattern = this.pattern,
+          json = {
+            type,
+            pattern
+          };
+
+    return json;
+  }
+
+  find(line) {
+    const occurrences = [],
+          content = line.getContent();
+
+    let offset = 0,
+        string = content, ///
+        result = string.match(this.regExp);
+
+    while (result !== null) {
+      const occurrence = Occurrence.fromResultAndOffset(result, offset),
+            end = occurrence.getEnd(),
+            start = end;  ///
+
+      string = string.substring(start); ///
+
+      offset += start;
+
+      occurrences.push(occurrence);
+
+      result = string.match(this.regExp);
+    }
+
+    return occurrences;
+  }
+
+  match(string) {
+    const matches = this.regExp.test(string);
+
+    return matches;
+  }
+
+  asString() {
+    const string = addForwardSlashes(this.pattern);  ///
+
+    return string;
+  }
+
+  static fromJSON(json) {
+    let regexRule = null;
+
+    const { type } = json;
+
+    if (type === REGEX_TYPE) {
+      const { pattern } = json,
+            regExp = new RegExp(pattern);
+
+      regexRule = new RegexRule(pattern, regExp);
+    }
+
+    return regexRule;
+  }
+
+  static fromStringAnchoredAndDirectory(string, anchored, directory) {
+    let regexRule = null;
+
+    const pattern = patternFromStringAndDirectory(string, anchored, directory);
+
+    if (pattern !== null) {
+      const regExp = new RegExp(pattern);
+
+      regexRule = new RegexRule(pattern, regExp);
+    }
+
+    return regexRule;
+  }
+}
+
+module.exports = RegexRule;
+
+function patternFromStringAndDirectory(string, anchored, directory) {
+  let pattern;
+
+  const stringRegexLiteral = isStringRegexLiteral(string);
+
+  if (stringRegexLiteral) {
+    const regexLiteral = string;  ///
+
+    pattern = removeForwardSlashes(regexLiteral);
+
+    pattern = removeAnchors(pattern); ///
+
+    pattern = removeTrailingEscapedForwardSlash(pattern);  ///
+
+    if (directory) {
+      pattern = addTrailingEscapedForwardSlash(pattern); ///
+    }
+
+    if (anchored) {
+      pattern = addAnchors(pattern);
+    }
+
+    try {
+      new RegExp(pattern);
+    } catch (error) {
+      pattern = null;
+    }
+  } else {
+    pattern = null;
+  }
+
+  return pattern;
+}
+

package/bin/rule/string.js

@@ -0,0 +1,117 @@
+"use strict";
+
+const Occurrence = require("../occurrence");
+
+const { STRING_TYPE } = require("../types"),
+      { isStringStringLiteral } = require("../utilities/literal"),
+      { addDoubleQuotes, removeDoubleQuotes, addTrailingForwardSlash, removeTrailingForwardSlash } = require("../utilities/string");
+
+class StringRule {
+  constructor(string) {
+    this.string = string;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  toJSON() {
+    const type = STRING_TYPE,
+          string = this.string,
+          json = {
+            type,
+            string
+          };
+
+    return json;
+  }
+
+  find(line) {
+    const occurrences = [],
+          content = line.getContent();
+
+    let offset = 0,
+        string = content, ///
+        index = string.indexOf(this.string);
+
+    while (index !== -1) {
+      const occurrence = Occurrence.fromIndexStringAndOffset(index, string, offset),
+            end = occurrence.getEnd(),
+            start = end;  ///
+
+      string = string.substring(start); ///
+
+      offset += start;
+
+      occurrences.push(occurrence);
+
+      index = string.match(this.regExp);
+    }
+
+    return occurrences;
+  }
+
+  match(string) {
+    this.string = removeDoubleQuotes(this.string);  ///
+
+    const matches = (this.string === string);
+
+    this.string = addDoubleQuotes(this.string); ///
+
+    return matches;
+  }
+
+  asString() {
+    return this.string;
+  }
+
+  static fromJSON(json) {
+    let stringRule = null;
+
+    const { type } = json;
+
+    if (type === STRING_TYPE) {
+      const { string } = json;
+
+      stringRule = new StringRule(string);
+    }
+
+    return stringRule;
+  }
+
+  static fromStringAnchoredAndDirectory(string, anchored, directory) {
+    let stringRule = null;
+
+    string = stringFromStringAndDirectory(string, directory); ///
+
+    if (string !== null) {
+      stringRule = new StringRule(string);
+    }
+
+    return stringRule;
+  }
+}
+
+module.exports = StringRule;
+
+function stringFromStringAndDirectory(string, directory) {
+  const stringStringLiteral = isStringStringLiteral(string);
+
+  if (stringStringLiteral) {
+    const stringLiteral = string; ///
+
+    string = removeDoubleQuotes(stringLiteral);  ///
+
+    string = removeTrailingForwardSlash(string);  ///
+
+    if (directory) {
+      string = addTrailingForwardSlash(string); ///
+    }
+
+    string = addDoubleQuotes(string); ///
+  } else {
+    string = null;
+  }
+
+  return string;
+}

package/bin/types.js

@@ -0,0 +1,11 @@
+"use strict";
+
+const GLOB_TYPE = "glob",
+      REGEX_TYPE = "regex",
+      STRING_TYPE = "string";
+
+module.exports = {
+  GLOB_TYPE,
+  REGEX_TYPE,
+  STRING_TYPE
+};

package/bin/utilities/literal.js

@@ -0,0 +1,19 @@
+"use strict";
+
+function isStringGlobLiteral(string) {
+  const stringStringLiteral = isStringStringLiteral(string),
+        stringRegexLiteral = isStringRegexLiteral(string),
+        stringGlobLiteral = (!stringStringLiteral && !stringRegexLiteral);
+
+  return stringGlobLiteral;
+}
+
+function isStringRegexLiteral(string) { return /^\/.*?\/$/.test(string); }
+
+function isStringStringLiteral(string) { return /^".*?"$/.test(string); }
+
+module.exports = {
+  isStringGlobLiteral,
+  isStringRegexLiteral,
+  isStringStringLiteral
+};

package/bin/utilities/log.js

@@ -0,0 +1,26 @@
+"use strict";
+
+const GREY_FOREGROUND_COLOUR = "\u001b[90m",
+      RED_FOREGROUND_COLOUR = "\u001b[31m",
+      BLUE_FOREGROUND_COLOUR = "\u001b[34m",
+      GREEN_FOREGROUND_COLOUR = "\u001b[32m",
+      YELLOW_FOREGROUND_COLOUR = "\u001b[33m",
+      RESET_FOREGROUND_COLOUR = "\u001b[39m";
+
+function grey(string) { return `${GREY_FOREGROUND_COLOUR}${string}${RESET_FOREGROUND_COLOUR}`; }
+
+function red(string) { return `${RED_FOREGROUND_COLOUR}${string}${RESET_FOREGROUND_COLOUR}`; }
+
+function blue(string) { return `${BLUE_FOREGROUND_COLOUR}${string}${RESET_FOREGROUND_COLOUR}`; }
+
+function green(string) { return `${GREEN_FOREGROUND_COLOUR}${string}${RESET_FOREGROUND_COLOUR}`; }
+
+function yellow(string) { return `${YELLOW_FOREGROUND_COLOUR}${string}${RESET_FOREGROUND_COLOUR}`; }
+
+module.exports = {
+  grey,
+  red,
+  blue,
+  green,
+  yellow
+};

package/bin/utilities/operation.js

@@ -0,0 +1,38 @@
+"use strict";
+
+const { asynchronousUtilities } = require("necessary");
+
+const { whilst } = asynchronousUtilities;
+
+function executeOperations(operations, callback, context) {
+  let completed = true;
+
+  const operationsLength = operations.length,
+        lastIndex = operationsLength - 1;
+
+  whilst((next, done, context, index) => {
+    if (index > lastIndex) {
+      done();
+
+      return;
+    }
+
+    const operation = operations[index],
+          proceed = next, ///
+          abort = () => {
+            completed = false;
+
+            done();
+          };
+
+    operation(proceed, abort, context);
+  }, done, context);
+
+  function done() {
+    callback(completed);
+  }
+}
+
+module.exports = {
+	executeOperations
+};

package/bin/utilities/path.js

@@ -0,0 +1,58 @@
+"use strict";
+
+const { pathUtilities } = require("necessary");
+
+const { CURRENT_DIRECTORY_PATH } = require("../constants");
+
+const { concatenatePaths } = pathUtilities;
+
+function stripRootDirectoryFromPath(path, context) {
+  const { rootDirectoryPaths } = context;
+
+  rootDirectoryPaths.some((rootDirectoryPath) => {
+    const pathStartsWithRootDirectoryPath = path.startsWith(rootDirectoryPath);
+
+    if (pathStartsWithRootDirectoryPath) {
+      const length = rootDirectoryPath.length,
+            start = length;
+
+      path = path.substring(start);  ///
+
+      return true;
+    }
+  });
+
+  return path;
+}
+
+function isDirectoryPathRootDirectoryPath(directoryPath, context) {
+  const { rootDirectoryPaths } = context,
+        rootDirectoryPathsIncludesDirectoryPath = rootDirectoryPaths.includes(directoryPath),
+        directoryPathRootDirectoryPath = rootDirectoryPathsIncludesDirectoryPath; ///
+
+  return directoryPathRootDirectoryPath;
+}
+
+function entryPathsFromEntryNamesAndDirectoryPath(entryNames, directoryPath) {
+  const entryPaths = entryNames.map((entryName) => {
+    const entryPath = entryPathFromEntryNameAndDirectoryPath(entryName, directoryPath);
+
+    return entryPath
+  });
+
+  return entryPaths;
+}
+
+module.exports = {
+  stripRootDirectoryFromPath,
+  isDirectoryPathRootDirectoryPath,
+  entryPathsFromEntryNamesAndDirectoryPath
+};
+
+function entryPathFromEntryNameAndDirectoryPath(entryName, directoryPath) {
+  const entryPath = (directoryPath === CURRENT_DIRECTORY_PATH) ?
+                         entryName : ///
+                           concatenatePaths(directoryPath, entryName);
+
+  return entryPath;
+}

package/bin/utilities/prompt.js

@@ -0,0 +1,7 @@
+"use strict";
+
+function isAnswerIgnore(answer) { return /^(?:ignore|i)$/i.test(answer); }
+
+module.exports = {
+  isAnswerIgnore
+};

package/bin/utilities/rule.js

@@ -0,0 +1,18 @@
+"use strict";
+
+const GlobRule = require("../rule/glob"),
+      RegexRule = require("../rule/regex"),
+      StringRule = require("../rule/string");
+
+function ruleFromStringAnchoredAndDirectory(string, anchored, directory) {
+  const globRule = GlobRule.fromStringAnchoredAndDirectory(string, anchored, directory),
+        regexRule = RegexRule.fromStringAnchoredAndDirectory(string, anchored, directory),
+        stringRule = StringRule.fromStringAnchoredAndDirectory(string, anchored, directory),
+        rule = (globRule || regexRule || stringRule);
+
+  return rule;
+}
+
+module.exports = {
+  ruleFromStringAnchoredAndDirectory
+};

package/bin/utilities/string.js

@@ -0,0 +1,36 @@
+"use strict";
+
+const { EMPTY_STRING } = require("../constants");
+
+function addAnchors(string) { return `^${string}$`; }
+
+function removeAnchors(string) { return string.replace(/(^\^|\$$)/g, EMPTY_STRING); }
+
+function addDoubleQuotes(string) { return `"${string}"`; }
+
+function addForwardSlashes(string) { return `/${string}/`; }
+
+function removeDoubleQuotes(string) { return string.replace(/(^"|"$)/g, EMPTY_STRING); }
+
+function removeForwardSlashes(string) { return string.replace(/(^\/|\/$)/g, EMPTY_STRING); }
+
+function addTrailingForwardSlash(string) { return `${string}\/`; }
+
+function removeTrailingForwardSlash(string) { return string.replace(/(\/$)/, EMPTY_STRING); }
+
+function addTrailingEscapedForwardSlash(string) { return `${string}\\\/`; }
+
+function removeTrailingEscapedForwardSlash(string) { return string.replace(/(\\\/$)/, EMPTY_STRING); }
+
+module.exports = {
+  addAnchors,
+  removeAnchors,
+  addDoubleQuotes,
+  addForwardSlashes,
+  removeDoubleQuotes,
+  removeForwardSlashes,
+  addTrailingForwardSlash,
+  removeTrailingForwardSlash,
+  addTrailingEscapedForwardSlash,
+  removeTrailingEscapedForwardSlash
+};