find-cli 0.0.3 → 1.4.3

package/README.md

@@ -1,21 +1,59 @@
 # Find-CLI
 
-An alternative to grep.
+Find...
 
 ## Installation
 
-You can install Furtle with [npm](https://www.npmjs.com/):
+You can install Find via [npm](https://www.npmjs.com/):
 
-    npm install find-cli
+    npm install --global find-cli
 
-You can also clone the repository with [Git](https://git-scm.com/):
+You may need to prepend [`sudo`](https://en.wikipedia.org/wiki/Sudo), depending on your setup.
+
+If you would like to contribute or would simply like to have a look at the code, you can clone the repository with [Git](https://git-scm.com/)...
 
     git clone https://github.com/djalbat/find-cli.git
 
-...and then install the dependencies with npm from within the project's root directory:
+...then install the dependencies with npm from within the project's root directory:
 
     npm install
 
+## Usage
+
+Find has the following commands and options:
+
+```
+  find [<options>] [<command>] [<argument>]
+
+Commands:
+
+  help                                     Show this help
+ 
+  version                                  Show the version
+
+  initialise                               Create a configuration file
+
+  add-root-directory                       Add a root directory
+
+  remove-root-directory                    Remove a root directory
+
+  list-root-directories                    List the root directories
+  
+Options:
+
+  --help|-h                                Show this help
+
+  --version|-v                             Show the version
+
+  --dry-run|-d                             Traverse the directories and files but do not search
+
+  --quietly|-q                             Execute shell commands without printing to the console
+```
+
+In the directory that contains the sub-directories holding your project's packages and binaries, run the following command:
+
+    find initialise
+
 ## Contact
 
 * james.smith@djalbat.com

package/bin/abbreviations.js

@@ -0,0 +1,10 @@
+"use strict";
+
+const { HELP_OPTION, VERSION_OPTION, DRY_RUN_OPTION, QUIETLY_OPTION } = require("./options");
+
+module.exports = {
+  "h": HELP_OPTION,
+  "v": VERSION_OPTION,
+  "d": DRY_RUN_OPTION,
+  "q": QUIETLY_OPTION
+};

package/bin/action/addRootDirectoryPath.js

@@ -0,0 +1,31 @@
+"use strict";
+
+const addRootDirectoryPathOperation = require("../operation/addRootDirectoryPath"),
+      validateRootDirectoryPathOperation = require("../operation/validateRootDirectoryPath"),
+      addRootDirectoryPathPromptOperation = require("../operation/prompt/addRootDirectoryPath");
+
+const { executeOperations } = require("../utilities/operation"),
+      { FAILED_ADD_ROOT_DIRECTORY_MESSAGE, SUCCESSFUL_ADD_ROOT_DIRECTORY_MESSAGE } = require("../messages");
+
+function addRootDirectoryPathAction(rootDirectoryPath) {
+  const operations = [
+          validateRootDirectoryPathOperation,
+          addRootDirectoryPathPromptOperation,
+          addRootDirectoryPathOperation
+        ],
+        context = {
+          rootDirectoryPath
+        };
+
+  executeOperations(operations, (completed) => {
+    if (!completed) {
+      console.log(FAILED_ADD_ROOT_DIRECTORY_MESSAGE);
+
+      return;
+    }
+
+    console.log(SUCCESSFUL_ADD_ROOT_DIRECTORY_MESSAGE);
+  }, context);
+}
+
+module.exports = addRootDirectoryPathAction;

package/bin/action/find.js

@@ -0,0 +1,46 @@
+"use strict";
+
+const ruleOperation = require("../operation/rule"),
+      findOperation = require("../operation/find"),
+      readConfigurationOperation = require("../operation/readConfiguration");
+
+const { executeOperations } = require("../utilities/operation"),
+      { FAILED_FIND_MESSAGE, SUCCESSFUL_FIND_MESSAGE } = require("../messages");
+
+function findAction(string, dryRun, quietly) {
+  const operations = [
+          ruleOperation,
+          readConfigurationOperation,
+          findOperation
+        ],
+        rule = null,
+        totalLines = 0,
+        totalFiles = 0,
+        totalDirectories = 0,
+        context = {
+          string,
+          dryRun,
+          quietly,
+          rule,
+          totalLines,
+          totalFiles,
+          totalDirectories
+        };
+
+  executeOperations(operations, (completed) => {
+    const { totalLines, totalFiles, totalDirectories } = context,
+          message = `A total of ${totalDirectories} directories, ${totalFiles} files and ${totalLines} lines searched.`;
+
+    console.log(message);
+
+    if (!completed) {
+      console.log(FAILED_FIND_MESSAGE);
+
+      return;
+    }
+
+    console.log(SUCCESSFUL_FIND_MESSAGE);
+  }, context);
+}
+
+module.exports = findAction;

package/bin/action/help.js

@@ -0,0 +1,40 @@
+"use strict";
+
+function helpAction() {
+  console.log(`Usage: 
+  
+  find [<options>] [<command>] [<argument>]
+
+Commands:
+
+  help                                     Show this help
+ 
+  version                                  Show the version
+
+  initialise                               Create a configuration file  
+
+  add-root-directory                       Add a root directory
+
+  remove-root-directory                    Remove a root directory
+
+  list-root-directories                    List the root directories
+
+Options:
+
+  --help|-h                                Show this help
+
+  --version|-v                             Show the version
+
+  --dry-run|-d                             Traverse the directories and files but do not search
+
+  --quietly|-q                             Execute shell commands without printing to the console
+
+Further information:
+
+Please see the readme file on GitHub:
+
+  https://github.com/djalbat/find-cli
+`);
+}
+
+module.exports = helpAction;

package/bin/action/initialise.js

@@ -0,0 +1,18 @@
+"use strict";
+
+const { createConfigurationFile, checkConfigurationFileExists } = require("../configuration"),
+      { FAILED_INITIALISE_MESSAGE, SUCCESSFUL_INITIALISE_MESSAGE } = require("../messages");
+
+function initialiseAction() {
+  const configurationFileExists = checkConfigurationFileExists();
+
+  if (configurationFileExists) {
+    console.log(FAILED_INITIALISE_MESSAGE);
+  } else {
+    createConfigurationFile();
+
+    console.log(SUCCESSFUL_INITIALISE_MESSAGE);
+  }
+}
+
+module.exports = initialiseAction;

package/bin/action/listRootDirectoryPaths.js

@@ -0,0 +1,18 @@
+"use strict";
+
+const listRootDirectoryPathsOperation = require("../operation/listRootDirectoryPaths");
+
+const { executeOperations } = require("../utilities/operation");
+
+function listRootDirectoryPathsAction() {
+  const operations = [
+          listRootDirectoryPathsOperation
+        ],
+        context = {};
+
+  executeOperations(operations, (completed) => {
+    ///
+  }, context);
+}
+
+module.exports = listRootDirectoryPathsAction;

package/bin/action/removeRootDirectoryPath.js

@@ -0,0 +1,33 @@
+"use strict";
+
+const removeRootDirectoryPathOperation = require("../operation/removeRootDirectoryPath"),
+      removeRootDirectoryPathPromptOperation = require("../operation/prompt/removeRootDirectoryPath"),
+      removeRootDirectoryPathByIndexOperation = require("../operation/removeRootDirectoryPathByIndex");
+
+const { executeOperations } = require("../utilities/operation"),
+      { FAILED_REMOVE_ROOT_DIRECTORY_MESSAGE, SUCCESSFUL_REMOVE_ROOT_DIRECTORY_MESSAGE } = require("../messages");
+
+function removeRootDirectoryPathAction(rootDirectoryPath) {
+  const operations = [
+          removeRootDirectoryPathOperation,
+          removeRootDirectoryPathPromptOperation,
+          removeRootDirectoryPathByIndexOperation
+        ],
+        index = null,
+        context = {
+          index,
+          rootDirectoryPath
+        };
+
+  executeOperations(operations, (completed) => {
+    if (!completed) {
+      console.log(FAILED_REMOVE_ROOT_DIRECTORY_MESSAGE);
+
+      return;
+    }
+
+    console.log(SUCCESSFUL_REMOVE_ROOT_DIRECTORY_MESSAGE);
+  }, context);
+}
+
+module.exports = removeRootDirectoryPathAction;

package/bin/action/version.js

@@ -0,0 +1,15 @@
+"use strict";
+
+const { packageUtilities } = require("necessary");
+
+const { FIND_CLI } = require("../constants");
+
+const { getVersion } = packageUtilities;
+
+function versionAction() {
+  const version = getVersion(); ///
+
+  console.log(`${FIND_CLI} version ${version}`);
+}
+
+module.exports = versionAction;

package/bin/commands.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const FIND_COMMAND = "find",
+      HELP_COMMAND = "help",
+      VERSION_COMMAND = "version",
+      INITIALISE_COMMAND = "initialise",
+      ADD_ROOT_DIRECTORY_PATH_COMMAND = "add-root-directory", ///
+      LIST_ROOT_DIRECTORY_PATHS_COMMAND = "list-root-directories",  ///
+      REMOVE_ROOT_DIRECTORY_PATH_COMMAND = "remove-root-directory";  ///
+
+module.exports = {
+  FIND_COMMAND,
+  HELP_COMMAND,
+  VERSION_COMMAND,
+  INITIALISE_COMMAND,
+  ADD_ROOT_DIRECTORY_PATH_COMMAND,
+  LIST_ROOT_DIRECTORY_PATHS_COMMAND,
+  REMOVE_ROOT_DIRECTORY_PATH_COMMAND
+};

package/bin/configuration/version_1_1.js

@@ -0,0 +1,26 @@
+"use strict";
+
+const { VERSION_1_1 } = require("../versions");
+
+function migrateConfigurationToVersion_1_1(configuration) {
+  const version = VERSION_1_1;
+
+  const ignoredFilePaths = [],
+        permittedFilePaths = [],
+        ignoredDirectoryPaths = [],
+        permittedDirectoryPaths = [];
+
+  configuration = Object.assign(configuration, {
+    version,
+    ignoredFilePaths,
+    permittedFilePaths,
+    ignoredDirectoryPaths,
+    permittedDirectoryPaths
+  });
+
+  return configuration;
+}
+
+module.exports = {
+  migrateConfigurationToVersion_1_1
+};

package/bin/configuration/version_1_2.js

@@ -0,0 +1,48 @@
+"use strict";
+
+const StringRule = require("../rule/string");
+
+const { VERSION_1_2 } = require("../versions");
+
+function migrateConfigurationToVersion_1_2(configuration) {
+  const version = VERSION_1_2;
+
+  const { ignoredFilePaths, permittedFilePaths, ignoredDirectoryPaths, permittedDirectoryPaths } = configuration,
+        ignoredFilePathMatchers = matchersFromPaths(ignoredFilePaths),
+        permittedFilePathMatchers = matchersFromPaths(permittedFilePaths),
+        ignoredDirectoryPathMatchers = matchersFromPaths(ignoredDirectoryPaths),
+        permittedDirectoryPathMatchers = matchersFromPaths(permittedDirectoryPaths);
+
+  configuration = {
+    version,
+    ignoredFilePathMatchers,
+    permittedFilePathMatchers,
+    ignoredDirectoryPathMatchers,
+    permittedDirectoryPathMatchers
+  };
+
+  return configuration;
+}
+
+module.exports = {
+  migrateConfigurationToVersion_1_2
+};
+
+function matchersFromPaths(paths) {
+  const matchers = paths.map((path) => {
+    let matcher;
+
+    const string = path,  ///
+          stringRule = StringRule.fromString(string);
+
+    matcher = stringRule;  ///
+
+    const json = matcher.toJSON();
+
+    matcher = json; ///
+
+    return matcher;
+  });
+
+  return matchers;
+}

package/bin/configuration/version_1_3.js

@@ -0,0 +1,22 @@
+"use strict";
+
+const { VERSION_1_3 } = require("../versions"),
+      { ROOT_DIRECTORY_PATH } = require("../constants");
+
+function migrateConfigurationToVersion_1_3(configuration) {
+  const version = VERSION_1_3,
+        rootDirectoryPaths = [
+          ROOT_DIRECTORY_PATH
+        ];
+
+  Object.assign(configuration, {
+    version,
+    rootDirectoryPaths
+  });
+
+  return configuration;
+}
+
+module.exports = {
+  migrateConfigurationToVersion_1_3
+};

package/bin/configuration/version_1_4.js

@@ -0,0 +1,58 @@
+"use strict";
+
+const { VERSION_1_4 } = require("../versions"),
+      { ROOT_DIRECTORY_PATH } = require("../constants");
+
+function migrateConfigurationToVersion_1_4(configuration) {
+  const { ignoredFilePathMatchers,
+          permittedFilePathMatchers,
+          ignoredDirectoryPathMatchers,
+          permittedDirectoryPathMatchers } = configuration;
+
+  delete configuration.ignoredFilePathMatchers;
+  delete configuration.permittedFilePathMatchers;
+  delete configuration.ignoredDirectoryPathMatchers;
+  delete configuration.permittedDirectoryPathMatchers;
+
+  const version = VERSION_1_4,
+        ignoredFilePathRules = ignoredFilePathMatchers, ///
+        permittedFilePathRules = permittedFilePathMatchers, ///
+        ignoredDirectoryPathRules = ignoredDirectoryPathMatchers, ///
+        permittedDirectoryPathRules = permittedDirectoryPathMatchers; ///
+
+  Object.assign(configuration, {
+    version,
+    ignoredFilePathRules,
+    permittedFilePathRules,
+    ignoredDirectoryPathRules,
+    permittedDirectoryPathRules
+  });
+
+  return configuration;
+}
+
+function createConfiguration() {
+  const version = VERSION_1_4,  ///
+        rootDirectoryPaths = [
+          ROOT_DIRECTORY_PATH
+        ],
+        ignoredFilePathRules = [],
+        permittedFilePathRules = [],
+        ignoredDirectoryPathRules = [],
+        permittedDirectoryPathRules = [],
+        configuration = {
+          version,
+          rootDirectoryPaths,
+          ignoredFilePathRules,
+          permittedFilePathRules,
+          ignoredDirectoryPathRules,
+          permittedDirectoryPathRules
+        };
+
+  return configuration;
+}
+
+module.exports = {
+  createConfiguration,
+  migrateConfigurationToVersion_1_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;
+}