/**
* This determines whether the given state and options combination
* should result in the file being ignored and not covered
* Big thanks to babel-plugin-transform-adana and their CC0-1.0 license
* from which this code was mostly copy/pasted
*/
function skip ({ opts, file } = { }) {
if (file && opts) {
const { ignore = [], only } = opts
return util.shouldIgnore(
file.opts.filename,
util.arrayify(ignore, util.regexify),
only ? util.arrayify(only, util.regexify) : null
)
}
return false
}
export default function (opts?: Object = {}) {
if (opts.only != null) only = util.arrayify(opts.only, util.regexify);
if (opts.ignore != null) ignore = util.arrayify(opts.ignore, util.regexify);
if (opts.extensions) hookExtensions(util.arrayify(opts.extensions));
if (opts.cache === false) cache = null;
delete opts.extensions;
delete opts.ignore;
delete opts.cache;
delete opts.only;
extend(transformOpts, opts);
}
process: function (src, filename) {
var isJISON = filename.match(/\.jison$/i);
// Don't bother doing anything to node_modules
if (filename.indexOf('node_modules') === -1 || filename.indexOf('node_modules/dcos-dygraphs') > -1) {
// Don't load image data - it can't be parsed by jest.
if (filename.match(/\.(jpe?g|png|gif|bmp|svg|less|raml)$/i)) {
return '';
}
// Use JISON generator for JISON grammar
if (isJISON) {
src = (new jison.Generator(src)).generate();
}
// Run our modules through Babel before running tests
if (babel.util.canCompile(filename) || isJISON) {
src = babel.transform(src, {
auxiliaryCommentBefore: ' istanbul ignore next ',
filename,
presets: [jestPreset].concat([
'babel-preset-es2015',
'babel-preset-react'
].map(require.resolve)),
retainLines: true,
}).code;
}
// Run our modules through the jest-webpack-alias plugin so we
// can use the webpack alias in tests. By default, jest doesn't work
// with webpack at all. webPackAlias matches filenames against the
// alias settings in webpack.config and rewrites the filename to the
// aliased path.
src = webpackAlias.process(src, filename);
}
return src;
}
const instrumentFile = (content: string, filename: Path): string => {
// NOTE: Keeping these requires inside this function reduces a single run
// time by 2sec if not running in `--coverage` mode
const babel = require('babel-core');
const babelPluginIstanbul = require('babel-plugin-istanbul').default;
if (babel.util.canCompile(filename)) {
return babel.transform(content, {
filename,
auxiliaryCommentBefore: ' istanbul ignore next ',
plugins: [
[
babelPluginIstanbul,
// right now babel-plugin-istanbul doesn't have any configuration
// for bypassing the excludes check, but there is a config for
// overwriting it. `.^` as a regexp that matches nothing.
// @see https://github.com/istanbuljs/test-exclude/issues/7
{exclude: ['.^']},
],
],
retainLines: true,
babelrc: false,
}).code;
}
return content;
};
const createTransformer = options => {
options = Object.assign({}, options, {
auxiliaryCommentBefore: ' istanbul ignore next ',
presets: (options && options.presets || []).concat([jestPreset]),
retainLines: true });
delete options.cacheDirectory;
return {
canInstrument: true,
process(
src,
filename,
config,
preprocessorOptions)
{
let plugins = options.plugins || [];
if (preprocessorOptions && preprocessorOptions.instrument) {
plugins = plugins.concat(require('babel-plugin-istanbul').default);
}
if (babel.util.canCompile(filename)) {
return babel.transform(
src,
Object.assign({}, options, { filename, plugins })).
code;
}
return src;
} };
};
function shouldIgnore(filename) {
if (!ignore && !only) {
return getRelativePath(filename).split(path.sep).indexOf("node_modules") >= 0;
} else {
return util.shouldIgnore(filename, ignore || [], only);
}
}
Babelify.configure = function (opts) {
opts = assign({}, opts);
var extensions = opts.extensions ? babel.util.arrayify(opts.extensions) : null;
var sourceMapRelative = opts.sourceMapRelative;
if (opts.sourceMap !== false) opts.sourceMap = "inline";
// babelify specific options
delete opts.sourceMapRelative;
delete opts.extensions;
delete opts.filename;
// browserify specific options
delete opts._flags;
delete opts.basedir;
delete opts.global;
return function (filename) {
if (!babel.canCompile(filename, extensions)) {
return stream.PassThrough();
}
if (sourceMapRelative) {
filename = path.relative(sourceMapRelative, filename);
}
return new Babelify(filename, opts);
};
};
function shouldIgnore(filename) {
if (!ignore && !only) {
return getRelativePath(filename).split(_path2["default"].sep).indexOf("node_modules") >= 0;
} else {
return _babelCore.util.shouldIgnore(filename, ignore || [], only);
}
}
exports["default"] = function () {
var opts /*:: ?: Object*/ = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
if (opts.only != null) only = _babelCore.util.arrayify(opts.only, _babelCore.util.regexify);
if (opts.ignore != null) ignore = _babelCore.util.arrayify(opts.ignore, _babelCore.util.regexify);
if (opts.extensions) hookExtensions(_babelCore.util.arrayify(opts.extensions));
if (opts.cache === false) cache = null;
delete opts.extensions;
delete opts.ignore;
delete opts.cache;
delete opts.only;
_lodashObjectExtend2["default"](transformOpts, opts);
};
exports.default = function () {
var opts = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
if (opts.only != null) only = _babelCore.util.arrayify(opts.only, _babelCore.util.regexify);
if (opts.ignore != null) ignore = _babelCore.util.arrayify(opts.ignore, _babelCore.util.regexify);
if (opts.extensions) hookExtensions(_babelCore.util.arrayify(opts.extensions));
if (opts.cache === false) cache = null;
delete opts.extensions;
delete opts.ignore;
delete opts.cache;
delete opts.only;
(0, _extend2.default)(transformOpts, opts);
};
require.extensions['.jsx'] = function (module, filename) {
var src = fs.readFileSync(filename, 'utf8');
// Ignore all files within node_modules
if (filename.indexOf('node_modules') === -1 && babel.util.canCompile(filename)) {
var compiled = babel.transform(src, { filename: filename }).code;
return module._compile(compiled, filename);
}
return module;
};
return function (filename) {
if (!babel.util.canCompile(filename, extensions)) {
return stream.PassThrough();
}
if (sourceMapRelative) {
filename = path.relative(sourceMapRelative, filename);
}
return new Babelify(filename, opts);
};
return function (filename) {
if (!babel.util.canCompile(filename, extensions)) {
return stream.PassThrough();
}
var _opts = sourceMapsAbsolute
? assign({sourceFileName: filename}, opts)
: opts;
return new Babelify(filename, _opts);
};
process: function (src, filename) {
// Ignore all files within node_modules
// babel files can be .js, .es, .jsx or .es6
if (filename.indexOf("node_modules") === -1 && babel.util.canCompile(filename)) {
return babel.transform(src, {
filename: filename,
retainLines: true
}).code;
}
return src;
}
process: function (src, filename) {
// Ignore all files within node_modules
// babel files can be .js, .es, .jsx or .es6
if (filename.indexOf("node_modules") === -1 && babel.util.canCompile(filename)) {
return babel.transform(src, {
filename: filename,
retainLines: true,
auxiliaryCommentBefore: 'istanbul ignore next',
plugins: ['transform-runtime']
}).code;
}
return src;
}
const createTransformer = (options: any) => {
options = Object.assign({}, options, {
auxiliaryCommentBefore: ' istanbul ignore next ',
presets: ((options && options.presets) || []).concat([jestPreset]),
retainLines: true,
});
delete options.cacheDirectory;
return {
canInstrument: true,
getCacheKey(
fileData: string,
filename: Path,
configString: string,
{instrument, watch}: TransformOptions,
): string {
return crypto.createHash('md5')
.update(fileData)
.update(configString)
// Don't use the in-memory cache in watch mode because the .babelrc
// file may be modified.
.update(getBabelRC(filename, {useCache: !watch}))
.update(instrument ? 'instrument' : '')
.digest('hex');
},
process(
src: string,
filename: Path,
config: Config,
transformOptions: TransformOptions,
): string {
let plugins = options.plugins || [];
if (transformOptions && transformOptions.instrument) {
plugins = plugins.concat(require('babel-plugin-istanbul').default);
}
if (babel.util.canCompile(filename)) {
return babel.transform(
src,
Object.assign({}, options, {filename, plugins}),
).code;
}
return src;
},
};
};
const createTransformer = options => {
options = Object.assign({}, options, {
auxiliaryCommentBefore: ' istanbul ignore next ',
presets: (options && options.presets || []).concat([jestPreset]),
retainLines: true });
delete options.cacheDirectory;
return {
process(src, filename) {
if (babel.util.canCompile(filename)) {
return babel.transform(
src,
Object.assign({}, options, { filename })).
code;}
return src;} };};
browserify.configure = function (opts) {
opts = assign({}, opts);
var extensions = opts.extensions ? babel.util.arrayify(opts.extensions) : null;
var sourceMapRelative = opts.sourceMapRelative;
if (opts.sourceMap !== false) opts.sourceMap = "inline";
// babelify specific options
delete opts.sourceMapRelative;
delete opts.extensions;
delete opts.filename;
// browserify specific options
delete opts._flags;
delete opts.basedir;
delete opts.global;
return function (filename) {
if (!babel.canCompile(filename, extensions)) {
return through();
}
if (sourceMapRelative) {
filename = path.relative(sourceMapRelative, filename);
}
var data = "";
var write = function (buf, enc, callback) {
data += buf;
callback();
};
var end = function (callback) {
opts.filename = filename;
try {
this.push(babel.transform(data, opts).code);
} catch(err) {
this.emit("error", err);
}
callback();
};
return through(write, end);
};
};
browserify.configure = function (opts) {
opts = opts || {};
if (opts.sourceMap !== false) opts.sourceMap = "inline" ;
if (opts.extensions) opts.extensions = babel.util.arrayify(opts.extensions);
return function (filename) {
if (!babel.canCompile(filename, opts.extensions)) {
return through();
}
if (opts.sourceMapRelative) {
filename = path.relative(opts.sourceMapRelative, filename);
}
var data = "";
var write = function (buf) {
data += buf;
};
var end = function () {
var opts2 = clone(opts);
delete opts2.sourceMapRelative;
delete opts2.extensions;
delete opts2.global;
opts2.filename = filename;
try {
var out = babel.transform(data, opts2).code;
} catch(err) {
stream.emit("error", err);
stream.queue(null);
return;
}
stream.queue(out);
stream.queue(null);
};
var stream = through(write, end);
return stream;
};
};
Babelify.configure = function (opts) {
opts = assign({}, opts);
var extensions = opts.extensions ? babel.util.arrayify(opts.extensions) : null;
var sourceMapsAbsolute = opts.sourceMapsAbsolute;
if (opts.sourceMaps !== false) opts.sourceMaps = "inline";
// babelify specific options
delete opts.sourceMapsAbsolute;
delete opts.extensions;
delete opts.filename;
// babelify backwards-compat
delete opts.sourceMapRelative;
// browserify specific options
delete opts._flags;
delete opts.basedir;
delete opts.global;
// browserify cli options
delete opts._;
// "--opt [ a b ]" and "--opt a --opt b" are allowed:
if (opts.ignore && opts.ignore._) opts.ignore = opts.ignore._;
if (opts.only && opts.only._) opts.only = opts.only._;
if (opts.plugins && opts.plugins._) opts.plugins = opts.plugins._;
if (opts.presets && opts.presets._) opts.presets = opts.presets._;
return function (filename) {
if (!babel.util.canCompile(filename, extensions)) {
return stream.PassThrough();
}
var _opts = sourceMapsAbsolute
? assign({sourceFileName: filename}, opts)
: opts;
return new Babelify(filename, _opts);
};
};
const createTransformer = (options) => {
options = Object.assign({}, options, {
plugins: (options && options.plugins) || [],
presets: ((options && options.presets) || []).concat([jestPreset]),
retainLines: true,
});
delete options.cacheDirectory;
delete options.filename;
return {
canInstrument: false,
getCacheKey(fileData) {
return crypto.createHash('md5').update(fileData).digest('hex');
},
process(src, filename) {
if (!babel.util.canCompile(filename)) {
return src;
}
const theseOptions = Object.assign({ filename }, options);
return babel.transform(src, theseOptions).code;
},
};
};
module.exports = function (opts) {
opts = _.defaults(opts || {}, {
options: {},
dest: "cache",
src: "assets",
ignore: false
});
opts.ignore = babel.util.regexify(opts.ignore);
var cache = Object.create(null);
return function (req, res, next) {
if (opts.ignore.test(req.url)) return next();
if (!babel.util.canCompile(req.url)) return next();
var pathname = path.normalize(url.parse(req.url).pathname);
var dest = path.join(opts.dest, pathname);
var src = path.join(opts.src, pathname);
var srcStat;
var send = function (data) {
res.setHeader("Content-Type", "application/javascript");
res.end(data);
};
var write = function (transformed) {
mkdirp(path.dirname(dest), function (err) {
if (err) return next(err);
fs.writeFile(dest, transformed, function (err) {
if (err) {
next(err);
} else {
cache[pathname] = +srcStat.mtime;
send(transformed);
}
});
})
};
var compile = function () {
var transformOpts = _.clone(opts.options);
transformOpts.sourceFileName = "babel:///" + src.replace(opts.src, "");
babel.transformFile(src, transformOpts, function (err, result) {
if (err) {
next(err);
} else {
write(result.code);
}
});
};
var tryCache = function () {
fs.readFile(dest, function (err, data) {
if (err && err.code === "ENOENT") {
compile();
} else if (err) {
next(err);
} else {
send(data);
}
});
};
fs.stat(src, function (err, stat) {
srcStat = stat;
if (err && err.code === "ENOENT") {
next();
} else if (err) {
next(err);
} else if (cache[pathname] === +stat.mtime) {
tryCache();
} else {
compile();
}
});
};
};
if (!filenames.length) {
errors.push("--watch requires filenames");
}
}
if (errors.length) {
console.error(errors.join(". "));
process.exit(2);
}
//
var opts = exports.opts = {};
each(options, function (opt, key) {
opts[key] = commander[key];
});
opts.ignore = util.arrayify(opts.ignore, util.regexify);
opts.only = util.arrayify(opts.only, util.regexify);
var fn;
if (commander.outDir) {
fn = require("./dir");
} else {
fn = require("./file");
}
fn(commander, filenames, exports.opts);
/**
* Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*/
'use strict';
const babel = require('babel-core');
const jestPreset = require('babel-preset-jest');
module.exports = {
process(src, filename) {
if (babel.util.canCompile(filename)) {
return babel.transform(src, {
auxiliaryCommentBefore: ' istanbul ignore next ',
filename,
presets: [jestPreset],
retainLines: true,
}).code.replace(/function\s_interop/g,
' /* istanbul ignore next */ function _interop');
}
return src;
},
};
return readdir(filename).filter(function (filename) {
return util.canCompile(filename);
});
commander.option("-x, --extensions [extensions]", "List of extensions to compile when a directory has been input [.es6,.js,.es,.jsx]");
commander.option("-w, --watch", "Recompile files on changes");
commander.option("-o, --out-file [out]", "Compile all input files into a single file");
commander.option("-d, --out-dir [out]", "Compile an input directory of modules into an output directory");
commander.option("-D, --copy-files", "When compiling a directory copy over non-compilable files");
commander.option("-q, --quiet", "Don't log anything");
let pkg = require("../../package.json");
commander.version(pkg.version + " (babel-core " + require("babel-core").version + ")");
commander.usage("[options] <files ...>");
commander.parse(process.argv);
//
if (commander.extensions) {
commander.extensions = util.arrayify(commander.extensions);
}
//
let errors = [];
let filenames = commander.args.reduce(function (globbed, input) {
let files = glob.sync(input);
if (!files.length) files = [input];
return globbed.concat(files);
}, []);
filenames = uniq(filenames);
each(filenames, function (filename) {
const createTransformer = (options: any): Transformer => {
const cache = Object.create(null);
const getBabelRC = filename => {
const paths = [];
let directory = filename;
while (directory !== (directory = path.dirname(directory))) {
if (cache[directory]) {
break;
}
paths.push(directory);
const configFilePath = path.join(directory, BABELRC_FILENAME);
if (fs.existsSync(configFilePath)) {
cache[directory] = fs.readFileSync(configFilePath, 'utf8');
break;
}
const configJsFilePath = path.join(directory, BABELRC_JS_FILENAME);
if (fs.existsSync(configJsFilePath)) {
// $FlowFixMe
cache[directory] = JSON.stringify(require(configJsFilePath));
break;
}
const resolvedJsonFilePath = path.join(directory, PACKAGE_JSON);
const packageJsonFilePath =
resolvedJsonFilePath === PACKAGE_JSON
? path.resolve(directory, PACKAGE_JSON)
: resolvedJsonFilePath;
if (fs.existsSync(packageJsonFilePath)) {
// $FlowFixMe
const packageJsonFileContents = require(packageJsonFilePath);
if (packageJsonFileContents[BABEL_CONFIG_KEY]) {
cache[directory] = JSON.stringify(
packageJsonFileContents[BABEL_CONFIG_KEY],
);
break;
}
}
}
paths.forEach(directoryPath => (cache[directoryPath] = cache[directory]));
return cache[directory] || '';
};
options = Object.assign({}, options, {
plugins: (options && options.plugins) || [],
presets: ((options && options.presets) || []).concat([jestPreset]),
sourceMaps: 'both',
});
delete options.cacheDirectory;
delete options.filename;
return {
canInstrument: true,
getCacheKey(
fileData: string,
filename: Path,
configString: string,
{instrument, rootDir}: CacheKeyOptions,
): string {
return crypto
.createHash('md5')
.update(THIS_FILE)
.update('\0', 'utf8')
.update(fileData)
.update('\0', 'utf8')
.update(path.relative(rootDir, filename))
.update('\0', 'utf8')
.update(configString)
.update('\0', 'utf8')
.update(getBabelRC(filename))
.update('\0', 'utf8')
.update(instrument ? 'instrument' : '')
.digest('hex');
},
process(
src: string,
filename: Path,
config: ProjectConfig,
transformOptions?: TransformOptions,
): string | TransformedSource {
const altExts = config.moduleFileExtensions.map(
extension => '.' + extension,
);
if (babelUtil && !babelUtil.canCompile(filename, altExts)) {
return src;
}
const theseOptions = Object.assign({filename}, options);
if (transformOptions && transformOptions.instrument) {
theseOptions.auxiliaryCommentBefore = ' istanbul ignore next ';
// Copied from jest-runtime transform.js
theseOptions.plugins = theseOptions.plugins.concat([
[
babelIstanbulPlugin,
{
// files outside `cwd` will not be instrumented
cwd: config.rootDir,
exclude: [],
},
],
]);
}
// babel v7 might return null in the case when the file has been ignored.
const transformResult = babelTransform(src, theseOptions);
if (!transformResult) {
return src;
}
const shouldReturnCodeOnly =
transformOptions == null ||
transformOptions.returnSourceString == null ||
transformOptions.returnSourceString === true;
return shouldReturnCodeOnly ? transformResult.code : transformResult;
},
};
};
const babelIgnoreRegexes = transpilationConfig.skip.map(item => {
return babelCore.util.regexify(item);
});
export function shouldIgnore(loc) {
return util.shouldIgnore(loc, index.opts.ignore, index.opts.only);
}