Node.JS wrapped GREP search command builder... ack on steroids, if you will!

cs

#!/usr/bin/env node
/* Any copyright is dedicated to the Public Domain.
 * http://creativecommons.org/publicdomain/zero/1.0/ */

"use strict";

var Fs = require("fs");
var Path = require("path");
var Spawn = require("child_process").spawn;

function escapeRegExp(str) {
  return str.replace(/([.*+?\^${}()|\[\]\/\\])/g, "\\$1");
};

// taken from http://xregexp.com/
function grepEscapeRegExp(str) {
  return str.replace(/[[\]{}()*+?.,\\^$|#\s"']/g, "\\$&");
}

function escapeShell(str) {
  return str.replace(/([\\"'`$\s\(\)<>])/g, "\\$1");
}

/**
 * Make sure that an array instance contains only unique values (NO duplicates).
 *
 * @type {Array}
 */
function makeUnique(arr) {
  var i, length, newArr = [];
  for (i = 0, length = arr.length; i < length; i++) {
    if (newArr.indexOf(arr[i]) == -1)
      newArr.push(arr[i]);
  }

  arr.length = 0;
  for (i = 0, length = newArr.length; i < length; i++)
    arr.push(newArr[i]);

  return arr;
}

/**
 * Removes trailing whitespace
 * version: 1107.2516
 * from: http://phpjs.org/functions/rtrim
 * original by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
 *     example 1: rtrim('    Kevin van Zonneveld    ');
 *     returns 1: '    Kevin van Zonneveld'
 */
function rtrim(str, charlist) {
  charlist = !charlist ? " \\s\u00A0" : (charlist + "").replace(/([\[\]\(\)\.\?\/\*\{\}\+\$\^\:])/g, "\\$1");
  var re = new RegExp("[" + charlist + "]+$", "g");
  return (str + "").replace(re, "");
}

var DEBUG = 0;//1;

var IGNORE_DIRS = {
  ".bzr"              : "Bazaar",
  ".cdv"              : "Codeville",
  "~.dep"             : "Interface Builder",
  "~.dot"             : "Interface Builder",
  "~.nib"             : "Interface Builder",
  "~.plst"            : "Interface Builder",
  ".git"              : "Git",
  ".hg"               : "Mercurial",
  ".pc"               : "quilt",
  ".svn"              : "Subversion",
  "_MTN"              : "Monotone",
  "blib"              : "Perl module building",
  "CVS"               : "CVS",
  "RCS"               : "RCS",
  "SCCS"              : "SCCS",
  "_darcs"            : "darcs",
  "_sgbak"            : "Vault/Fortress",
  "autom4te.cache"    : "autoconf",
  "cover_db"          : "Devel::Cover",
  "_build"            : "Module::Build"
};

var MAPPINGS = {
  "actionscript": ["as", "mxml"],
  "ada"         : ["ada", "adb", "ads"],
  "asm"         : ["asm", "s"],
  "batch"       : ["bat", "cmd"],
  //"binary"      : q{Binary files, as defined by Perl's -B op (default: off)},
  "cc"          : ["c", "h", "xs"],
  "cfmx"        : ["cfc", "cfm", "cfml"],
  "clojure"     : ["clj"],
  "cpp"         : ["cpp", "cc", "cxx", "m", "hpp", "hh", "h", "hxx"],
  "csharp"      : ["cs"],
  "css"         : ["css", "less", "scss", "sass"],
  "coffee"      : ["coffee"],
  "elisp"       : ["el"],
  "erlang"      : ["erl", "hrl"],
  "fortran"     : ["f", "f77", "f90", "f95", "f03", "for", "ftn", "fpp"],
  "haskell"     : ["hs", "lhs"],
  "hh"          : ["h"],
  "html"        : ["htm", "html", "shtml", "xhtml"],
  "jade"        : ["jade"],
  "java"        : ["java", "properties"],
  "groovy"      : ["groovy"],
  "js"          : ["js"],
  "json"        : ["json"],
  "latex"       : ["latex", "ltx"],
  "jsp"         : ["jsp", "jspx", "jhtm", "jhtml"],
  "lisp"        : ["lisp", "lsp"],
  "lua"         : ["lua"],
  "make"        : ["makefile", "Makefile"],
  "mason"       : ["mas", "mhtml", "mpl", "mtxt"],
  "markdown"    : ["md", "markdown"],
  "objc"        : ["m", "h"],
  "objcpp"      : ["mm", "h"],
  "ocaml"       : ["ml", "mli"],
  "parrot"      : ["pir", "pasm", "pmc", "ops", "pod", "pg", "tg"],
  "perl"        : ["pl", "pm", "pod", "t"],
  "php"         : ["php", "phpt", "php3", "php4", "php5", "phtml"],
  "plone"       : ["pt", "cpt", "metadata", "cpy", "py"],
  "powershell"  : ["ps1"],
  "python"      : ["py"],
  "rake"        : ["rakefile"],
  "ruby"        : ["rb", "ru", "rhtml", "rjs", "rxml", "erb", "rake", "gemspec"],
  "scala"       : ["scala"],
  "scheme"      : ["scm", "ss"],
  "shell"       : ["sh", "bash", "csh", "tcsh", "ksh", "zsh"],
  //"skipped"     : "q"{"Files but not directories normally skipped by ack ("default": "off")},
  "smalltalk"   : ["st"],
  "sql"         : ["sql", "ctl"],
  "tcl"         : ["tcl", "itcl", "itk"],
  "tex"         : ["tex", "cls", "sty"],
  "text"        : ["txt"],
  "textile"     : ["textile"],
  "tt"          : ["tt", "tt2", "ttml"],
  "vb"          : ["bas", "cls", "frm", "ctl", "vb", "resx"],
  "vim"         : ["vim"],
  "yaml"        : ["yaml", "yml"],
  "xml"         : ["xml", "dtd", "xslt", "ent", "rdf", "rss", "svg", "wsdl", "atom", "mathml", "mml"]
};

var exts = [];
for (var type in MAPPINGS) {
  exts = exts.concat(MAPPINGS[type]);
}
// grep pattern matching for extensions
var PATTERN_EXT = makeUnique(exts).join(",");
var dirs = [];
for (type in IGNORE_DIRS) {
  dirs.push(type);
}
dirs = makeUnique(dirs);
var PATTERN_DIR  = escapeRegExp(dirs.join("|"));
var PATTERN_EDIR = dirs.join(",");
var GREP_CMD = "grep";
var PERL_CMD = "perl";
var PREVIOUS_FILE;

var ARGS_MAP = {
  casesensitive: {
    short: "i",
    type: "boolean",
    def: false,
    desc: "whether to match strings sensitive to upper or lower case characters"
  },
  pattern: {
    short: "p",
    type: "string",
    desc: "a comma-separated list of file patterns to include in the search"
  },
  maxresults: {
    short: "m",
    type: "number",
    desc: "the maximum number of search results to return"
  },
  wholeword: {
    short: "w",
    type: "boolean",
    def: false,
    desc: "only match strings that are delimited by non-word characters"
  },
  query: {
    short: "q",
    type: "string",
    index: 0,
    req: true,
    desc: "string to search for. The needle. Put quotes around queries with multiple words or regular expressions"
  },
  path: {
    short: "p",
    type: "string",
    def: process.cwd(),
    index: 1,
    desc: "specific path to use as the root of the search operation. Defaults to the current working dir"
  },
  replaceAll: {
    short: "a",
    type: "boolean",
    def: false,
    desc: "during a replace action, replace all occurrences"
  },
  replace: {
    short: "r",
    type: "string",
    def: false,
    desc: "string to replace a match with"
  },
  regexp: {
    short: "x",
    type: "boolean",
    def: false,
    desc: "whether [query] should be interpreted as a regular expression"
  }
};

var ARGS_MAP_SHORT = {};
var ARGS_MAP_INDEXED = [];
var ARG_NAMES = Object.keys(ARGS_MAP);
ARG_NAMES.forEach(function(arg) {
  ARGS_MAP[arg].name = arg;
  var shortName = ARGS_MAP[arg].short;
  if (shortName)
    ARGS_MAP_SHORT[shortName] = arg;

  var index = ARGS_MAP[arg].index;
  if (typeof index == "number") {
    ARGS_MAP_INDEXED.splice(index >= 0 || index < ARGS_MAP_INDEXED.length - 1 ?
                            index : Infinity, 0, ARGS_MAP[arg]);
  }
});

function usageDef(arg, indexed) {
  return (arg.short && !indexed ? "-" + arg.short + "/ " : "")
       + (!indexed ? "--" : "") + arg.name
       + "\t\t" + (arg.desc ? arg.desc : "")
       + (arg.req ? " [required]" : (typeof arg.def != "undefined" ?
         " [default=" + String(arg.def) + "]" : " [optional]") + ".");
}

function usage() {
  var names = [].concat(ARG_NAMES).sort();
  var indexed = ARGS_MAP_INDEXED.map(function(arg) {
    names.splice(names.indexOf(arg.name), 1);
    return arg.name;
  });
  
  var cmd = "cs ";
  var cmdArgs = [];
  var defs = [];
  names.forEach(function(argName) {
    var arg = ARGS_MAP[argName];
    defs.push(usageDef(arg));
    cmdArgs.push("[" + (arg.short ? "-" + arg.short + "|" : "") + "--" + argName
               + (arg.type == "boolean" ? "" : " " + arg.type) + "]");
  });
  indexed.forEach(function(argName) {
    var arg = ARGS_MAP[argName];
    var req = !!arg.req;
    defs.unshift(usageDef(arg, true));
    cmdArgs.push((req ? "" : "[") + argName + (req ? "" : "]"));
  });

  console.log("Usage: " + cmd + cmdArgs.join(" "));
  console.log("\n\n" + defs.join("\n"));
  process.exit(1);
}

function parseArgs() {
  var options = {};
  // Remove 'node' and script path from the argv list.
  process.argv.splice(0, 2);
  var argCount = process.argv.length;
  if (!argCount)
    return usage();

  var noNameIdx = -1;
  var currName, currArg;
  for (; argCount >= 0; --argCount) {
    currName = (process.argv[argCount - 1] || "").replace(/^[-]*/g, "");
    currArg = ARGS_MAP[currName] || ARGS_MAP[ARGS_MAP_SHORT[currArg]];
    if (!currArg) {
      // Un-named, indexed arguments.
      currArg = ARGS_MAP_INDEXED[noNameIdx++];
      if (!currArg)
        continue;
      options[currArg.name] = process.argv[argCount];
    } else {
      var bool = (currArg.type == "boolean");
      options[currArg.name] = bool ? true : process.argv[argCount];
      if (!bool)
        --argCount;
    }
  }

  ARG_NAMES.forEach(function(arg) {
    if (typeof options[arg] != "undefined")
      return;
    if (DEBUG)
      console.log("DEBUG:: unused arg: ", arg, ARGS_MAP[arg].def)
    if (typeof ARGS_MAP[arg].def != "undefined")
      options[arg] = ARGS_MAP[arg].def;
    else if (ARGS_MAP[arg].type == "boolean")
      options[arg] = false;
    else
      options[arg] = null;
  });

  return options;
}

var count = 0;
var filecount = 0;

function parseSearchResult(res, basePath, options) {
  var parts, file, lineno;
  var result = "";
  var aLines = (typeof res == "string" ? res : "").split(/([\n\r]+)/g);
  var i = 0;
  var l = aLines.length;

  for (; i < l; ++i) {
    parts = aLines[i].split(":");

    if (parts.length < 3)
      continue;

    file = encodeURI(rtrim(parts.shift().replace(basePath, "")), "/");

    lineno = parseInt(parts.shift(), 10);
    if (!lineno)
      continue;

    ++count;
    if (file !== PREVIOUS_FILE) {
      filecount++;
      if (PREVIOUS_FILE)
        result += "\n\n";
      result += file + ":";
      PREVIOUS_FILE = file;
    }

    parts = parts.map(function(part) {
      return part.replace(basePath, "");
    });
    result += "\n\t" + lineno + ": " + parts.join(":");
  }

  process.stdout.write(result);
}

function buildGrepCommand(options) {
  var cmd = GREP_CMD + " -s -r --color=never --binary-files=without-match -n "
          + (!options.casesensitive ? "-i " : "");

  var include = "";

  if (options.pattern) { // handles grep peculiarities with --include
    if (options.pattern.split(",").length > 1)
      include = "{" + options.pattern + "}";
    else
      include = options.pattern;
  } else {
    include = "\\*{" + PATTERN_EXT + "}";
  }

  if (options.maxresults)
    cmd += "-m " + parseInt(options.maxresults, 10);

  if (options.wholeword)
    cmd += " -w";

  var query = options.query;
  // grep has a funny way of handling new lines (that is to say, it's non-existent)
  // if we're not doing a regex search, then we must split everything between the
  // new lines, escape the content, and then smush it back together; due to
  // new lines, this is also why we're now passing -P as default to grep
  if (!options.replaceAll && !options.regexp) {
    var splitQuery = query.split("\\n");

    for (var q in splitQuery)
      splitQuery[q] = grepEscapeRegExp(splitQuery[q]);
    query = splitQuery.join("\\n");
  }

  // ticks must be double escaped for BSD grep
  query = query.replace(new RegExp("\\\'", "g"), "'\\''");

  cmd += " --exclude=*{" + PATTERN_EDIR + "}*"
      +  " --include=" + include
      + " '" + query.replace(/-/g, "\\-") + "'"
      + " \"" + escapeShell(options.path) + "\"";

  if (options.replaceAll) {
    if (options.replacement === undefined)
      options.replacement = "";

    if (!options.regexp)
      query = escapeRegExp(query);

    // pipe the grep results into perl
    cmd += " -l | xargs " + PERL_CMD
           // print the grep result to STDOUT (to arrange in parseSearchResult())
         + " -pi -e 'print STDOUT \"$ARGV:$.:$_\""
           // do the actual replace
         + " if s/" + query + "/" + options.replacement + "/mg"
         + (!options.casesensitive ? "i" : "" ) + ";'"
  }

  return cmd;
}

function main() {
  var options = parseArgs();
  if (DEBUG)
    console.log("DEBUG:: options: ", options);
  var cmd = buildGrepCommand(options);

  if (DEBUG)
    console.log("DEBUG:: search command: " + cmd);

  var child;
  try {
    child = Spawn("/bin/bash", ["-c", cmd]);
  } catch (e) {
    console.error("Could not spawn grep process");
    process.exit(1);
  }

  child.stdout.setEncoding("utf8");
  child.stderr.setEncoding("utf8");

  var buf = "";

  function onData(data) {
    if (!data)
      return;

    buf += data;
    if (data.indexOf("\n") >= 0) {
      if (DEBUG)
        console.log("DEBUG:: " + data);

      parseSearchResult(data, options.path, options);
      buf = "";
    }
  }
  child.stdout.on("data", onData);
  child.stderr.on("data", onData);
  child.on("exit", function(code, signal) {
    process.stdout.write("\nResults: {\"count\": " + count + ", \"filecount\":"
                         + filecount + "}\n");
  });
}

main();

usage

Usage: cs [-i|--casesensitive] [-m|--maxresults number] [-p|--pattern string] [-x|--regexp] [-r|--replace string] [-a|--replaceAll] [-w|--wholeword] query [path]


path		specific path to use as the root of the search operation. Defaults to the current working dir [default=/Users/mikedeboer/Projects/jsDAV].
query		string to search for. The needle. Put quotes around queries with multiple words or regular expressions [required]
-i/ --casesensitive		whether to match strings sensitive to upper or lower case characters [default=false].
-m/ --maxresults		the maximum number of search results to return [optional].
-p/ --pattern		a comma-separated list of file patterns to include in the search [optional].
-x/ --regexp		whether [query] should be interpreted as a regular expression [default=false].
-r/ --replace		string to replace a match with [default=false].
-a/ --replaceAll		during a replace action, replace all occurrences [default=false].
-w/ --wholeword		only match strings that are delimited by non-word characters [default=false].