find-cli 0.0.3 → 1.4.4

package/bin/configuration.js

@@ -0,0 +1,230 @@
+"use strict";
+
+const { versionUtilities, configurationUtilities } = require("necessary");
+
+const GlobRule = require("./rule/glob"),
+      RegexRule = require("./rule/regex"),
+      StringRule = require("./rule/string");
+
+const { FIND } = require("./constants"),
+      { createConfiguration } = require("./configuration/version_1_4"),
+      { migrateConfigurationToVersion_1_1 } = require("./configuration/version_1_1"),
+      { migrateConfigurationToVersion_1_2 } = require("./configuration/version_1_2"),
+      { migrateConfigurationToVersion_1_3 } = require("./configuration/version_1_3"),
+      { migrateConfigurationToVersion_1_4 } = require("./configuration/version_1_4"),
+      { CONFIGURATION_FILE_DOES_NOT_EXIST_MESSAGE } = require("./messages"),
+      { VERSION_1_0, VERSION_1_1, VERSION_1_2, VERSION_1_3, VERSION_1_4 } = require("./versions");
+
+const { rc } = configurationUtilities,
+      { migrate } = versionUtilities,
+      { setRCBaseExtension, checkRCFileExists, updateRCFile, writeRCFile, readRCFile } = rc;
+
+setRCBaseExtension(FIND);
+
+function retrieveRootDirectoryPaths() {
+  const configuration = readConfigurationFile(),
+        { rootDirectoryPaths } = configuration;
+
+  return rootDirectoryPaths;
+}
+
+function retrieveIgnoredFilePathRules() {
+  const configuration = readConfigurationFile();
+
+  let { ignoredFilePathRules } = configuration;
+
+  const ignoredFilePathRulesJSON = ignoredFilePathRules;  ///
+
+  ignoredFilePathRules = rulesFromPathRulesJSON(ignoredFilePathRulesJSON);
+
+  return ignoredFilePathRules;
+}
+
+function retrievePermittedFilePathRules() {
+  const configuration = readConfigurationFile();
+
+  let { permittedFilePathRules } = configuration;
+
+  const permittedFilePathRulesJSON = permittedFilePathRules;  ///
+
+  permittedFilePathRules = rulesFromPathRulesJSON(permittedFilePathRulesJSON);
+
+  return permittedFilePathRules;
+}
+
+function retrieveIgnoredDirectoryPathRules() {
+  const configuration = readConfigurationFile();
+
+  let { ignoredDirectoryPathRules } = configuration;
+
+  const ignoredDirectoryPathRulesJSON = ignoredDirectoryPathRules;  ///
+
+  ignoredDirectoryPathRules = rulesFromPathRulesJSON(ignoredDirectoryPathRulesJSON);
+
+  return ignoredDirectoryPathRules;
+}
+
+function retrievePermittedDirectoryPathRules() {
+  const configuration = readConfigurationFile();
+
+  let { permittedDirectoryPathRules } = configuration;
+
+  const permittedDirectoryPathRulesJSON = permittedDirectoryPathRules;  ///
+
+  permittedDirectoryPathRules = rulesFromPathRulesJSON(permittedDirectoryPathRulesJSON);
+
+  return permittedDirectoryPathRules;
+}
+
+function updateRootDirectoryPaths(rootDirectoryPaths) {
+  updateConfigurationFile({
+    rootDirectoryPaths
+  });
+}
+
+function updateIgnoredFilePathRules(ignoredFilePathRules) {
+  const ignoredFilePathRulesJSON = rulesJSONFromRules(ignoredFilePathRules);
+
+  ignoredFilePathRules = ignoredFilePathRulesJSON;  ///
+
+  updateConfigurationFile({
+    ignoredFilePathRules
+  });
+}
+
+function updatePermittedFilePathRules(permittedFilePathRules) {
+  const permittedFilePathRulesJSON = rulesJSONFromRules(permittedFilePathRules);
+
+  permittedFilePathRules = permittedFilePathRulesJSON;  ///
+
+  updateConfigurationFile({
+    permittedFilePathRules
+  });
+}
+
+function updateIgnoredDirectoryPathRules(ignoredDirectoryPathRules) {
+  const ignoredDirectoryPathRulesJSON = rulesJSONFromRules(ignoredDirectoryPathRules);
+
+  ignoredDirectoryPathRules = ignoredDirectoryPathRulesJSON;  ///
+
+  updateConfigurationFile({
+    ignoredDirectoryPathRules
+  });
+}
+
+function updatePermittedDirectoryPathRules(permittedDirectoryPathRules) {
+  const permittedDirectoryPathRulesJSON = rulesJSONFromRules(permittedDirectoryPathRules);
+
+  permittedDirectoryPathRules = permittedDirectoryPathRulesJSON;  ///
+
+  updateConfigurationFile({
+    permittedDirectoryPathRules
+  });
+}
+
+function createConfigurationFile() {
+  const configuration = createConfiguration(),
+        json = configuration; ///
+
+  writeRCFile(json);
+}
+
+function migrateConfigurationFile() {
+  assertConfigurationFileExists();
+
+  let json = readRCFile();
+
+  const migrationMap = {
+          [ VERSION_1_0 ]: migrateConfigurationToVersion_1_1,
+          [ VERSION_1_1 ]: migrateConfigurationToVersion_1_2,
+          [ VERSION_1_2 ]: migrateConfigurationToVersion_1_3,
+          [ VERSION_1_3 ]: migrateConfigurationToVersion_1_4
+        },
+        latestVersion = VERSION_1_4;
+
+  json = migrate(json, migrationMap, latestVersion);
+
+  writeRCFile(json);
+}
+
+function checkConfigurationFileExists() {
+  const rcFileExists = checkRCFileExists(),
+        configurationFileExists = rcFileExists; ///
+
+  return configurationFileExists;
+}
+
+function assertConfigurationFileExists() {
+  const configurationFileExists = checkConfigurationFileExists();
+
+  if (!configurationFileExists) {
+    console.log(CONFIGURATION_FILE_DOES_NOT_EXIST_MESSAGE);
+
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  retrieveRootDirectoryPaths,
+  retrieveIgnoredFilePathRules,
+  retrievePermittedFilePathRules,
+  retrieveIgnoredDirectoryPathRules,
+  retrievePermittedDirectoryPathRules,
+  updateRootDirectoryPaths,
+  updateIgnoredFilePathRules,
+  updatePermittedFilePathRules,
+  updateIgnoredDirectoryPathRules,
+  updatePermittedDirectoryPathRules,
+  createConfigurationFile,
+  migrateConfigurationFile,
+  checkConfigurationFileExists
+};
+
+function readConfigurationFile() {
+  assertConfigurationFileExists();
+
+  const json = readRCFile(),
+        configuration = json; ///
+
+  return configuration;
+}
+
+function writeConfigurationFile(configuration) {
+  assertConfigurationFileExists();
+
+  const json = configuration; ///
+
+  writeRCFile(json);
+}
+
+function updateConfigurationFile(addedConfiguration, ...deleteConfigurationNames) {
+  assertConfigurationFileExists();
+
+  const addedProperties = addedConfiguration, ///
+        deletedPropertyNames = deleteConfigurationNames;  ///
+
+  updateRCFile(addedProperties, ...deletedPropertyNames);
+}
+
+function rulesFromPathRulesJSON(rulesJSON) {
+  const rules = rulesJSON.map((ruleJSON) => {
+    const json = ruleJSON, ///
+          rule = GlobRule.fromJSON(json) ||
+                    RegexRule.fromJSON(json) ||
+                    StringRule.fromJSON(json);
+
+    return rule;
+  });
+
+  return rules;
+}
+
+function rulesJSONFromRules(rules) {
+  const rulesJSON = rules.map((rule) => {
+    const ruleJSON = rule.toJSON();
+
+    return ruleJSON;
+  });
+
+  return rulesJSON;
+}

package/bin/constants.js

@@ -0,0 +1,25 @@
+"use strict";
+
+const S = "s",
+      ZERO = 0,
+      FIND = "find",
+      FILE = "file",
+      G_FLAG = "g",
+      FIND_CLI = "Find-CLI",
+      DIRECTORY = "directory",
+      EMPTY_STRING = "",
+      SINGLE_SPACE = " ",
+      ROOT_DIRECTORY_PATH = "./";
+
+module.exports = {
+  S,
+  ZERO,
+  FIND,
+  FILE,
+  G_FLAG,
+  FIND_CLI,
+  DIRECTORY,
+  EMPTY_STRING,
+  SINGLE_SPACE,
+  ROOT_DIRECTORY_PATH
+};

package/bin/converter/alternates.js

@@ -0,0 +1,29 @@
+"use strict";
+
+const { characters } = require("necessary");
+
+const Converter = require("../converter");
+
+const { BAR_CHARACTER, COMMA_CHARACTER } = characters;
+
+class AlternatesConverter extends Converter {
+  callback(characters) {
+    characters.pop();
+
+    characters.shift();
+
+    const alternates = characters.split(COMMA_CHARACTER),
+          alternation = alternates.join(BAR_CHARACTER),
+          result = `(${alternation})`;
+
+    return result;
+  }
+
+  static regex = /^{[^}]+}/;
+
+  static fromNothing() { return Converter.fromNothing(AlternatesConverter); }
+}
+
+const alternatesConverter = AlternatesConverter.fromNothing();
+
+module.exports = alternatesConverter;

