find-cli 0.0.3 → 1.4.3

package/bin/constants.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const FIND = "find",
+      FILE = "file",
+      G_FLAG = "g",
+      FIND_CLI = "Find-CLI",
+      DIRECTORY = "directory",
+      EMPTY_STRING = "",
+      ROOT_DIRECTORY_PATH = "./";
+
+module.exports = {
+  FIND,
+  FILE,
+  G_FLAG,
+  FIND_CLI,
+  DIRECTORY,
+  EMPTY_STRING,
+  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,118 @@
+"use strict";
+
+const { arrayUtilities, fileSystemUtilities } = require("necessary");
+
+const { grey, blue } = require("./utilities/log"),
+      { EMPTY_STRING } = require("./constants");
+
+const { readFile } = fileSystemUtilities,
+      { backwardsForEach } = arrayUtilities;
+
+function find(filePath, context) {
+  const { rule } = context,
+        content = readFile(filePath),
+        lines = linesFromContent(content);
+
+  let { totalLines } = context;
+
+  lines.forEach((line, index) => {
+    const string = line,  ///
+          occurrences = rule.find(string),
+          length = occurrences.length;
+
+    if (length > 0) {
+      const gaps = [],
+            matches = [];
+
+      gapsAndMatchesFromLineAndOccurrences(line, occurrences, gaps, matches);
+
+      line = lineFromGapsAndMatches(gaps, matches); ///
+
+      console.log(filePath, index, line);
+    }
+
+    totalLines++;
+  });
+
+  Object.assign(context, {
+    totalLines
+  });
+}
+
+module.exports = find;
+
+function linesFromContent(content) {
+  const contents = content.split(/(\r\n|\r|\n)/),
+        lines = contents.map((content) => {
+          const line = content.replace(/(\r\n|\r|\n)$/, EMPTY_STRING);
+
+          return line;
+        });
+
+  return lines;
+}
+
+function lineFromGapsAndMatches(gaps, matches) {
+  let line = EMPTY_STRING;
+
+  gaps = [ ...gaps ]; ///
+
+  let gap = gaps.pop(); ///
+
+  gaps.forEach((gap, index) => {
+    let match = matches[index];
+
+    gap = grey(gap);  ///
+
+    match = blue(match);  ///
+
+    line = `${line}${gap}${match}`;
+  });
+
+  gap = grey(gap);  ///
+
+  line = `${line}${gap}`;
+
+  return line;
+}
+
+function gapsAndMatchesFromLineAndOccurrences(line, occurrences, gaps, matches) {
+  let end,
+      start;
+
+  backwardsForEach(occurrences, (occurrence) => {
+    end = occurrence.getEnd();
+
+    start = end;  ///
+
+    end = Infinity;
+
+    const gap = line.substring(start, end);
+
+    gaps.unshift(gap);
+
+    end = occurrence.getEnd();
+
+    start = 0;
+
+    line = line.substring(start, end);
+
+    start = occurrence.getStart();
+
+    end = Infinity;
+
+    const match = line.substring(start, end);
+
+    matches.unshift(match);
+
+    end = start;  ///
+
+    start = 0;
+
+    line = line.substring(start, end);  ///
+  });
+
+  const gap = line; ///
+
+  gaps.unshift(gap);
+}

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
+};