Security News
ESLint is Now Language-Agnostic: Linting JSON, Markdown, and Beyond
ESLint has added JSON and Markdown linting support with new officially-supported plugins, expanding its versatility beyond JavaScript.
standard-engine
Advanced tools
The standard-engine npm package is a tool for creating JavaScript style guides and enforcing code style rules. It provides a way to define and apply custom linting rules, ensuring code consistency and quality across projects.
Linting
This feature allows you to create a custom linter using standard-engine. You can define your own linting rules and apply them to your project files.
const standardEngine = require('standard-engine');
const opts = {
cmd: 'my-linter',
version: '1.0.0',
homepage: 'https://example.com',
bugs: 'https://example.com/issues',
eslintConfig: {
configFile: 'path/to/eslint/config'
}
};
const linter = standardEngine.linter(opts);
linter.lintFiles(['src/**/*.js'], (err, results) => {
if (err) throw err;
console.log(results);
});
Fixing
This feature allows you to automatically fix linting errors in your code. By setting the `fix` option to true, standard-engine will attempt to correct any issues it finds.
const standardEngine = require('standard-engine');
const opts = {
cmd: 'my-linter',
version: '1.0.0',
homepage: 'https://example.com',
bugs: 'https://example.com/issues',
eslintConfig: {
configFile: 'path/to/eslint/config'
}
};
const linter = standardEngine.linter(opts);
linter.lintFiles(['src/**/*.js'], { fix: true }, (err, results) => {
if (err) throw err;
console.log(results);
});
Custom Reporters
This feature allows you to use custom reporters to format the linting results. You can define your own formatter and pass it to standard-engine.
const standardEngine = require('standard-engine');
const opts = {
cmd: 'my-linter',
version: '1.0.0',
homepage: 'https://example.com',
bugs: 'https://example.com/issues',
eslintConfig: {
configFile: 'path/to/eslint/config'
},
customFormatter: require('my-custom-formatter')
};
const linter = standardEngine.linter(opts);
linter.lintFiles(['src/**/*.js'], (err, results) => {
if (err) throw err;
console.log(results);
});
ESLint is a widely-used JavaScript linter that helps you find and fix problems in your JavaScript code. It is highly configurable and supports custom rules, plugins, and configurations. Compared to standard-engine, ESLint is more flexible and has a larger community and ecosystem.
Prettier is an opinionated code formatter that enforces a consistent style by parsing your code and re-printing it with its own rules. While it focuses more on code formatting rather than linting, it can be used in conjunction with linters like ESLint. Compared to standard-engine, Prettier is more focused on code formatting rather than enforcing specific linting rules.
JSHint is a static code analysis tool used to detect errors and potential problems in JavaScript code. It is less configurable than ESLint but still provides a good set of default rules. Compared to standard-engine, JSHint is simpler and less flexible but can be easier to set up for basic linting needs.
Wrap your own eslint rules in a easy-to-use command line tool and/or a JS module.
npm install standard-engine
standard-engine
?Here is a list of packages using standard-engine
. Dive into them for ideas!
standard
with semicolons sprinkled on top.Did you make your own? Create a pull request and we will add it to the README!
Create the files below and fill in your own values for options.js
.
index.js
// programmatic usage
var Linter = require('standard-engine').linter
var opts = require('./options.js')
module.exports = new Linter(opts)
cli.js
#!/usr/bin/env node
var opts = require('../options.js')
require('standard-engine').cli(opts)
options.js
var eslint = require('eslint')
var path = require('path')
var pkg = require('./package.json')
module.exports = {
// homepage, version and bugs pulled from package.json
version: pkg.version,
homepage: pkg.homepage,
bugs: pkg.bugs.url,
eslint: eslint, // pass any version of eslint >= 1.0.0
cmd: 'pocketlint', // should match the "bin" key in your package.json
tagline: 'Live by your own standards!', // displayed in output --help
eslintConfig: {
configFile: path.join(__dirname, 'eslintrc.json')
},
cwd: '' // current working directory, passed to eslint
}
Additionally an optional parseOpts()
function can be provided. See below for details.
eslintrc.json Put all your .eslintrc rules in this file. A good practice is to create an ESLint Shareable Config and extend it, but its not required:
{
// pretend that the package eslint-config-pocketlint exists!
"extends": ["pocketlint"]
}
Take a look at eslint-config-standard as an example, or if you want to extend/mutate standard
, see eslint-config-semistandard.
linter-js-standard-engine is an Atom plugin that supports some of
the more popular standard-engine implementations out of the box. It detects them
by scanning through the dependencies of the project that you are editing.
You can use it with any other implementation through configuration in the
projects package.json
file.
The paths node_modules/**
, *.min.js
, bundle.js
, coverage/**
, hidden files/folders
(beginning with .
), and all patterns in a project's root .gitignore
file are
automatically ignored.
Sometimes you need to ignore additional folders or specific minfied files. To do that, add
a ignore
property to package.json
:
"pocketlint": { // this key should equal the value of cmd in options.js
"ignore": [
"**/out/",
"/lib/select2/",
"/lib/ckeditor/",
"tmp.js"
]
}
Some files are ignored by default:
var DEFAULT_IGNORE = [
'**/*.min.js',
'**/bundle.js',
'coverage/**',
'node_modules/**',
'vendor/**'
]
You can disable these default ignores by setting noDefaultIgnore
option to true
.
Since standard-engine
uses eslint
under-the-hood, you can
hide warnings as you normally would if you used eslint
directly.
To get verbose output (so you can find the particular rule name to ignore), run:
$ pocketlint --verbose
Error: Live by your own standards!
routes/error.js:20:36: 'file' was used before it was defined. (no-use-before-define)
Disable all rules on a specific line:
file = 'I know what I am doing' // eslint-disable-line
Or, disable only the "no-use-before-define"
rule:
file = 'I know what I am doing' // eslint-disable-line no-use-before-define
Or, disable the "no-use-before-define"
rule for multiple lines:
/*eslint-disable no-use-before-define */
// offending code here...
// offending code here...
// offending code here...
/*eslint-enable no-use-before-define */
package.json
standard-engine
will also look in a project's package.json
and respect any global variables defined like so:
{
"pocketlint": { // this key should equal the value of cmd in options.js
"globals": [ // can be a string or an array of strings
"myVar1",
"myVar2"
]
}
}
You may use global
as an alias for globals
(just don't specify both).
package.json
Additional ESLint plugins can be specified like so:
{
"pocketlint": { // this key should equal the value of cmd in options.js
"plugins": [ // can be a string or an array of strings
"flowtype"
]
}
}
You may use plugin
as an alias for plugins
(just don't specify both). Plugins must be installed (example: npm install eslint-plugin-flowtype
or globally: npm install eslint-plugin-flowtype -g
).
package.json
Additional environments can be specified like so:
{
"pocketlint": { // this key should equal the value of cmd in options.js
"envs": [ "browser", "mocha" ]
}
}
envs
can be a string, an array of strings, or an object. In the latter case the keys are used as the environment name, but falsy values mean the environment is not actually loaded. You cannot unload environments by setting a falsy value.
You may use env
as an alias for envs
(just don't specify both).
standard-engine
supports custom JS parsers. To use a custom parser, install it from npm
(example: npm install babel-eslint
) and add this to your package.json
:
{
"pocketlint": { // this key should equal the value of cmd in your options.js
"parser": "babel-eslint"
}
}
If you're using your custom linter globally (you installed it with -g
), then you also need to
install babel-eslint
globally with npm install babel-eslint -g
.
You can provide a parseOpts()
function in the options.js
exports:
var eslint = require('eslint')
var path = require('path')
var pkg = require('./package.json')
module.exports = {
// homepage, version and bugs pulled from package.json
version: pkg.version,
homepage: pkg.homepage,
bugs: pkg.bugs.url,
eslint: eslint, // pass any version of eslint >= 1.0.0
cmd: 'pocketlint', // should match the "bin" key in your package.json
tagline: 'Live by your own standards!', // displayed in output --help
eslintConfig: {
configFile: path.join(__dirname, 'eslintrc.json')
},
parseOpts: function (opts, packageOpts, rootDir) {
// provide implementation here, then return the opts object (or a new one)
return opts
}
}
This function is called with the current options object (opts
), any options extracted from the project's package.json
(packageOpts
), and the directory that contained that package.json
file (rootDir
, equivalent to opts.cwd
if no file was found).
Modify and return opts
, or return a new object with the options that are to be used.
The following options are provided in the opts
object, and must be on the returned object:
ignore
: array of file globs to ignorecwd
: string, the current working directoryfix
: boolean, whether to automatically fix problemseslintConfig
: object, the options passed to ESLint's CLIEngine
engine.lintText(text, [opts], callback)
Lint the provided source text
to enforce your defined style. An opts
object may
be provided:
{
cwd: '', // current working directory (default: process.cwd())
filename: '', // path of file containing the text being linted
fix: false, // automatically fix problems
globals: [], // custom global variables to declare
plugins: [], // custom eslint plugins
envs: [], // custom eslint environment
parser: '', // custom js parser (e.g. babel-eslint)
usePackageJson: true // use options from nearest package.json?
}
All options are optional, though some ESLint plugins require the filename
option.
Additional options may be loaded from a package.json
if it's found for the current working directory. See below for further details.
The callback
will be called with an Error
and results
object.
The results
object will contain the following properties:
var results = {
results: [
{
filePath: '',
messages: [
{ ruleId: '', message: '', line: 0, column: 0 }
],
errorCount: 0,
warningCount: 0,
output: '' // fixed source code (only present with {fix: true} option)
}
],
errorCount: 0,
warningCount: 0
}
results = engine.lintTextSync(text, [opts])
Synchronous version of engine.lintText()
. If an error occurs, an exception is
thrown. Otherwise, a results
object is returned.
engine.lintFiles(files, [opts], callback)
Lint the provided files
globs. An opts
object may be provided:
{
ignore: [], // file globs to ignore (has sane defaults)
cwd: '', // current working directory (default: process.cwd())
fix: false, // automatically fix problems
globals: [], // custom global variables to declare
plugins: [], // custom eslint plugins
envs: [], // custom eslint environment
parser: '', // custom js parser (e.g. babel-eslint)
usePackageJson: true // use options from nearest package.json?
}
Additional options may be loaded from a package.json
if it's found for the current working directory. See below for further details.
Both ignore
and files
globs are resolved relative to the current working directory.
The callback
will be called with an Error
and results
object (same as above).
NOTE: There is no synchronous version of engine.lintFiles()
.
opts
This is the full set of options accepted by the above APIs. Not all options make sense for each API, for example ignore
is not used with lintText()
, and filename
is not used with lintFiles()
.
{
ignore: [], // file globs to ignore (has sane defaults)
cwd: '', // current working directory (default: process.cwd())
filename: '', // path of the file containing the text being linted (optional)
fix: false, // automatically fix problems
globals: [], // custom global variables to declare
plugins: [], // custom eslint plugins
envs: [], // custom eslint environment
parser: '' // custom js parser (e.g. babel-eslint)
}
The following aliases are available:
{
global: [], // custom global variables to declare
plugin: [], // custom eslint plugins
env: [], // custom eslint environment
}
Note that globals
, plugins
and envs
take preference.
The parser
option takes preference over any parser
setting in the project's package.json
.
8.0.1 2018-03-02
FAQs
Wrap your standards in a tortilla and cover it in special sauce.
The npm package standard-engine receives a total of 360,422 weekly downloads. As such, standard-engine popularity was classified as popular.
We found that standard-engine demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 14 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
ESLint has added JSON and Markdown linting support with new officially-supported plugins, expanding its versatility beyond JavaScript.
Security News
Members Hub is conducting large-scale campaigns to artificially boost Discord server metrics, undermining community trust and platform integrity.
Security News
NIST has failed to meet its self-imposed deadline of clearing the NVD's backlog by the end of the fiscal year. Meanwhile, CVE's awaiting analysis have increased by 33% since June.