package/bin/converter/characterClass.js

@@ -0,0 +1,45 @@
+"use strict";
+
+const { characters } = require("necessary");
+
+const Converter = require("../converter");
+
+const { HAT_CHARACTER, EXCLAMATION_MARK_CHARACTER } = characters;
+
+class CharacterClassConverter extends Converter {
+  callback(characters) {
+    characters.pop();
+
+    characters.shift();
+
+    let negated = true;
+
+    const firstCharacter = characters.shift() || null;
+
+    if (firstCharacter !== null) {
+      if ((firstCharacter === HAT_CHARACTER) || (firstCharacter === EXCLAMATION_MARK_CHARACTER)) {
+        negated = true;
+      } else {
+        characters.unshift(firstCharacter);
+      }
+    }
+
+    let characterClass = `${characters}`;
+
+    if (negated) {
+      characterClass = `^${characterClass}`;
+    }
+
+    const result = `[${characterClass}]`;
+
+    return result;
+  }
+
+  static regex = /^\[[^\]]+]/;
+
+  static fromNothing() { return Converter.fromNothing(CharacterClassConverter); }
+}
+
+const characterClassConverter = CharacterClassConverter.fromNothing();
+
+module.exports = characterClassConverter;

package/bin/converter/default.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const Converter = require("../converter");
+
+class DefaultConverter extends Converter {
+  callback(characters) {
+    const result = characters;  ///
+
+    return result;
+  }
+
+  static regex = /./;
+
+  static fromNothing() { return Converter.fromNothing(DefaultConverter); }
+}
+
+const defaultConverter = DefaultConverter.fromNothing();
+
+module.exports = defaultConverter;

