find-cli 0.0.3 → 1.4.3

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,24 @@
+"use strict";
+
+const { ruleFromStringAnchoredAndDirectory } = require("../utilities/rule");
+
+function ruleOperation(proceed, abort, context) {
+  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
+};

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,165 @@
+"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(string) {
+    const occurrences = [];
+
+    let result = string.match(this.regExp);
+
+    while (result !== null) {
+      const occurrence = Occurrence.fromResult(result),
+            end = occurrence.getEnd(),
+            start = end;  ///
+
+      string = string.substring(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,136 @@
+"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(string) {
+    const occurrences = [];
+
+    let result = string.match(this.regExp);
+
+    while (result !== null) {
+      const occurrence = Occurrence.fromResult(result),
+            end = occurrence.getEnd(),
+            start = end;  ///
+
+      string = string.substring(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,112 @@
+"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(string) {
+    const occurrences = [];
+
+    let index = string.indexOf(this.string);
+
+    while (index !== -1) {
+      const occurrence = Occurrence.fromIndexAndString(index, string),
+            end = occurrence.getEnd(),
+            start = end;  ///
+
+      string = string.substring(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
+};