jspatch

#!/usr/bin/env node

var Narcissus = require('narcissus/main');
var _ = require('underscore');
var child_process = require('child_process');
var fs = require('fs');
var path = require('path');

var jsgrep = require('./lib/jsgrep.js');

var config = {
  paths: [ ],
  recursive: false,
  patchFile: false,
};

function usage(hasError) {
  if (hasError) {
    console.log("See jspatch --help for usage information.");
    process.exit(hasError ? 1 : 0);
  }
  console.log("jspatch: JavaScript source code refactoring tool");
  console.log("");
  console.log("Usage: jspatch [OPTIONS] PATCHFILE FILES...");
  console.log("");
  console.log("Options:");
  console.log("  -f, --patch-script=FILE   Path to patch script.");
  console.log("  -r, --recursive           Scan directories for JavaScript files.");
  process.exit(0);
}

(function parseArgs() {
  var getopt = require('node-getopt');
  var parser = new getopt.BasicParser(
    'f:(match-script)r(recursive)_(help)',
    process.argv);

  while ((option = parser.getopt()) !== undefined) {
    switch(option.option) {
      case 'f':
        config.patchFile = option.optarg;
        break;
      case 'r':
        config.recursive = true;
        break;
      case '?':
      case '_':
        usage(option.error);
        break;
    }
  }

  config.paths = process.argv.slice(parser.optind());

  if (!config.patchFile) {
    if (config.paths.length > 0) {
      config.patchFile = config.paths.shift();
    } else {
      console.error("jspatch: Must specify a patch file.");
      usage(true);
    }
  }
})();

var patchSource = fs.readFileSync(config.patchFile).toString();
// Validate patch file before evaling
try {
  var patchAst =
    Narcissus.parser.parse(patchSource, config.patchFile, 1);
} catch(e) {
  console.error("jspatch: " + e.name + ": " + e.message);
  process.exit(1);
}
var matchFn = eval("(function custom_matcher(jsgrep) {" + patchSource + "})");

function generateDiff(oldFilename, newFile, callback) {
  var tempFilename, tries = 1;
  do {
    tempFilename = path.join(process.env.TEMP || "/tmp",
      "jspatch." + path.basename(oldFilename, ".js") +
      (tries == 1 ? "" : ("." + tries)) + ".js");
    tries++;
  } while (path.existsSync(tempFilename));

  var tempFile = fs.openSync(tempFilename, 'w');
  try {
    fs.writeSync(tempFile, newFile);
  } finally {
    fs.closeSync(tempFile);
  }

  var child =
    child_process.spawn('diff', [ '-u', oldFilename, tempFilename ]);

  child.stdout.on('data', function(data) {
    process.stdout.write(data);
  });
  child.stderr.on('data', function(data) {
    process.stderr.write(data);
  });

  child.on('exit', function(code) {
    fs.unlinkSync(tempFilename);
    if (code !== 0 && code !== 1) {
      // diff returns 0 for no differences, 1 for differences, 2 for error
      console.error('jspatch: diff exited with code ' + code);
      process.exit(1);
    }
    callback();
  });
}

function doFile(filename, callback) {
  var source = fs.readFileSync(filename).toString();
  // If the first character is a shebang, comment it out
  if (source.substr(0, 2) == '#!') {
    source = "//" + source;
  }

  try {
    var ast = Narcissus.parser.parse(source, filename, 1);
  } catch(e) {
    console.warn(e.name + ": " + e.message);
    return callback();
  }

  try {
    jsgrep.jsgrep({
      source: ast,
      matchScript: matchFn,
      callback: function(node, variables) {
      }
    });
  } catch(e) {
    if (!(e instanceof Error) && e.message) {
      console.error("jspatch: " + e.message);
      process.exit(1);
    }
    throw e;
  }

  var modifiedSource = ast.tokenizer.source;

  // Try to parse the modified source
  try {
    Narcissus.parser.parse(modifiedSource, 'modified source', 1);
  } catch(e) {
    console.log('jspatch: ' + filename +
      ': warning: modifications resulted in an invalid JavaScript file!');
    console.log('This is probably a bug in jspatch. ' +
      'Please let ry@fb.com know!');
  }

  if (source.substr(0, 4) == '//#!') {
    // Now remove the comment from the shebang
    source = source.substr(2);
    modifiedSource = modifiedSource.substr(2);
  }

  generateDiff(filename, modifiedSource, callback);
}

var paths = config.paths;

function queueDirectory(directory) {
  if (!config.recursive) {
    return;
  }
  var files = fs.readdirSync(directory);
  for (var i = 0; i < files.length; i++) {
    var filePath = path.join(directory, files[i]);
    var stat = fs.statSync(filePath);
    if (stat.isDirectory() ||
        filePath.substr(-3) == ".js") {
      paths.push(filePath);
    }
  }
}

function jspatch_loop() {
  if (paths.length == 0) {
    return;
  }

  var nextPath = paths.shift();
  var stat = fs.statSync(nextPath);
  if (stat.isDirectory()) {
    queueDirectory(nextPath);
    return jspatch_loop();
  } else {
    doFile(nextPath, jspatch_loop);
  }
}

jspatch_loop();

// vim: ft=javascript