package/bin/converter/directory.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const Converter = require("../converter");
+
+class DirectoryConverter extends Converter {
+  callback(characters) {
+    const result = `\\/`;
+
+    return result;
+  }
+
+  static regex = /^\//;
+
+  static fromNothing() { return Converter.fromNothing(DirectoryConverter); }
+}
+
+const directoryConverter = DirectoryConverter.fromNothing();
+
+module.exports = directoryConverter;

package/bin/converter/escapedCharacter.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const Converter = require("../converter");
+
+class EscapedCharacterConverter extends Converter {
+  callback(characters) {
+    const result = characters;  ///
+
+    return result;
+  }
+
+  static regex = /^\\./;
+
+  static fromNothing() { return Converter.fromNothing(EscapedCharacterConverter); }
+}
+
+const questionMarkCharacterConverter = EscapedCharacterConverter.fromNothing();
+
+module.exports = questionMarkCharacterConverter;

package/bin/converter/period.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const Converter = require("../converter");
+
+class PeriodConverter extends Converter {
+  callback(characters) {
+    const result = `\\.`;
+
+    return result;
+  }
+
+  static regex = /^\./;
+
+  static fromNothing() { return Converter.fromNothing(PeriodConverter); }
+}
+
+const periodConverter = PeriodConverter.fromNothing();
+
+module.exports = periodConverter;

