Skip to content

B
babel-plugin-ry-istanbul
Commit 67d840bc by lxyang
Options

feat: 上传bat版本

parents
Showing with 1908 additions and 0 deletions
.gitignore 0 → 100644
lib/
node_modules/
*tgz
.history
dist
# Logs
logs
*.log
npm-debug.log*
# Runtime data
pids
*.pid
*.seed
# Directory for instrumented libs generated by jscoverage/JSCover
lib-cov
# Coverage directory used by tools like istanbul
coverage
# nyc test coverage
.nyc_output
# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
.grunt
# node-waf configuration
.lock-wscript
# Compiled binary addons (http://nodejs.org/api/addons.html)
build/Release
# Dependency directories
node_modules
!fixtures/node_modules
jspm_packages
# Optional npm cache directory
.npm
# Optional REPL history
.node_repl_history
.npmrc 0 → 100644
package-lock=false
LICENSE 0 → 100644
Copyright (c) 2016, Istanbul Code Coverage
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of babel-plugin-istanbul nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
README.md 0 → 100644
# babel-plugin-istanbul
[![Coverage Status](https://coveralls.io/repos/github/istanbuljs/babel-plugin-istanbul/badge.svg?branch=master)](https://coveralls.io/github/istanbuljs/babel-plugin-istanbul?branch=master)
[![Conventional Commits](https://img.shields.io/badge/Conventional%20Commits-1.0.0-yellow.svg)](https://conventionalcommits.org)
[![community slack](http://devtoolscommunity.herokuapp.com/badge.svg)](http://devtoolscommunity.herokuapp.com)
_Having problems? want to contribute? join our [community slack](http://devtoolscommunity.herokuapp.com)_.
A Babel plugin that instruments your code with Istanbul coverage.
It can instantly be used with [karma-coverage](https://github.com/karma-runner/karma-coverage) and mocha on Node.js (through [nyc](https://github.com/bcoe/nyc)).
__Note:__ This plugin does not generate any report or save any data to any file;
it only adds instrumenting code to your JavaScript source code.
To integrate with testing tools, please see the [Integrations](#integrations) section.
## 新增目录istanlibment
此目录为插桩方法，日后优化时使用，现使用原版本文件
新增方法：增量插桩两种方式
Serve packjson启动增加配置到时候不需要可以更改IS_PITCHING_PILE为false即可
"serve": "cross-env IS_PITCHING_PILE=true;cross-env INCREMENT=true;cross-env BRANCH=origin/master; vue-cli-service serve --mode dev"
IS_PITCHING_PILE是否插桩
INCREMENT是否过滤增量文件
BRANCH需要对比的分支isPitchingPile为true时默认origin/master当ISPITCHINGPILE为false的时候可以不穿
第二种（第一种后期优化加上现在使用第二种如参方式）
[
babel-plugin-ry-istanbul,
{
extension: ['.js', '.vue'],
instrmenttation: { IS_PITCHING_PILE: true, INCREMENT: true, BRANCH: 'origin/master' }
}
]
]
## Usage
Install it:
```
npm install --save-dev babel-plugin-istanbul
```
Add it to `.babelrc` in test mode:
```js
{
"env": {
"test": {
"plugins": [ "istanbul" ]
}
}
}
```
Optionally, use [cross-env](https://www.npmjs.com/package/cross-env) to set
`NODE_ENV=test`:
```json
{
"scripts": {
"test": "cross-env NODE_ENV=test nyc --reporter=lcov --reporter=text mocha test/*.js"
}
}
```
## Integrations
### karma
It _just works_ with Karma. First, make sure that the code is already transpiled by Babel (either using `karma-babel-preprocessor`, `karma-webpack`, or `karma-browserify`). Then, simply set up [karma-coverage](https://github.com/karma-runner/karma-coverage) according to the docs, but __don’t add the `coverage` preprocessor.__ This plugin has already instrumented your code, and Karma should pick it up automatically.
It has been tested with [bemusic/bemuse](https://codecov.io/github/bemusic/bemuse) project, which contains ~2400 statements.
### mocha on node.js (through nyc)
Configure Mocha to transpile JavaScript code using Babel, then you can run your tests with [`nyc`](https://github.com/bcoe/nyc), which will collect all the coverage report.
babel-plugin-istanbul respects the `include`/`exclude` configuration options from nyc,
but you also need to __configure NYC not to instrument your code__ by adding these settings in your `package.json`:
```js
"nyc": {
"sourceMap": false,
"instrument": false
},
```
## Ignoring files
You don't want to cover your test files as this will skew your coverage results. You can configure this by providing plugin options matching nyc's [`exclude`/`include` rules](https://github.com/bcoe/nyc#excluding-files):
```json
{
"env": {
"test": {
"plugins": [
["istanbul", {
"exclude": [
"**/*.spec.js"
]
}]
]
}
}
}
```
If you don't provide options in your Babel config, the plugin will look for `exclude`/`include` config under an `"nyc"` key in `package.json`.
You can also use [istanbul's ignore hints](https://github.com/gotwarlost/istanbul/blob/master/ignoring-code-for-coverage.md#ignoring-code-for-coverage-purposes) to specify specific lines of code to skip instrumenting.
## Source Maps
By default, this plugin will pick up inline source maps and attach them to the instrumented code such that code coverage can be remapped back to the original source, even for multi-step build processes. This can be memory intensive. Set `useInlineSourceMaps` to prevent this behavior.
```json
{
"env": {
"test": {
"plugins": [
["istanbul", {
"useInlineSourceMaps": false
}]
]
}
}
}
```
If you're instrumenting code programatically, you can pass a source map explicitly.
```js
import babelPluginIstanbul from 'babel-plugin-istanbul';
function instrument(sourceCode, sourceMap, fileName) {
return babel.transform(sourceCode, {
filename,
plugins: [
[babelPluginIstanbul, {
inputSourceMap: sourceMap
}]
]
})
}
```
## Credit where credit is due
The approach used in `babel-plugin-istanbul` was inspired by [Thai Pangsakulyanont](https://github.com/dtinth)'s original library [`babel-plugin-__coverage__`](https://github.com/dtinth/babel-plugin-__coverage__).
## `babel-plugin-istanbul` for enterprise
Available as part of the Tidelift Subscription.
The maintainers of `babel-plugin-istanbul` and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/npm-babel-plugin-istanbul?utm_source=npm-babel-plugin-istanbul&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)
babel.config.js 0 → 100644
'use strict'
module.exports = {
plugins: ['@babel/plugin-transform-modules-commonjs'],
env: {
test: {
plugins: ['./lib']
}
}
}
fixtures/class-functions.js 0 → 100644
class Foo1 {
bar() {}
barz() {}
}
class Foo2 {
bar() {}
barz() {}
}
module.exports = { Foo1, Foo2 }
fixtures/config/file1.js 0 → 100644
console.log('file1')
fixtures/config/file2.js 0 → 100644
console.log('file2')
fixtures/config/nyc-alt.config.js 0 → 100644
'use strict'
module.exports = {
include: ['file2.js']
}
fixtures/config/nyc.config.js 0 → 100644
'use strict'
module.exports = {
include: ['file1.js']
}
fixtures/has-inline-source-map.js 0 → 100644
"use strict";
var Say = (function () {
function Say() {
}
Say.prototype.hello = function () {
console.log('hello');
};
return Say;
}());
exports.__esModule = true;
exports["default"] = Say;
//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2hlY2tib3gudGVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIkNoZWNrYm94LnRlc3QudHN4Il0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTtJQUFBO0lBSUEsQ0FBQztJQUhDLG1CQUFLLEdBQUw7UUFDRSxPQUFPLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQ3ZCLENBQUM7SUFDSCxVQUFDO0FBQUQsQ0FBQyxBQUpELElBSUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZGVmYXVsdCBjbGFzcyBTYXkge1xyXG4gIGhlbGxvKCkge1xyXG4gICAgY29uc29sZS5sb2coJ2hlbGxvJyk7XHJcbiAgfVxyXG59Il19"
\ No newline at end of file
fixtures/issue-201.js 0 → 100644
import { resolve } from 'path'
function test () {
const _path = 'path'
return resolve(_path)
}
test()
fixtures/issue-78.js 0 → 100644
export const updateName = (name) => {
return {
type: 'UPDATE_NAME',
name
}
}
export const updateName2 = (name) => {
return {
type: 'UPDATE_NAME',
name
}
}
fixtures/node_modules/should-cover.js 0 → 100644
const foo = function () {
console.log('foo')
}
foo()
fixtures/node_modules/should-not-cover.js 0 → 100644
const bar = function () {
console.log('bar')
}
bar()
fixtures/plugin-should-cover.js 0 → 100644
const foo = function () {
console.log('foo')
}
foo()
fixtures/plugin-should-not-cover.js 0 → 100644
const bar = function () {
console.log('bar')
}
bar()
fixtures/should-cover.js 0 → 100644
const foo = function () {
console.log('foo')
}
foo()
fixtures/should-not-cover.js 0 → 100644
const bar = function () {
console.log('bar')
}
bar()
fixtures/should-respect-cwd.js 0 → 100644
const foo = function () {
console.log('foo')
}
foo()
package.json 0 → 100644
{
"name": "babel-plugin-ry-istanbul",
"version": "0.0.1-bat",
"author": "Thai Pangsakulyanont @dtinth",
"license": "BSD-3-Clause",
"description": "A babel plugin that adds istanbul instrumentation to ES6 code",
"main": "lib/index.js",
"files": [
"lib"
],
"dependencies": {
"@babel/helper-plugin-utils": "^7.0.0",
"@babel/parser": "^7.14.7",
"@istanbuljs/load-nyc-config": "^1.0.0",
"@istanbuljs/schema": "^0.1.2",
"babel-generator": "^6.18.0",
"babel-template": "^6.26.0",
"babel-traverse": "^6.18.0",
"babel-types": "^6.18.0",
"babylon": "^6.13.0",
"cross-env": "^7.0.3",
"istanbul-lib-coverage": "^1.0.0",
"onchange": "^7.1.0",
"parse-diff": "^0.9.0",
"ry-istanbul-web": "^0.0.1",
"semver": "^6.3.0",
"test-exclude": "^6.0.0"
},
"devDependencies": {
"@babel/cli": "^7.7.5",
"@babel/core": "^7.7.5",
"@babel/plugin-proposal-optional-chaining": "^7.16.7",
"@babel/plugin-transform-modules-commonjs": "^7.7.5",
"@babel/register": "^7.7.4",
"chai": "^4.2.0",
"coveralls": "^3.0.9",
"cross-env": "^6.0.3",
"gaze": "^1.1.3",
"mocha": "^6.2.2",
"nyc": "^15.0.0",
"pmock": "^0.2.3",
"standard": "^14.3.1",
"pass-diff": "^0.9.0",
"babel-cli": "^6.3.17",
"babel-plugin-istanbul": "^2.0.3",
"babel-preset-es2015": "^6.3.13",
"babel-register": "^6.16.3",
"clone": "^2.0.0",
"documentation": "^4.0.0-beta9",
"js-yaml": "^3.3.1",
"jshint": "^2.8.0",
"nopt": "^3.0.6",
"standard-version": "^3.0.0"
},
"scripts": {
"coverage": "nyc report --reporter=text-lcov | coveralls",
"release": "babel src --out-dir lib",
"pretest": "standard && npm run release",
"test": "cross-env NODE_ENV=test nyc --reporter=lcov --reporter=text mocha --timeout 5000 test/*.js",
"prepublish": "npm test && npm run release",
"build:watch": "onchange ./src -- npm run release"
},
"standard": {
"ignore": [
"fixtures/*.js"
]
},
"keywords": [
"istanbul",
"babel",
"plugin",
"instrumentation"
],
"nyc": {
"include": [
"src/*.js",
"fixtures/should-cover.js"
],
"require": [
"@babel/register"
],
"sourceMap": false,
"instrument": false
},
"engines": {
"node": ">=8"
}
}
src/index.js 0 → 100644
const path = require('path')
import { realpathSync } from 'fs'
import { execFileSync, execSync } from 'child_process'
import { declare } from '@babel/helper-plugin-utils'
// import { programVisitor } from './istanlibment'
import { programVisitor } from 'istanbul-lib-instrument'
import TestExclude from 'test-exclude'
import schema from '@istanbuljs/schema'
import parseDiffData from 'parse-diff'
function getRealpath(n) {
try {
return realpathSync(n) || /* istanbul ignore next */ n
} catch (e) {
/* istanbul ignore next */
return n
}
}
const memoize = new Map()
/* istanbul ignore next */
const memosep = path.sep === '/' ? ':' : ';'
function loadNycConfig (cwd, opts) {
let memokey = cwd
const args = [
path.resolve(__dirname, 'load-nyc-config-sync.js'),
cwd
]
if ('nycrcPath' in opts) {
args.push(opts.nycrcPath)
memokey += memosep + opts.nycrcPath
}
/* execFileSync is expensive, avoid it if possible! */
if (memoize.has(memokey)) {
return memoize.get(memokey)
}
const result = JSON.parse(execFileSync(process.execPath, args))
const error = result['load-nyc-config-sync-error']
if (error) {
throw new Error(error)
}
const config = {
...schema.defaults.babelPluginIstanbul,
cwd,
...result
}
memoize.set(memokey, config)
return config
}
function findConfig (opts) {
const cwd = getRealpath(opts.cwd || process.env.NYC_CWD || /* istanbul ignore next */ process.cwd())
const keys = Object.keys(opts)
const ignored = Object.keys(opts).filter(s => s === 'nycrcPath' || s === 'cwd')
if (keys.length > ignored.length) {
// explicitly configuring options in babel
// takes precedence.
return {
...schema.defaults.babelPluginIstanbul,
cwd,
...opts
}
}
if (ignored.length === 0 && process.env.NYC_CONFIG) {
// defaults were already applied by nyc
return JSON.parse(process.env.NYC_CONFIG)
}
return loadNycConfig(cwd, opts)
}
function makeShouldSkip () {
let exclude
return function shouldSkip (file, nycConfig) {
if (!exclude || (exclude.cwd !== nycConfig.cwd)) {
exclude = new TestExclude({
cwd: nycConfig.cwd,
include: nycConfig.include,
exclude: nycConfig.exclude,
extension: nycConfig.extension,
// Make sure this is true unless explicitly set to `false`. `undefined` is still `true`.
excludeNodeModules: nycConfig.excludeNodeModules !== false
})
}
return !exclude.shouldInstrument(file)
}
}
export default declare(api => {
api.assertVersion(7)
const shouldSkip = makeShouldSkip()
const t = api.types
return {
visitor: {
Program: {
enter(path) {
// 筛选后的数据增量文件
let diffScreen = null
this.__dv__ = null
this.nycConfig = findConfig(this.opts)
const realPath = getRealpath(this.file.opts.filename)
const { instrmenttation } = this.nycConfig // npm引入参数
const {
IS_PITCHING_PILE = false,
INCREMENT = false,
BRANCH = 'origin/master'
} = instrmenttation || {} // 是否全量代码和对比分支
console.log(IS_PITCHING_PILE, INCREMENT, BRANCH, 'IS_PITCHING_PILE, INCREMENT, BRANCH')
// instrumenttation (branch: git diff 跟那个分支对比, increment 是否开启增量代码检测) 拿配置到底是全量代码还是增量代码
if (!IS_PITCHING_PILE) {
return
}
// const changeList = []
// 下面的是零时的
// const gitDiffCode = execSync(`git diff ${branch}`)
// const diffData = parseDiffData(gitDiffCode.toString())
// diffScreen = diffData.find(item => {
// return realPath.indexOf(item.to) > -1
// })
// 后面解开
if (INCREMENT && BRANCH) {
const gitDiffCode = execSync(`git diff ${BRANCH}`)
const diffData = parseDiffData(gitDiffCode.toString())
diffScreen = diffData.find(item => {
return realPath.indexOf(item.to) > -1
})
}
if (shouldSkip(realPath, this.nycConfig)) {
return
}
let { inputSourceMap } = this.opts
if (this.opts.useInlineSourceMaps) {
if (!inputSourceMap && this.file.inputMap) {
inputSourceMap = this.file.inputMap.sourcemap
}
}
const visitorOptions = {}
Object.entries(schema.defaults.instrumentVisitor).forEach(([name, defaultValue]) => {
if (name in this.nycConfig) {
visitorOptions[name] = this.nycConfig[name]
} else {
visitorOptions[name] = schema.defaults.instrumentVisitor[name]
}
})
// 后增加|| !increment这个条件判断条件后面加上
// if (diffScreen !== null && increment) {
// if (diffScreen) {
// if (Array.isArray(diffScreen && diffScreen.chunks)) {
// diffScreen.chunks.forEach(item => {
// let changes = Array.isArray(item.changes) ? item.changes : []
// changes.forEach(items => {
// if (items && items.add) {
// changeList.push(items.ln)
// }
// })
// })
// }
// changeList
this.__dv__ = programVisitor(t, realPath, {
...visitorOptions,
inputSourceMap
})
this.__dv__.enter(path)
// } else {
// this.__dv__ = programVisitor(t, realPath, {
// ...visitorOptions,
// inputSourceMap
// })
// this.__dv__.enter(path)
// }
},
exit(path) {
if (!this.__dv__) {
return
}
const result = this.__dv__.exit(path)
if (this.opts.onCover) {
this.opts.onCover(getRealpath(this.file.opts.filename), result.fileCoverage)
}
}
}
}
}
})
// 增量代码babel引入方法 babel.js 或 babel.config.js
// 'plugins': [
// ['@hliang/babel-plugin-transfrom-modules-commonjs', {
// extension: ['.js', '.vue'],
// instrmenttation: {
// increment: true, // 是否全量插桩
// branch: 'origin/master' // 对比分支
// }
// }]
// ]
src/istanlibment/constants.js 0 → 100644
// import { major } from 'semver';
// import { name, version } from '../package.json';
const { createHash } = require('crypto')
// function to use for creating hashes
const VERSION = '4'
const SHA = 'sha1'
// name of coverage data magic key
// const MAGIC_KEY = '_coverageSchema'
// name of coverage data magic value
// export const MAGIC_VALUE = createHash(SHA).update(name + '@' + major(version)).digest('hex');
module.exports = {
SHA,
MAGIC_KEY: '_coverageSchema',
MAGIC_VALUE: createHash(SHA)
.update('name' + '@' + VERSION)
.digest('hex')
}
src/istanlibment/index.js 0 → 100644
const { defaults } = require('@istanbuljs/schema')
const Instrumenter = require('./instrumenter')
const programVisitor = require('./visitor')
const readInitialCoverage = require('./read-coverage')
/**
* createInstrumenter creates a new instrumenter with the
* supplied options.
* @param {Object} opts - instrumenter options. See the documentation
* for the Instrumenter class.
*/
function createInstrumenter(opts) {
return new Instrumenter(opts)
}
module.exports = {
createInstrumenter,
programVisitor,
readInitialCoverage,
defaultOpts: defaults.instrumenter
}
src/istanlibment/instrumenter.js 0 → 100644
/*
Copyright 2012-2015, Yahoo Inc.
Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
*/
const babylon = require('babylon');
const t = require('babel-types');
const traverse = require('babel-traverse');
const generate = require('babel-generator');
const programVisitor = require('./visitor');
function defaultOpts() {
return {
coverageVariable: "__coverage__",
preserveComments: false,
compact: true,
esModules: false,
autoWrap: false,
produceSourceMap: false,
sourceMapUrlCallback: null,
debug: false
};
}
/**
* Instrumenter is the public API for the instrument library.
* It is typically used for ES5 code. For ES6 code that you
* are already running under `babel` use the coverage plugin
* instead.
* @param {Object} opts optional.
* @param {string} [opts.coverageVariable=__coverage__] name of global coverage variable.
* @param {boolean} [opts.preserveComments=false] preserve comments in output
* @param {boolean} [opts.compact=true] generate compact code.
* @param {boolean} [opts.esModules=false] set to true to instrument ES6 modules.
* @param {boolean} [opts.autoWrap=false] set to true to allow `return` statements outside of functions.
* @param {boolean} [opts.produceSourceMap=false] set to true to produce a source map for the instrumented code.
* @param {Function} [opts.sourceMapUrlCallback=null] a callback function that is called when a source map URL
* is found in the original code. This function is called with the source file name and the source map URL.
* @param {boolean} [opts.debug=false] - turn debugging on
*/
class Instrumenter {
constructor(opts=defaultOpts()) {
this.opts = this.normalizeOpts(opts);
this.fileCoverage = null;
this.sourceMap = null;
}
/**
* normalize options passed in and assign defaults.
* @param opts
* @private
*/
normalizeOpts(opts) {
const normalize = (name, defaultValue) => {
if (!opts.hasOwnProperty(name)) {
opts[name] = defaultValue;
}
};
const defOpts = defaultOpts();
Object.keys(defOpts).forEach(function (k) {
normalize(k, defOpts[k]);
});
return opts;
}
/**
* instrument the supplied code and track coverage against the supplied
* filename. It throws if invalid code is passed to it. ES5 and ES6 syntax
* is supported. To instrument ES6 modules, make sure that you set the
* `esModules` property to `true` when creating the instrumenter.
*
* @param {string} code - the code to instrument
* @param {string} filename - the filename against which to track coverage.
* @param {object} [inputSourceMap] - the source map that maps the not instrumented code back to it's original form.
* Is assigned to the coverage object and therefore, is available in the json output and can be used to remap the
* coverage to the untranspiled source.
* @returns {string} the instrumented code.
*/
instrumentSync(code, filename, inputSourceMap) {
if (typeof code !== 'string') {
throw new Error('Code must be a string');
}
filename = filename || String(new Date().getTime()) + '.js';
const opts = this.opts;
const ast = babylon.parse(code, {
allowReturnOutsideFunction: opts.autoWrap,
sourceType: opts.esModules ? "module" : "script"
});
const ee = programVisitor(t, filename, {
coverageVariable: opts.coverageVariable,
inputSourceMap: inputSourceMap
});
let output = {};
const visitor = {
Program: {
enter: ee.enter,
exit: function (path) {
output = ee.exit(path);
}
}
};
traverse(ast, visitor);
const generateOptions = {
compact: opts.compact,
sourceMaps: opts.produceSourceMap,
sourceFileName: filename
};
const codeMap = generate(ast, generateOptions, code);
this.fileCoverage = output.fileCoverage;
this.sourceMap = codeMap.map;
const cb = this.opts.sourceMapUrlCallback;
if (cb && output.sourceMappingURL) {
cb(filename, output.sourceMappingURL);
}
return codeMap.code;
}
/**
* callback-style instrument method that calls back with an error
* as opposed to throwing one. Note that in the current implementation,
* the callback will be called in the same process tick and is not asynchronous.
*
* @param {string} code - the code to instrument
* @param {string} filename - the filename against which to track coverage.
* @param {Function} callback - the callback
* @param {Object} inputSourceMap - the source map that maps the not instrumented code back to it's original form.
* Is assigned to the coverage object and therefore, is available in the json output and can be used to remap the
* coverage to the untranspiled source.
*/
instrument(code, filename, callback, inputSourceMap) {
if (!callback && typeof filename === 'function') {
callback = filename;
filename = null;
}
try {
var out = this.instrumentSync(code, filename, inputSourceMap);
callback(null, out);
} catch (ex) {
callback(ex);
}
}
/**
* returns the file coverage object for the last file instrumented.
* @returns {Object} the file coverage object.
*/
lastFileCoverage() {
return this.fileCoverage;
}
/**
* returns the source map produced for the last file instrumented.
* @returns {null|Object} the source map object.
*/
lastSourceMap() {
return this.sourceMap;
}
}
export default Instrumenter;
src/istanlibment/read-coverage.js 0 → 100644
// import { MAGIC_KEY, MAGIC_VALUE } from './constants';
// import { parse } from 'babylon';
const traverse = require('babel-traverse')
// import * as t from 'babel-types';
const { parseSync } = require('@babel/core')
const { defaults } = require('@istanbuljs/schema')
const { MAGIC_KEY, MAGIC_VALUE } = require('./constants')
function getAst (code) {
if (typeof code === 'object' && typeof code.type === 'string') {
return code
}
if (typeof code !== 'string') {
throw new Error('Code must be a string')
}
return parseSync(code, {
babelrc: false,
configFile: false,
parserOpts: {
allowAwaitOutsideFunction: true,
allowImportExportEverywhere: true,
allowReturnOutsideFunction: true,
allowSuperOutsideMethod: true,
sourceType: 'script',
plugins: defaults.instrumenter.parserPlugins
}
})
}
module.exports = function readInitialCoverage (code) {
const ast = getAst(code)
let covScope
traverse(ast, {
ObjectProperty: function (path) {
const { node } = path;
if (!node.computed &&
path.get('key').isIdentifier() &&
node.key.name === MAGIC_KEY)
{
const magicValue = path.get('value').evaluate()
if (!magicValue.confident || magicValue.value !== MAGIC_VALUE) {
return
}
covScope = path.scope.getFunctionParent() || path.scope.getProgramParent()
path.stop()
}
}
})
if (!covScope) {
return null
}
const result = {}
for (const key of ['path', 'hash', 'gcv', 'coverageData']) {
const binding = covScope.getOwnBinding(key)
if (!binding) {
return null
}
const valuePath = binding.path.get('init')
const value = valuePath.evaluate()
if (!value.confident) {
return null
}
result[key] = value.value
}
delete result.coverageData[MAGIC_KEY]
delete result.coverageData.hash
return result
}
// export default function readInitialCoverage (code) {
// if (typeof code !== 'string') {
// throw new Error('Code must be a string');
// }
// // Parse as leniently as possible
// const ast = parse(code, {
// allowImportExportEverywhere: true,
// allowReturnOutsideFunction: true,
// allowSuperOutsideMethod: true,
// sourceType: "script", // I think ?
// plugins: ["*"]
// });
// let covScope;
// traverse(ast, {
// ObjectProperty: function (path) {
// const { node } = path;
// if (!node.computed &&
// t.isIdentifier(node.key) &&
// node.key.name === MAGIC_KEY)
// {
// const magicValue = path.get('value').evaluate();
// if (!magicValue.confident || magicValue.value !== MAGIC_VALUE) {
// return;
// }
// covScope = path.scope.getFunctionParent();
// path.stop();
// }
// }
// });
// if (!covScope) {
// return null;
// }
// const result = {};
// for (const key of ['path', 'hash', 'gcv', 'coverageData']) {
// const binding = covScope.getOwnBinding(key);
// if (!binding) {
// return null;
// }
// const valuePath = binding.path.get('init');
// const value = valuePath.evaluate();
// if (!value.confident) {
// return null;
// }
// result[key] = value.value;
// }
// delete result.coverageData[MAGIC_KEY];
// return result;
// }
src/istanlibment/source-coverage.js 0 → 100644
const { classes } = require('istanbul-lib-coverage');
function cloneLocation(loc) {
return {
start: {
line: loc && loc.start.line,
column: loc && loc.start.column
},
end: {
line: loc && loc.end.line,
column: loc && loc.end.column
}
};
}
function isExistIncrementStartmentCode(changeList, loc) {
for (let i = 0; i < changeList.length; i++) {
if (changeList[i] > loc.start.line && changeList[i] <= loc.end.line) {
return true
}
}
return false
}
/**
* SourceCoverage provides mutation methods to manipulate the structure of
* a file coverage object. Used by the instrumenter to create a full coverage
* object for a file incrementally.
*
* @private
* @param pathOrObj {String|Object} - see the argument for {@link FileCoverage}
* @extends FileCoverage
* @constructor
*/
class SourceCoverage extends classes.FileCoverage {
constructor(pathOrObj, changeList) {
super(pathOrObj);
this.data.changeList = changeList ? changeList : [];
this.meta = {
last: {
s: 0,
f: 0,
b: 0
}
};
}
newStatement(loc) {
var s = this.meta.last.s;
this.data.statementMap[s] = cloneLocation(loc);
this.data.s[s] = 0;
this.meta.last.s += 1;
return s;
}
newFunction(name, decl, loc) {
var f = this.meta.last.f;
name = name || '(anonymous_' + f + ')';
this.data.fnMap[f] = {
name: name,
decl: cloneLocation(decl),
loc: cloneLocation(loc)
};
this.data.f[f] = 0;
this.meta.last.f += 1;
return f;
}
newBranch(type, loc) {
var b = this.meta.last.b;
this.data.b[b] = [];
this.data.branchMap[b] = {
loc: cloneLocation(loc),
type: type,
locations: []
};
this.meta.last.b += 1;
return b;
}
addBranchPath(name, location) {
var bMeta = this.data.branchMap[name],
counts = this.data.b[name];
/* istanbul ignore if: paranoid check */
if (!bMeta) {
throw new Error("Invalid branch " + name);
}
bMeta.locations.push(cloneLocation(location));
counts.push(0);
return counts.length - 1;
}
/**
* Assigns an input source map to the coverage that can be used
* to remap the coverage output to the original source
* @param sourceMap {object} the source map
*/
inputSourceMap(sourceMap) {
this.data.inputSourceMap = sourceMap;
}
freeze() {
// prune empty branches
var map = this.data.branchMap,
branches = this.data.b;
Object.keys(map).forEach(function (b) {
if (map[b].locations.length === 0) {
delete map[b];
delete branches[b];
}
});
}
}
export { SourceCoverage };
src/istanlibment/visitor.js 0 → 100644
const { SourceCoverage } = require('./source-coverage');
const { SHA, MAGIC_KEY, MAGIC_VALUE } = require('./constants');
const { createHash } = require('crypto');
const template = require('babel-template');
const { Console } = require('console');
// istanbul ignore comment pattern
const COMMENT_RE = /^\s*istanbul\s+ignore\s+(if|else|next)(?=\W|$)/;
// source map URL pattern
const SOURCE_MAP_RE = /[#@]\s*sourceMappingURL=(.*)\s*$/m;
// generate a variable name from hashing the supplied file path
function genVar(filename) {
var hash = createHash(SHA);
hash.update(filename);
return 'cov_' + parseInt(hash.digest('hex').substr(0, 12), 16).toString(36);
}
// VisitState holds the state of the visitor, provides helper functions
// and is the `this` for the individual coverage visitors.
class VisitState {
constructor(types, sourceFilePath, inputSourceMap, changeList = []) {
this.varName = genVar(sourceFilePath);
this.attrs = {};
this.nextIgnore = null;
let changeLists = changeList ? changeList : []
this.cov = new SourceCoverage(sourceFilePath, changeLists);
if (typeof (inputSourceMap) !== "undefined") {
this.cov.inputSourceMap(inputSourceMap);
}
this.types = types;
this.sourceMappingURL = null;
}
// should we ignore the node? Yes, if specifically ignoring
// or if the node is generated.
shouldIgnore(path) {
return this.nextIgnore || !path.node.loc;
}
// extract the ignore comment hint (next|if|else) or null
hintFor(node) {
let hint = null;
if (node.leadingComments) {
node.leadingComments.forEach(function (c) {
const v = (c.value || /* istanbul ignore next: paranoid check */ "").trim();
const groups = v.match(COMMENT_RE);
if (groups) {
hint = groups[1];
}
});
}
return hint;
}
// extract a source map URL from comments and keep track of it
maybeAssignSourceMapURL(node) {
const that = this;
const extractURL = (comments) => {
if (!comments) {
return;
}
comments.forEach(function (c) {
const v = (c.value || /* istanbul ignore next: paranoid check */ "").trim();
const groups = v.match(SOURCE_MAP_RE);
if (groups) {
that.sourceMappingURL = groups[1];
}
});
};
extractURL(node.leadingComments);
extractURL(node.trailingComments);
}
// all the generic stuff that needs to be done on enter for every node
onEnter(path) {
const n = path.node;
this.maybeAssignSourceMapURL(n);
// if already ignoring, nothing more to do
if (this.nextIgnore !== null) {
return;
}
// check hint to see if ignore should be turned on
const hint = this.hintFor(n);
if (hint === 'next') {
this.nextIgnore = n;
return;
}
// else check custom node attribute set by a prior visitor
if (this.getAttr(path.node, 'skip-all') !== null) {
this.nextIgnore = n;
}
}
// all the generic stuff on exit of a node,
// including reseting ignores and custom node attrs
onExit(path) {
// restore ignore status, if needed
if (path.node === this.nextIgnore) {
this.nextIgnore = null;
}
// nuke all attributes for the node
delete(path.node.__cov__);
}
// set a node attribute for the supplied node
setAttr(node, name, value) {
node.__cov__ = node.__cov__ || {};
node.__cov__[name] = value;
}
// retrieve a node attribute for the supplied node or null
getAttr(node, name) {
const c = node.__cov__;
if (!c) {
return null;
}
return c[name];
}
//
increase(type, id, index) {
const T = this.types;
const wrap = (index !== null
// If `index` present, turn `x` into `x[index]`.
? (x) => T.memberExpression(x, T.numericLiteral(index), true)
: (x) => x
);
const memberExpression = T.memberExpression(
T.memberExpression(T.identifier(this.varName), T.identifier(type)),
T.numericLiteral(id),
true
)
let data = T.unaryExpression('++', wrap(memberExpression));
return data
}
insertCounter(path, increment) {
const T = this.types;
if (path.isBlockStatement()) {
path.node.body.unshift(T.expressionStatement(increment));
} else if (path.isStatement()) {
path.insertBefore(T.expressionStatement(increment));
} else if ((path.isFunctionExpression() || path.isArrowFunctionExpression()) && T.isVariableDeclarator(path.parentPath)) {
// make an attempt to hoist the statement counter, so that
// function names are maintained.
const parent = path.parentPath.parentPath;
if (parent && (T.isProgram(parent.parentPath) || T.isBlockStatement(parent.parentPath))) {
parent.insertBefore(T.expressionStatement(
increment
));
} else {
path.replaceWith(T.sequenceExpression([increment, path.node]));
}
} else {
/* istanbul ignore else: not expected */
if (path.isExpression()) {
path.replaceWith(T.sequenceExpression([increment, path.node]));
} else {
console.error('Unable to insert counter for node type:', path.node.type);
}
}
}
insertStatementCounter(path) {
/* istanbul ignore if: paranoid check */
if (!(path.node && path.node.loc)) {
return;
}
const index = this.cov.newStatement(path.node.loc);
const increment = this.increase('s', index, null);
this.insertCounter(path, increment);
}
insertFunctionCounter(path) {
const T = this.types;
/* istanbul ignore if: paranoid check */
if (!(path.node && path.node.loc)) {
return;
}
const n = path.node;
let dloc = null;
// get location for declaration
switch (n.type) {
case "FunctionDeclaration":
/* istanbul ignore else: paranoid check */
if (n.id) {
dloc = n.id.loc;
}
break;
case "FunctionExpression":
if (n.id) {
dloc = n.id.loc;
}
break;
}
if (!dloc) {
dloc = {
start: n.loc.start,
end: { line: n.loc.start.line, column: n.loc.start.column + 1 }
};
}
const name = path.node.id ? path.node.id.name : path.node.name;
const index = this.cov.newFunction(name, dloc, path.node.body.loc);
const increment = this.increase('f', index, null);
const body = path.get('body');
/* istanbul ignore else: not expected */
if (body.isBlockStatement()) {
body.node.body.unshift(T.expressionStatement(increment));
} else {
console.error('Unable to process function body node type:', path.node.type);
}
}
getBranchIncrement(branchName, loc) {
const index = this.cov.addBranchPath(branchName, loc);
console.log(3, index)
return this.increase('b', branchName, index);
}
insertBranchCounter(path, branchName, loc) {
const increment = this.getBranchIncrement(branchName, loc || path.node.loc);
this.insertCounter(path, increment);
}
findLeaves(node, accumulator, parent, property) {
if (!node) {
return;
}
if (node.type === "LogicalExpression") {
const hint = this.hintFor(node);
if (hint !== 'next') {
this.findLeaves(node.left, accumulator, node, 'left');
this.findLeaves(node.right, accumulator, node, 'right');
}
} else {
accumulator.push({
node: node,
parent: parent,
property: property
});
}
}
}
// generic function that takes a set of visitor methods and
// returns a visitor object with `enter` and `exit` properties,
// such that:
//
// * standard entry processing is done
// * the supplied visitors are called only when ignore is not in effect
// This relieves them from worrying about ignore states and generated nodes.
// * standard exit processing is done
//
function entries() {
const enter = Array.prototype.slice.call(arguments);
// the enter function
const wrappedEntry = function (path, node) {
this.onEnter(path);
if (this.shouldIgnore(path)) {
return;
}
const that = this;
enter.forEach(function (e) {
if (typeof e === 'functon' || typeof e !== null) {
e.call(that, path, node);
}
});
};
const exit = function (path, node) {
this.onExit(path, node);
};
return {
enter: wrappedEntry,
exit: exit
};
}
function coverStatement(path) {
this.insertStatementCounter(path);
}
/* istanbul ignore next: no node.js support */
function coverAssignmentPattern(path) {
const n = path.node;
const b = this.cov.newBranch('default-arg', n.loc);
this.insertBranchCounter(path.get('right'), b);
}
function coverFunction(path) {
this.insertFunctionCounter(path);
}
function coverVariableDeclarator(path) {
this.insertStatementCounter(path.get('init'));
}
function skipInit(path) {
if (path.node.init) {
this.setAttr(path.node.init, 'skip-all', true);
}
}
function makeBlock(path) {
const T = this.types;
if (!path.node) {
path.replaceWith(T.blockStatement([]));
}
if (!path.isBlockStatement()) {
path.replaceWith(T.blockStatement([path.node]));
path.node.loc = path.node.body[0].loc;
}
}
function blockProp(prop) {
return function (path) {
makeBlock.call(this, path.get(prop));
};
}
function convertArrowExpression(path) {
const n = path.node;
const T = this.types;
if (n.expression) {
const bloc = n.body.loc;
n.expression = false;
n.body = T.blockStatement([
T.returnStatement(
n.body
)
]);
// restore body location
n.body.loc = bloc;
// set up the location for the return statement so it gets
// instrumented
n.body.body[0].loc = bloc;
}
}
function coverIfBranches(path) {
const n = path.node,
hint = this.hintFor(n),
ignoreIf = hint === 'if',
ignoreElse = hint === 'else',
branch = this.cov.newBranch('if', n.loc);
if (ignoreIf) {
this.setAttr(n.consequent, 'skip-all', true);
} else {
this.insertBranchCounter(path.get('consequent'), branch, n.loc);
}
if (ignoreElse) {
this.setAttr(n.alternate, 'skip-all', true);
} else {
this.insertBranchCounter(path.get('alternate'), branch, n.loc);
}
}
function createSwitchBranch(path) {
const b = this.cov.newBranch('switch', path.node.loc);
this.setAttr(path.node, 'branchName', b);
}
function coverSwitchCase(path) {
const T = this.types;
const b = this.getAttr(path.parentPath.node, 'branchName');
/* istanbul ignore if: paranoid check */
if (b === null) {
throw new Error('Unable to get switch branch name');
}
const increment = this.getBranchIncrement(b, path.node.loc);
path.node.consequent.unshift(T.expressionStatement(increment));
}
function coverTernary(path) {
const n = path.node,
branch = this.cov.newBranch('cond-expr', path.node.loc),
cHint = this.hintFor(n.consequent),
aHint = this.hintFor(n.alternate);
if (cHint !== 'next') {
this.insertBranchCounter(path.get('consequent'), branch);
}
if (aHint !== 'next') {
this.insertBranchCounter(path.get('alternate'), branch);
}
}
function coverLogicalExpression(path) {
const T = this.types;
if (path.parentPath.node.type === "LogicalExpression") {
return; // already processed
}
let leaves = [];
this.findLeaves(path.node, leaves);
const b = this.cov.newBranch("binary-expr", path.node.loc);
for (let i = 0; i < leaves.length; i += 1) {
const leaf = leaves[i];
const hint = this.hintFor(leaf.node);
if (hint === 'next') {
continue;
}
const increment = this.getBranchIncrement(b, leaf.node.loc);
if (!increment) {
continue;
}
leaf.parent[leaf.property] = T.sequenceExpression([increment, leaf.node]);
}
}
const codeVisitor = {
ArrowFunctionExpression: entries(convertArrowExpression, coverFunction),
AssignmentPattern: entries(coverAssignmentPattern),
BlockStatement: entries(), // ignore processing only
ClassMethod: entries(coverFunction),
ExpressionStatement: entries(coverStatement),
BreakStatement: entries(coverStatement),
ContinueStatement: entries(coverStatement),
DebuggerStatement: entries(coverStatement),
ReturnStatement: entries(coverStatement),
ThrowStatement: entries(coverStatement),
TryStatement: entries(coverStatement),
VariableDeclaration: entries(), // ignore processing only
VariableDeclarator: entries(coverVariableDeclarator),
IfStatement: entries(blockProp('consequent'), blockProp('alternate'), coverStatement, coverIfBranches),
ForStatement: entries(blockProp('body'), skipInit, coverStatement),
ForInStatement: entries(blockProp('body'), skipInit, coverStatement),
ForOfStatement: entries(blockProp('body'), skipInit, coverStatement),
WhileStatement: entries(blockProp('body'), coverStatement),
DoWhileStatement: entries(blockProp('body'), coverStatement),
SwitchStatement: entries(createSwitchBranch, coverStatement),
SwitchCase: entries(coverSwitchCase),
WithStatement: entries(blockProp('body'), coverStatement),
FunctionDeclaration: entries(coverFunction),
FunctionExpression: entries(coverFunction),
LabeledStatement: entries(coverStatement),
ConditionalExpression: entries(coverTernary),
LogicalExpression: entries(coverLogicalExpression)
};
// the template to insert at the top of the program.
const coverageTemplate = template(`
var COVERAGE_VAR = (function () {
var path = PATH,
hash = HASH,
global = (new Function('return this'))(),
gcv = GLOBAL_COVERAGE_VAR,
coverageData = INITIAL,
coverage = global[gcv] || (global[gcv] = {});
if (coverage[path] && coverage[path].hash === hash) {
return coverage[path];
}
coverageData.hash = hash;
return coverage[path] = coverageData;
})();
`);
/**
* programVisitor is a `babel` adaptor for instrumentation.
* It returns an object with two methods `enter` and `exit`.
* These should be assigned to or called from `Program` entry and exit functions
* in a babel visitor.
* These functions do not make assumptions about the state set by Babel and thus
* can be used in a context other than a Babel plugin.
*
* The exit function returns an object that currently has the following keys:
*
* `fileCoverage` - the file coverage object created for the source file.
* `sourceMappingURL` - any source mapping URL found when processing the file.
*
* @param {Object} types - an instance of babel-types
* @param {string} sourceFilePath - the path to source file
* @param {Object} opts - additional options
* @param {string} [opts.coverageVariable=__coverage__] the global coverage variable name.
* @param {object} [opts.inputSourceMap=undefined] the input source map, that maps the uninstrumented code back to the
* original code.
*/
module.exports = function programVisitor (types, sourceFilePath = 'unknown.js', opts = {coverageVariable: '__coverage__', inputSourceMap: undefined, changeList: []}) {
const T = types;
const visitState = new VisitState(types, sourceFilePath, opts.inputSourceMap, opts.changeList);
return {
enter(path) {
path.traverse(codeVisitor, visitState);
},
exit(path) {
visitState.cov.freeze();
const coverageData = visitState.cov.toJSON();
coverageData[MAGIC_KEY] = MAGIC_VALUE;
const hash = createHash(SHA).update(JSON.stringify(coverageData)).digest('hex');
const coverageNode = T.valueToNode(coverageData);
delete coverageData[MAGIC_KEY];
const cv = coverageTemplate({
GLOBAL_COVERAGE_VAR: T.stringLiteral(opts.coverageVariable),
COVERAGE_VAR: T.identifier(visitState.varName),
PATH: T.stringLiteral(sourceFilePath),
INITIAL: coverageNode,
HASH: T.stringLiteral(hash)
});
cv._blockHoist = 3;
path.node.body.unshift(cv);
return {
fileCoverage: coverageData,
sourceMappingURL: visitState.sourceMappingURL
};
}
};
}
// export default {
// programVisitor
// }
// export default programVisitor;
src/load-nyc-config-sync.js 0 → 100644
#!/usr/bin/env node
'use strict'
const { loadNycConfig } = require('@istanbuljs/load-nyc-config')
async function main () {
const [cwd, nycrcPath] = process.argv.slice(2)
console.log(JSON.stringify(await loadNycConfig({ cwd, nycrcPath })))
}
main().catch(error => {
console.log(JSON.stringify({ 'load-nyc-config-sync-error': error.message }))
})
test/babel-plugin-istanbul.js 0 → 100644
/* eslint-env mocha */
import * as babel from '@babel/core'
import makeVisitor from '../src'
import path from 'path'
require('chai').should()
describe('babel-plugin-istanbul', function () {
context('Babel plugin config', function () {
it('should instrument file if shouldSkip returns false', function () {
var result = babel.transformFileSync('./fixtures/plugin-should-cover.js', {
babelrc: false,
configFile: false,
plugins: [
[makeVisitor, {
include: ['fixtures/plugin-should-cover.js']
}]
]
})
result.code.should.match(/statementMap/)
})
it('should not instrument file if shouldSkip returns true', function () {
var result = babel.transformFileSync('./fixtures/plugin-should-not-cover.js', {
babelrc: false,
configFile: false,
plugins: [
[makeVisitor, {
include: ['fixtures/plugin-should-cover.js']
}]
]
})
result.code.should.not.match(/statementMap/)
})
context('local node_modules', function () {
it('should instrument file if shouldSkip returns false', function () {
var result = babel.transformFileSync('./fixtures/node_modules/should-cover.js', {
babelrc: false,
configFile: false,
plugins: [
[makeVisitor, {
excludeNodeModules: false,
exclude: ['node_modules/**'],
include: ['fixtures/node_modules/should-cover.js']
}]
]
})
result.code.should.match(/statementMap/)
})
it('should not instrument file if shouldSkip returns true', function () {
var result = babel.transformFileSync('./fixtures/node_modules/should-not-cover.js', {
babelrc: false,
configFile: false,
plugins: [
[makeVisitor, {
include: ['fixtures/node_modules/should-not-cover.js']
}]
]
})
result.code.should.not.match(/statementMap/)
})
})
it('should call onCover callback', function () {
var args
babel.transformFileSync('./fixtures/plugin-should-cover.js', {
babelrc: false,
configFile: false,
plugins: [
[makeVisitor, {
onCover: function () {
args = [].slice.call(arguments)
},
include: ['fixtures/plugin-should-cover.js']
}]
]
})
args[0].should.equal(path.resolve('./fixtures/plugin-should-cover.js'))
args[1].statementMap.should.exist // eslint-disable-line
})
})
context('source maps', function () {
it('should use inline source map', function () {
var result = babel.transformFileSync('./fixtures/has-inline-source-map.js', {
babelrc: false,
configFile: false,
plugins: [
[makeVisitor, {
include: ['fixtures/has-inline-source-map.js']
}]
]
})
result.code.should.match(/inputSourceMap/)
})
it('should not use inline source map if inputSourceMap is set to false', function () {
var result = babel.transformFileSync('./fixtures/has-inline-source-map.js', {
babelrc: false,
configFile: false,
plugins: [
[makeVisitor, {
include: ['fixtures/has-inline-source-map.js'],
useInlineSourceMaps: false
}]
]
})
result.code.should.not.match(/inputSourceMap/)
})
it('should use provided source map', function () {
var result = babel.transformFileSync('./fixtures/has-inline-source-map.js', {
babelrc: false,
configFile: false,
plugins: [
[makeVisitor, {
include: ['fixtures/has-inline-source-map.js'],
inputSourceMap: { asdfQwer: 'foo' }
}]
]
})
result.code.should.match(/inputSourceMap:\s*{\s*asdfQwer: "foo"\s*}/)
})
})
context('instrument options', function () {
it('should honor coverageVariable option', function () {
const result = babel.transformFileSync('./fixtures/should-cover.js', {
babelrc: false,
configFile: false,
plugins: [
[makeVisitor, {
include: ['fixtures/should-cover.js'],
coverageVariable: '__TEST_VARIABLE__'
}]
]
})
result.code.should.match(/__TEST_VARIABLE__/)
result.code.should.not.match(/__coverage__/)
})
it('should honor coverageGlobalScope option', function () {
const result = babel.transformFileSync('./fixtures/should-cover.js', {
babelrc: false,
configFile: false,
plugins: [
[makeVisitor, {
include: ['fixtures/should-cover.js'],
coverageGlobalScope: 'window'
}]
]
})
result.code.should.match(/new Function\("return window"\)/)
result.code.should.not.match(/new Function\("return this"\)/)
})
it('should honor coverageGlobalScope option', function () {
const result = babel.transformFileSync('./fixtures/should-cover.js', {
babelrc: false,
configFile: false,
plugins: [
[makeVisitor, {
include: ['fixtures/should-cover.js'],
coverageGlobalScopeFunc: false
}]
]
})
result.code.should.match(/global\s*=\s*this/)
result.code.should.not.match(/global\s*=\s*new Function\("return this"\)/)
})
it('should honor ignoreClassMethods option', function () {
const result = babel.transformFileSync('./fixtures/class-functions.js', {
babelrc: false,
configFile: false,
plugins: [
[makeVisitor, {
include: ['fixtures/class-functions.js'],
ignoreClassMethods: ['bar']
}]
]
})
// bar() is ignored
result.code.should.match(/bar\(\)\s*{\s*}/)
result.code.should.not.match(/bar\(\)\s*{\s*cov_.*/)
// barz() does not get instrumented
result.code.should.match(/barz\(\)\s*{\s*cov_.*/)
result.code.should.not.match(/barz\(\)\s*{\s*}/)
})
})
context('package.json "nyc" config', function () {
context('process.env.NYC_CONFIG is set', function () {
it('should instrument file if shouldSkip returns false', function () {
var result = babel.transformFileSync('./fixtures/should-cover.js', {
babelrc: false,
configFile: false,
plugins: [
makeVisitor
]
})
result.code.should.match(/statementMap/)
})
it('should not instrument file if shouldSkip returns true', function () {
var result = babel.transformFileSync('./fixtures/should-not-cover.js', {
babelrc: false,
configFile: false,
plugins: [
makeVisitor
]
})
result.code.should.not.match(/statementMap/)
})
})
context('process.env.NYC_CONFIG is not set', function () {
this.timeout(10000)
const OLD_NYC_CONFIG = process.env.NYC_CONFIG
const OLD_NYC_CWD = process.env.NYC_CWD
before(() => {
delete process.env.NYC_CONFIG
delete process.env.NYC_CWD
})
after(() => {
process.env.NYC_CONFIG = OLD_NYC_CONFIG
process.env.NYC_CWD = OLD_NYC_CWD
})
it('should instrument file if shouldSkip returns false', function () {
var result = babel.transformFileSync('./fixtures/should-cover.js', {
babelrc: false,
configFile: false,
plugins: [
makeVisitor
]
})
result.code.should.match(/statementMap/)
})
it('should not instrument file if shouldSkip returns true', function () {
var result = babel.transformFileSync('./fixtures/should-not-cover.js', {
babelrc: false,
configFile: false,
plugins: [
makeVisitor
]
})
result.code.should.not.match(/statementMap/)
})
it('should load config using cwd', function () {
const cwd = path.resolve(__dirname, '..', 'fixtures', 'config')
function helper (file, match, opts) {
const result = babel.transformFileSync(
path.resolve(cwd, file),
{
babelrc: false,
configFile: false,
plugins: [
[makeVisitor, { cwd, ...opts }]
]
}
)
if (match) {
result.code.should.match(/statementMap/)
} else {
result.code.should.not.match(/statementMap/)
}
}
helper('file1.js', true)
helper('file2.js', false)
helper('file1.js', false, { nycrcPath: 'nyc-alt.config.js' })
helper('file2.js', true, { nycrcPath: 'nyc-alt.config.js' })
;(function () {
babel.transformFileSync(
path.resolve(cwd, 'file1.js'),
{
babelrc: false,
configFile: false,
plugins: [
[makeVisitor, { cwd, nycrcPath: 'missing-config.js' }]
]
}
)
}).should.throw(/Requested configuration file missing-config.js not found/)
})
})
})
// TODO: setup istanbul-lib-instrument, such that we can
// run various babel configurations.
context('regression tests', () => {
// regression test for https://github.com/istanbuljs/babel-plugin-istanbul/issues/78
it('should instrument: export const foo = () => {}', function () {
var result = babel.transformFileSync('./fixtures/issue-78.js', {
babelrc: false,
configFile: false,
plugins: [
[makeVisitor, {
include: ['fixtures/issue-78.js']
}]
]
})
result.code.match(/statementMap/)
})
// regression test for https://github.com/istanbuljs/babel-plugin-istanbul/issues/201
it('should not conflict with transform-modules-commonjs', function () {
var result = babel.transformFileSync('./fixtures/issue-201.js', {
babelrc: false,
configFile: false,
plugins: [
[makeVisitor, {
include: ['fixtures/issue-201.js']
}],
'@babel/plugin-transform-modules-commonjs'
]
})
result.code.should.match(/_path.*\.resolve\)\(_path\)/)
result.code.should.not.match(/_path\.resolve\)\(_path\)/)
})
})
})
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment