function gulpEslint(options) {
options = util.migrateOptions(options) || {};
const linter = new CLIEngine(options);
function verify(str, filePath) {
const result = linter.executeOnText(str, filePath).results[0];
// Note: Fixes are applied as part of "executeOnText".
// Any applied fix messages have been removed from the result.
if (options.quiet) {
// ignore warnings
return util.filterResult(result, options.quiet);
}
return result;
}
return util.transform((file, enc, cb) => {
const filePath = path.relative(process.cwd(), file.path);
if (file.isNull()) {
cb(null, file);
return;
}
if (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 `CLIEngine.executeOnText`. So, gulp-eslint must account for this limitation.
if (linter.options.ignore && options.warnFileIgnored) {
// Warn that gulp.src is needlessly reading files that ESLint ignores
file.eslint = util.createIgnoreResult(file);
}
cb(null, file);
return;
}
if (file.isStream()) {
file.contents = file.contents.pipe(new BufferStreams((err, buf, done) => {
file.eslint = verify(String(buf), filePath);
// Update the fixed output; otherwise, fixable messages are simply ignored.
if (file.eslint.hasOwnProperty('output')) {
buf = new Buffer(file.eslint.output);
file.eslint.fixed = true;
}
done(null, buf);
cb(null, file);
}));
return;
}
file.eslint = verify(file.contents.toString(), filePath);
// Update the fixed output; otherwise, fixable messages are simply ignored.
if (file.eslint.hasOwnProperty('output')) {
file.contents = new Buffer(file.eslint.output);
file.eslint.fixed = true;
}
cb(null, file);
});
}n/a
() => {
return gulpEslint.results(results => {
const count = results.errorCount;
if (!count) {
return;
}
throw new PluginError('gulp-eslint', {
name: 'ESLintError',
message: 'Failed with ' + count + (count === 1 ? ' error' : ' errors')
});
});
}...
// 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());
});
gulp.task('default', ['lint'], function () {
// This will only run if the lint task is successful...
});
```
...() => {
return gulpEslint.result(result => {
const error = util.firstResultMessage(result, util.isErrorMessage);
if (!error) {
return;
}
throw new PluginError('gulp-eslint', {
name: 'ESLintError',
fileName: result.filePath,
message: error.message,
lineNumber: error.line
});
});
}...
}));
```
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())
...(formatter, writable) => {
formatter = util.resolveFormatter(formatter);
writable = util.resolveWritable(writable);
return gulpEslint.results(results => {
// Only format results if files has been lint'd
if (results.length) {
util.writeResults(results, formatter, writable);
}
});
}...
// So, it's best to have gulp ignore the directory as well.
// Also, Be sure to return the stream from the task;
// Otherwise, the task may end before the stream has finished.
return gulp.src(['**/*.js','!node_modules/**'])
// 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());
});
...(formatter, writable) => {
formatter = util.resolveFormatter(formatter);
writable = util.resolveWritable(writable);
return gulpEslint.result(result => util.writeResults([result], formatter, writable));
}...
// Also, Be sure to return the stream from the task;
// Otherwise, the task may end before the stream has finished.
return gulp.src(['**/*.js','!node_modules/**'])
// 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());
});
gulp.task('default', ['lint'], function () {
...action => {
if (typeof action !== 'function') {
throw new Error('Expected callable argument');
}
return util.transform((file, enc, done) => {
if (file.eslint) {
util.tryResultAction(action, file.eslint, util.handleCallback(done, file));
} else {
done(null, file);
}
});
}...
### eslint(configFilePath)
Type: `String`
Shorthand for defining `options.configFile`.
### eslint.result(action)
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/**'])
...results = function (action) {
if (typeof action !== 'function') {
throw new Error('Expected callable argument');
}
const results = [];
results.errorCount = 0;
results.warningCount = 0;
return util.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 => {
util.tryResultAction(action, results, util.handleCallback(done));
});
}...
```
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)
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.
...file => {
return {
filePath: file.path,
messages: [{
fatal: false,
severity: 1,
message: file.path.indexOf('node_modules/') < 0 ?
'File ignored because of .eslintignore file' :
'File ignored because it has a node_modules/** path'
}],
errorCount: 0,
warningCount: 1
};
}...
// (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 `CLIEngine.executeOnText`. So, gulp-eslint must account for this limitation.
if (linter.options.ignore && options.warnFileIgnored) {
// Warn that gulp.src is needlessly reading files that ESLint ignores
file.eslint = util.createIgnoreResult(file);
}
cb(null, file);
return;
}
if (file.isStream()) {
file.contents = file.contents.pipe(new BufferStreams((err, buf, done) => {
...(result, filter) => {
if (typeof filter !== 'function') {
filter = isErrorMessage;
}
const messages = result.messages.filter(filter, result);
return {
filePath: result.filePath,
messages: messages,
errorCount: messages.reduce(countErrorMessage, 0),
warningCount: messages.reduce(countWarningMessage, 0)
};
}...
function verify(str, filePath) {
const result = linter.executeOnText(str, filePath).results[0];
// Note: Fixes are applied as part of "executeOnText".
// Any applied fix messages have been removed from the result.
if (options.quiet) {
// ignore warnings
return util.filterResult(result, options.quiet);
}
return result;
}
return util.transform((file, enc, cb) => {
const filePath = path.relative(process.cwd(), file.path);
...(result, condition) => {
if (!result.messages) {
return null;
}
return result.messages.find(condition);
}...
/**
* Fail when an ESLint error is found in ESLint results.
*
* @returns {stream} gulp file stream
*/
gulpEslint.failOnError = () => {
return gulpEslint.result(result => {
const error = util.firstResultMessage(result, util.isErrorMessage);
if (!error) {
return;
}
throw new PluginError('gulp-eslint', {
name: 'ESLintError',
fileName: result.filePath,
...(callback, value) => {
return err => {
if (err != null && !(err instanceof gutil.PluginError)) {
err = new gutil.PluginError(err.plugin || 'gulp-eslint', err, {
showStack: (err.showStack !== false)
});
}
callback(err, value);
};
}...
gulpEslint.result = action => {
if (typeof action !== 'function') {
throw new Error('Expected callable argument');
}
return util.transform((file, enc, done) => {
if (file.eslint) {
util.tryResultAction(action, file.eslint, util.handleCallback(done, file));
} else {
done(null, file);
}
});
};
/**
...function isErrorMessage(message) {
const level = message.fatal ? 2 : message.severity;
if (Array.isArray(level)) {
return level[0] > 1;
}
return level > 1;
}n/a
function migrateOptions(options) {
if (typeof options === 'string') {
// basic config path overload: gulpEslint('path/to/config.json')
options = {
configFile: options
};
}
return options;
}...
/**
* 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) {
options = util.migrateOptions(options) || {};
const linter = new CLIEngine(options);
function verify(str, filePath) {
const result = linter.executeOnText(str, filePath).results[0];
// Note: Fixes are applied as part of "executeOnText".
// Any applied fix messages have been removed from the result.
...(formatter) => {
// use ESLint to look up formatter references
if (typeof formatter !== 'function') {
// load formatter (module, relative to cwd, ESLint formatter)
formatter = CLIEngine.getFormatter(formatter) || formatter;
}
return formatter;
}...
* 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=gulp-util.log] - A funtion or stream to write the formatted ESLint results.
* @returns {stream} gulp file stream
*/
gulpEslint.formatEach = (formatter, writable) => {
formatter = util.resolveFormatter(formatter);
writable = util.resolveWritable(writable);
return gulpEslint.result(result => util.writeResults([result], formatter, writable));
};
/**
* Wait until all files have been linted and format all results at once.
...(writable) => {
if (!writable) {
writable = gutil.log;
} else if (typeof writable.write === 'function') {
writable = writable.write.bind(writable);
}
return writable;
}...
*
* @param {(String|Function)} [formatter=stylish] - The name or function for a ESLint result formatter
* @param {(Function|Stream)} [writable=gulp-util.log] - A funtion or stream to write the formatted ESLint results.
* @returns {stream} gulp file stream
*/
gulpEslint.formatEach = (formatter, writable) => {
formatter = util.resolveFormatter(formatter);
writable = util.resolveWritable(writable);
return gulpEslint.result(result => util.writeResults([result], formatter, writable));
};
/**
* Wait until all files have been linted and format all results at once.
*
...transform = function (transform, flush) {
if (typeof flush === 'function') {
return new Transform({
objectMode: true,
transform,
flush
});
}
return new Transform({
objectMode: true,
transform
});
}...
// ignore warnings
return util.filterResult(result, options.quiet);
}
return result;
}
return util.transform((file, enc, cb) => {
const filePath = path.relative(process.cwd(), file.path);
if (file.isNull()) {
cb(null, file);
return;
}
...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);
}
}...
gulpEslint.result = action => {
if (typeof action !== 'function') {
throw new Error('Expected callable argument');
}
return util.transform((file, enc, done) => {
if (file.eslint) {
util.tryResultAction(action, file.eslint, util.handleCallback(done, file));
} else {
done(null, file);
}
});
};
/**
...(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);
}
}...
* @param {(Function|Stream)} [writable=gulp-util.log] - A funtion or stream to write the formatted ESLint results.
* @returns {stream} gulp file stream
*/
gulpEslint.formatEach = (formatter, writable) => {
formatter = util.resolveFormatter(formatter);
writable = util.resolveWritable(writable);
return gulpEslint.result(result => util.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=gulp-util.log] - A funtion or stream to write the formatted ESLint results.
...