package/bin/converter/questionMark.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const Converter = require("../converter");
+
+class QuestionMarkConverter extends Converter {
+  callback(characters) {
+    const result = `.`;
+
+    return result;
+  }
+
+  static regex = /^\?/;
+
+  static fromNothing() { return Converter.fromNothing(QuestionMarkConverter); }
+}
+
+const questionMarkConverter = QuestionMarkConverter.fromNothing();
+
+module.exports = questionMarkConverter;

package/bin/converter/repeatedDirectories.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const Converter = require("../converter");
+
+class RepeatedDirectoriesConverter extends Converter {
+  callback(characters) {
+    const result = `(?:[^/]*\\/)*`;
+
+    return result;
+  }
+
+  static regex = /^\*\*\//;
+
+  static fromNothing() { return Converter.fromNothing(RepeatedDirectoriesConverter); }
+}
+
+const repeatedDirectoriesConverter = RepeatedDirectoriesConverter.fromNothing();
+
+module.exports = repeatedDirectoriesConverter;

package/bin/converter/repeatedWildcard.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const Converter = require("../converter");
+
+class RepeatedWildcardConverter extends Converter {
+  callback(characters) {
+    const result = `.*`;
+
+    return result;
+  }
+
+  static regex = /^\*\*/;
+
+  static fromNothing() { return Converter.fromNothing(RepeatedWildcardConverter); }
+}
+
+const singleDirectoryConverter = RepeatedWildcardConverter.fromNothing();
+
+module.exports = singleDirectoryConverter;

package/bin/converter/singleDirectory.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const Converter = require("../converter");
+
+class SingleDirectoryConverter extends Converter {
+  callback(characters) {
+    const result = `[^/]*\\/`;
+
+    return result;
+  }
+
+  static regex = /^\*\//;
+
+  static fromNothing() { return Converter.fromNothing(SingleDirectoryConverter); }
+}
+
+const singleDirectoryConverter = SingleDirectoryConverter.fromNothing();
+
+module.exports = singleDirectoryConverter;

package/bin/converter/singleWildcard.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const Converter = require("../converter");
+
+class SingleWildcardConverter extends Converter {
+  callback(characters) {
+    const result = `.+?`;
+
+    return result;
+  }
+
+  static regex = /^\*/;
+
+  static fromNothing() { return Converter.fromNothing(SingleWildcardConverter); }
+}
+
+const singleWildcardConverter = SingleWildcardConverter.fromNothing();
+
+module.exports = singleWildcardConverter;

package/bin/converter.js

@@ -0,0 +1,48 @@
+"use strict";
+
+const { arrayUtilities } = require("necessary");
+
+const { EMPTY_STRING } = require("./constants");
+
+const { first } = arrayUtilities;
+
+class Converter {
+  constructor(regex) {
+    this.regex = regex;
+  }
+
+  getRegex() {
+    return this.regex;
+  }
+
+  match(characters) {
+    let result = null;
+
+    const string = characters.join(EMPTY_STRING),
+          matches = this.regex.exec(string);
+
+    if (matches !== null) {
+      const firstMatch = first(matches),
+            match = firstMatch; ///
+
+      result = this.callback(match);
+
+      const length = match.length,
+            start = 0,
+            deleteCount = length;
+
+      characters.splice(start, deleteCount);
+    }
+
+    return result;
+  }
+
+  static fromNothing(Class) {
+    const { regex } = Class,
+          converter = new Class(regex);
+
+    return converter;
+  }
+}
+
+module.exports = Converter;

