pax_global_header00006660000000000000000000000064132651737050014523gustar00rootroot0000000000000052 comment=38f9c44a179167f9bd97bd800454c787c0c2b05f eslint-rule-composer-0.3.0/000077500000000000000000000000001326517370500156135ustar00rootroot00000000000000eslint-rule-composer-0.3.0/.eslintrc.yml000066400000000000000000000005261326517370500202420ustar00rootroot00000000000000extends: - airbnb-base - plugin:node/recommended parserOptions: sourceType: script plugins: - node env: node: true rules: comma-dangle: [error, always-multiline] function-paren-newline: [error, consistent] max-len: off prefer-rest-params: off prefer-spread: off no-restricted-syntax: off prefer-destructuring: off eslint-rule-composer-0.3.0/.gitignore000066400000000000000000000000161326517370500176000ustar00rootroot00000000000000/node_modules eslint-rule-composer-0.3.0/.travis.yml000066400000000000000000000000731326517370500177240ustar00rootroot00000000000000language: node_js node_js: - '4' - '6' - '8' - '9' eslint-rule-composer-0.3.0/CHANGELOG.md000066400000000000000000000022241326517370500174240ustar00rootroot00000000000000# Changelog ## v0.3.0 (2018-04-16) * Update: Add filename property to metadata ([#3](https://github.com/not-an-aardvark/eslint-rule-composer/issues/3)) ([c6982df](https://github.com/not-an-aardvark/eslint-rule-composer/commit/c6982df862ffd9f2f7595d05d407eb7b5f9e83f9)) ## v0.2.0 (2018-04-14) * Update: Add a reference to context settings and options ([#1](https://github.com/not-an-aardvark/eslint-rule-composer/issues/1)) ([e7312ba](https://github.com/not-an-aardvark/eslint-rule-composer/commit/e7312bae50399f7576220649a52b8bbb4d4083c2)) * Build: set up Travis CI ([7e43e8c](https://github.com/not-an-aardvark/eslint-rule-composer/commit/7e43e8c05f667b0335f8ca7505acf831e1616070)) ## v0.1.1 (2018-03-14) * Chore: set up release script ([2ce3403](https://github.com/not-an-aardvark/eslint-rule-composer/commit/2ce3403d9cade255f904a3f8b9135076fa0937f1)) * Update: support rules that use messageIds ([861137c](https://github.com/not-an-aardvark/eslint-rule-composer/commit/861137cd9080c6a9f9e1dfe5a5e0fa03f81bf5ec)) * Docs: fix formatting in readme ([bad652b](https://github.com/not-an-aardvark/eslint-rule-composer/commit/bad652b05f6470e2155df02746acfa85a45fb4ab)) eslint-rule-composer-0.3.0/LICENSE.md000066400000000000000000000021221326517370500172140ustar00rootroot00000000000000The MIT License (MIT) ===================== Copyright © 2017 Teddy Katz 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. eslint-rule-composer-0.3.0/README.md000066400000000000000000000131241326517370500170730ustar00rootroot00000000000000# eslint-rule-composer This is a utility that allows you to build [ESLint](https://eslint.org/) rules out of other ESLint rules. ## Installation ``` npm install eslint-rule-composer --save ``` Requires Node 4 or later. ## Examples The following example creates a modified version of the [`no-unused-expressions`](https://eslint.org/docs/rules/no-unused-expressions) rule which does not report lines starting with `expect`. ```js const ruleComposer = require('eslint-rule-composer'); const eslint = require('eslint'); const noUnusedExpressionsRule = new eslint.Linter().getRules().get('no-unused-expressions'); module.exports = ruleComposer.filterReports( noUnusedExpressionsRule, (problem, metadata) => metadata.sourceCode.getFirstToken(problem.node).value !== 'expect' ); ``` The following example creates a modified version of the [`semi`](https://eslint.org/docs/rules/semi) rule which reports missing semicolons after experimental class properties: ```js const ruleComposer = require('eslint-rule-composer'); const eslint = require('eslint'); const semiRule = new eslint.Linter().getRules().get('semi'); module.exports = ruleComposer.joinReports([ semiRule, context => ({ ClassProperty(node) { if (context.getSourceCode().getLastToken(node).value !== ';') { context.report({ node, message: 'Missing semicolon.' }) } } }) ]); ``` You can access rule's options and [shared settings](https://eslint.org/docs/user-guide/configuring#adding-shared-settings) from the current ESLint configuration. The following example creates a modified version of the [`no-unused-expressions`](https://eslint.org/docs/rules/no-unused-expressions) rule which accepts a list of exceptions. ```js /* rule configuration: { "custom-no-unused-expressions": ["error", { "whitelist": ["expect", "test"] }] } */ const ruleComposer = require('eslint-rule-composer'); const eslint = require('eslint'); const noUnusedExpressionsRule = new eslint.Linter().getRules().get('no-unused-expressions'); module.exports = ruleComposer.filterReports( noUnusedExpressionsRule, (problem, metadata) => { const firstToken = metadata.sourceCode.getFirstToken(problem.node); const whitelist = metadata.options[0].whitelist; return whitelist.includes(value) === false } ); ``` ## API ### `ruleComposer.filterReports(rule, predicate)` and `ruleComposer.mapReports(rule, predicate)` Both of these functions accept two arguments: `rule` (an ESLint rule object) and `predicate` (a function) `filterReports(rule, predicate)` returns a new rule such that whenever the original rule would have reported a problem, the new rule will report a problem only if `predicate` returns true for that problem. `mapReports(rule, predicate)` returns a new rule such that whenever the original rule would have reported a problem, the new rule reports the result of calling `predicate` on the problem. In both cases, `predicate` is called with two arguments: `problem` and `metadata`. * `problem` is a normalized representation of a problem reported by the original rule. This has the following schema: ``` { node: ASTNode | null, message: string, messageId: string | null, data: Object | null, loc: { start: { line: number, column: number }, end: { line: number, column: number } | null }, fix: Function } ``` Note that the `messageId` and `data` properties will only be present if the original rule reported a problem using [Message IDs](https://eslint.org/docs/developer-guide/working-with-rules#messageids), otherwise they will be null. When returning a descriptor with `mapReports`, the `messageId` property on the returned descriptor will be used to generate the new message. To modify a report message directly for a rule that uses message IDs, ensure that the `predicate` function returns an object without a `messageId` property. * `metadata` is an object containing information about the source text that was linted. This has the following properties: * `sourceCode`: a [`SourceCode`](https://eslint.org/docs/developer-guide/working-with-rules#contextgetsourcecode) instance corresponding to the linted text. * `settings`: linter instance's [shared settings](https://eslint.org/docs/user-guide/configuring#adding-shared-settings) * `options`: rule's [configuration options](https://eslint.org/docs/developer-guide/working-with-rules#contextoptions) * `filename`: corresponding filename for the linted text. ### `ruleComposer.joinReports(rules)` Given an array of ESLint rule objects, `joinReports` returns a new rule that will report all of the problems from any of the rules in the array. The options provided to the new rule will also be provided to all of the rules in the array. ### Getting a reference to an ESLint rule To get a reference to an ESLint core rule, you can use ESLint's [public API](https://eslint.org/docs/developer-guide/nodejs-api) like this: ```js // get a reference to the 'semi' rule const eslint = require('eslint'); const semiRule = new eslint.Linter().getRules().get('semi'); ``` To get a reference to a rule from a plugin, you can do this: ```js // get a reference to the 'react/boolean-prop-naming' rule const booleanPropNamingRule = require('eslint-plugin-react').rules['boolean-prop-naming']; ``` You can also create your own rules (see the [rule documentation](https://eslint.org/docs/developer-guide/working-with-rules)): ```js const myCustomRule = { create(context) { return { DebuggerStatement(node) { context.report({ node, message: 'Do not use debugger statements.' }); } } } }; ``` ## License MIT License eslint-rule-composer-0.3.0/lib/000077500000000000000000000000001326517370500163615ustar00rootroot00000000000000eslint-rule-composer-0.3.0/lib/rule-composer.js000066400000000000000000000160531326517370500215200ustar00rootroot00000000000000'use strict'; /** * Translates a multi-argument context.report() call into a single object argument call * @param {...*} arguments A list of arguments passed to `context.report` * @returns {MessageDescriptor} A normalized object containing report information */ function normalizeMultiArgReportCall() { // If there is one argument, it is considered to be a new-style call already. if (arguments.length === 1) { return arguments[0]; } // If the second argument is a string, the arguments are interpreted as [node, message, data, fix]. if (typeof arguments[1] === 'string') { return { node: arguments[0], message: arguments[1], data: arguments[2], fix: arguments[3], }; } // Otherwise, the arguments are interpreted as [node, loc, message, data, fix]. return { node: arguments[0], loc: arguments[1], message: arguments[2], data: arguments[3], fix: arguments[4], }; } /** * Normalizes a MessageDescriptor to always have a `loc` with `start` and `end` properties * @param {MessageDescriptor} descriptor A descriptor for the report from a rule. * @returns {{start: Location, end: (Location|null)}} An updated location that infers the `start` and `end` properties * from the `node` of the original descriptor, or infers the `start` from the `loc` of the original descriptor. */ function normalizeReportLoc(descriptor) { if (descriptor.loc) { if (descriptor.loc.start) { return descriptor.loc; } return { start: descriptor.loc, end: null }; } return descriptor.node.loc; } /** * Interpolates data placeholders in report messages * @param {MessageDescriptor} descriptor The report message descriptor. * @param {Object} messageIds Message IDs from rule metadata * @returns {{message: string, data: Object}} The interpolated message and data for the descriptor */ function normalizeMessagePlaceholders(descriptor, messageIds) { const message = typeof descriptor.messageId === 'string' ? messageIds[descriptor.messageId] : descriptor.message; if (!descriptor.data) { return { message, data: typeof descriptor.messageId === 'string' ? {} : null, }; } const normalizedData = Object.create(null); const interpolatedMessage = message.replace(/\{\{\s*([^{}]+?)\s*\}\}/g, (fullMatch, term) => { if (term in descriptor.data) { normalizedData[term] = descriptor.data[term]; return descriptor.data[term]; } return fullMatch; }); return { message: interpolatedMessage, data: Object.freeze(normalizedData), }; } function getRuleMeta(rule) { return typeof rule === 'object' && rule.meta && typeof rule.meta === 'object' ? rule.meta : {}; } function getMessageIds(rule) { const meta = getRuleMeta(rule); return meta.messages && typeof rule.meta.messages === 'object' ? meta.messages : {}; } function getReportNormalizer(rule) { const messageIds = getMessageIds(rule); return function normalizeReport() { const descriptor = normalizeMultiArgReportCall.apply(null, arguments); const interpolatedMessageAndData = normalizeMessagePlaceholders(descriptor, messageIds); return { node: descriptor.node, message: interpolatedMessageAndData.message, messageId: typeof descriptor.messageId === 'string' ? descriptor.messageId : null, data: typeof descriptor.messageId === 'string' ? interpolatedMessageAndData.data : null, loc: normalizeReportLoc(descriptor), fix: descriptor.fix, }; }; } function getRuleCreateFunc(rule) { return typeof rule === 'function' ? rule : rule.create; } function removeMessageIfMessageIdPresent(reportDescriptor) { const newDescriptor = Object.assign({}, reportDescriptor); if (typeof reportDescriptor.messageId === 'string' && typeof reportDescriptor.message === 'string') { delete newDescriptor.message; } return newDescriptor; } module.exports = Object.freeze({ filterReports(rule, predicate) { return Object.freeze({ create(context) { const filename = context.getFilename(); const sourceCode = context.getSourceCode(); const settings = context.settings; const options = context.options; return getRuleCreateFunc(rule)( Object.freeze( Object.create( context, { report: { enumerable: true, value() { const reportDescriptor = getReportNormalizer(rule).apply(null, arguments); if (predicate(reportDescriptor, { sourceCode, settings, options, filename, })) { context.report(removeMessageIfMessageIdPresent(reportDescriptor)); } }, }, } ) ) ); }, schema: rule.schema, meta: getRuleMeta(rule), }); }, mapReports(rule, iteratee) { return Object.freeze({ create(context) { const filename = context.getFilename(); const sourceCode = context.getSourceCode(); const settings = context.settings; const options = context.options; return getRuleCreateFunc(rule)( Object.freeze( Object.create( context, { report: { enumerable: true, value() { context.report( removeMessageIfMessageIdPresent( iteratee( getReportNormalizer(rule).apply(null, arguments), { sourceCode, settings, options, filename, } ) ) ); }, }, } ) ) ); }, schema: rule.schema, meta: getRuleMeta(rule), }); }, joinReports(rules) { return Object.freeze({ create(context) { return rules .map(rule => getRuleCreateFunc(rule)(context)) .reduce( (allListeners, ruleListeners) => Object.keys(ruleListeners).reduce( (combinedListeners, key) => { const currentListener = combinedListeners[key]; const ruleListener = ruleListeners[key]; if (currentListener) { return Object.assign({}, combinedListeners, { [key]() { currentListener.apply(null, arguments); ruleListener.apply(null, arguments); }, }); } return Object.assign({}, combinedListeners, { [key]: ruleListener }); }, allListeners ), Object.create(null) ); }, meta: Object.freeze({ messages: Object.assign.apply( null, [Object.create(null)].concat(rules.map(getMessageIds)) ), fixable: 'code', }), }); }, }); eslint-rule-composer-0.3.0/package.json000066400000000000000000000020141326517370500200760ustar00rootroot00000000000000{ "name": "eslint-rule-composer", "version": "0.3.0", "description": "A utility for composing ESLint rules from other ESLint rules", "main": "lib/rule-composer.js", "files": [ "lib/" ], "scripts": { "lint": "eslint lib/ tests/", "test": "npm run lint && mocha tests/**/*.js", "generate-release": "node-release-script" }, "repository": { "type": "git", "url": "git+https://github.com/not-an-aardvark/eslint-rule-composer.git" }, "keywords": [ "eslint" ], "author": "Teddy Katz", "license": "MIT", "bugs": { "url": "https://github.com/not-an-aardvark/eslint-rule-composer/issues" }, "homepage": "https://github.com/not-an-aardvark/eslint-rule-composer#readme", "devDependencies": { "@not-an-aardvark/node-release-script": "^0.1.0", "chai": "^4.1.2", "eslint": "^4.7.1", "eslint-config-airbnb-base": "^12.0.0", "eslint-plugin-import": "^2.7.0", "eslint-plugin-node": "^5.1.1", "mocha": "^3.5.3" }, "engines": { "node": ">=4.0.0" } } eslint-rule-composer-0.3.0/tests/000077500000000000000000000000001326517370500167555ustar00rootroot00000000000000eslint-rule-composer-0.3.0/tests/lib/000077500000000000000000000000001326517370500175235ustar00rootroot00000000000000eslint-rule-composer-0.3.0/tests/lib/rule-composer.js000066400000000000000000000167661326517370500226750ustar00rootroot00000000000000'use strict'; const eslint = require('eslint'); const assert = require('chai').assert; const ruleComposer = require('../..'); const RuleTester = eslint.RuleTester; const ruleTester = new RuleTester(); const coreRules = new eslint.Linter().getRules(); ruleTester.run( 'filterReports', ruleComposer.filterReports(coreRules.get('no-undef'), descriptor => descriptor.node && descriptor.node.name !== 'foo'), { valid: [ 'foo;', 'var bar; bar;', ], invalid: [ { code: 'bar;', errors: [{ line: 1, column: 1 }], }, { code: 'foo; bar;', errors: [{ line: 1, column: 6 }], }, { code: 'bar; foo;', errors: [{ line: 1, column: 1 }], }, ], } ); // test with settings ruleTester.run( 'filterReports - with settings', ruleComposer.filterReports(coreRules.get('no-undef'), (descriptor, m) => ( descriptor.node && m.settings.tokenWhitelist.indexOf(descriptor.node.name) === -1 )), { valid: [ { code: 'foo;', settings: { tokenWhitelist: ['foo'] }, }, { code: 'var bar; bar;', settings: { tokenWhitelist: ['foo'] }, }, ], invalid: [ { code: 'bar;', errors: [{ line: 1, column: 1 }], settings: { tokenWhitelist: ['foo'] }, }, { code: 'foo; bar;', errors: [{ line: 1, column: 6 }], settings: { tokenWhitelist: ['foo'] }, }, { code: 'bar; foo;', errors: [{ line: 1, column: 1 }], settings: { tokenWhitelist: ['foo'] }, }, ], } ); const ruleWithOptions = ruleComposer.filterReports(coreRules.get('no-undef'), (descriptor, m) => ( descriptor.node && m.options[0].tokenWhitelist.indexOf(descriptor.node.name) === -1 )); // overwrite schema to allow custom options... ruleWithOptions.meta.schema[0].additionalProperties = true; ruleTester.run( 'filterReports - with options', ruleWithOptions, { valid: [ { code: 'foo;', options: [{ tokenWhitelist: ['foo'] }], }, { code: 'var bar; bar;', options: [{ tokenWhitelist: ['foo'] }], }, ], invalid: [ { code: 'bar;', errors: [{ line: 1, column: 1 }], options: [{ tokenWhitelist: ['foo'] }], }, { code: 'foo; bar;', errors: [{ line: 1, column: 6 }], options: [{ tokenWhitelist: ['foo'] }], }, { code: 'bar; foo;', errors: [{ line: 1, column: 1 }], options: [{ tokenWhitelist: ['foo'] }], }, ], } ); ruleTester.run( 'filterReports with filename', ruleComposer.filterReports(coreRules.get('no-undef'), (descriptor, metadata) => { assert.strictEqual(metadata.filename, 'index.js'); return descriptor.node && descriptor.node.name !== 'foo'; }), { valid: [ { code: 'foo', filename: 'index.js', }, { code: 'var bar; bar;', filename: 'index.js', }, ], invalid: [ { code: 'bar;', errors: [{ line: 1, column: 1 }], filename: 'index.js', }, ], } ); ruleTester.run( 'joinReports', ruleComposer.joinReports([ context => ({ Program: node => context.report(node, 'foo') }), context => ({ 'Program:exit': node => context.report(node, 'bar') }), { create: context => ({ 'Program:exit': node => context.report(node, 'baz') }) }, ]), { valid: [], invalid: [ { code: 'a', errors: [ { type: 'Program', message: 'foo' }, { type: 'Program', message: 'bar' }, { type: 'Program', message: 'baz' }, ], }, ], } ); ruleTester.run( 'mapReports', ruleComposer.mapReports( context => ({ Program: node => context.report({ node, message: 'foo' }) }), descriptor => Object.assign({}, descriptor, { message: descriptor.message.toUpperCase() }) ), { valid: [], invalid: [ { code: 'a', errors: [ { type: 'Program', message: 'FOO' }, ], }, ], } ); // test with settings ruleTester.run( 'mapReports - with settings', ruleComposer.mapReports( context => ({ Program: node => context.report({ node, message: 'foo' }) }), (descriptor, m) => Object.assign({}, descriptor, { message: descriptor.message[m.settings.method]() }) ), { valid: [], invalid: [ { code: 'a', errors: [ { type: 'Program', message: 'FOO' }, ], settings: { method: 'toUpperCase' }, }, ], } ); // test with settings ruleTester.run( 'mapReports - with options', ruleComposer.mapReports( context => ({ Program: node => context.report({ node, message: 'foo' }) }), (descriptor, m) => Object.assign({}, descriptor, { message: descriptor.message[m.options[0].method]() }) ), { valid: [], invalid: [ { code: 'a', errors: [ { type: 'Program', message: 'FOO' }, ], options: [{ method: 'toUpperCase' }], }, ], } ); ruleTester.run( 'mapReports with filename', ruleComposer.mapReports( context => ({ Program: node => context.report({ node, message: 'foo' }) }), (descriptor, metadata) => Object.assign({}, descriptor, { message: metadata.filename }) ), { valid: [], invalid: [ { code: 'a', filename: 'test.js', errors: [ { type: 'Program', message: 'test.js' }, ], }, ], } ); ruleTester.run( 'checking the first token of the report', ruleComposer.filterReports( coreRules.get('no-unused-expressions'), (problem, metadata) => metadata.sourceCode.getFirstToken(problem.node).value !== 'expect' ), { valid: [ 'expect(foo).to.be.true;', 'expect;', ], invalid: [ { code: 'foo;', errors: 1, }, ], } ); ruleTester.run( 'composing rules that use messageId', ruleComposer.filterReports( { meta: { messages: { foo: 'Foo error.', bar: 'Bar error.', baz: 'Baz error {{myData}}.', }, }, create(context) { return { Program(node) { context.report({ node, messageId: 'foo' }); context.report({ node, messageId: 'bar' }); context.report({ node, messageId: 'baz', data: { myData: 'BAZ', otherData: 'blah' } }); context.report({ node, message: 'Not message id {{aa}}', data: { aa: 'foo' } }); }, }; }, }, (problem) => { if (problem.messageId === 'baz') { assert.strictEqual(problem.message, 'Baz error BAZ.'); assert.deepEqual(problem.data, { myData: 'BAZ' }); } else if (problem.messageId === 'foo') { assert.strictEqual(problem.message, 'Foo error.'); assert.deepEqual(problem.data, {}); } else if (problem.messageId === 'bar') { assert.strictEqual(problem.message, 'Bar error.'); assert.deepEqual(problem.data, {}); } else if (problem.messageId === null) { assert.strictEqual(problem.message, 'Not message id foo'); assert.strictEqual(problem.data, null); } else { assert.fail('Unexpected reported problem'); } return problem.message === 'Foo error.' || problem.messageId === 'baz'; } ), { valid: [], invalid: [ { code: 'x', errors: [ { type: 'Program', message: 'Foo error.' }, { type: 'Program', message: 'Baz error BAZ.' }, ], }, ], } );