#!/usr/bin/env node
// Copyright 2011 Itay Neeman
//
// Licensed under the MIT License
// TODO:
(function() {
var fs = require('fs');
var path = require('path');
var vm = require("vm");
var crypto = require('crypto');
var Module = require('module').Module;
var _ = require('underscore');
var _s = require('underscore.string');
var which = require('which').sync;
var commander = require('../contrib/commander');
var Table = require('../contrib/cli-table');
var pkg = require('../package.json');
var exists = fs.existsSync || path.existsSync;
var patch_console = require('../utils/console');
var cover = require("../index.js");
// Store the initial CWD, to harden us against process.chdir
var CWD = path.resolve(process.cwd());
// Get a list of the built-in reporters
var reporterOptions = "[" + _.keys(cover.reporters).join(",") + "]";
/* ====== Utilities ====== */
// Delete a directory recursively
var rmdirRecursiveSync = function(dirPath) {
var files = fs.readdirSync(dirPath);
for(var i = 0; i < files.length; i++) {
var filePath = path.join(dirPath, files[i]);
var file = fs.statSync(filePath);
if (file.isDirectory()) {
rmdirRecursiveSync(filePath);
}
else {
fs.unlinkSync(filePath);
}
}
fs.rmdirSync(dirPath);
};
/* ====== Config/Ignore File Handling ====== */
// Default config
var defaultConfigPath = path.join(path.resolve(__dirname), ".coverrc");
var defaultConfig = {};
var removeJSONComments = function(str) {
str = str || '';
str = str.replace(/\/\*[\s\S]*(?:\*\/)/g, ''); //everything between "/* */"
str = str.replace(/\/\/[^\n\r]*/g, ''); //everything after "//"
return str;
};
var readIgnoreFile = function(ignorePath, ignoreModules) {
var ignore = {};
// Get the full path relative to the CWD
var fullIgnorePath = path.resolve(CWD, ignorePath);
if (exists(fullIgnorePath)) {
// If we found an ignore file, read it in
var ignoreContents = fs.readFileSync(fullIgnorePath, "utf-8");
try {
// Note that directory fo the ignore path
var dir = path.dirname(fullIgnorePath);
var ignores = ignoreContents.split("\n");
// For each line (ignoring blank ones), get the full path,
// and add it to our ignore list.
for(var i = 0; i < ignores.length; i++) {
if (ignores[i].trim() === "") {
continue;
}
var filePath = path.resolve(dir, ignores[i].trim());
ignore[path.resolve(dir, filePath)] = true;
}
}
catch (ex) {
throw new Error("There was a problem parsing your .coverignore file at: " + ignorePath);
}
}
return ignore;
};
var readConfigFile = function(configFile) {
var config = {}
// Get the full path relative to the CWD
configFile = path.resolve(CWD, configFile);
if (!exists(configFile)) {
configFile = defaultConfigPath;
}
// Remove any comments from the JSON
var configContents = removeJSONComments(fs.readFileSync(path.resolve(configFile), "utf-8"));
try {
// If there is no content, we'll just add an empty object
if (configContents.trim() === "") {
configContents = "{}";
}
// Parse it and copy in the defaults
var rawConfig = JSON.parse(configContents);
for(var key in defaultConfig) {
config[key] = defaultConfig[key];
}
// Override the defaults with specific ones.
for(var key in rawConfig) {
config[key] = rawConfig[key];
}
}
catch (ex) {
throw new Error("There was a problem parsing your .coverrc file at: " + configFile);
}
return config;
};
var getOptionsAndIgnore = function(cmdline, options) {
options = options || {};
// Get configuration
var config = {};
if (cmdline.config || ".coverrc") {
if (_.isObject(cmdline.config)) {
config = cmdline.config;
}
else {
config = readConfigFile(cmdline.config || ".coverrc");
}
}
// Get ignore
var ignore = {};
if (cmdline.ignore || config.ignore || ".coverignore") {
if (_.isObject(cmdline.ignore)) {
ignore = cmdline.ignore;
}
else {
ignore = readIgnoreFile(cmdline.ignore || config.ignore || ".coverignore");
}
}
// If we didn't override it on the command line and the
// coverrc file says to ingore node_modules, then ignore
// it
if (options.modules !== true && config.modules === false) {
ignore[path.resolve(CWD, "node_modules")] = true;
}
return {
config: config,
ignore: ignore
}
};
defaultConfig = readConfigFile(defaultConfigPath);
/* ====== Context and Execution Handling ====== */
// Run a file with coverage enabled
var runFile = function(file, options, ignore, debug) {
if (!exists(file)) {
try {
file = which(file);
}
catch(ex) {
console.log("Could not find file: '" + file + "' -- exiting...");
return null;
}
}
else {
file = path.resolve(file);
}
var coverage = cover.cover(null, ignore, debug);
process.nextTick(function() {
try {
// Load up the new argv
options = options || [];
process.argv = ["node", file].concat(options)
// Load the file as the main module
Module.runMain(file, null, true)
}
catch(ex) {
console.log(ex.stack);
}
});
return coverage;
};
/* ====== Save/Load Coverage Data ====== */
var saveCoverageData = function(coverageData, configs, noPrecombine) {
if (!noPrecombine) {
savePrecombinedCoverageData(coverageData, configs);
}
// Setup the information we're going to save
var files = {};
var toSave = {
version: pkg.version,
files: files
};
_.each(coverageData, function(fileData, fileName, lst) {
// For each file, we hash the source to get a "version ID"
// for it
var stats = fileData.stats();
var fileSource = stats.source;
var md5 = crypto.createHash('md5');
md5.update(fileSource);
var hash = md5.digest('hex');
// We also save the stats and the hash,
// which is everything we need in order
// to be able to generate reports
files[fileName] = {
stats: stats,
hash: hash
}
});
// Turn it into JSON and write it out
var data = JSON.stringify(toSave);
// Get the ID for this data (md5 hash)
var dataMd5 = crypto.createHash('md5');
dataMd5.update(data);
var dataHash = dataMd5.digest('hex');
// Make the directory
var dataDirectory = path.join(CWD, configs.dataDirectory);
if (!exists(dataDirectory)) {
fs.mkdirSync(dataDirectory, "0755");
}
// Write out the file
var dataFilename = path.join(dataDirectory, configs.prefix + dataHash);
fs.writeFileSync(dataFilename, data);
};
var savePrecombinedCoverageData = function(coverageData, configs) {
// Setup the information we're going to save
var files = {};
var toSave = {
version: "0.2.0",
files: files
};
var coverageStore = require('../coverage_store');
_.each(coverageData, function(fileData, fileName, lst) {
var store = coverageStore.getStore(fileName);
// For each file, we hash the source to get a "version ID"
// for it
var fileSource = fileData.source;
var md5 = crypto.createHash('md5');
md5.update(fileSource);
var hash = md5.digest('hex');
// We also save the stats and the hash,
// which is everything we need in order
// to be able to generate reports
files[fileName] = {
nodes: store.nodes,
blocks: store.blocks,
hash: hash,
instrumentor: fileData.instrumentor.objectify()
}
});
// Turn it into JSON and write it out
var data = JSON.stringify(toSave);
// Get the ID for this data (md5 hash)
var dataMd5 = crypto.createHash('md5');
dataMd5.update(data);
var dataHash = dataMd5.digest('hex');
// Make the directory
var dataDirectory = path.join(CWD, configs.dataDirectory);
if (!exists(dataDirectory)) {
fs.mkdirSync(dataDirectory, "0755");
}
// Write out the file
var dataFilename = path.join(dataDirectory, "precombined_" + configs.prefix + dataHash);
fs.writeFileSync(dataFilename, data);
};
var loadCoverageData = function(filename, configs) {
var dataDirectory = configs.dataDirectory;
var dataPrefix = configs.prefix;
if (!filename) {
// If we weren't given a file, try and read it from the data directory.
var filesInDataDirectory = fs.readdirSync(dataDirectory);
var matchingFiles = _.filter(filesInDataDirectory, function(file) { return _s.startsWith(file, dataPrefix); });
if (matchingFiles.length > 1) {
// If there is more than one file, we'll use the last modified one.
var latestTime = 0;
for(var i = 0; i < matchingFiles.length; i++) {
var fileLatest = fs.statSync(path.join(dataDirectory, matchingFiles[i])).mtime;
if (fileLatest > latestTime) {
latestTime = fileLatest;
filename = matchingFiles[i];
}
}
}
else if (matchingFiles.length === 1) {
// If there was exactly one file, we'll use that one
filename = matchingFiles[0];
}
else if (matchingFiles.length === 0) {
// If there was no file, error.
console.error("Could not find a coverage data file. Please specify one.");
process.exit(1);
}
// Note the full path to the file
filename = path.join(dataDirectory, filename);
}
// If it doesn't exist, then error out
if (!exists(filename)) {
console.error("Coverage data file does not exist: " + filename);
process.exit(1);
}
// Read the file
var data = fs.readFileSync(filename, "utf-8");
var coverageData = JSON.parse(data);
var overall = {
filename: 'Overall',
missing : 0,
seen : 0,
total : 0,
blocks : {
total : 0,
seen : 0,
missing : 0
}
};
// Remake the objects into what the reporters expect
_.each(coverageData.files, function(fileData, fileName) {
var stats = fileData.stats;
fileData.filename = fileName;
fileData.stats = function() { return stats; };
fileData.source = stats.source;
_.each(['missing', 'seen', 'total'], function(field) {
overall[field] += stats[field];
overall.blocks[field] += stats.blocks[field];
});
});
overall.percentage = overall.seen / overall.total;
overall.blocks.percentage = overall.blocks.seen / overall.blocks.total;
coverageData.overall = {stats: function() { return overall; }};
return coverageData;
};
var loadPrecombinedCoverageData = function(configs) {
var dataDirectory = configs.dataDirectory;
var dataPrefix = configs.prefix;
var filesInDataDirectory = fs.readdirSync(dataDirectory);
var files = _.filter(filesInDataDirectory, function(file) {
return _s.startsWith(file, "precombined_" + dataPrefix);
}).map(function(file) {
return path.join(dataDirectory, file);
});
var datas = [];
_.each(files, function(filename) {
// If it doesn't exist, then error out
if (!exists(filename)) {
console.error("Coverage data file does not exist: " + filename);
process.exit(1);
}
// Read the file
var data = fs.readFileSync(filename, "utf-8");
datas.push(JSON.parse(data));
fs.unlinkSync(filename);
});
var coverageData = cover.load(datas);
return coverageData;
};
/* ====== Reporters ====== */
var reporterHandlers = {
html: function(coverageData, config) {
fileData = coverageData.files;
var files = _.sortBy(_.keys(fileData), function(file) { return file; });
var allStats = [];
var statsByFile = {};
var htmlDirectory = path.join(CWD, config.html.directory);
var templateDir = path.resolve(__dirname, "..", "templates");
var resourceDir = path.resolve(__dirname, "..", "resources");
function statsRow(name, stats) {
return [
name,
Math.floor(stats.percentage * 100) + "%",
stats.missing,
stats.total,
Math.floor(stats.blocks.percentage * 100) + "%",
stats.blocks.missing,
stats.blocks.total
];
}
var htmls = {};
for(var i = 0; i < files.length; i++) {
var filename = files[i];
htmls[filename] = cover.reporters.html.format(fileData[filename]);
}
// For each file, we compile a list of its summmary stats
for(var i = 0; i < files.length; i++) {
var filename = files[i];
var stats = fileData[filename].stats();
statsByFile[filename] = {
percentage: Math.floor(stats.percentage * 100) + "%",
missingLines: stats.missing,
seenLines: stats.seen,
partialLines: _.values(stats.coverage).filter(function(lineinfo) { return lineinfo.partial; }).length,
totalLines: stats.total,
blockPercentage: Math.floor(stats.blocks.percentage * 100) + "%",
missingBlocks: stats.blocks.missing,
seenBlocks: stats.blocks.seen,
totalBlocks: stats.blocks.total,
};
allStats.push(statsRow(path.relative(CWD, filename), stats));
}
allStats.push(statsRow('Overall', coverageData.overall.stats()));
// Delete the HTML directory if necessary, and then create it
if (exists(htmlDirectory)) {
rmdirRecursiveSync(htmlDirectory);
}
fs.mkdirSync(htmlDirectory, "755");
// For each HTML file, use the template to generate an HTML file,
// and write it out to disk
_.each(htmls, function(html, filename) {
var outputPath = path.join(htmlDirectory, filename.replace(/[\/|\:|\\]/g, "_") + ".html");
var htmlTemplateString = fs.readFileSync(path.join(templateDir, "file.html")).toString("utf-8");
var htmlTemplate = _.template(htmlTemplateString);
var completeHtml = htmlTemplate({
filename: filename,
code: html,
stats: statsByFile[filename]
});
fs.writeFileSync(outputPath, completeHtml);
});
// Compile the index file with the template, and write it out to disk
var indexTemplateString = fs.readFileSync(path.join(templateDir, "index.html")).toString("utf-8");
var indexTemplate = _.template(indexTemplateString);
var headers = ["Filename", "% Covered", "Missed Lines", "# Lines", "% Blocks", "Missed Blocks", "# Blocks"];
var fileUrls = {};
_.each(files, function(file) {
fileUrls[path.relative(CWD, file)] = file.replace(/[\/|\:|\\]/g, "_") + ".html";
});
var indexHtml = indexTemplate({ headers: headers, data: allStats, fileUrls: fileUrls });
fs.writeFileSync(path.join(htmlDirectory, "index.html"), indexHtml);
// Copy over the resource files
fs.link(path.join(resourceDir, "bootstrap.css"), path.join(htmlDirectory, "bootstrap.css"));
fs.link(path.join(resourceDir, "prettify.css"), path.join(htmlDirectory, "prettify.css"));
fs.link(path.join(resourceDir, "prettify.js"), path.join(htmlDirectory, "prettify.js"));
fs.link(path.join(resourceDir, "jquery.min.js"), path.join(htmlDirectory, "jquery.min.js"));
fs.link(path.join(resourceDir, "jquery.tablesorter.min.js"), path.join(htmlDirectory, "jquery.tablesorter.min.js"));
},
cli: function(coverageData, config) {
fileData = coverageData.files;
var files = _.sortBy(_.keys(fileData), function(file) { return file; });
var table = new Table({
head: ["Filename", "% Covered", "Missed Lines", "# Lines", "% Blocks", "Missed Blocks", "# Blocks"],
style : {
'padding-left' : 1,
'padding-right ': 1,
head: ['cyan']
},
colWidths: [cover.reporters.cli.MAX_FILENAME_LENGTH + 5, 10, 14, 10, 10, 14, 10]
});
for(var i = 0; i < files.length; i++) {
var filename = files[i];
table.push(cover.reporters.cli.format(fileData[filename]));
}
table.push(cover.reporters.cli.format(coverageData.overall));
console.log(table.toString());
},
plain: function(coverageData, config) {
fileData = coverageData.files;
var files = _.sortBy(_.keys(fileData), function(file) { return file; });
for(var i = 0; i < files.length; i++) {
var filename = files[i];
console.log(cover.reporters.plain.format(fileData[filename]));
}
},
json: function(coverageData, config) {
fileData = coverageData.files;
var files = _.sortBy(_.keys(fileData), function(file) { return file; });
var jsons = [];
for(var i = 0; i < files.length; i++) {
var filename = files[i];
jsons.push(cover.reporters.json.format(fileData[filename]));
}
jsons.push(cover.reporters.json.format(coverageData.overall));
console.log(JSON.stringify(jsons));
},
__catch_all: function(coverageData, config, reporter) {
}
};
/* ====== Commands ====== */
var run = function(file, cmdline, config, ignore, debug) {
if (debug) {
var debugDirectory = path.join(CWD, config.debugDirectory);
if (!exists(debugDirectory)) {
fs.mkdirSync(debugDirectory, "0755");
}
}
// Run the file
var coverage = runFile(file, cmdline, ignore, debug ? config.debugDirectory : null);
// Setup the on exit listener
process.on(
"exit",
function() {
// For debugging purposes, make sure we can print things
patch_console.patch();
if (!coverage) {
return;
}
coverage(function(coverageData) {
try {
saveCoverageData(coverageData, config);
}
catch(e) {
console.log(e.stack);
}
});
}
);
};
var report = function(reporterName, file, config, ignore) {
var coverageData = loadCoverageData(file, config);
reporterName = reporterName || "cli";
var reporter = "";
if (cover.reporters[reporterName]) {
reporter = cover.reporters[reporterName];
}
else {
try {
reporter = require(path.resolve(reporterName));
}
catch(ex) {
console.log("Could not find reporter: " + reporterName);
process.exit(1);
}
}
(reporterHandlers[reporterName] || reporterHandlers.__catch_all)(coverageData, config, reporter);
}
var combine = function(configFile, ignoreFile) {
var files = getOptionsAndIgnore({config: configFile, ignore: ignoreFile});
var config = files.config;
var ignore = files.ignore;
var coverageData = loadPrecombinedCoverageData(config);
saveCoverageData(coverageData, config, true);
}
var hook = function(configFile, ignoreFile) {
var files = getOptionsAndIgnore({config: configFile, ignore: ignoreFile});
var config = files.config;
var ignore = files.ignore;
var cover = require('../index.js');
coverage = cover.cover(null, ignore, global);
// Setup the on exit listener
process.on(
"exit",
function() {
// For debugging purposes, make sure we can print things
patch_console.patch();
coverage(function(coverageData) {
try {
saveCoverageData(coverageData, config);
}
catch(e) {
console.log(e.stack);
}
});
}
);
}
var hookAndReport = function(reporterName, configFile, ignoreFile) {
var files = getOptionsAndIgnore({config: configFile, ignore: ignoreFile});
var config = files.config;
var ignore = files.ignore;
hook(configFile, ignoreFile);
process.on("exit", function() {
report(reporterName, null, config, ignore);
});
}
var hookAndCombine = function(configFile, ignoreFile) {
var files = getOptionsAndIgnore({config: configFile, ignore: ignoreFile});
var config = files.config;
var ignore = files.ignore;
hook(configFile, ignoreFile);
process.on("exit", function() {
combine(config);
});
}
var hookAndCombineAndReport = function(reporterName, configFile, ignoreFile) {
var files = getOptionsAndIgnore({config: configFile, ignore: ignoreFile});
var config = files.config;
var ignore = files.ignore;
hook(configFile, ignoreFile);
process.on("exit", function() {
combine(config);
report(reporterName, null, config, ignore);
});
}
/* ====== Command Line Parsing ====== */
commander
.version(pkg.version)
.option("-c, --config <config>", "Path to a .coverrc file")
.option("-i, --ignore <ignore>", "Path to a .coverignore file")
commander.command("run <file>")
.description("Run a file and collect code coverage information for it")
.option("-d, --debug", "Enable debugging")
.option("-m, --modules", "Enable coverage for node_modules")
.action(function(file, options) {
var configs = getOptionsAndIgnore(this, options);
var config = configs.config;
var ignore = configs.ignore;
var debug = options.debug;
// Remove the command itself
var cmdline = this.args.slice(1);
run(file, cmdline, config, ignore, debug);
});
commander.command("report [reporter] [file]")
.description("Report on saved coverage data. Specify a coverage file and a reporter: " + reporterOptions)
.action(function(reporterName, file) {
var configs = getOptionsAndIgnore(this);
var config = configs.config;
var ignore = configs.ignore;
report(reporterName, file, config, ignore);
});
commander.command("combine")
.description("Combine multiple coverage files (from multiple runs) into a single, reportable file")
.action(function(reporterName, file) {
var configs = getOptionsAndIgnore(this);
var config = configs.config;
var ignore = configs.ignore;
combine(config, ignore);
});
var printHelp = function() {
console.log(commander.helpInformation());
}
commander.command("*")
.action(function() {
printHelp();
});
/* ====== Exports ====== */
module.exports = {
parse: function(argv) {
var cmdline = commander.parse(argv);
if (!cmdline.executedCommand) {
printHelp();
}
return cmdline;
},
run: run,
report: report,
hook: hook,
hookAndReport: hookAndReport,
combine: combine,
hookAndCombine: hookAndCombine,
hookAndCombineAndReport: hookAndCombineAndReport
};
})();
if (module === require.main) {
module.exports.parse(process.argv);
}