package/bin/converters.js

@@ -0,0 +1,29 @@
+"use strict";
+
+const periodConverter = require("./converter/period"),
+      defaultConverter = require("./converter/default"),
+      directoryConverter = require("./converter/directory"),
+      alternatesConverter = require("./converter/alternates"),
+      questionMarkConverter = require("./converter/questionMark"),
+      characterClassConverter = require("./converter/characterClass"),
+      singleWildcardConverter = require("./converter/singleWildcard"),
+      singleDirectoryConverter = require("./converter/singleDirectory"),
+      repeatedWildcardConverter = require("./converter/repeatedWildcard"),
+      escapedCharacterConverter = require("./converter/escapedCharacter"),
+      repeatedDirectoriesConverter = require("./converter/repeatedDirectories");
+
+const converters = [
+  repeatedDirectoriesConverter,
+  singleDirectoryConverter,
+  directoryConverter,
+  repeatedWildcardConverter,
+  singleWildcardConverter,
+  escapedCharacterConverter,
+  questionMarkConverter,
+  periodConverter,
+  alternatesConverter,
+  characterClassConverter,
+  defaultConverter
+];
+
+module.exports = converters;

package/bin/defaults.js

@@ -0,0 +1,13 @@
+"use strict";
+
+const DEFAULT_HELP = false,
+      DEFAULT_VERSION = false,
+      DEFAULT_DRY_RUN = false,
+      DEFAULT_QUIETLY = false;
+
+module.exports = {
+  DEFAULT_HELP,
+  DEFAULT_VERSION,
+  DEFAULT_DRY_RUN,
+  DEFAULT_QUIETLY
+};

package/bin/descriptions.js

@@ -0,0 +1,11 @@
+"use strict";
+
+const GLOB_STRING_OR_REGEX_DESCRIPTION = `Glob, string or regex: `,
+      ADD_ROOT_DIRECTORY_PATH_DESCRIPTION = `Root directory: `,
+      REMOVE_ROOT_DIRECTORY_PATH_DESCRIPTION = `Root directory index: `;
+
+module.exports = {
+  GLOB_STRING_OR_REGEX_DESCRIPTION,
+  ADD_ROOT_DIRECTORY_PATH_DESCRIPTION,
+  REMOVE_ROOT_DIRECTORY_PATH_DESCRIPTION
+};

package/bin/find.js

@@ -0,0 +1,55 @@
+"use strict";
+
+const { fileSystemUtilities } = require("necessary");
+
+const Line = require("./line");
+
+const { readFile } = fileSystemUtilities;
+
+function find(filePath, context) {
+  const { rule } = context,
+        content = readFile(filePath),
+        lines = linesFromContentAndFilePath(content, filePath);
+
+  let { linesTotal } = context;
+
+  lines.forEach((line) => {
+    const occurrences = rule.find(line, filePath),
+          occurrencesLength = occurrences.length;
+
+    if (occurrencesLength > 0) {
+      let { occurrencesTotal } = context;
+
+      occurrencesTotal += occurrencesLength;
+
+      Object.assign(context, {
+        occurrencesTotal
+      });
+
+      const { lines } = context;
+
+      lines.push(line);
+
+      line.setOccurrences(occurrences);
+    }
+
+    linesTotal++;
+  });
+
+  Object.assign(context, {
+    linesTotal
+  });
+}
+
+module.exports = find;
+
+function linesFromContentAndFilePath(content, filePath) {
+  const contents = content.split(/(\r\n|\r|\n)/),
+        lines = contents.map((content, index) => {
+          const line = Line.fromIndexContentAndFilePath(index, content, filePath);
+
+          return line;
+        });
+
+  return lines;
+}