The `--preload-sources` option is now deprecated and superseded by the
`--include-all-sources` option instead. This provides a better coverage representation
of the code that has not been included for testing.
v0.3.4
Merge #219 - Support reporting within symlink/junction. Thanks to @dougwilson
v0.3.3
Merge #268 - per file coverage enforcement. Thanks to @ryan-roemer
v0.3.2
Republish 0.3.1 because of bad shasum
v0.3.1
Fixes #249
v0.3.0
The *reports* release. **Potentially backwards-incompatible** if you are using
undocumented features or custom report implementations.
Change report command line to support multiple reports, add back-compat processing with warnings
Enable `report` command to read report list from config, thanks to @piuccio
Support multiple reports for `cover` and `report` commands
Support per-report config options in configuration file
Turn reports into event emitters so they can signal `done`
Add `Reporter` class to be able to generate multiple reports
Add a bunch of API docs, refactor README
v0.2.16
Make YUI links https-always since relative links break local
filesystem use-case
v0.2.15
make link protocols relative so they don't break on https connections
(thanks to @yasyf)
v0.2.14
Fix hook to deal with non-string/ missing filenames
(thanks to @jason0x43), update dependencies
v0.2.13
Add `--preload-sources` option to `cover` command to make
code not required by tests to appear in the coverage report.
v0.2.12
Text summary as valid markdown, thanks to @smikes
v0.2.11
Allow source map generation, thanks to @jason0x43
v0.2.10
Add flag to handle sigints and dump coverage, thanks to @samccone
v0.2.9
Fix #202
v0.2.8
Upgrade esprima
v0.2.7
Upgrade esprima
Misc jshint fixes
v0.2.6
Revert bad commit for tree summarizer
v0.2.5
Add clover report, thanks to @bixdeng, @mpderbec
Fix cobertura report bug for relative paths, thanks to @jxiaodev
Run self-coverage on tests always
Fix tree summarizer when relative paths are involved, thanks to @Swatinem
v0.2.4
Fix line-split algo to handle Mac lin separators, thanks to @asifrc
Update README for quick intro to ignoring code for coverage, thanks to @gergelyke
v0.2.3
Add YAML config file. `istanbul help config` has more details
Support custom reporting thresholds using the `watermarks` section of the config file
v0.2.2
update escodegen, handlebars and resolve dependency versions
v0.2.1
Add ability to skip branches and other hard-to-test code using comments.
See the doc for more details
Turn `util.error` into `console.error` for node 0.11 compatibility, thanks to @pornel
v0.2.0
Add --preserve-comments to instrumenter options, thanks to @arikon
Support 'use strict;' in file scope, thanks to @pornel
Up minor version due to the new way in which the global object is accessed.
This _should_ be backwards-compatible but has not been tested in the wild.
v0.1.46
Fix #114
v0.1.45
Add teamcity reporter, thanks to @chrisgladd
v0.1.44
Fix inconsistency in processing empty switch with latest esprima, up deps
v0.1.43
Add colors to text report thanks to @runk
v0.1.42
fix #78: embed source regression introduced in v0.1.38. Fix broken test for this
v0.1.41
add json report to dump coverage object for certain use cases
v0.1.40
forward sourceStore from lcov to html report, pull request by @vojtajina
v0.1.39
add tag to cobertura report, pull request by @jhansche
v0.1.38
factor out AST instrumentation into own instrumentASTSync method
always set function declaration coverage stats to 1 since every such declaration is "executed" exactly one time by the compiler
v0.1.37
--complete-copy flag contrib from @kami, correct strict mode semantics for instrumented functions
v0.1.36
real quiet when --print=none specified, add repo URL to package.json, add contributors
v0.1.35
accept cobertura contrib from @nbrownus, fix #52
v0.1.34
fix async reporting, update dependencies, accept html cleanup contrib from @mathiasbynens
v0.1.33
initialize global coverage object before running tests to workaround mocha leak detection
v0.1.32
Fix for null nodes in array expressions, add @unindented as contributor
v0.1.31
Misc internal fixes and test changes
v0.1.30
Write standard blurbs ("writing coverage object..." etc.) to stderr rather than stdout
v0.1.29
Allow --post-require-hook to be a module that can be `require`-d
v0.1.28
Add --post-require-hook switch to support use-cases similar to the YUI loader
v0.1.27
Add --hook-run-in-context switch to support RequireJS modules. Thanks to @millermedeiros for the pull request
v0.1.26
Add support for minimum uncovered unit for check-coverage. Fixes #25
v0.1.25
Allow for relative paths in the YUI loader hook
v0.1.24
Add lcov summaries. Fixes issue #20
v0.1.23
Add ability to save a baseline coverage file for the instrument command. Fixes issue #19
v0.1.22
Add signature attribute to cobertura method tags to fix NPE by the Hudson publisher
v0.1.21
Add cobertura XML report format; exprimental for now
v0.1.20
Fix HTML/ lcov report interface to be more customizable for middleware needs
v0.1.19
make all hooking non-destructive in that already loaded modules are never reloaded. Add self-test mode so that already loaded istanbul modules can be unloaded prior to hooking.
v0.1.18
Add option to hook in non-destructive mode; i.e. the require cache is not unloaded when hooking
v0.1.17
Export some more objects; undocumented for now
v0.1.16
Fix npm keywords for istanbul which expects an array of strings but was being fed a single string with keywords instead
v0.1.15
Add the 'check-coverage' command so that Istanbul can be used as a posttest script to enforce minimum coverage
v0.1.14
Expose the experimental YUI load hook in the interface
v0.1.13
Internal jshint cleanup, no features or fixes
v0.1.12
Give npm the README that was getting inadvertently excluded
v0.1.11
Merge pull request #14 for HTML tweaks. Thanks @davglass. Add @davglass and @nowamasa as contributors in `package.json`
v0.1.10
Fix to issue #12. Do not install `uncaughtException` handler and pass input error back to CLI using a callback as opposed to throwing.
v0.1.9
Attempt to create reporting directory again just before writing coverage in addition to initial creation
v0.1.8
Fix issue #11.
v0.1.7
Add text summary and detailed reporting available as --print [summary|detail|both|none]. summary is the default if nothing specified.
v0.1.6
Handle backslashes in the file path correctly in emitted code. Fixes #9. Thanks to @nowamasa for bug report and fix
v0.1.5
make object-utils.js work on a browser as-is
v0.1.4
partial fix for issue #4; add titles to missing coverage spans, remove negative margin for missing if/else indicators
v0.1.3
Set the environment variable running_under_istanbul to 1 when that is the case. This allows test runners that use istanbul as a library to back off on using it when set.
v0.1.2
HTML reporting cosmetics. Reports now show syntax-colored JS using `prettify`. Summary tables no longer wrap in awkward places.
v0.1.1
Fixes issue #1. HTML reports use sources embedded inside the file coverage objects if found rather than reading from the filesystem
'
].join('\n'),
lt = '\u0001',
gt = '\u0002',
RE_LT = //g,
RE_AMP = /&/g,
RE_lt = /\u0001/g,
RE_gt = /\u0002/g;
handlebars.registerHelper('show_picture', function (opts) {
var num = Number(opts.fn(this)),
rest,
cls = '';
if (isFinite(num)) {
if (num === 100) {
cls = ' cover-full';
}
num = Math.floor(num);
rest = 100 - num;
return '' +
'';
} else {
return '';
}
});
handlebars.registerHelper('if_has_ignores', function (metrics, opts) {
return (metrics.statements.skipped +
metrics.functions.skipped +
metrics.branches.skipped) === 0 ? '' : opts.fn(this);
});
handlebars.registerHelper('show_ignores', function (metrics) {
var statements = metrics.statements.skipped,
functions = metrics.functions.skipped,
branches = metrics.branches.skipped,
result;
if (statements === 0 && functions === 0 && branches === 0) {
return 'none';
}
result = [];
if (statements >0) { result.push(statements === 1 ? '1 statement': statements + ' statements'); }
if (functions >0) { result.push(functions === 1 ? '1 function' : functions + ' functions'); }
if (branches >0) { result.push(branches === 1 ? '1 branch' : branches + ' branches'); }
return result.join(', ');
});
handlebars.registerHelper('show_lines', function (opts) {
var maxLines = Number(opts.fn(this)),
i,
array = [];
for (i = 0; i < maxLines; i += 1) {
array[i] = i + 1;
}
return array.join('\n');
});
handlebars.registerHelper('show_line_execution_counts', function (context, opts) {
var lines = context.l,
maxLines = Number(opts.fn(this)),
i,
lineNumber,
array = [],
covered,
value = '';
for (i = 0; i < maxLines; i += 1) {
lineNumber = i + 1;
value = ' ';
covered = 'neutral';
if (lines.hasOwnProperty(lineNumber)) {
if (lines[lineNumber] > 0) {
covered = 'yes';
value = lines[lineNumber] + '×';
} else {
covered = 'no';
}
}
array.push('' + value + '');
}
return array.join('\n');
});
function customEscape(text) {
text = text.toString();
return text.replace(RE_AMP, '&')
.replace(RE_LT, '<')
.replace(RE_GT, '>')
.replace(RE_lt, '<')
.replace(RE_gt, '>');
}
handlebars.registerHelper('show_code', function (context /*, opts */) {
var array = [];
context.forEach(function (item) {
array.push(customEscape(item.text) || ' ');
});
return array.join('\n');
});
function title(str) {
return ' title="' + str + '" ';
}
function annotateLines(fileCoverage, structuredText) {
var lineStats = fileCoverage.l;
if (!lineStats) { return; }
Object.keys(lineStats).forEach(function (lineNumber) {
var count = lineStats[lineNumber];
if (structuredText[lineNumber]) {
structuredText[lineNumber].covered = count > 0 ? 'yes' : 'no';
}
});
structuredText.forEach(function (item) {
if (item.covered === null) {
item.covered = 'neutral';
}
});
}
function annotateStatements(fileCoverage, structuredText) {
var statementStats = fileCoverage.s,
statementMeta = fileCoverage.statementMap;
Object.keys(statementStats).forEach(function (stName) {
var count = statementStats[stName],
meta = statementMeta[stName],
type = count > 0 ? 'yes' : 'no',
startCol = meta.start.column,
endCol = meta.end.column + 1,
startLine = meta.start.line,
endLine = meta.end.line,
openSpan = lt + 'span class="' + (meta.skip ? 'cstat-skip' : 'cstat-no') + '"' + title('statement not covered') + gt,
closeSpan = lt + '/span' + gt,
text;
if (type === 'no') {
if (endLine !== startLine) {
endLine = startLine;
endCol = structuredText[startLine].text.originalLength();
}
text = structuredText[startLine].text;
text.wrap(startCol,
openSpan,
startLine === endLine ? endCol : text.originalLength(),
closeSpan);
}
});
}
function annotateFunctions(fileCoverage, structuredText) {
var fnStats = fileCoverage.f,
fnMeta = fileCoverage.fnMap;
if (!fnStats) { return; }
Object.keys(fnStats).forEach(function (fName) {
var count = fnStats[fName],
meta = fnMeta[fName],
type = count > 0 ? 'yes' : 'no',
startCol = meta.loc.start.column,
endCol = meta.loc.end.column + 1,
startLine = meta.loc.start.line,
endLine = meta.loc.end.line,
openSpan = lt + 'span class="' + (meta.skip ? 'fstat-skip' : 'fstat-no') + '"' + title('function not covered') + gt,
closeSpan = lt + '/span' + gt,
text;
if (type === 'no') {
if (endLine !== startLine) {
endLine = startLine;
endCol = structuredText[startLine].text.originalLength();
}
text = structuredText[startLine].text;
text.wrap(startCol,
openSpan,
startLine === endLine ? endCol : text.originalLength(),
closeSpan);
}
});
}
function annotateBranches(fileCoverage, structuredText) {
var branchStats = fileCoverage.b,
branchMeta = fileCoverage.branchMap;
if (!branchStats) { return; }
Object.keys(branchStats).forEach(function (branchName) {
var branchArray = branchStats[branchName],
sumCount = branchArray.reduce(function (p, n) { return p + n; }, 0),
metaArray = branchMeta[branchName].locations,
i,
count,
meta,
type,
startCol,
endCol,
startLine,
endLine,
openSpan,
closeSpan,
text;
if (sumCount > 0) { //only highlight if partial branches are missing
for (i = 0; i < branchArray.length; i += 1) {
count = branchArray[i];
meta = metaArray[i];
type = count > 0 ? 'yes' : 'no';
startCol = meta.start.column;
endCol = meta.end.column + 1;
startLine = meta.start.line;
endLine = meta.end.line;
openSpan = lt + 'span class="branch-' + i + ' ' + (meta.skip ? 'cbranch-skip' : 'cbranch-no') + '"' + title('branch not covered') + gt;
closeSpan = lt + '/span' + gt;
if (count === 0) { //skip branches taken
if (endLine !== startLine) {
endLine = startLine;
endCol = structuredText[startLine].text.originalLength();
}
text = structuredText[startLine].text;
if (branchMeta[branchName].type === 'if') { // and 'if' is a special case since the else branch might not be visible, being non-existent
text.insertAt(startCol, lt + 'span class="' + (meta.skip ? 'skip-if-branch' : 'missing-if-branch') + '"' +
title((i === 0 ? 'if' : 'else') + ' path not taken') + gt +
(i === 0 ? 'I' : 'E') + lt + '/span' + gt, true, false);
} else {
text.wrap(startCol,
openSpan,
startLine === endLine ? endCol : text.originalLength(),
closeSpan);
}
}
}
}
});
}
function getReportClass(stats, watermark) {
var coveragePct = stats.pct,
identity = 1;
if (coveragePct * identity === coveragePct) {
return coveragePct >= watermark[1] ? 'high' : coveragePct >= watermark[0] ? 'medium' : 'low';
} else {
return '';
}
}
function cleanPath(name) {
var SEP = path.sep || '/';
return (SEP !== '/') ? name.split(SEP).join('/') : name;
}
function isEmptySourceStore(sourceStore) {
if (!sourceStore) {
return true;
}
var cache = sourceStore.sourceCache;
return cache && !Object.keys(cache).length;
}
/**
* a `Report` implementation that produces HTML coverage reports.
*
* Usage
* -----
*
* var report = require('istanbul').Report.create('html');
*
*
* @class HtmlReport
* @extends Report
* @module report
* @constructor
* @param {Object} opts optional
* @param {String} [opts.dir] the directory in which to generate reports. Defaults to `./html-report`
*/
function HtmlReport(opts) {
Report.call(this);
this.opts = opts || {};
this.opts.dir = this.opts.dir || path.resolve(process.cwd(), 'html-report');
this.opts.sourceStore = isEmptySourceStore(this.opts.sourceStore) ?
Store.create('fslookup') : this.opts.sourceStore;
this.opts.linkMapper = this.opts.linkMapper || this.standardLinkMapper();
this.opts.writer = this.opts.writer || null;
this.opts.templateData = { datetime: Date() };
this.opts.watermarks = this.opts.watermarks || defaults.watermarks();
}
HtmlReport.TYPE = 'html';
util.inherits(HtmlReport, Report);
Report.mix(HtmlReport, {
synopsis: function () {
return 'Navigable HTML coverage report for every file and directory';
},
getPathHtml: function (node, linkMapper) {
var parent = node.parent,
nodePath = [],
linkPath = [],
i;
while (parent) {
nodePath.push(parent);
parent = parent.parent;
}
for (i = 0; i < nodePath.length; i += 1) {
linkPath.push('' +
(cleanPath(nodePath[i].relativeName) || 'all files') + '');
}
linkPath.reverse();
return linkPath.length > 0 ? linkPath.join(' / ') + ' ' +
cleanPath(node.displayShortName()) : '/';
},
fillTemplate: function (node, templateData) {
var opts = this.opts,
linkMapper = opts.linkMapper;
templateData.entity = node.name || 'All files';
templateData.metrics = node.metrics;
templateData.reportClass = getReportClass(node.metrics.statements, opts.watermarks.statements);
templateData.pathHtml = this.getPathHtml(node, linkMapper);
templateData.base = {
css: linkMapper.asset(node, 'base.css')
};
templateData.sorter = {
js: linkMapper.asset(node, 'sorter.js'),
image: linkMapper.asset(node, 'sort-arrow-sprite.png')
};
templateData.prettify = {
js: linkMapper.asset(node, 'prettify.js'),
css: linkMapper.asset(node, 'prettify.css')
};
},
writeDetailPage: function (writer, node, fileCoverage) {
var opts = this.opts,
sourceStore = opts.sourceStore,
templateData = opts.templateData,
sourceText = fileCoverage.code && Array.isArray(fileCoverage.code) ?
fileCoverage.code.join('\n') + '\n' : sourceStore.get(fileCoverage.path),
code = sourceText.split(/(?:\r?\n)|\r/),
count = 0,
structured = code.map(function (str) { count += 1; return { line: count, covered: null, text: new InsertionText(str, true) }; }),
context;
structured.unshift({ line: 0, covered: null, text: new InsertionText("") });
this.fillTemplate(node, templateData);
writer.write(headerTemplate(templateData));
writer.write('
\n');
annotateLines(fileCoverage, structured);
//note: order is important, since statements typically result in spanning the whole line and doing branches late
//causes mismatched tags
annotateBranches(fileCoverage, structured);
annotateFunctions(fileCoverage, structured);
annotateStatements(fileCoverage, structured);
structured.shift();
context = {
structured: structured,
maxLines: structured.length,
fileCoverage: fileCoverage
};
writer.write(detailTemplate(context));
writer.write('
\n');
writer.write(footerTemplate(templateData));
},
writeIndexPage: function (writer, node) {
var linkMapper = this.opts.linkMapper,
templateData = this.opts.templateData,
children = Array.prototype.slice.apply(node.children),
watermarks = this.opts.watermarks;
children.sort(function (a, b) {
return a.name < b.name ? -1 : 1;
});
this.fillTemplate(node, templateData);
writer.write(headerTemplate(templateData));
writer.write(summaryTableHeader);
children.forEach(function (child) {
var metrics = child.metrics,
reportClasses = {
statements: getReportClass(metrics.statements, watermarks.statements),
lines: getReportClass(metrics.lines, watermarks.lines),
functions: getReportClass(metrics.functions, watermarks.functions),
branches: getReportClass(metrics.branches, watermarks.branches)
},
data = {
metrics: metrics,
reportClasses: reportClasses,
file: cleanPath(child.displayShortName()),
output: linkMapper.fromParent(child)
};
writer.write(summaryLineTemplate(data) + '\n');
});
writer.write(summaryTableFooter);
writer.write(footerTemplate(templateData));
},
writeFiles: function (writer, node, dir, collector) {
var that = this,
indexFile = path.resolve(dir, 'index.html'),
childFile;
if (this.opts.verbose) { console.error('Writing ' + indexFile); }
writer.writeFile(indexFile, function (contentWriter) {
that.writeIndexPage(contentWriter, node);
});
node.children.forEach(function (child) {
if (child.kind === 'dir') {
that.writeFiles(writer, child, path.resolve(dir, child.relativeName), collector);
} else {
childFile = path.resolve(dir, child.relativeName + '.html');
if (that.opts.verbose) { console.error('Writing ' + childFile); }
writer.writeFile(childFile, function (contentWriter) {
that.writeDetailPage(contentWriter, child, collector.fileCoverageFor(child.fullPath()));
});
}
});
},
standardLinkMapper: function () {
return {
fromParent: function (node) {
var relativeName = cleanPath(node.relativeName);
return node.kind === 'dir' ? relativeName + 'index.html' : relativeName + '.html';
},
ancestorHref: function (node, num) {
var href = '',
notDot = function(part) {
return part !== '.';
},
separated,
levels,
i,
j;
for (i = 0; i < num; i += 1) {
separated = cleanPath(node.relativeName).split('/').filter(notDot);
levels = separated.length - 1;
for (j = 0; j < levels; j += 1) {
href += '../';
}
node = node.parent;
}
return href;
},
ancestor: function (node, num) {
return this.ancestorHref(node, num) + 'index.html';
},
asset: function (node, name) {
var i = 0,
parent = node.parent;
while (parent) { i += 1; parent = parent.parent; }
return this.ancestorHref(node, i) + name;
}
};
},
writeReport: function (collector, sync) {
var opts = this.opts,
dir = opts.dir,
summarizer = new TreeSummarizer(),
writer = opts.writer || new FileWriter(sync),
that = this,
tree,
copyAssets = function (subdir) {
var srcDir = path.resolve(__dirname, '..', 'assets', subdir);
fs.readdirSync(srcDir).forEach(function (f) {
var resolvedSource = path.resolve(srcDir, f),
resolvedDestination = path.resolve(dir, f),
stat = fs.statSync(resolvedSource);
if (stat.isFile()) {
if (opts.verbose) {
console.log('Write asset: ' + resolvedDestination);
}
writer.copyFile(resolvedSource, resolvedDestination);
}
});
};
collector.files().forEach(function (key) {
summarizer.addFileCoverageSummary(key, utils.summarizeFileCoverage(collector.fileCoverageFor(key)));
});
tree = summarizer.getTreeSummary();
[ '.', 'vendor'].forEach(function (subdir) {
copyAssets(subdir);
});
writer.on('done', function () { that.emit('done'); });
//console.log(JSON.stringify(tree.root, undefined, 4));
this.writeFiles(writer, tree.root, dir, collector);
writer.done();
}
});
module.exports = HtmlReport;
istanbul-0.4.5/lib/report/index.js 0000664 0000000 0000000 00000006456 12756403262 0017111 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2012, Yahoo! Inc. All rights reserved.
Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
*/
var util = require('util'),
EventEmitter = require('events').EventEmitter,
Factory = require('../util/factory'),
factory = new Factory('report', __dirname, false);
/**
* An abstraction for producing coverage reports.
* This class is both the base class as well as a factory for `Report` implementations.
* All reports are event emitters and are expected to emit a `done` event when
* the report writing is complete.
*
* See also the `Reporter` class for easily producing multiple coverage reports
* with a single call.
*
* Usage
* -----
*
* var Report = require('istanbul').Report,
* report = Report.create('html'),
* collector = new require('istanbul').Collector;
*
* collector.add(coverageObject);
* report.on('done', function () { console.log('done'); });
* report.writeReport(collector);
*
* @class Report
* @module report
* @main report
* @constructor
* @protected
* @param {Object} options Optional. The options supported by a specific store implementation.
*/
function Report(/* options */) {
EventEmitter.call(this);
}
util.inherits(Report, EventEmitter);
//add register, create, mix, loadAll, getReportList as class methods
factory.bindClassMethods(Report);
/**
* registers a new report implementation.
* @method register
* @static
* @param {Function} constructor the constructor function for the report. This function must have a
* `TYPE` property of type String, that will be used in `Report.create()`
*/
/**
* returns a report implementation of the specified type.
* @method create
* @static
* @param {String} type the type of report to create
* @param {Object} opts Optional. Options specific to the report implementation
* @return {Report} a new store of the specified type
*/
/**
* returns the list of available reports as an array of strings
* @method getReportList
* @static
* @return an array of supported report formats
*/
var proto = {
/**
* returns a one-line summary of the report
* @method synopsis
* @return {String} a description of what the report is about
*/
synopsis: function () {
throw new Error('synopsis must be overridden');
},
/**
* returns a config object that has override-able keys settable via config
* @method getDefaultConfig
* @return {Object|null} an object representing keys that can be overridden via
* the istanbul configuration where the values are the defaults used when
* not specified. A null return implies no config attributes
*/
getDefaultConfig: function () {
return null;
},
/**
* writes the report for a set of coverage objects added to a collector.
* @method writeReport
* @param {Collector} collector the collector for getting the set of files and coverage
* @param {Boolean} sync true if reports must be written synchronously, false if they can be written using asynchronous means (e.g. stream.write)
*/
writeReport: function (/* collector, sync */) {
throw new Error('writeReport: must be overridden');
}
};
Object.keys(proto).forEach(function (k) {
Report.prototype[k] = proto[k];
});
module.exports = Report;
istanbul-0.4.5/lib/report/json-summary.js 0000664 0000000 0000000 00000005012 12756403262 0020431 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2012, Yahoo! Inc. All rights reserved.
Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
*/
var path = require('path'),
objectUtils = require('../object-utils'),
Writer = require('../util/file-writer'),
util = require('util'),
Report = require('./index');
/**
* a `Report` implementation that produces a coverage JSON object with summary info only.
*
* Usage
* -----
*
* var report = require('istanbul').Report.create('json-summary');
*
*
* @class JsonSummaryReport
* @extends Report
* @module report
* @constructor
* @param {Object} opts optional
* @param {String} [opts.dir] the directory in which to write the `coverage-summary.json` file. Defaults to `process.cwd()`
*/
function JsonSummaryReport(opts) {
this.opts = opts || {};
this.opts.dir = this.opts.dir || process.cwd();
this.opts.file = this.opts.file || this.getDefaultConfig().file;
this.opts.writer = this.opts.writer || null;
}
JsonSummaryReport.TYPE = 'json-summary';
util.inherits(JsonSummaryReport, Report);
Report.mix(JsonSummaryReport, {
synopsis: function () {
return 'prints a summary coverage object as JSON to a file';
},
getDefaultConfig: function () {
return {
file: 'coverage-summary.json'
};
},
writeReport: function (collector, sync) {
var outputFile = path.resolve(this.opts.dir, this.opts.file),
writer = this.opts.writer || new Writer(sync),
that = this;
var summaries = [],
finalSummary;
collector.files().forEach(function (file) {
summaries.push(objectUtils.summarizeFileCoverage(collector.fileCoverageFor(file)));
});
finalSummary = objectUtils.mergeSummaryObjects.apply(null, summaries);
writer.on('done', function () { that.emit('done'); });
writer.writeFile(outputFile, function (contentWriter) {
contentWriter.println("{");
contentWriter.write('"total":');
contentWriter.write(JSON.stringify(finalSummary));
collector.files().forEach(function (key) {
contentWriter.println(",");
contentWriter.write(JSON.stringify(key));
contentWriter.write(":");
contentWriter.write(JSON.stringify(objectUtils.summarizeFileCoverage(collector.fileCoverageFor(key))));
});
contentWriter.println("}");
});
writer.done();
}
});
module.exports = JsonSummaryReport;
istanbul-0.4.5/lib/report/json.js 0000664 0000000 0000000 00000004130 12756403262 0016736 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2012, Yahoo! Inc. All rights reserved.
Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
*/
var path = require('path'),
Writer = require('../util/file-writer'),
util = require('util'),
Report = require('./index');
/**
* a `Report` implementation that produces a coverage JSON object.
*
* Usage
* -----
*
* var report = require('istanbul').Report.create('json');
*
*
* @class JsonReport
* @extends Report
* @module report
* @constructor
* @param {Object} opts optional
* @param {String} [opts.dir] the directory in which to write the `coverage-final.json` file. Defaults to `process.cwd()`
*/
function JsonReport(opts) {
this.opts = opts || {};
this.opts.dir = this.opts.dir || process.cwd();
this.opts.file = this.opts.file || this.getDefaultConfig().file;
this.opts.writer = this.opts.writer || null;
}
JsonReport.TYPE = 'json';
util.inherits(JsonReport, Report);
Report.mix(JsonReport, {
synopsis: function () {
return 'prints the coverage object as JSON to a file';
},
getDefaultConfig: function () {
return {
file: 'coverage-final.json'
};
},
writeReport: function (collector, sync) {
var outputFile = path.resolve(this.opts.dir, this.opts.file),
writer = this.opts.writer || new Writer(sync),
that = this;
writer.on('done', function () { that.emit('done'); });
writer.writeFile(outputFile, function (contentWriter) {
var first = true;
contentWriter.println("{");
collector.files().forEach(function (key) {
if (first) {
first = false;
} else {
contentWriter.println(",");
}
contentWriter.write(JSON.stringify(key));
contentWriter.write(":");
contentWriter.write(JSON.stringify(collector.fileCoverageFor(key)));
});
contentWriter.println("}");
});
writer.done();
}
});
module.exports = JsonReport;
istanbul-0.4.5/lib/report/lcov.js 0000664 0000000 0000000 00000004061 12756403262 0016733 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2012, Yahoo! Inc. All rights reserved.
Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
*/
var path = require('path'),
util = require('util'),
mkdirp = require('mkdirp'),
Report = require('./index'),
LcovOnlyReport = require('./lcovonly'),
HtmlReport = require('./html');
/**
* a `Report` implementation that produces an LCOV coverage file and an associated HTML report from coverage objects.
* The name and behavior of this report is designed to ease migration for projects that currently use `yuitest_coverage`
*
* Usage
* -----
*
* var report = require('istanbul').Report.create('lcov');
*
*
* @class LcovReport
* @extends Report
* @module report
* @constructor
* @param {Object} opts optional
* @param {String} [opts.dir] the directory in which to the `lcov.info` file.
* HTML files are written in a subdirectory called `lcov-report`. Defaults to `process.cwd()`
*/
function LcovReport(opts) {
Report.call(this);
opts = opts || {};
var baseDir = path.resolve(opts.dir || process.cwd()),
htmlDir = path.resolve(baseDir, 'lcov-report');
mkdirp.sync(baseDir);
this.lcov = new LcovOnlyReport({ dir: baseDir, watermarks: opts.watermarks });
this.html = new HtmlReport({ dir: htmlDir, watermarks: opts.watermarks, sourceStore: opts.sourceStore});
}
LcovReport.TYPE = 'lcov';
util.inherits(LcovReport, Report);
Report.mix(LcovReport, {
synopsis: function () {
return 'combined lcovonly and html report that generates an lcov.info file as well as HTML';
},
writeReport: function (collector, sync) {
var handler = this.handleDone.bind(this);
this.inProgress = 2;
this.lcov.on('done', handler);
this.html.on('done', handler);
this.lcov.writeReport(collector, sync);
this.html.writeReport(collector, sync);
},
handleDone: function () {
this.inProgress -= 1;
if (this.inProgress === 0) {
this.emit('done');
}
}
});
module.exports = LcovReport;
istanbul-0.4.5/lib/report/lcovonly.js 0000664 0000000 0000000 00000006657 12756403262 0017652 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2012, Yahoo! Inc. All rights reserved.
Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
*/
var path = require('path'),
Writer = require('../util/file-writer'),
util = require('util'),
Report = require('./index'),
utils = require('../object-utils');
/**
* a `Report` implementation that produces an LCOV coverage file from coverage objects.
*
* Usage
* -----
*
* var report = require('istanbul').Report.create('lcovonly');
*
*
* @class LcovOnlyReport
* @extends Report
* @module report
* @constructor
* @param {Object} opts optional
* @param {String} [opts.dir] the directory in which to the `lcov.info` file. Defaults to `process.cwd()`
*/
function LcovOnlyReport(opts) {
this.opts = opts || {};
this.opts.dir = this.opts.dir || process.cwd();
this.opts.file = this.opts.file || this.getDefaultConfig().file;
this.opts.writer = this.opts.writer || null;
}
LcovOnlyReport.TYPE = 'lcovonly';
util.inherits(LcovOnlyReport, Report);
Report.mix(LcovOnlyReport, {
synopsis: function () {
return 'lcov coverage report that can be consumed by the lcov tool';
},
getDefaultConfig: function () {
return { file: 'lcov.info' };
},
writeFileCoverage: function (writer, fc) {
var functions = fc.f,
functionMap = fc.fnMap,
lines = fc.l,
branches = fc.b,
branchMap = fc.branchMap,
summary = utils.summarizeFileCoverage(fc);
writer.println('TN:'); //no test name
writer.println('SF:' + fc.path);
Object.keys(functions).forEach(function (key) {
var meta = functionMap[key];
writer.println('FN:' + [ meta.line, meta.name ].join(','));
});
writer.println('FNF:' + summary.functions.total);
writer.println('FNH:' + summary.functions.covered);
Object.keys(functions).forEach(function (key) {
var stats = functions[key],
meta = functionMap[key];
writer.println('FNDA:' + [ stats, meta.name ].join(','));
});
Object.keys(lines).forEach(function (key) {
var stat = lines[key];
writer.println('DA:' + [ key, stat ].join(','));
});
writer.println('LF:' + summary.lines.total);
writer.println('LH:' + summary.lines.covered);
Object.keys(branches).forEach(function (key) {
var branchArray = branches[key],
meta = branchMap[key],
line = meta.line,
i = 0;
branchArray.forEach(function (b) {
writer.println('BRDA:' + [line, key, i, b].join(','));
i += 1;
});
});
writer.println('BRF:' + summary.branches.total);
writer.println('BRH:' + summary.branches.covered);
writer.println('end_of_record');
},
writeReport: function (collector, sync) {
var outputFile = path.resolve(this.opts.dir, this.opts.file),
writer = this.opts.writer || new Writer(sync),
that = this;
writer.on('done', function () { that.emit('done'); });
writer.writeFile(outputFile, function (contentWriter) {
collector.files().forEach(function (key) {
that.writeFileCoverage(contentWriter, collector.fileCoverageFor(key));
});
});
writer.done();
}
});
module.exports = LcovOnlyReport;
istanbul-0.4.5/lib/report/none.js 0000664 0000000 0000000 00000001577 12756403262 0016740 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2012, Yahoo! Inc. All rights reserved.
Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
*/
var util = require('util'),
Report = require('./index');
/**
* a `Report` implementation that does nothing. Use to specify that no reporting
* is needed.
*
* Usage
* -----
*
* var report = require('istanbul').Report.create('none');
*
*
* @class NoneReport
* @extends Report
* @module report
* @constructor
*/
function NoneReport() {
Report.call(this);
}
NoneReport.TYPE = 'none';
util.inherits(NoneReport, Report);
Report.mix(NoneReport, {
synopsis: function () {
return 'Does nothing. Useful to override default behavior and suppress reporting entirely';
},
writeReport: function (/* collector, sync */) {
//noop
this.emit('done');
}
});
module.exports = NoneReport;
istanbul-0.4.5/lib/report/teamcity.js 0000664 0000000 0000000 00000006013 12756403262 0017606 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2012, Yahoo! Inc. All rights reserved.
Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
*/
var path = require('path'),
util = require('util'),
mkdirp = require('mkdirp'),
fs = require('fs'),
utils = require('../object-utils'),
Report = require('./index');
/**
* a `Report` implementation that produces system messages interpretable by TeamCity.
*
* Usage
* -----
*
* var report = require('istanbul').Report.create('teamcity');
*
* @class TeamcityReport
* @extends Report
* @module report
* @constructor
* @param {Object} opts optional
* @param {String} [opts.dir] the directory in which to the text coverage report will be written, when writing to a file
* @param {String} [opts.file] the filename for the report. When omitted, the report is written to console
*/
function TeamcityReport(opts) {
Report.call(this);
opts = opts || {};
this.dir = opts.dir || process.cwd();
this.file = opts.file;
this.blockName = opts.blockName || this.getDefaultConfig().blockName;
}
TeamcityReport.TYPE = 'teamcity';
util.inherits(TeamcityReport, Report);
function lineForKey(value, teamcityVar) {
return '##teamcity[buildStatisticValue key=\'' + teamcityVar + '\' value=\'' + value + '\']';
}
Report.mix(TeamcityReport, {
synopsis: function () {
return 'report with system messages that can be interpreted with TeamCity';
},
getDefaultConfig: function () {
return { file: null , blockName: 'Code Coverage Summary'};
},
writeReport: function (collector /*, sync */) {
var summaries = [],
finalSummary,
lines = [],
text;
collector.files().forEach(function (file) {
summaries.push(utils.summarizeFileCoverage(collector.fileCoverageFor(file)));
});
finalSummary = utils.mergeSummaryObjects.apply(null, summaries);
lines.push('');
lines.push('##teamcity[blockOpened name=\''+ this.blockName +'\']');
//Statements Covered
lines.push(lineForKey(finalSummary.statements.pct, 'CodeCoverageB'));
//Methods Covered
lines.push(lineForKey(finalSummary.functions.covered, 'CodeCoverageAbsMCovered'));
lines.push(lineForKey(finalSummary.functions.total, 'CodeCoverageAbsMTotal'));
lines.push(lineForKey(finalSummary.functions.pct, 'CodeCoverageM'));
//Lines Covered
lines.push(lineForKey(finalSummary.lines.covered, 'CodeCoverageAbsLCovered'));
lines.push(lineForKey(finalSummary.lines.total, 'CodeCoverageAbsLTotal'));
lines.push(lineForKey(finalSummary.lines.pct, 'CodeCoverageL'));
lines.push('##teamcity[blockClosed name=\''+ this.blockName +'\']');
text = lines.join('\n');
if (this.file) {
mkdirp.sync(this.dir);
fs.writeFileSync(path.join(this.dir, this.file), text, 'utf8');
} else {
console.log(text);
}
this.emit('done');
}
});
module.exports = TeamcityReport;
istanbul-0.4.5/lib/report/templates/ 0000775 0000000 0000000 00000000000 12756403262 0017427 5 ustar 00root root 0000000 0000000 istanbul-0.4.5/lib/report/templates/foot.txt 0000664 0000000 0000000 00000001000 12756403262 0021126 0 ustar 00root root 0000000 0000000
{{#if prettify}}
{{/if}}