gulp-eslint-new 0.4.0

package/LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 ADAMETRY
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,282 @@
+# gulp-eslint-new · [![npm version][npm badge]][npm URL]
+
+> A [gulp](https://gulpjs.com/) plugin to lint code with [ESLint](https://eslint.org/) 8
+
+## Installation
+
+[Use](https://docs.npmjs.com/cli/install) [npm](https://docs.npmjs.com/about-npm).
+
+```
+npm install gulp-eslint-new
+```
+
+## Usage
+
+```javascript
+const {src, task} = require('gulp');
+const eslint = require('gulp-eslint-new');
+
+task('default', () => {
+    return src(['scripts/*.js'])
+        // eslint() attaches the lint output to the "eslint" property
+        // of the file object so it can be used by other modules.
+        .pipe(eslint())
+        // eslint.format() outputs the lint results to the console.
+        // Alternatively use eslint.formatEach() (see Docs).
+        .pipe(eslint.format())
+        // To have the process exit with an error code (1) on
+        // lint error, return the stream and pipe to failAfterError last.
+        .pipe(eslint.failAfterError());
+});
+```
+
+Or use the plugin API to do things like:
+
+```javascript
+gulp.src(['**/*.js','!node_modules/**'])
+	.pipe(eslint({
+		rules: {
+			'my-custom-rule': 1,
+			'strict': 2
+		},
+		globals: [
+			'jQuery',
+			'$'
+		],
+		envs: [
+			'browser'
+		]
+	}))
+	.pipe(eslint.formatEach('compact', process.stderr));
+```
+
+For additional examples, look through the [example directory](https://github.com/fasttime/gulp-eslint-new/tree/master/example).
+
+## API
+
+### `eslint()`
+
+*No explicit configuration.* A `.eslintrc` file may be resolved relative to each linted file.
+
+### `eslint(options)`
+
+[ESLint constructor options](https://eslint.org/docs/developer-guide/nodejs-api#parameters).
+Additionally, the following options are supported, mostly for backward compatibility with [gulp-eslint](https://github.com/adametry/gulp-eslint).
+
+#### `options.rules`
+
+Type: `Object`
+
+Set [configuration](https://eslint.org/docs/user-guide/configuring/rules#configuring-rules) of [rules](https://eslint.org/docs/rules/).
+
+```javascript
+{
+	"rules":{
+		"camelcase": 1,
+		"comma-dangle": 2,
+		"quotes": 0
+	}
+}
+```
+
+_Prefer using `options.overrideConfig.rules` instead._
+
+#### `options.globals`
+
+Type: `Array`
+
+Specify [global variables](https://eslint.org/docs/user-guide/configuring/language-options#specifying-globals) to declare.
+
+```javascript
+{
+	"globals":[
+		"jQuery",
+		"$"
+	]
+}
+```
+
+_Prefer using `options.overrideConfig.globals` instead. Note the different format._
+
+#### `options.fix`
+
+Type: `Boolean`
+
+This option instructs ESLint to try to fix as many issues as possible. The fixes are applied to the gulp stream. The fixed content can be saved to file using `gulp.dest` (See [example/fix.js](https://github.com/fasttime/gulp-eslint-new/blob/master/example/fix.js)). Rules that are fixable can be found in ESLint's [rules list](https://eslint.org/docs/rules/).
+
+When fixes are applied, a "fixed" property is set to `true` on the fixed file's ESLint result.
+
+#### `options.quiet`
+
+Type: `Boolean`
+
+When `true`, this option will filter warning messages from ESLint results. This mimics the ESLint CLI [`--quiet` option](https://eslint.org/docs/user-guide/command-line-interface#-quiet).
+
+Type: `function (message, index, list) { return Boolean(); }`
+
+When provided a function, it will be used to filter ESLint result messages, removing any messages that do not return a `true` (or truthy) value.
+
+#### `options.envs`
+
+Type: `Array`
+
+Specify a list of [environments](https://eslint.org/docs/user-guide/configuring/language-options#specifying-environments) to be applied.
+
+_Prefer using `options.overrideConfig.env` instead. Note the different option name and format._
+
+#### `options.rulePaths`
+
+Type: `Array`
+
+This option allows you to specify additional directories from which to load rules files. This is useful when you have custom rules that aren't suitable for being bundled with ESLint. This option works much like the ESLint CLI's [`--rulesdir` option](https://eslint.org/docs/user-guide/command-line-interface#-rulesdir).
+
+#### `options.configFile`
+
+Type: `String`
+
+Path to the ESLint rules configuration file. For more information, see the ESLint CLI [`--config` option](https://eslint.org/docs/user-guide/command-line-interface#-c-config) and [Using Configuration Files](https://eslint.org/docs/user-guide/configuring/configuration-files#using-configuration-files).
+
+_Prefer using `options.overrideConfig.configFile` instead._
+
+#### `options.warnFileIgnored` or `options.warnIgnored`
+
+Type: `Boolean`
+
+When `true`, add a result warning when ESLint ignores a file. This can be used to file files that are needlessly being loaded by `gulp.src`. For example, since ESLint automatically ignores "node_modules" file paths and gulp.src does not, a gulp task may take seconds longer just reading files from the "node_modules" directory.
+
+#### `options.useEslintrc`
+
+Type: `Boolean`
+
+When `false`, ESLint will not load [.eslintrc files](https://eslint.org/docs/user-guide/configuring/configuration-files#using-configuration-files).
+
+### `eslint(configFilePath)`
+
+Param type: `String`
+
+Shorthand for defining `options.overrideConfigFile`.
+
+### `eslint.result(action)`
+
+Param type: `function (result) {}`
+
+Call a function for each ESLint file result. No returned value is expected. If an error is thrown, it will be wrapped in a Gulp PluginError and emitted from the stream.
+
+```javascript
+gulp.src(['**/*.js','!node_modules/**'])
+	.pipe(eslint())
+	.pipe(eslint.result(result => {
+	    // Called for each ESLint result.
+	    console.log(`ESLint result: ${result.filePath}`);
+	    console.log(`# Messages: ${result.messages.length}`);
+	    console.log(`# Warnings: ${result.warningCount}`);
+	    console.log(`# Errors: ${result.errorCount}`);
+	}));
+```
+
+Type: `function (result, callback) { callback(error); }`
+
+Call an asynchronous function for each ESLint file result. The callback must be called for the stream to finish. If a value is passed to the callback, it will be wrapped in a Gulp PluginError and emitted from the stream.
+
+
+### `eslint.results(action)`
+
+Param type: `function (results) {}`
+
+Call a function once for all ESLint file results before a stream finishes. No returned value is expected. If an error is thrown, it will be wrapped in a Gulp PluginError and emitted from the stream.
+
+The results list has a "warningCount" property that is the sum of warnings in all results; likewise, an "errorCount" property is set to the sum of errors in all results.
+
+```javascript
+gulp.src(['**/*.js','!node_modules/**'])
+	.pipe(eslint())
+	.pipe(eslint.results(results => {
+    	// Called once for all ESLint results.
+	    console.log(`Total Results: ${results.length}`);
+	    console.log(`Total Warnings: ${results.warningCount}`);
+	    console.log(`Total Errors: ${results.errorCount}`);
+	}));
+```
+
+Param type: `function (results, callback) { callback(error); }`
+
+Call an asynchronous function once for all ESLint file results before a stream finishes. The callback must be called for the stream to finish. If a value is passed to the callback, it will be wrapped in a Gulp PluginError and emitted from the stream.
+
+### `eslint.failOnError()`
+
+Stop a task/stream if an ESLint error has been reported for any file.
+
+```javascript
+// Cause the stream to stop(/fail) before copying an invalid JS file to the output directory
+gulp.src(['**/*.js','!node_modules/**'])
+	.pipe(eslint())
+	.pipe(eslint.failOnError());
+```
+
+### `eslint.failAfterError()`
+
+Stop a task/stream if an ESLint error has been reported for any file, but wait for all of them to be processed first.
+
+```javascript
+// Cause the stream to stop(/fail) when the stream ends if any ESLint error(s) occurred.
+gulp.src(['**/*.js','!node_modules/**'])
+	.pipe(eslint())
+	.pipe(eslint.failAfterError());
+```
+
+### `eslint.format(formatter, output)`
+
+Format all linted files once. This should be used in the stream after piping through `eslint`; otherwise, this will find no ESLint results to format.
+
+The `formatter` argument may be a `String`, `Function`, or `undefined`. As a `String`, a formatter module by that name or path will be resolved as a module, relative to `process.cwd()`, or as one of the [ESLint-provided formatters](https://github.com/eslint/eslint/tree/master/lib/cli-engine/formatters). If `undefined`, the ESLint “stylish” formatter will be resolved. A `Function` will be called with an `Array` of file linting results to format.
+
+```javascript
+// use the default "stylish" ESLint formatter
+eslint.format()
+
+// use the "checkstyle" ESLint formatter
+eslint.format('checkstyle')
+
+// use the "eslint-path-formatter" module formatter
+// (@see https://github.com/Bartvds/eslint-path-formatter)
+eslint.format('node_modules/eslint-path-formatter')
+```
+
+The `output` argument may be a `WritableStream`, `Function`, or `undefined`. As a `WritableStream`, the formatter results will be written to the stream. If `undefined`, the formatter results will be written to [gulp’s log](https://github.com/gulpjs/gulp-util#logmsg). A `Function` will be called with the formatter results as the only parameter.
+
+```javascript
+// write to gulp's log (default)
+eslint.format();
+
+// write messages to stdout
+eslint.format('junit', process.stdout)
+```
+
+### `eslint.formatEach(formatter, output)`
+
+Format each linted file individually. This should be used in the stream after piping through `eslint`; otherwise, this will find no ESLint results to format.
+
+The arguments for `formatEach` are the same as the arguments for `format`.
+
+
+## Configuration
+
+ESLint may be configured explicity by using any of the supported [configuration options](https://eslint.org/docs/user-guide/configuring/). If the [`useEslintrc` option](#optionsuseEslintrc) is not set to `false`, ESLint will attempt to resolve a file by the name of `.eslintrc` within the same directory as the file to be linted. If not found there, parent directories will be searched until `.eslintrc` is found or the directory root is reached.
+
+## Ignore Files
+
+ESLint will ignore files that do not have a `.js` file extension at the point of linting ([some plugins](https://github.com/gulp-community/gulp-coffee) may change file extensions mid-stream). This avoids unintentional linting of non-JavaScript files.
+
+ESLint will also detect an `.eslintignore` file at the cwd or a parent directory. See the [ESLint docs](https://eslint.org/docs/user-guide/configuring/ignoring-code#the-eslintignore-file) to learn how to construct this file.
+
+## Extensions
+
+ESLint results are attached as an "eslint" property to the vinyl files that pass through a Gulp.js stream pipeline. This is available to streams that follow the initial `eslint` stream. The [eslint.result](#result) and [eslint.results](#results) methods are made available to support extensions and custom handling of ESLint results.
+
+#### Gulp-Eslint Extensions:
+
+* [gulp-eslint-if-fixed](https://github.com/lukeapage/gulp-eslint-if-fixed)
+* [gulp-eslint-threshold](https://github.com/krmbkt/gulp-eslint-threshold)
+
+[npm badge]: https://badge.fury.io/js/gulp-eslint-new.svg
+[npm URL]: https://www.npmjs.com/package/gulp-eslint-new

package/index.js

@@ -0,0 +1,204 @@
+'use strict';
+
+const PluginError = require('plugin-error');
+const { ESLint } = require('eslint');
+const {
+	createIgnoreResult,
+	filterResult,
+	firstResultMessage,
+	handleCallback,
+	isErrorMessage,
+	migrateOptions,
+	resolveFormatter,
+	resolveWritable,
+	transform,
+	tryResultAction,
+	writeResults
+} = require('./util');
+const {relative} = require('path');
+
+async function lintFile(linter, file, quiet, warnIgnored) {
+	if (file.isNull()) {
+		return;
+	}
+
+	if (file.isStream()) {
+		throw 'gulp-eslint-new doesn\'t support vinyl files with Stream contents.';
+	}
+
+	const filePath = relative(process.cwd(), file.path);
+	if (await linter.isPathIgnored(filePath)) {
+		// Note:
+		// Vinyl files can have an independently defined cwd, but ESLint works relative to `process.cwd()`.
+		// (https://github.com/gulpjs/gulp/blob/master/docs/recipes/specifying-a-cwd.md)
+		// Also, ESLint doesn't adjust file paths relative to an ancestory .eslintignore path.
+		// E.g., If ../.eslintignore has "foo/*.js", ESLint will ignore ./foo/*.js, instead of ../foo/*.js.
+		// Eslint rolls this into `ESLint.lintText`. So, gulp-eslint-new must account for this limitation.
+
+		if (warnIgnored) {
+			// Warn that gulp.src is needlessly reading files that ESLint ignores
+			file.eslint = createIgnoreResult(file);
+		}
+		return;
+	}
+
+	const [result] = await linter.lintText(file.contents.toString(), { filePath });
+	// Note: Fixes are applied as part of "lintText".
+	// Any applied fix messages have been removed from the result.
+
+	if (quiet) {
+		// ignore warnings
+		file.eslint = filterResult(result, quiet);
+	} else {
+		file.eslint = result;
+	}
+
+	// Update the fixed output; otherwise, fixable messages are simply ignored.
+	if (file.eslint.hasOwnProperty('output')) {
+		file.contents = Buffer.from(file.eslint.output);
+		file.eslint.fixed = true;
+	}
+}
+
+/**
+ * Append ESLint result to each file
+ *
+ * @param {(Object|String)} [options] - Configure rules, env, global, and other options for running ESLint
+ * @returns {stream} gulp file stream
+ */
+function gulpEslint(options) {
+	const { eslintOptions, quiet, warnIgnored } = migrateOptions(options);
+	const linter = new ESLint(eslintOptions);
+
+	return transform((file, enc, cb) => {
+		lintFile(linter, file, quiet, warnIgnored)
+			.then(() => cb(null, file))
+			.catch(error => cb(new PluginError('gulp-eslint-new', error)));
+	});
+}
+
+/**
+ * Handle each ESLint result as it passes through the stream.
+ *
+ * @param {Function} action - A function to handle each ESLint result
+ * @returns {stream} gulp file stream
+ */
+gulpEslint.result = action => {
+	if (typeof action !== 'function') {
+		throw new Error('Expected callable argument');
+	}
+
+	return transform((file, enc, done) => {
+		if (file.eslint) {
+			tryResultAction(action, file.eslint, handleCallback(done, file));
+		} else {
+			done(null, file);
+		}
+	});
+};
+
+/**
+ * Handle all ESLint results at the end of the stream.
+ *
+ * @param {Function} action - A function to handle all ESLint results
+ * @returns {stream} gulp file stream
+ */
+gulpEslint.results = function(action) {
+	if (typeof action !== 'function') {
+		throw new Error('Expected callable argument');
+	}
+
+	const results = [];
+	results.errorCount = 0;
+	results.warningCount = 0;
+
+	return transform((file, enc, done) => {
+		if (file.eslint) {
+			results.push(file.eslint);
+			// collect total error/warning count
+			results.errorCount += file.eslint.errorCount;
+			results.warningCount += file.eslint.warningCount;
+		}
+		done(null, file);
+
+	}, done => {
+		tryResultAction(action, results, handleCallback(done));
+	});
+};
+
+/**
+ * Fail when an ESLint error is found in ESLint results.
+ *
+ * @returns {stream} gulp file stream
+ */
+gulpEslint.failOnError = () => {
+	return gulpEslint.result(result => {
+		const error = firstResultMessage(result, isErrorMessage);
+		if (!error) {
+			return;
+		}
+
+		throw new PluginError('gulp-eslint-new', {
+			name: 'ESLintError',
+			fileName: result.filePath,
+			message: error.message,
+			lineNumber: error.line
+		});
+	});
+};
+
+/**
+ * Fail when the stream ends if any ESLint error(s) occurred
+ *
+ * @returns {stream} gulp file stream
+ */
+gulpEslint.failAfterError = () => {
+	return gulpEslint.results(results => {
+		const count = results.errorCount;
+		if (!count) {
+			return;
+		}
+
+		throw new PluginError('gulp-eslint-new', {
+			name: 'ESLintError',
+			message: 'Failed with ' + count + (count === 1 ? ' error' : ' errors')
+		});
+	});
+};
+
+/**
+ * Format the results of each file individually.
+ *
+ * @param {(String|Function)} [formatter=stylish] - The name or function for a ESLint result formatter
+ * @param {(Function|Stream)} [writable=fancy-log] - A funtion or stream to write the formatted ESLint results.
+ * @returns {stream} gulp file stream
+ */
+gulpEslint.formatEach = (formatter, writable) => {
+	formatter = resolveFormatter(formatter);
+	writable = resolveWritable(writable);
+
+	return gulpEslint.result(result => writeResults([result], formatter, writable));
+};
+
+/**
+ * Wait until all files have been linted and format all results at once.
+ *
+ * @param {(String|Function)} [formatter=stylish] - The name or function for a ESLint result formatter
+ * @param {(Function|stream)} [writable=fancy-log] - A funtion or stream to write the formatted ESLint results.
+ * @returns {stream} gulp file stream
+ */
+gulpEslint.format = (formatter, writable) => {
+	formatter = resolveFormatter(formatter);
+	writable = resolveWritable(writable);
+
+	return gulpEslint.results(results => {
+		// Only format results if files has been lint'd
+		if (results.length) {
+			writeResults(results, formatter, writable);
+		}
+	});
+};
+
+gulpEslint.PluginError = PluginError;
+
+module.exports = gulpEslint;

package/legacy-get-formatter.js

@@ -0,0 +1,68 @@
+/**
+ * @author Nicholas C. Zakas
+ */
+
+'use strict';
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const path = require('path');
+
+const { Legacy: { naming, ModuleResolver } } = require('@eslint/eslintrc');
+
+/**
+ * Returns the formatter representing the given format or null if the `format` is not a string.
+ * @param {string} [format] The name of the format to load or the path to a custom formatter.
+ * @throws {any} As may be thrown by requiring the formatter.
+ * @returns {Function} The formatter function.
+ */
+function getFormatter(format) {
+
+	// default is stylish
+	const resolvedFormatName = format == null ? 'stylish' : `${format}`;
+
+	// replace \ with / for Windows compatibility
+	const normalizedFormatName = resolvedFormatName.replace(/\\/gu, '/');
+
+	const cwd = process.cwd();
+	const namespace = naming.getNamespaceFromTerm(normalizedFormatName);
+
+	let formatterPath;
+
+	// if there's a slash, then it's a file
+	if (!namespace && normalizedFormatName.includes('/')) {
+		formatterPath = path.resolve(cwd, normalizedFormatName);
+	} else {
+		try {
+			const npmFormat
+			= naming.normalizePackageName(normalizedFormatName, 'eslint-formatter');
+
+			formatterPath
+			= ModuleResolver.resolve(npmFormat, path.join(cwd, '__placeholder__.js'));
+		} catch (ex) {
+			const baseDir = require.resolve('eslint');
+			formatterPath
+			= path.resolve(baseDir, '../cli-engine/formatters', normalizedFormatName);
+		}
+	}
+
+	try {
+		return require(formatterPath);
+	} catch (ex) {
+		/* c8 ignore start */
+		if (format === 'table' || format === 'codeframe') {
+			ex.message
+			= `The ${format} formatter is no longer part of core ESLint. Install it manually `
+			+ `with \`npm install -D eslint-formatter-${format}\``;
+			/* c8 ignore stop */
+		} else {
+			ex.message
+			= `There was a problem loading formatter: ${formatterPath}\nError: ${ex.message}`;
+		}
+		throw ex;
+	}
+}
+
+module.exports = getFormatter;

package/package.json

@@ -0,0 +1,58 @@
+{
+	"name": "gulp-eslint-new",
+	"version": "0.4.0",
+	"description": "A gulp plugin to lint code with ESLint 8",
+	"repository": "fasttime/gulp-eslint-new",
+	"files": [
+		"index.js",
+		"legacy-get-formatter.js",
+		"util.js"
+	],
+	"directories": {
+		"example": "example",
+		"test": "test"
+	},
+	"scripts": {
+		"build": "npm install && gulp",
+		"lint": "eslint .",
+		"test": "mocha --check-leaks"
+	},
+	"keywords": [
+		"gulpplugin",
+		"eslint",
+		"gulp",
+		"errors",
+		"warnings",
+		"check",
+		"source",
+		"code",
+		"formatter",
+		"js",
+		"javascript",
+		"task",
+		"lint",
+		"plugin"
+	],
+	"author": "Adametry",
+	"contributors": [
+		"Shinnosuke Watanabe <snnskwtnb@gmail.com> (https://github.com/shinnn)"
+	],
+	"license": "MIT",
+	"dependencies": {
+		"eslint": "^8.0.0",
+		"fancy-log": "^1.3.3",
+		"plugin-error": "^1.0.1"
+	},
+	"devDependencies": {
+		"@babel/core": "^7.15.8",
+		"@babel/eslint-parser": "^7.15.8",
+		"@shinnn/eslint-config": "^7.0.0",
+		"c8": "^7.10.0",
+		"eslint-plugin-eslint-comments": "^3.2.0",
+		"eslint-plugin-node": "^11.1.0",
+		"from2-string": "^1.1.0",
+		"gulp": "^4.0.2",
+		"mocha": "^9.1.2",
+		"vinyl": "^2.2.1"
+	}
+}

package/util.js

@@ -0,0 +1,328 @@
+'use strict';
+
+const {Transform} = require('stream');
+const PluginError = require('plugin-error');
+const fancyLog = require('fancy-log');
+const getFormatter = require('./legacy-get-formatter');
+
+/**
+ * Convenience method for creating a transform stream in object mode
+ *
+ * @param {Function} transform - An async function that is called for each stream chunk
+ * @param {Function} [flush] - An async function that is called before closing the stream
+ * @returns {stream} A transform stream
+ */
+exports.transform = function(transform, flush) {
+	if (typeof flush === 'function') {
+		return new Transform({
+			objectMode: true,
+			transform,
+			flush
+		});
+	}
+
+	return new Transform({
+		objectMode: true,
+		transform
+	});
+};
+
+/**
+ * Mimic the CLIEngine's createIgnoreResult function,
+ * only without the ESLint CLI reference.
+ *
+ * @param {Object} file - file with a "path" property
+ * @returns {Object} An ESLint report with an ignore warning
+ */
+exports.createIgnoreResult = file => {
+	return {
+		filePath: file.path,
+		messages: [{
+			fatal: false,
+			severity: 1,
+			message: file.path.includes('node_modules/') ?
+				'File ignored because it has a node_modules/** path' :
+				'File ignored because of .eslintignore file'
+		}],
+		errorCount: 0,
+		warningCount: 1
+	};
+};
+
+/**
+ * Convert a string array to a boolean map.
+ * @param {string[]|null} keys The keys to assign true.
+ * @param {boolean} defaultValue The default value for each property.
+ * @param {string} displayName The property name which is used in error message.
+ * @returns {Record<string,boolean>} The boolean map.
+ */
+function toBooleanMap(keys, defaultValue, displayName) {
+	if (keys && !Array.isArray(keys)) {
+		throw Error(`${displayName} must be an array.`);
+	}
+	if (keys && keys.length > 0) {
+		return keys.reduce((map, def) => {
+			const [key, value] = def.split(':');
+
+			if (key !== '__proto__') {
+				map[key] = value === undefined ? defaultValue : value === 'true';
+			}
+
+			return map;
+		}, { });
+	}
+}
+
+/**
+ * Create config helper to merge various config sources
+ *
+ * @param {Object} options - options to migrate
+ * @returns {Object} migrated options
+ */
+exports.migrateOptions = function migrateOptions(options = { }) {
+	if (typeof options === 'string') {
+		// basic config path overload: gulpEslint('path/to/config.json')
+		const returnValue = { eslintOptions: { overrideConfigFile: options } };
+		return returnValue;
+	}
+	const {
+		overrideConfig: originalOverrideConfig,
+		quiet,
+		warnFileIgnored,
+		warnIgnored: originalWarnIgnored,
+		...eslintOptions
+	}
+	= options;
+	if (originalOverrideConfig != null && typeof originalOverrideConfig !== 'object') {
+		throw Error('\'overrideConfig\' must be an object or null.');
+	}
+	const overrideConfig = eslintOptions.overrideConfig
+	= originalOverrideConfig != null ? { ...originalOverrideConfig } : { };
+
+	function migrateOption(oldName, newName = oldName, convert = value => value) {
+		const value = eslintOptions[oldName];
+		delete eslintOptions[oldName];
+		if (value !== undefined) {
+			overrideConfig[newName] = convert(value);
+		}
+	}
+
+	{
+		const { configFile } = eslintOptions;
+		delete eslintOptions.configFile;
+		if (configFile !== undefined) {
+			eslintOptions.overrideConfigFile = configFile;
+		}
+	}
+	migrateOption('envs', 'env', envs => toBooleanMap(envs, true, 'envs'));
+	migrateOption('globals', undefined, globals => toBooleanMap(globals, false, 'globals'));
+	migrateOption('ignorePattern', 'ignorePatterns');
+	migrateOption('parser');
+	migrateOption('parserOptions');
+	if (Array.isArray(eslintOptions.plugins)) {
+		migrateOption('plugins');
+	}
+	migrateOption('rules');
+	const warnIgnored = warnFileIgnored !== undefined ? warnFileIgnored : originalWarnIgnored;
+	const returnValue = { eslintOptions, quiet, warnIgnored };
+	return returnValue;
+};
+
+/**
+ * Ensure that callback errors are wrapped in a gulp PluginError
+ *
+ * @param {Function} callback - callback to wrap
+ * @param {Object} [value=] - A value to pass to the callback
+ * @returns {Function} A callback to call(back) the callback
+ */
+exports.handleCallback = (callback, value) => {
+	return err => {
+		if (err != null && !(err instanceof PluginError)) {
+			err = new PluginError(err.plugin || 'gulp-eslint-new', err, {
+				showStack: (err.showStack !== false)
+			});
+		}
+
+		callback(err, value);
+	};
+};
+
+/**
+ * Call sync or async action and handle any thrown or async error
+ *
+ * @param {Function} action - Result action to call
+ * @param {(Object|Array)} result - An ESLint result or result list
+ * @param {Function} done - An callback for when the action is complete
+ */
+exports.tryResultAction = function(action, result, done) {
+	try {
+		if (action.length > 1) {
+			// async action
+			action.call(this, result, done);
+		} else {
+			// sync action
+			action.call(this, result);
+			done();
+		}
+	} catch (error) {
+		done(error == null ? new Error('Unknown Error') : error);
+	}
+};
+
+/**
+ * Get first message in an ESLint result to meet a condition
+ *
+ * @param {Object} result - An ESLint result
+ * @param {Function} condition - A condition function that is passed a message and returns a boolean
+ * @returns {Object} The first message to pass the condition or null
+ */
+exports.firstResultMessage = (result, condition) => {
+	if (!result.messages) {
+		return null;
+	}
+
+	return result.messages.find(condition);
+};
+
+/**
+ * Determine if a message is an error
+ *
+ * @param {Object} message - an ESLint message
+ * @returns {Boolean} whether the message is an error message
+ */
+function isErrorMessage(message) {
+	const level = message.fatal ? 2 : message.severity;
+
+	if (Array.isArray(level)) {
+		return level[0] > 1;
+	}
+
+	return level > 1;
+}
+exports.isErrorMessage = isErrorMessage;
+
+/**
+ * Increment count if message is an error
+ *
+ * @param {Number} count - count of errors
+ * @param {Object} message - an ESLint message
+ * @returns {Number} The number of errors, message included
+ */
+function countErrorMessage(count, message) {
+	return count + Number(isErrorMessage(message));
+}
+
+/**
+ * Increment count if message is a warning
+ *
+ * @param {Number} count - count of warnings
+ * @param {Object} message - an ESLint message
+ * @returns {Number} The number of warnings, message included
+ */
+function countWarningMessage(count, message) {
+	return count + Number(message.severity === 1);
+}
+
+/**
+ * Increment count if message is a fixable error
+ *
+ * @param {Number} count - count of errors
+ * @param {Object} message - an ESLint message
+ * @returns {Number} The number of errors, message included
+ */
+function countFixableErrorMessage(count, message) {
+	return count + Number(isErrorMessage(message) && message.fix !== undefined);
+}
+
+/**
+ * Increment count if message is a fixable warning
+ *
+ * @param {Number} count - count of errors
+ * @param {Object} message - an ESLint message
+ * @returns {Number} The number of errors, message included
+ */
+function countFixableWarningMessage(count, message) {
+	return count + Number(message.severity === 1 && message.fix !== undefined);
+}
+
+/**
+ * Filter result messages, update error and warning counts
+ *
+ * @param {Object} result - an ESLint result
+ * @param {Function} [filter=isErrorMessage] - A function that evaluates what messages to keep
+ * @returns {Object} A filtered ESLint result
+ */
+exports.filterResult = (result, filter) => {
+	if (typeof filter !== 'function') {
+		filter = isErrorMessage;
+	}
+	const messages = result.messages.filter(filter, result);
+	const newResult = {
+		filePath: result.filePath,
+		messages: messages,
+		errorCount: messages.reduce(countErrorMessage, 0),
+		warningCount: messages.reduce(countWarningMessage, 0),
+		fixableErrorCount: messages.reduce(countFixableErrorMessage, 0),
+		fixableWarningCount: messages.reduce(countFixableWarningMessage, 0)
+	};
+
+	if (result.output !== undefined) {
+		newResult.output = result.output;
+	} else {
+		newResult.source = result.source;
+	}
+
+	return newResult;
+};
+
+/**
+ * Resolve formatter from unknown type (accepts string or function)
+ *
+ * @throws TypeError thrown if unable to resolve the formatter type
+ * @param {(String|Function)} [formatter=stylish] - A name to resolve as a formatter. If a function is provided, the same function is returned.
+ * @returns {Function} An ESLint formatter
+ */
+exports.resolveFormatter = (formatter) => {
+	// use ESLint to look up formatter references
+	if (typeof formatter !== 'function') {
+		// load formatter (module, relative to cwd, ESLint formatter)
+		formatter =	getFormatter(formatter);
+	}
+
+	return formatter;
+};
+
+/**
+ * Resolve writable
+ *
+ * @param {(Function|stream)} [writable=fancyLog] - A stream or function to resolve as a format writer
+ * @returns {Function} A function that writes formatted messages
+ */
+exports.resolveWritable = (writable) => {
+	if (!writable) {
+		writable = fancyLog;
+	} else if (typeof writable.write === 'function') {
+		writable = writable.write.bind(writable);
+	}
+	return writable;
+};
+
+/**
+ * Write formatter results to writable/output
+ *
+ * @param {Object[]} results - A list of ESLint results
+ * @param {Function} formatter - A function used to format ESLint results
+ * @param {Function} writable - A function used to write formatted ESLint results
+ */
+exports.writeResults = (results, formatter, writable) => {
+	if (!results) {
+		results = [];
+	}
+
+	const firstResult = results.find(result => result.config);
+
+	const message = formatter(results, firstResult ? firstResult.config : {});
+	if (writable && message != null && message !== '') {
+		writable(message);
+	}
+};