find-cli 1.4.3 → 1.4.5

package/bin/action/find.js

@@ -4,7 +4,8 @@ const ruleOperation = require("../operation/rule"),
       findOperation = require("../operation/find"),
       readConfigurationOperation = require("../operation/readConfiguration");
 
-const { executeOperations } = require("../utilities/operation"),
+const { S, EMPTY_STRING } = require("../constants"),
+      { executeOperations } = require("../utilities/operation"),
       { FAILED_FIND_MESSAGE, SUCCESSFUL_FIND_MESSAGE } = require("../messages");
 
 function findAction(string, dryRun, quietly) {
@@ -14,24 +15,25 @@ function findAction(string, dryRun, quietly) {
           findOperation
         ],
         rule = null,
-        totalLines = 0,
-        totalFiles = 0,
-        totalDirectories = 0,
+        lines = [],
+        linesTotal = 0,
+        filesTotal = 0,
+        directoriesTotal = 0,
+        occurrencesTotal = 0,
         context = {
           string,
           dryRun,
           quietly,
           rule,
-          totalLines,
-          totalFiles,
-          totalDirectories
+          lines,
+          linesTotal,
+          filesTotal,
+          directoriesTotal,
+          occurrencesTotal
         };
 
   executeOperations(operations, (completed) => {
-    const { totalLines, totalFiles, totalDirectories } = context,
-          message = `A total of ${totalDirectories} directories, ${totalFiles} files and ${totalLines} lines searched.`;
-
-    console.log(message);
+    logTottals(context);
 
     if (!completed) {
       console.log(FAILED_FIND_MESSAGE);
@@ -39,8 +41,44 @@ function findAction(string, dryRun, quietly) {
       return;
     }
 
+    logLines(context);
+
     console.log(SUCCESSFUL_FIND_MESSAGE);
   }, context);
 }
 
 module.exports = findAction;
+
+function logLines(context) {
+  const { lines } = context;
+
+  let maximumIndexLength = 0,
+      maximumContentLength = 0;
+
+  lines.forEach((line) => {
+    const indexLength = line.getIndexLength(),
+          filePathLength = line.getFilePathLength();
+
+    maximumIndexLength = Math.max(indexLength, maximumIndexLength);
+    maximumContentLength = Math.max(filePathLength, maximumContentLength);
+  });
+
+  const requiredIndexLength = maximumIndexLength, ///
+        requiredContentLength = maximumContentLength; ///
+
+  lines.forEach((line) => {
+    const message = line.asMessage(requiredIndexLength, requiredContentLength);
+
+    console.log(message);
+  });
+}
+
+function logTottals(context) {
+  const { linesTotal, filesTotal, directoriesTotal, occurrencesTotal } = context,
+        optionalS = (occurrencesTotal === 1) ?
+                      EMPTY_STRING :
+                        S,
+        message = `Found ${occurrencesTotal} occurrence${optionalS} across ${directoriesTotal} directories, ${filesTotal} files and ${linesTotal} lines.`;
+
+  console.log(message);
+}

package/bin/constants.js

@@ -1,19 +1,25 @@
 "use strict";
 
-const FIND = "find",
+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/find.js

@@ -1,118 +1,55 @@
 "use strict";
 
-const { arrayUtilities, fileSystemUtilities } = require("necessary");
+const { fileSystemUtilities } = require("necessary");
 
-const { grey, blue } = require("./utilities/log"),
-      { EMPTY_STRING } = require("./constants");
+const Line = require("./line");
 
-const { readFile } = fileSystemUtilities,
-      { backwardsForEach } = arrayUtilities;
+const { readFile } = fileSystemUtilities;
 
 function find(filePath, context) {
   const { rule } = context,
         content = readFile(filePath),
-        lines = linesFromContent(content);
+        lines = linesFromContentAndFilePath(content, filePath);
 
-  let { totalLines } = context;
+  let { linesTotal } = context;
 
-  lines.forEach((line, index) => {
-    const string = line,  ///
-          occurrences = rule.find(string),
-          length = occurrences.length;
+  lines.forEach((line) => {
+    const occurrences = rule.find(line, filePath),
+          occurrencesLength = occurrences.length;
 
-    if (length > 0) {
-      const gaps = [],
-            matches = [];
+    if (occurrencesLength > 0) {
+      let { occurrencesTotal } = context;
 
-      gapsAndMatchesFromLineAndOccurrences(line, occurrences, gaps, matches);
+      occurrencesTotal += occurrencesLength;
 
-      line = lineFromGapsAndMatches(gaps, matches); ///
+      Object.assign(context, {
+        occurrencesTotal
+      });
 
-      console.log(filePath, index, line);
+      const { lines } = context;
+
+      lines.push(line);
+
+      line.setOccurrences(occurrences);
     }
 
-    totalLines++;
+    linesTotal++;
   });
 
   Object.assign(context, {
-    totalLines
+    linesTotal
   });
 }
 
 module.exports = find;
 
-function linesFromContent(content) {
+function linesFromContentAndFilePath(content, filePath) {
   const contents = content.split(/(\r\n|\r|\n)/),
-        lines = contents.map((content) => {
-          const line = content.replace(/(\r\n|\r|\n)$/, EMPTY_STRING);
+        lines = contents.map((content, index) => {
+          const line = Line.fromIndexContentAndFilePath(index, content, filePath);
 
           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/line.js

@@ -0,0 +1,181 @@
+"use strict";
+
+const { arrayUtilities } = require("necessary");
+
+const { grey, blue, yellow } = require("./utilities/log"),
+      { EMPTY_STRING, SINGLE_SPACE } = require("./constants");
+
+const { backwardsForEach } = arrayUtilities;
+
+class Line {
+  constructor(index, content, filePath, occurrences) {
+    this.index = index;
+    this.content = content;
+    this.filePath = filePath;
+    this.occurences = occurrences;
+  }
+
+  getIndex() {
+    return this.index;
+  }
+
+  getContent() {
+    return this.content;
+  }
+
+  getFilePath() {
+    return this.filePath;
+  }
+
+  getOccurrences() {
+    return this.occurences;
+  }
+
+  setIndex(index) {
+    this.index = index;
+  }
+
+  setContent(content) {
+    this.content = content;
+  }
+
+  setFilePath(filePath) {
+    this.filePath = filePath;
+  }
+
+  setOccurrences(occurrences) {
+    this.occurrences = occurrences;
+  }
+
+  getIndexLength() {
+    const indexLength = this.index.length;
+
+    return indexLength;
+  }
+
+  getFilePathLength() {
+    const filePathLength = this.filePath.length;
+
+    return filePathLength;
+  }
+
+  addOccurrences(occurrences) {
+
+  }
+
+  getFormattedIndex(requiredIndexLength) {
+    let index;
+
+    const indexLength = this.getIndexLength(),
+          paddingLength = requiredIndexLength - indexLength,
+          padding = paddingFromPaddingLength(paddingLength);
+
+    index = `${padding}${this.index}`;
+
+    const formattedIndex = yellow(index);
+
+    return formattedIndex;
+  }
+
+  getFormattedContent() {
+    const gaps = [],
+          matches = [];
+
+    let end,
+        start,
+        string = this.content;  ///
+
+    backwardsForEach(this.occurrences, (occurrence) => {
+      end = occurrence.getEnd();
+
+      start = end;  ///
+
+      end = Infinity;
+
+      const gap = string.substring(start, end);
+
+      gaps.unshift(gap);
+
+      end = occurrence.getEnd();
+
+      start = 0;
+
+      string = string.substring(start, end);
+
+      start = occurrence.getStart();
+
+      end = Infinity;
+
+      const match = string.substring(start, end);
+
+      matches.unshift(match);
+
+      end = start;  ///
+
+      start = 0;
+
+      string = string.substring(start, end);  ///
+    });
+
+    let gap = string; ///
+
+    gap = grey(gap);  ///
+
+    string = gap; ///
+
+    gaps.forEach((gap, index) => {
+      let match = matches[index];
+
+      gap = grey(gap);  ///
+
+      match = blue(match);  ///
+
+      string = `${string}${match}${gap}`;
+    });
+
+    const formattedContent = string;  ///
+
+    return formattedContent;
+  }
+
+  getFormattedFilePath(requiredFilePathLength) {
+    const filePathLength = this.getFilePathLength(),
+          paddingLength = requiredFilePathLength - filePathLength,
+          padding = paddingFromPaddingLength(paddingLength),
+          formattedFilePath =  `${this.filePath}${padding}`;
+
+    return formattedFilePath;
+  }
+
+  asMessage(requiredIndexLength, requiredFilePathLength) {
+    const formattedIndex = this.getFormattedIndex(requiredIndexLength),
+          formattedContent = this.getFormattedContent(),
+          formattedFilePath = this.getFormattedFilePath(requiredFilePathLength),
+          message = `| ${formattedFilePath}  ${formattedIndex} | ${formattedContent}`;
+
+    return message;
+  }
+
+  static fromIndexContentAndFilePath(index, content, filePath) {
+    index = `${index}`; ///
+
+    content = content.replace(/(\r\n|\r|\n)$/, EMPTY_STRING); ///
+
+    const occurrences = [],
+          line = new Line(index, content, filePath, occurrences);
+
+    return line;
+  }
+}
+
+module.exports = Line;
+
+function paddingFromPaddingLength(paddingLength) {
+  let padding = EMPTY_STRING;
+
+  for (let count = 0; count < paddingLength; count++) {
+    padding += SINGLE_SPACE;
+  }
+
+  return padding;
+}

package/bin/main.js

@@ -63,7 +63,7 @@ function main(command, argument, options) {
     }
 
     case FIND_COMMAND: {
-      if (argument === null) {
+      if ((argument === null) && !dryRun) {
         console.log(NO_ARGUMENT_GIVEN_MESSAGE);
       } else {
         const string = argument;  ///

package/bin/occurrence.js

@@ -1,5 +1,7 @@
 "use strict";
 
+const { ZERO } = require("./constants");
+
 class Occurrence {
   constructor(start, end) {
     this.start = start;
@@ -14,20 +16,20 @@ class Occurrence {
     return this.end;
   }
 
-  static fromResult(result) {
+  static fromResultAndOffset(result, offset) {
     const { index } = result,
-          match = result[0],  ///
+          match = result[ZERO],
           length = match.length,
-          start = index,  ///
+          start = index + offset,
           end = start + length,
           occurrence = new Occurrence(start, end);
 
     return occurrence;
   }
 
-  static fromIndexAndString(index, string) {
+  static fromIndexStringAndOffset(index, string, offset) {
     const length = string.length,
-          start = index,  ///
+          start = index + offset,
           end = start + length,
           occurrence = new Occurrence(start, end);
 

package/bin/operation/find.js

@@ -112,12 +112,12 @@ function findInFile(filePath, callback, context) {
     }
 
     if (!filePathIgnored) {
-      let { totalFiles } = context;
+      let { filesTotal } = context;
 
-      totalFiles++;
+      filesTotal++;
 
       Object.assign(context, {
-        totalFiles
+        filesTotal
       });
 
       const { dryRun } = context;
@@ -170,12 +170,12 @@ function findInDirectory(directoryPath, callback, context) {
     }
 
     if (!directoryPathIgnored) {
-      let { totalDirectories } = context;
+      let { directoriesTotal } = context;
 
-      totalDirectories++;
+      directoriesTotal++;
 
       Object.assign(context, {
-        totalDirectories
+        directoriesTotal
       });
 
       const entryNames = readDirectory(directoryPath),

package/bin/operation/rule.js

@@ -3,6 +3,14 @@
 const { ruleFromStringAnchoredAndDirectory } = require("../utilities/rule");
 
 function ruleOperation(proceed, abort, context) {
+  const { dryRun } = context;
+
+  if (dryRun) {
+    proceed();
+
+    return;
+  }
+
   const { string } = context,
         directory = false,
         anchored = false,

package/bin/rule/glob.js

@@ -40,18 +40,23 @@ class GlobRule {
     return json;
   }
 
-  find(string) {
-    const occurrences = [];
+  find(line) {
+    const occurrences = [],
+          content = line.getContent();
 
-    let result = string.match(this.regExp);
+    let offset = 0,
+        string = content, ///
+        result = string.match(this.regExp);
 
     while (result !== null) {
-      const occurrence = Occurrence.fromResult(result),
+      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);

package/bin/rule/regex.js

@@ -36,18 +36,23 @@ class RegexRule {
     return json;
   }
 
-  find(string) {
-    const occurrences = [];
+  find(line) {
+    const occurrences = [],
+          content = line.getContent();
 
-    let result = string.match(this.regExp);
+    let offset = 0,
+        string = content, ///
+        result = string.match(this.regExp);
 
     while (result !== null) {
-      const occurrence = Occurrence.fromResult(result),
+      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);

package/bin/rule/string.js

@@ -26,18 +26,23 @@ class StringRule {
     return json;
   }
 
-  find(string) {
-    const occurrences = [];
+  find(line) {
+    const occurrences = [],
+          content = line.getContent();
 
-    let index = string.indexOf(this.string);
+    let offset = 0,
+        string = content, ///
+        index = string.indexOf(this.string);
 
     while (index !== -1) {
-      const occurrence = Occurrence.fromIndexAndString(index, string),
+      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);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "find-cli",
   "author": "James Smith",
-  "version": "1.4.3",
+  "version": "1.4.5",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/find-cli",
   "description": "An alternative to grep.",