mirror of https://github.com/lukechilds/node.git
Browse Source
Update ESLint to 2.1.0. ESLint has a number of potentially-useful new features but this change attempts to be minimal in its changes. However, some things could not be avoided reasonably. ESLint 2.1.0 found a few lint issues that ESLing 1.x missed with template strings that did not take advantage of any features of template strings, and `let` declarations where `const` sufficed. Additionally, ESLint 2.1.0 removes some granularity around enabling ES6 features. Some features (e.g., spread operator) that had been turned off in our configuration for ESLint 1.x are now permitted. PR-URL: https://github.com/nodejs/node/pull/5214 Reviewed-By: Michaël Zasso <mic.besace@gmail.com> Reviewed-By: jbergstroem - Johan Bergström <bugs@bergstroem.nu> Reviewed-By: James M Snell <jasnell@gmail.com> Reviewed-By: Roman Reiss <me@silverwind.io> Reviewed-By: Myles Borins <myles.borins@gmail.com>process-exit-stdio-flushing
Rich Trott
9 years ago
2898 changed files with 115478 additions and 128590 deletions
@ -0,0 +1,33 @@ |
|||||
|
/** |
||||
|
* @fileoverview Default CLIEngineOptions. |
||||
|
* @author Ian VanSchooten |
||||
|
* @copyright 2016 Ian VanSchooten. All rights reserved. |
||||
|
* See LICENSE in root directory for full license. |
||||
|
*/ |
||||
|
|
||||
|
"use strict"; |
||||
|
|
||||
|
var DEFAULT_PARSER = require("../conf/eslint.json").parser; |
||||
|
|
||||
|
module.exports = { |
||||
|
configFile: null, |
||||
|
baseConfig: false, |
||||
|
rulePaths: [], |
||||
|
useEslintrc: true, |
||||
|
envs: [], |
||||
|
globals: [], |
||||
|
rules: {}, |
||||
|
extensions: [".js"], |
||||
|
ignore: true, |
||||
|
ignorePath: null, |
||||
|
parser: DEFAULT_PARSER, |
||||
|
cache: false, |
||||
|
// in order to honor the cacheFile option if specified
|
||||
|
// this option should not have a default value otherwise
|
||||
|
// it will always be used
|
||||
|
cacheLocation: "", |
||||
|
cacheFile: ".eslintcache", |
||||
|
fix: false, |
||||
|
allowInlineConfig: true, |
||||
|
cwd: process.cwd() |
||||
|
}; |
||||
@ -0,0 +1,640 @@ |
|||||
|
/** |
||||
|
* @fileoverview A class of the code path analyzer. |
||||
|
* @author Toru Nagashima |
||||
|
* @copyright 2015 Toru Nagashima. All rights reserved. |
||||
|
* See LICENSE file in root directory for full license. |
||||
|
*/ |
||||
|
|
||||
|
"use strict"; |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Requirements
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
var assert = require("assert"), |
||||
|
CodePath = require("./code-path"), |
||||
|
CodePathSegment = require("./code-path-segment"), |
||||
|
IdGenerator = require("./id-generator"), |
||||
|
debug = require("./debug-helpers"), |
||||
|
astUtils = require("../ast-utils"); |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Helpers
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
/** |
||||
|
* Checks whether or not a given node is a `case` node (not `default` node). |
||||
|
* |
||||
|
* @param {ASTNode} node - A `SwitchCase` node to check. |
||||
|
* @returns {boolean} `true` if the node is a `case` node (not `default` node). |
||||
|
*/ |
||||
|
function isCaseNode(node) { |
||||
|
return Boolean(node.test); |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Checks whether or not a given logical expression node goes different path |
||||
|
* between the `true` case and the `false` case. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node to check. |
||||
|
* @returns {boolean} `true` if the node is a test of a choice statement. |
||||
|
*/ |
||||
|
function isForkingByTrueOrFalse(node) { |
||||
|
var parent = node.parent; |
||||
|
switch (parent.type) { |
||||
|
case "ConditionalExpression": |
||||
|
case "IfStatement": |
||||
|
case "WhileStatement": |
||||
|
case "DoWhileStatement": |
||||
|
case "ForStatement": |
||||
|
return parent.test === node; |
||||
|
|
||||
|
case "LogicalExpression": |
||||
|
return true; |
||||
|
|
||||
|
default: |
||||
|
return false; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Gets the boolean value of a given literal node. |
||||
|
* |
||||
|
* This is used to detect infinity loops (e.g. `while (true) {}`). |
||||
|
* Statements preceded by an infinity loop are unreachable if the loop didn't |
||||
|
* have any `break` statement. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node to get. |
||||
|
* @returns {boolean|undefined} a boolean value if the node is a Literal node, |
||||
|
* otherwise `undefined`. |
||||
|
*/ |
||||
|
function getBooleanValueIfSimpleConstant(node) { |
||||
|
if (node.type === "Literal") { |
||||
|
return Boolean(node.value); |
||||
|
} |
||||
|
return void 0; |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Checks that a given identifier node is a reference or not. |
||||
|
* |
||||
|
* This is used to detect the first throwable node in a `try` block. |
||||
|
* |
||||
|
* @param {ASTNode} node - An Identifier node to check. |
||||
|
* @returns {boolean} `true` if the node is a reference. |
||||
|
*/ |
||||
|
function isIdentifierReference(node) { |
||||
|
var parent = node.parent; |
||||
|
|
||||
|
switch (parent.type) { |
||||
|
case "LabeledStatement": |
||||
|
case "BreakStatement": |
||||
|
case "ContinueStatement": |
||||
|
case "ArrayPattern": |
||||
|
case "RestElement": |
||||
|
case "ImportSpecifier": |
||||
|
case "ImportDefaultSpecifier": |
||||
|
case "ImportNamespaceSpecifier": |
||||
|
case "CatchClause": |
||||
|
return false; |
||||
|
|
||||
|
case "FunctionDeclaration": |
||||
|
case "FunctionExpression": |
||||
|
case "ArrowFunctionExpression": |
||||
|
case "ClassDeclaration": |
||||
|
case "ClassExpression": |
||||
|
case "VariableDeclarator": |
||||
|
return parent.id !== node; |
||||
|
|
||||
|
case "Property": |
||||
|
case "MethodDefinition": |
||||
|
return ( |
||||
|
parent.key !== node || |
||||
|
parent.computed || |
||||
|
parent.shorthand |
||||
|
); |
||||
|
|
||||
|
case "AssignmentPattern": |
||||
|
return parent.key !== node; |
||||
|
|
||||
|
default: |
||||
|
return true; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Updates the current segment with the head segment. |
||||
|
* This is similar to local branches and tracking branches of git. |
||||
|
* |
||||
|
* To separate the current and the head is in order to not make useless segments. |
||||
|
* |
||||
|
* In this process, both "onCodePathSegmentStart" and "onCodePathSegmentEnd" events |
||||
|
* are fired. |
||||
|
* |
||||
|
* @param {CodePathAnalyzer} analyzer - The instance. |
||||
|
* @param {ASTNode} node - The current AST node. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function forwardCurrentToHead(analyzer, node) { |
||||
|
var codePath = analyzer.codePath; |
||||
|
var state = CodePath.getState(codePath); |
||||
|
var currentSegments = state.currentSegments; |
||||
|
var headSegments = state.headSegments; |
||||
|
var end = Math.max(currentSegments.length, headSegments.length); |
||||
|
var i, currentSegment, headSegment; |
||||
|
|
||||
|
// Fires leaving events.
|
||||
|
for (i = 0; i < end; ++i) { |
||||
|
currentSegment = currentSegments[i]; |
||||
|
headSegment = headSegments[i]; |
||||
|
|
||||
|
if (currentSegment !== headSegment && currentSegment) { |
||||
|
debug.dump("onCodePathSegmentEnd " + currentSegment.id); |
||||
|
|
||||
|
if (currentSegment.reachable) { |
||||
|
analyzer.emitter.emit( |
||||
|
"onCodePathSegmentEnd", |
||||
|
currentSegment, |
||||
|
node); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Update state.
|
||||
|
state.currentSegments = headSegments; |
||||
|
|
||||
|
// Fires entering events.
|
||||
|
for (i = 0; i < end; ++i) { |
||||
|
currentSegment = currentSegments[i]; |
||||
|
headSegment = headSegments[i]; |
||||
|
|
||||
|
if (currentSegment !== headSegment && headSegment) { |
||||
|
debug.dump("onCodePathSegmentStart " + headSegment.id); |
||||
|
|
||||
|
CodePathSegment.markUsed(headSegment); |
||||
|
if (headSegment.reachable) { |
||||
|
analyzer.emitter.emit( |
||||
|
"onCodePathSegmentStart", |
||||
|
headSegment, |
||||
|
node); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Updates the current segment with empty. |
||||
|
* This is called at the last of functions or the program. |
||||
|
* |
||||
|
* @param {CodePathAnalyzer} analyzer - The instance. |
||||
|
* @param {ASTNode} node - The current AST node. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function leaveFromCurrentSegment(analyzer, node) { |
||||
|
var state = CodePath.getState(analyzer.codePath); |
||||
|
var currentSegments = state.currentSegments; |
||||
|
|
||||
|
for (var i = 0; i < currentSegments.length; ++i) { |
||||
|
var currentSegment = currentSegments[i]; |
||||
|
|
||||
|
debug.dump("onCodePathSegmentEnd " + currentSegment.id); |
||||
|
if (currentSegment.reachable) { |
||||
|
analyzer.emitter.emit( |
||||
|
"onCodePathSegmentEnd", |
||||
|
currentSegment, |
||||
|
node); |
||||
|
} |
||||
|
} |
||||
|
state.currentSegments = []; |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Updates the code path due to the position of a given node in the parent node |
||||
|
* thereof. |
||||
|
* |
||||
|
* For example, if the node is `parent.consequent`, this creates a fork from the |
||||
|
* current path. |
||||
|
* |
||||
|
* @param {CodePathAnalyzer} analyzer - The instance. |
||||
|
* @param {ASTNode} node - The current AST node. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function preprocess(analyzer, node) { |
||||
|
var codePath = analyzer.codePath; |
||||
|
var state = CodePath.getState(codePath); |
||||
|
var parent = node.parent; |
||||
|
|
||||
|
switch (parent.type) { |
||||
|
case "LogicalExpression": |
||||
|
if (parent.right === node) { |
||||
|
state.makeLogicalRight(); |
||||
|
} |
||||
|
break; |
||||
|
|
||||
|
case "ConditionalExpression": |
||||
|
case "IfStatement": |
||||
|
// Fork if this node is at `consequent`/`alternate`.
|
||||
|
// `popForkContext()` exists at `IfStatement:exit` and
|
||||
|
// `ConditionalExpression:exit`.
|
||||
|
if (parent.consequent === node) { |
||||
|
state.makeIfConsequent(); |
||||
|
} else if (parent.alternate === node) { |
||||
|
state.makeIfAlternate(); |
||||
|
} |
||||
|
break; |
||||
|
|
||||
|
case "SwitchCase": |
||||
|
if (parent.consequent[0] === node) { |
||||
|
state.makeSwitchCaseBody(false, !parent.test); |
||||
|
} |
||||
|
break; |
||||
|
|
||||
|
case "TryStatement": |
||||
|
if (parent.handler === node) { |
||||
|
state.makeCatchBlock(); |
||||
|
} else if (parent.finalizer === node) { |
||||
|
state.makeFinallyBlock(); |
||||
|
} |
||||
|
break; |
||||
|
|
||||
|
case "WhileStatement": |
||||
|
if (parent.test === node) { |
||||
|
state.makeWhileTest(getBooleanValueIfSimpleConstant(node)); |
||||
|
} else { |
||||
|
assert(parent.body === node); |
||||
|
state.makeWhileBody(); |
||||
|
} |
||||
|
break; |
||||
|
|
||||
|
case "DoWhileStatement": |
||||
|
if (parent.body === node) { |
||||
|
state.makeDoWhileBody(); |
||||
|
} else { |
||||
|
assert(parent.test === node); |
||||
|
state.makeDoWhileTest(getBooleanValueIfSimpleConstant(node)); |
||||
|
} |
||||
|
break; |
||||
|
|
||||
|
case "ForStatement": |
||||
|
if (parent.test === node) { |
||||
|
state.makeForTest(getBooleanValueIfSimpleConstant(node)); |
||||
|
} else if (parent.update === node) { |
||||
|
state.makeForUpdate(); |
||||
|
} else if (parent.body === node) { |
||||
|
state.makeForBody(); |
||||
|
} |
||||
|
break; |
||||
|
|
||||
|
case "ForInStatement": |
||||
|
case "ForOfStatement": |
||||
|
if (parent.left === node) { |
||||
|
state.makeForInOfLeft(); |
||||
|
} else if (parent.right === node) { |
||||
|
state.makeForInOfRight(); |
||||
|
} else { |
||||
|
assert(parent.body === node); |
||||
|
state.makeForInOfBody(); |
||||
|
} |
||||
|
break; |
||||
|
|
||||
|
case "AssignmentPattern": |
||||
|
// Fork if this node is at `right`.
|
||||
|
// `left` is executed always, so it uses the current path.
|
||||
|
// `popForkContext()` exists at `AssignmentPattern:exit`.
|
||||
|
if (parent.right === node) { |
||||
|
state.pushForkContext(); |
||||
|
state.forkBypassPath(); |
||||
|
state.forkPath(); |
||||
|
} |
||||
|
break; |
||||
|
|
||||
|
default: |
||||
|
break; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Updates the code path due to the type of a given node in entering. |
||||
|
* |
||||
|
* @param {CodePathAnalyzer} analyzer - The instance. |
||||
|
* @param {ASTNode} node - The current AST node. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function processCodePathToEnter(analyzer, node) { |
||||
|
var codePath = analyzer.codePath; |
||||
|
var state = codePath && CodePath.getState(codePath); |
||||
|
var parent = node.parent; |
||||
|
|
||||
|
switch (node.type) { |
||||
|
case "Program": |
||||
|
case "FunctionDeclaration": |
||||
|
case "FunctionExpression": |
||||
|
case "ArrowFunctionExpression": |
||||
|
if (codePath) { |
||||
|
// Emits onCodePathSegmentStart events if updated.
|
||||
|
forwardCurrentToHead(analyzer, node); |
||||
|
debug.dumpState(node, state, false); |
||||
|
} |
||||
|
|
||||
|
// Create the code path of this scope.
|
||||
|
codePath = analyzer.codePath = new CodePath( |
||||
|
analyzer.idGenerator.next(), |
||||
|
codePath, |
||||
|
analyzer.onLooped |
||||
|
); |
||||
|
state = CodePath.getState(codePath); |
||||
|
|
||||
|
// Emits onCodePathStart events.
|
||||
|
debug.dump("onCodePathStart " + codePath.id); |
||||
|
analyzer.emitter.emit("onCodePathStart", codePath, node); |
||||
|
break; |
||||
|
|
||||
|
case "LogicalExpression": |
||||
|
state.pushChoiceContext(node.operator, isForkingByTrueOrFalse(node)); |
||||
|
break; |
||||
|
|
||||
|
case "ConditionalExpression": |
||||
|
case "IfStatement": |
||||
|
state.pushChoiceContext("test", false); |
||||
|
break; |
||||
|
|
||||
|
case "SwitchStatement": |
||||
|
state.pushSwitchContext( |
||||
|
node.cases.some(isCaseNode), |
||||
|
astUtils.getLabel(node)); |
||||
|
break; |
||||
|
|
||||
|
case "TryStatement": |
||||
|
state.pushTryContext(Boolean(node.finalizer)); |
||||
|
break; |
||||
|
|
||||
|
case "SwitchCase": |
||||
|
// Fork if this node is after the 2st node in `cases`.
|
||||
|
// It's similar to `else` blocks.
|
||||
|
// The next `test` node is processed in this path.
|
||||
|
if (parent.discriminant !== node && parent.cases[0] !== node) { |
||||
|
state.forkPath(); |
||||
|
} |
||||
|
break; |
||||
|
|
||||
|
case "WhileStatement": |
||||
|
case "DoWhileStatement": |
||||
|
case "ForStatement": |
||||
|
case "ForInStatement": |
||||
|
case "ForOfStatement": |
||||
|
state.pushLoopContext(node.type, astUtils.getLabel(node)); |
||||
|
break; |
||||
|
|
||||
|
case "LabeledStatement": |
||||
|
if (!astUtils.isBreakableStatement(node.body)) { |
||||
|
state.pushBreakContext(false, node.label.name); |
||||
|
} |
||||
|
break; |
||||
|
|
||||
|
default: |
||||
|
break; |
||||
|
} |
||||
|
|
||||
|
// Emits onCodePathSegmentStart events if updated.
|
||||
|
forwardCurrentToHead(analyzer, node); |
||||
|
debug.dumpState(node, state, false); |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Updates the code path due to the type of a given node in leaving. |
||||
|
* |
||||
|
* @param {CodePathAnalyzer} analyzer - The instance. |
||||
|
* @param {ASTNode} node - The current AST node. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function processCodePathToExit(analyzer, node) { |
||||
|
var codePath = analyzer.codePath; |
||||
|
var state = CodePath.getState(codePath); |
||||
|
var dontForward = false; |
||||
|
|
||||
|
switch (node.type) { |
||||
|
case "IfStatement": |
||||
|
case "ConditionalExpression": |
||||
|
case "LogicalExpression": |
||||
|
state.popChoiceContext(); |
||||
|
break; |
||||
|
|
||||
|
case "SwitchStatement": |
||||
|
state.popSwitchContext(); |
||||
|
break; |
||||
|
|
||||
|
case "SwitchCase": |
||||
|
// This is the same as the process at the 1st `consequent` node in
|
||||
|
// `preprocess` function.
|
||||
|
// Must do if this `consequent` is empty.
|
||||
|
if (node.consequent.length === 0) { |
||||
|
state.makeSwitchCaseBody(true, !node.test); |
||||
|
} |
||||
|
if (state.forkContext.reachable) { |
||||
|
dontForward = true; |
||||
|
} |
||||
|
break; |
||||
|
|
||||
|
case "TryStatement": |
||||
|
state.popTryContext(); |
||||
|
break; |
||||
|
|
||||
|
case "BreakStatement": |
||||
|
forwardCurrentToHead(analyzer, node); |
||||
|
state.makeBreak(node.label && node.label.name); |
||||
|
dontForward = true; |
||||
|
break; |
||||
|
|
||||
|
case "ContinueStatement": |
||||
|
forwardCurrentToHead(analyzer, node); |
||||
|
state.makeContinue(node.label && node.label.name); |
||||
|
dontForward = true; |
||||
|
break; |
||||
|
|
||||
|
case "ReturnStatement": |
||||
|
forwardCurrentToHead(analyzer, node); |
||||
|
state.makeReturn(); |
||||
|
dontForward = true; |
||||
|
break; |
||||
|
|
||||
|
case "ThrowStatement": |
||||
|
forwardCurrentToHead(analyzer, node); |
||||
|
state.makeThrow(); |
||||
|
dontForward = true; |
||||
|
break; |
||||
|
|
||||
|
case "Identifier": |
||||
|
if (isIdentifierReference(node)) { |
||||
|
state.makeFirstThrowablePathInTryBlock(); |
||||
|
dontForward = true; |
||||
|
} |
||||
|
break; |
||||
|
|
||||
|
case "CallExpression": |
||||
|
case "MemberExpression": |
||||
|
case "NewExpression": |
||||
|
state.makeFirstThrowablePathInTryBlock(); |
||||
|
break; |
||||
|
|
||||
|
case "WhileStatement": |
||||
|
case "DoWhileStatement": |
||||
|
case "ForStatement": |
||||
|
case "ForInStatement": |
||||
|
case "ForOfStatement": |
||||
|
state.popLoopContext(); |
||||
|
break; |
||||
|
|
||||
|
case "AssignmentPattern": |
||||
|
state.popForkContext(); |
||||
|
break; |
||||
|
|
||||
|
case "LabeledStatement": |
||||
|
if (!astUtils.isBreakableStatement(node.body)) { |
||||
|
state.popBreakContext(); |
||||
|
} |
||||
|
break; |
||||
|
|
||||
|
default: |
||||
|
break; |
||||
|
} |
||||
|
|
||||
|
// Skip updating the current segment to avoid creating useless segments if
|
||||
|
// the node type is the same as the parent node type.
|
||||
|
if (!dontForward && (!node.parent || node.type !== node.parent.type)) { |
||||
|
// Emits onCodePathSegmentStart events if updated.
|
||||
|
forwardCurrentToHead(analyzer, node); |
||||
|
} |
||||
|
debug.dumpState(node, state, true); |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Updates the code path to finalize the current code path. |
||||
|
* |
||||
|
* @param {CodePathAnalyzer} analyzer - The instance. |
||||
|
* @param {ASTNode} node - The current AST node. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function postprocess(analyzer, node) { |
||||
|
switch (node.type) { |
||||
|
case "Program": |
||||
|
case "FunctionDeclaration": |
||||
|
case "FunctionExpression": |
||||
|
case "ArrowFunctionExpression": |
||||
|
var codePath = analyzer.codePath; |
||||
|
|
||||
|
// Mark the current path as the final node.
|
||||
|
CodePath.getState(codePath).makeFinal(); |
||||
|
|
||||
|
// Emits onCodePathSegmentEnd event of the current segments.
|
||||
|
leaveFromCurrentSegment(analyzer, node); |
||||
|
|
||||
|
// Emits onCodePathEnd event of this code path.
|
||||
|
debug.dump("onCodePathEnd " + codePath.id); |
||||
|
analyzer.emitter.emit("onCodePathEnd", codePath, node); |
||||
|
debug.dumpDot(codePath); |
||||
|
|
||||
|
codePath = analyzer.codePath = analyzer.codePath.upper; |
||||
|
if (codePath) { |
||||
|
debug.dumpState(node, CodePath.getState(codePath), true); |
||||
|
} |
||||
|
break; |
||||
|
|
||||
|
default: |
||||
|
break; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Public Interface
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
/** |
||||
|
* The class to analyze code paths. |
||||
|
* This class implements the EventGenerator interface. |
||||
|
* |
||||
|
* @constructor |
||||
|
* @param {EventGenerator} eventGenerator - An event generator to wrap. |
||||
|
*/ |
||||
|
function CodePathAnalyzer(eventGenerator) { |
||||
|
this.original = eventGenerator; |
||||
|
this.emitter = eventGenerator.emitter; |
||||
|
this.codePath = null; |
||||
|
this.idGenerator = new IdGenerator("s"); |
||||
|
this.currentNode = null; |
||||
|
this.onLooped = this.onLooped.bind(this); |
||||
|
} |
||||
|
|
||||
|
CodePathAnalyzer.prototype = { |
||||
|
constructor: CodePathAnalyzer, |
||||
|
|
||||
|
/** |
||||
|
* Does the process to enter a given AST node. |
||||
|
* This updates state of analysis and calls `enterNode` of the wrapped. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node which is entering. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
enterNode: function(node) { |
||||
|
this.currentNode = node; |
||||
|
|
||||
|
// Updates the code path due to node's position in its parent node.
|
||||
|
if (node.parent) { |
||||
|
preprocess(this, node); |
||||
|
} |
||||
|
|
||||
|
// Updates the code path.
|
||||
|
// And emits onCodePathStart/onCodePathSegmentStart events.
|
||||
|
processCodePathToEnter(this, node); |
||||
|
|
||||
|
// Emits node events.
|
||||
|
this.original.enterNode(node); |
||||
|
|
||||
|
this.currentNode = null; |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Does the process to leave a given AST node. |
||||
|
* This updates state of analysis and calls `leaveNode` of the wrapped. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node which is leaving. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
leaveNode: function(node) { |
||||
|
this.currentNode = node; |
||||
|
|
||||
|
// Updates the code path.
|
||||
|
// And emits onCodePathStart/onCodePathSegmentStart events.
|
||||
|
processCodePathToExit(this, node); |
||||
|
|
||||
|
// Emits node events.
|
||||
|
this.original.leaveNode(node); |
||||
|
|
||||
|
// Emits the last onCodePathStart/onCodePathSegmentStart events.
|
||||
|
postprocess(this, node); |
||||
|
|
||||
|
this.currentNode = null; |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* This is called on a code path looped. |
||||
|
* Then this raises a looped event. |
||||
|
* |
||||
|
* @param {CodePathSegment} fromSegment - A segment of prev. |
||||
|
* @param {CodePathSegment} toSegment - A segment of next. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
onLooped: function(fromSegment, toSegment) { |
||||
|
if (fromSegment.reachable && toSegment.reachable) { |
||||
|
debug.dump("onCodePathSegmentLoop " + fromSegment.id + " -> " + toSegment.id); |
||||
|
this.emitter.emit( |
||||
|
"onCodePathSegmentLoop", |
||||
|
fromSegment, |
||||
|
toSegment, |
||||
|
this.currentNode |
||||
|
); |
||||
|
} |
||||
|
} |
||||
|
}; |
||||
|
|
||||
|
module.exports = CodePathAnalyzer; |
||||
@ -0,0 +1,208 @@ |
|||||
|
/** |
||||
|
* @fileoverview A class of the code path segment. |
||||
|
* @author Toru Nagashima |
||||
|
* @copyright 2015 Toru Nagashima. All rights reserved. |
||||
|
* See LICENSE file in root directory for full license. |
||||
|
*/ |
||||
|
|
||||
|
"use strict"; |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Requirements
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
var assert = require("assert"), |
||||
|
debug = require("./debug-helpers"); |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Helpers
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
/** |
||||
|
* Replaces unused segments with the previous segments of each unused segment. |
||||
|
* |
||||
|
* @param {CodePathSegment[]} segments - An array of segments to replace. |
||||
|
* @returns {CodePathSegment[]} The replaced array. |
||||
|
*/ |
||||
|
function flattenUnusedSegments(segments) { |
||||
|
var done = Object.create(null); |
||||
|
var retv = []; |
||||
|
|
||||
|
for (var i = 0; i < segments.length; ++i) { |
||||
|
var segment = segments[i]; |
||||
|
|
||||
|
// Ignores duplicated.
|
||||
|
if (done[segment.id]) { |
||||
|
continue; |
||||
|
} |
||||
|
|
||||
|
// Use previous segments if unused.
|
||||
|
if (!segment.internal.used) { |
||||
|
for (var j = 0; j < segment.allPrevSegments.length; ++j) { |
||||
|
var prevSegment = segment.allPrevSegments[j]; |
||||
|
|
||||
|
if (!done[prevSegment.id]) { |
||||
|
done[prevSegment.id] = true; |
||||
|
retv.push(prevSegment); |
||||
|
} |
||||
|
} |
||||
|
} else { |
||||
|
done[segment.id] = true; |
||||
|
retv.push(segment); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return retv; |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Checks whether or not a given segment is reachable. |
||||
|
* |
||||
|
* @param {CodePathSegment} segment - A segment to check. |
||||
|
* @returns {boolean} `true` if the segment is reachable. |
||||
|
*/ |
||||
|
function isReachable(segment) { |
||||
|
return segment.reachable; |
||||
|
} |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Public Interface
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
/** |
||||
|
* A code path segment. |
||||
|
* |
||||
|
* @constructor |
||||
|
* @param {string} id - An identifier. |
||||
|
* @param {CodePathSegment[]} allPrevSegments - An array of the previous segments. |
||||
|
* This array includes unreachable segments. |
||||
|
* @param {boolean} reachable - A flag which shows this is reachable. |
||||
|
*/ |
||||
|
function CodePathSegment(id, allPrevSegments, reachable) { |
||||
|
/** |
||||
|
* The identifier of this code path. |
||||
|
* Rules use it to store additional information of each rule. |
||||
|
* @type {string} |
||||
|
*/ |
||||
|
this.id = id; |
||||
|
|
||||
|
/** |
||||
|
* An array of the next segments. |
||||
|
* @type {CodePathSegment[]} |
||||
|
*/ |
||||
|
this.nextSegments = []; |
||||
|
|
||||
|
/** |
||||
|
* An array of the previous segments. |
||||
|
* @type {CodePathSegment[]} |
||||
|
*/ |
||||
|
this.prevSegments = allPrevSegments.filter(isReachable); |
||||
|
|
||||
|
/** |
||||
|
* An array of the next segments. |
||||
|
* This array includes unreachable segments. |
||||
|
* @type {CodePathSegment[]} |
||||
|
*/ |
||||
|
this.allNextSegments = []; |
||||
|
|
||||
|
/** |
||||
|
* An array of the previous segments. |
||||
|
* This array includes unreachable segments. |
||||
|
* @type {CodePathSegment[]} |
||||
|
*/ |
||||
|
this.allPrevSegments = allPrevSegments; |
||||
|
|
||||
|
/** |
||||
|
* A flag which shows this is reachable. |
||||
|
* @type {boolean} |
||||
|
*/ |
||||
|
this.reachable = reachable; |
||||
|
|
||||
|
// Internal data.
|
||||
|
Object.defineProperty(this, "internal", {value: { |
||||
|
used: false |
||||
|
}}); |
||||
|
|
||||
|
/* istanbul ignore if */ |
||||
|
if (debug.enabled) { |
||||
|
this.internal.nodes = []; |
||||
|
this.internal.exitNodes = []; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Creates the root segment. |
||||
|
* |
||||
|
* @param {string} id - An identifier. |
||||
|
* @returns {CodePathSegment} The created segment. |
||||
|
*/ |
||||
|
CodePathSegment.newRoot = function(id) { |
||||
|
return new CodePathSegment(id, [], true); |
||||
|
}; |
||||
|
|
||||
|
/** |
||||
|
* Creates a segment that follows given segments. |
||||
|
* |
||||
|
* @param {string} id - An identifier. |
||||
|
* @param {CodePathSegment[]} allPrevSegments - An array of the previous segments. |
||||
|
* @returns {CodePathSegment} The created segment. |
||||
|
*/ |
||||
|
CodePathSegment.newNext = function(id, allPrevSegments) { |
||||
|
return new CodePathSegment( |
||||
|
id, |
||||
|
flattenUnusedSegments(allPrevSegments), |
||||
|
allPrevSegments.some(isReachable)); |
||||
|
}; |
||||
|
|
||||
|
/** |
||||
|
* Creates an unreachable segment that follows given segments. |
||||
|
* |
||||
|
* @param {string} id - An identifier. |
||||
|
* @param {CodePathSegment[]} allPrevSegments - An array of the previous segments. |
||||
|
* @returns {CodePathSegment} The created segment. |
||||
|
*/ |
||||
|
CodePathSegment.newUnreachable = function(id, allPrevSegments) { |
||||
|
return new CodePathSegment(id, flattenUnusedSegments(allPrevSegments), false); |
||||
|
}; |
||||
|
|
||||
|
/** |
||||
|
* Creates a segment that follows given segments. |
||||
|
* This factory method does not connect with `allPrevSegments`. |
||||
|
* But this inherits `reachable` flag. |
||||
|
* |
||||
|
* @param {string} id - An identifier. |
||||
|
* @param {CodePathSegment[]} allPrevSegments - An array of the previous segments. |
||||
|
* @returns {CodePathSegment} The created segment. |
||||
|
*/ |
||||
|
CodePathSegment.newDisconnected = function(id, allPrevSegments) { |
||||
|
return new CodePathSegment(id, [], allPrevSegments.some(isReachable)); |
||||
|
}; |
||||
|
|
||||
|
/** |
||||
|
* Makes a given segment being used. |
||||
|
* |
||||
|
* And this function registers the segment into the previous segments as a next. |
||||
|
* |
||||
|
* @param {CodePathSegment} segment - A segment to mark. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
CodePathSegment.markUsed = function(segment) { |
||||
|
assert(!segment.internal.used, segment.id + " is marked twice."); |
||||
|
segment.internal.used = true; |
||||
|
|
||||
|
var i; |
||||
|
if (segment.reachable) { |
||||
|
for (i = 0; i < segment.allPrevSegments.length; ++i) { |
||||
|
var prevSegment = segment.allPrevSegments[i]; |
||||
|
|
||||
|
prevSegment.allNextSegments.push(segment); |
||||
|
prevSegment.nextSegments.push(segment); |
||||
|
} |
||||
|
} else { |
||||
|
for (i = 0; i < segment.allPrevSegments.length; ++i) { |
||||
|
segment.allPrevSegments[i].allNextSegments.push(segment); |
||||
|
} |
||||
|
} |
||||
|
}; |
||||
|
|
||||
|
module.exports = CodePathSegment; |
||||
File diff suppressed because it is too large
@ -0,0 +1,118 @@ |
|||||
|
/** |
||||
|
* @fileoverview A class of the code path. |
||||
|
* @author Toru Nagashima |
||||
|
* @copyright 2015 Toru Nagashima. All rights reserved. |
||||
|
* See LICENSE file in root directory for full license. |
||||
|
*/ |
||||
|
|
||||
|
"use strict"; |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Requirements
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
var CodePathState = require("./code-path-state"); |
||||
|
var IdGenerator = require("./id-generator"); |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Public Interface
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
/** |
||||
|
* A code path. |
||||
|
* |
||||
|
* @constructor |
||||
|
* @param {string} id - An identifier. |
||||
|
* @param {CodePath|null} upper - The code path of the upper function scope. |
||||
|
* @param {function} onLooped - A callback function to notify looping. |
||||
|
*/ |
||||
|
function CodePath(id, upper, onLooped) { |
||||
|
/** |
||||
|
* The identifier of this code path. |
||||
|
* Rules use it to store additional information of each rule. |
||||
|
* @type {string} |
||||
|
*/ |
||||
|
this.id = id; |
||||
|
|
||||
|
/** |
||||
|
* The code path of the upper function scope. |
||||
|
* @type {CodePath|null} |
||||
|
*/ |
||||
|
this.upper = upper; |
||||
|
|
||||
|
/** |
||||
|
* The code paths of nested function scopes. |
||||
|
* @type {CodePath[]} |
||||
|
*/ |
||||
|
this.childCodePaths = []; |
||||
|
|
||||
|
// Initializes internal state.
|
||||
|
Object.defineProperty( |
||||
|
this, |
||||
|
"internal", |
||||
|
{value: new CodePathState(new IdGenerator(id + "_"), onLooped)}); |
||||
|
|
||||
|
// Adds this into `childCodePaths` of `upper`.
|
||||
|
if (upper) { |
||||
|
upper.childCodePaths.push(this); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
CodePath.prototype = { |
||||
|
constructor: CodePath, |
||||
|
|
||||
|
/** |
||||
|
* The initial code path segment. |
||||
|
* @type {CodePathSegment} |
||||
|
*/ |
||||
|
get initialSegment() { |
||||
|
return this.internal.initialSegment; |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Final code path segments. |
||||
|
* This array is a mix of `returnedSegments` and `thrownSegments`. |
||||
|
* @type {CodePathSegment[]} |
||||
|
*/ |
||||
|
get finalSegments() { |
||||
|
return this.internal.finalSegments; |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Final code path segments which is with `return` statements. |
||||
|
* This array contains the last path segment if it's reachable. |
||||
|
* Since the reachable last path returns `undefined`. |
||||
|
* @type {CodePathSegment[]} |
||||
|
*/ |
||||
|
get returnedSegments() { |
||||
|
return this.internal.returnedForkContext; |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Final code path segments which is with `throw` statements. |
||||
|
* @type {CodePathSegment[]} |
||||
|
*/ |
||||
|
get thrownSegments() { |
||||
|
return this.internal.thrownForkContext; |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Current code path segments. |
||||
|
* @type {CodePathSegment[]} |
||||
|
*/ |
||||
|
get currentSegments() { |
||||
|
return this.internal.currentSegments; |
||||
|
} |
||||
|
}; |
||||
|
|
||||
|
/** |
||||
|
* Gets the state of a given code path. |
||||
|
* |
||||
|
* @param {CodePath} codePath - A code path to get. |
||||
|
* @returns {CodePathState} The state of the code path. |
||||
|
*/ |
||||
|
CodePath.getState = function getState(codePath) { |
||||
|
return codePath.internal; |
||||
|
}; |
||||
|
|
||||
|
module.exports = CodePath; |
||||
@ -0,0 +1,197 @@ |
|||||
|
/** |
||||
|
* @fileoverview Helpers to debug for code path analysis. |
||||
|
* @author Toru Nagashima |
||||
|
* @copyright 2015 Toru Nagashima. All rights reserved. |
||||
|
* See LICENSE file in root directory for full license. |
||||
|
*/ |
||||
|
|
||||
|
"use strict"; |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Requirements
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
var debug = require("debug")("eslint:code-path"); |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Helpers
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
/** |
||||
|
* Gets id of a given segment. |
||||
|
* @param {CodePathSegment} segment - A segment to get. |
||||
|
* @returns {string} Id of the segment. |
||||
|
*/ |
||||
|
/* istanbul ignore next */ |
||||
|
function getId(segment) { // eslint-disable-line require-jsdoc
|
||||
|
return segment.id + (segment.reachable ? "" : "!"); |
||||
|
} |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Public Interface
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
module.exports = { |
||||
|
/** |
||||
|
* A flag that debug dumping is enabled or not. |
||||
|
* @type {boolean} |
||||
|
*/ |
||||
|
enabled: debug.enabled, |
||||
|
|
||||
|
/** |
||||
|
* Dumps given objects. |
||||
|
* |
||||
|
* @param {...any} args - objects to dump. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
dump: debug, |
||||
|
|
||||
|
/** |
||||
|
* Dumps the current analyzing state. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node to dump. |
||||
|
* @param {CodePathState} state - A state to dump. |
||||
|
* @param {boolean} leaving - A flag whether or not it's leaving |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
dumpState: !debug.enabled ? debug : /* istanbul ignore next */ function(node, state, leaving) { |
||||
|
for (var i = 0; i < state.currentSegments.length; ++i) { |
||||
|
var segInternal = state.currentSegments[i].internal; |
||||
|
if (leaving) { |
||||
|
segInternal.exitNodes.push(node); |
||||
|
} else { |
||||
|
segInternal.nodes.push(node); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
debug( |
||||
|
state.currentSegments.map(getId).join(",") + ") " + |
||||
|
node.type + (leaving ? ":exit" : "") |
||||
|
); |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Dumps a DOT code of a given code path. |
||||
|
* The DOT code can be visialized with Graphvis. |
||||
|
* |
||||
|
* @param {CodePath} codePath - A code path to dump. |
||||
|
* @returns {void} |
||||
|
* @see http://www.graphviz.org
|
||||
|
* @see http://www.webgraphviz.com
|
||||
|
*/ |
||||
|
dumpDot: !debug.enabled ? debug : /* istanbul ignore next */ function(codePath) { |
||||
|
var text = |
||||
|
"\n" + |
||||
|
"digraph {\n" + |
||||
|
"node[shape=box,style=\"rounded,filled\",fillcolor=white];\n" + |
||||
|
"initial[label=\"\",shape=circle,style=filled,fillcolor=black,width=0.25,height=0.25];\n"; |
||||
|
|
||||
|
if (codePath.returnedSegments.length > 0) { |
||||
|
text += "final[label=\"\",shape=doublecircle,style=filled,fillcolor=black,width=0.25,height=0.25];\n"; |
||||
|
} |
||||
|
if (codePath.thrownSegments.length > 0) { |
||||
|
text += "thrown[label=\"✘\",shape=circle,width=0.3,height=0.3,fixedsize];\n"; |
||||
|
} |
||||
|
|
||||
|
var traceMap = Object.create(null); |
||||
|
var arrows = this.makeDotArrows(codePath, traceMap); |
||||
|
|
||||
|
for (var id in traceMap) { // eslint-disable-line guard-for-in
|
||||
|
var segment = traceMap[id]; |
||||
|
|
||||
|
text += id + "["; |
||||
|
|
||||
|
if (segment.reachable) { |
||||
|
text += "label=\""; |
||||
|
} else { |
||||
|
text += "style=\"rounded,dashed,filled\",fillcolor=\"#FF9800\",label=\"<<unreachable>>\\n"; |
||||
|
} |
||||
|
|
||||
|
if (segment.internal.nodes.length > 0) { |
||||
|
text += segment.internal.nodes.map(function(node) { |
||||
|
switch (node.type) { |
||||
|
case "Identifier": return node.type + " (" + node.name + ")"; |
||||
|
case "Literal": return node.type + " (" + node.value + ")"; |
||||
|
default: return node.type; |
||||
|
} |
||||
|
}).join("\\n"); |
||||
|
} else if (segment.internal.exitNodes.length > 0) { |
||||
|
text += segment.internal.exitNodes.map(function(node) { |
||||
|
switch (node.type) { |
||||
|
case "Identifier": return node.type + ":exit (" + node.name + ")"; |
||||
|
case "Literal": return node.type + ":exit (" + node.value + ")"; |
||||
|
default: return node.type + ":exit"; |
||||
|
} |
||||
|
}).join("\\n"); |
||||
|
} else { |
||||
|
text += "????"; |
||||
|
} |
||||
|
|
||||
|
text += "\"];\n"; |
||||
|
} |
||||
|
|
||||
|
text += arrows + "\n"; |
||||
|
text += "}"; |
||||
|
debug("DOT", text); |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Makes a DOT code of a given code path. |
||||
|
* The DOT code can be visialized with Graphvis. |
||||
|
* |
||||
|
* @param {CodePath} codePath - A code path to make DOT. |
||||
|
* @param {object} traceMap - Optional. A map to check whether or not segments had been done. |
||||
|
* @returns {string} A DOT code of the code path. |
||||
|
*/ |
||||
|
makeDotArrows: function(codePath, traceMap) { |
||||
|
var stack = [[codePath.initialSegment, 0]]; |
||||
|
var done = traceMap || Object.create(null); |
||||
|
var lastId = codePath.initialSegment.id; |
||||
|
var text = "initial->" + codePath.initialSegment.id; |
||||
|
|
||||
|
while (stack.length > 0) { |
||||
|
var item = stack.pop(); |
||||
|
var segment = item[0]; |
||||
|
var index = item[1]; |
||||
|
if (done[segment.id] && index === 0) { |
||||
|
continue; |
||||
|
} |
||||
|
done[segment.id] = segment; |
||||
|
|
||||
|
var nextSegment = segment.allNextSegments[index]; |
||||
|
if (!nextSegment) { |
||||
|
continue; |
||||
|
} |
||||
|
|
||||
|
if (lastId === segment.id) { |
||||
|
text += "->" + nextSegment.id; |
||||
|
} else { |
||||
|
text += ";\n" + segment.id + "->" + nextSegment.id; |
||||
|
} |
||||
|
lastId = nextSegment.id; |
||||
|
|
||||
|
stack.unshift([segment, 1 + index]); |
||||
|
stack.push([nextSegment, 0]); |
||||
|
} |
||||
|
|
||||
|
codePath.returnedSegments.forEach(function(finalSegment) { |
||||
|
if (lastId === finalSegment.id) { |
||||
|
text += "->final"; |
||||
|
} else { |
||||
|
text += ";\n" + finalSegment.id + "->final"; |
||||
|
} |
||||
|
lastId = null; |
||||
|
}); |
||||
|
|
||||
|
codePath.thrownSegments.forEach(function(finalSegment) { |
||||
|
if (lastId === finalSegment.id) { |
||||
|
text += "->thrown"; |
||||
|
} else { |
||||
|
text += ";\n" + finalSegment.id + "->thrown"; |
||||
|
} |
||||
|
lastId = null; |
||||
|
}); |
||||
|
|
||||
|
return text + ";"; |
||||
|
} |
||||
|
}; |
||||
@ -0,0 +1,258 @@ |
|||||
|
/** |
||||
|
* @fileoverview A class to operate forking. |
||||
|
* |
||||
|
* This is state of forking. |
||||
|
* This has a fork list and manages it. |
||||
|
* |
||||
|
* @author Toru Nagashima |
||||
|
* @copyright 2015 Toru Nagashima. All rights reserved. |
||||
|
* See LICENSE file in root directory for full license. |
||||
|
*/ |
||||
|
|
||||
|
"use strict"; |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Requirements
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
var assert = require("assert"), |
||||
|
CodePathSegment = require("./code-path-segment"); |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Helpers
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
/** |
||||
|
* Gets whether or not a given segment is reachable. |
||||
|
* |
||||
|
* @param {CodePathSegment} segment - A segment to get. |
||||
|
* @returns {boolean} `true` if the segment is reachable. |
||||
|
*/ |
||||
|
function isReachable(segment) { |
||||
|
return segment.reachable; |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Creates new segments from the specific range of `context.segmentsList`. |
||||
|
* |
||||
|
* When `context.segmentsList` is `[[a, b], [c, d], [e, f]]`, `begin` is `0`, and |
||||
|
* `end` is `-1`, this creates `[g, h]`. This `g` is from `a`, `c`, and `e`. |
||||
|
* This `h` is from `b`, `d`, and `f`. |
||||
|
* |
||||
|
* @param {ForkContext} context - An instance. |
||||
|
* @param {number} begin - The first index of the previous segments. |
||||
|
* @param {number} end - The last index of the previous segments. |
||||
|
* @param {function} create - A factory function of new segments. |
||||
|
* @returns {CodePathSegment[]} New segments. |
||||
|
*/ |
||||
|
function makeSegments(context, begin, end, create) { |
||||
|
var list = context.segmentsList; |
||||
|
if (begin < 0) { |
||||
|
begin = list.length + begin; |
||||
|
} |
||||
|
if (end < 0) { |
||||
|
end = list.length + end; |
||||
|
} |
||||
|
|
||||
|
var segments = []; |
||||
|
for (var i = 0; i < context.count; ++i) { |
||||
|
var allPrevSegments = []; |
||||
|
|
||||
|
for (var j = begin; j <= end; ++j) { |
||||
|
allPrevSegments.push(list[j][i]); |
||||
|
} |
||||
|
|
||||
|
segments.push(create(context.idGenerator.next(), allPrevSegments)); |
||||
|
} |
||||
|
|
||||
|
return segments; |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* `segments` becomes doubly in a `finally` block. Then if a code path exits by a |
||||
|
* control statement (such as `break`, `continue`) from the `finally` block, the |
||||
|
* destination's segments may be half of the source segments. In that case, this |
||||
|
* merges segments. |
||||
|
* |
||||
|
* @param {ForkContext} context - An instance. |
||||
|
* @param {CodePathSegment[]} segments - Segments to merge. |
||||
|
* @returns {CodePathSegment[]} The merged segments. |
||||
|
*/ |
||||
|
function mergeExtraSegments(context, segments) { |
||||
|
while (segments.length > context.count) { |
||||
|
var merged = []; |
||||
|
for (var i = 0, length = segments.length / 2 | 0; i < length; ++i) { |
||||
|
merged.push(CodePathSegment.newNext( |
||||
|
context.idGenerator.next(), |
||||
|
[segments[i], segments[i + length]] |
||||
|
)); |
||||
|
} |
||||
|
segments = merged; |
||||
|
} |
||||
|
return segments; |
||||
|
} |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Public Interface
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
/** |
||||
|
* A class to manage forking. |
||||
|
* |
||||
|
* @constructor |
||||
|
* @param {IdGenerator} idGenerator - An identifier generator for segments. |
||||
|
* @param {ForkContext|null} upper - An upper fork context. |
||||
|
* @param {number} count - A number of parallel segments. |
||||
|
*/ |
||||
|
function ForkContext(idGenerator, upper, count) { |
||||
|
this.idGenerator = idGenerator; |
||||
|
this.upper = upper; |
||||
|
this.count = count; |
||||
|
this.segmentsList = []; |
||||
|
} |
||||
|
|
||||
|
ForkContext.prototype = { |
||||
|
constructor: ForkContext, |
||||
|
|
||||
|
/** |
||||
|
* The head segments. |
||||
|
* @type {CodePathSegment[]} |
||||
|
*/ |
||||
|
get head() { |
||||
|
var list = this.segmentsList; |
||||
|
return list.length === 0 ? [] : list[list.length - 1]; |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* A flag which shows empty. |
||||
|
* @type {boolean} |
||||
|
*/ |
||||
|
get empty() { |
||||
|
return this.segmentsList.length === 0; |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* A flag which shows reachable. |
||||
|
* @type {boolean} |
||||
|
*/ |
||||
|
get reachable() { |
||||
|
var segments = this.head; |
||||
|
return segments.length > 0 && segments.some(isReachable); |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Creates new segments from this context. |
||||
|
* |
||||
|
* @param {number} begin - The first index of previous segments. |
||||
|
* @param {number} end - The last index of previous segments. |
||||
|
* @returns {CodePathSegment[]} New segments. |
||||
|
*/ |
||||
|
makeNext: function(begin, end) { |
||||
|
return makeSegments(this, begin, end, CodePathSegment.newNext); |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Creates new segments from this context. |
||||
|
* The new segments is always unreachable. |
||||
|
* |
||||
|
* @param {number} begin - The first index of previous segments. |
||||
|
* @param {number} end - The last index of previous segments. |
||||
|
* @returns {CodePathSegment[]} New segments. |
||||
|
*/ |
||||
|
makeUnreachable: function(begin, end) { |
||||
|
return makeSegments(this, begin, end, CodePathSegment.newUnreachable); |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Creates new segments from this context. |
||||
|
* The new segments don't have connections for previous segments. |
||||
|
* But these inherit the reachable flag from this context. |
||||
|
* |
||||
|
* @param {number} begin - The first index of previous segments. |
||||
|
* @param {number} end - The last index of previous segments. |
||||
|
* @returns {CodePathSegment[]} New segments. |
||||
|
*/ |
||||
|
makeDisconnected: function(begin, end) { |
||||
|
return makeSegments(this, begin, end, CodePathSegment.newDisconnected); |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Adds segments into this context. |
||||
|
* The added segments become the head. |
||||
|
* |
||||
|
* @param {CodePathSegment[]} segments - Segments to add. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
add: function(segments) { |
||||
|
assert(segments.length >= this.count, segments.length + " >= " + this.count); |
||||
|
|
||||
|
this.segmentsList.push(mergeExtraSegments(this, segments)); |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Replaces the head segments with given segments. |
||||
|
* The current head segments are removed. |
||||
|
* |
||||
|
* @param {CodePathSegment[]} segments - Segments to add. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
replaceHead: function(segments) { |
||||
|
assert(segments.length >= this.count, segments.length + " >= " + this.count); |
||||
|
|
||||
|
this.segmentsList.splice(-1, 1, mergeExtraSegments(this, segments)); |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Adds all segments of a given fork context into this context. |
||||
|
* |
||||
|
* @param {ForkContext} context - A fork context to add. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
addAll: function(context) { |
||||
|
assert(context.count === this.count); |
||||
|
|
||||
|
var source = context.segmentsList; |
||||
|
for (var i = 0; i < source.length; ++i) { |
||||
|
this.segmentsList.push(source[i]); |
||||
|
} |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Clears all secments in this context. |
||||
|
* |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
clear: function() { |
||||
|
this.segmentsList = []; |
||||
|
} |
||||
|
}; |
||||
|
|
||||
|
/** |
||||
|
* Creates the root fork context. |
||||
|
* |
||||
|
* @param {IdGenerator} idGenerator - An identifier generator for segments. |
||||
|
* @returns {ForkContext} New fork context. |
||||
|
*/ |
||||
|
ForkContext.newRoot = function(idGenerator) { |
||||
|
var context = new ForkContext(idGenerator, null, 1); |
||||
|
|
||||
|
context.add([CodePathSegment.newRoot(idGenerator.next())]); |
||||
|
|
||||
|
return context; |
||||
|
}; |
||||
|
|
||||
|
/** |
||||
|
* Creates an empty fork context preceded by a given context. |
||||
|
* |
||||
|
* @param {ForkContext} parentContext - The parent fork context. |
||||
|
* @param {boolean} forkLeavingPath - A flag which shows inside of `finally` block. |
||||
|
* @returns {ForkContext} New fork context. |
||||
|
*/ |
||||
|
ForkContext.newEmpty = function(parentContext, forkLeavingPath) { |
||||
|
return new ForkContext( |
||||
|
parentContext.idGenerator, |
||||
|
parentContext, |
||||
|
(forkLeavingPath ? 2 : 1) * parentContext.count); |
||||
|
}; |
||||
|
|
||||
|
module.exports = ForkContext; |
||||
@ -0,0 +1,43 @@ |
|||||
|
/** |
||||
|
* @fileoverview A class of identifiers generator for code path segments. |
||||
|
* |
||||
|
* Each rule uses the identifier of code path segments to store additional |
||||
|
* information of the code path. |
||||
|
* |
||||
|
* @author Toru Nagashima |
||||
|
* @copyright 2015 Toru Nagashima. All rights reserved. |
||||
|
* See LICENSE file in root directory for full license. |
||||
|
*/ |
||||
|
|
||||
|
"use strict"; |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Public Interface
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
/** |
||||
|
* A generator for unique ids. |
||||
|
* |
||||
|
* @constructor |
||||
|
* @param {string} prefix - Optional. A prefix of generated ids. |
||||
|
*/ |
||||
|
function IdGenerator(prefix) { |
||||
|
this.prefix = String(prefix); |
||||
|
this.n = 0; |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Generates id. |
||||
|
* |
||||
|
* @returns {string} A generated id. |
||||
|
*/ |
||||
|
IdGenerator.prototype.next = function() { |
||||
|
this.n = 1 + this.n | 0; |
||||
|
/* istanbul ignore if */ |
||||
|
if (this.n < 0) { |
||||
|
this.n = 1; |
||||
|
} |
||||
|
return this.prefix + this.n; |
||||
|
}; |
||||
|
|
||||
|
module.exports = IdGenerator; |
||||
@ -0,0 +1,336 @@ |
|||||
|
/** |
||||
|
* @fileoverview Used for creating a suggested configuration based on project code. |
||||
|
* @author Ian VanSchooten |
||||
|
* @copyright 2015 Ian VanSchooten. All rights reserved. |
||||
|
* See LICENSE in root directory for full license. |
||||
|
*/ |
||||
|
|
||||
|
"use strict"; |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Requirements
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
var lodash = require("lodash"), |
||||
|
debug = require("debug"), |
||||
|
eslint = require("../eslint"), |
||||
|
configRule = require("./config-rule"), |
||||
|
recConfig = require("../../conf/eslint.json"); |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Data
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
var MAX_CONFIG_COMBINATIONS = 17, // 16 combinations + 1 for severity only
|
||||
|
RECOMMENDED_CONFIG_NAME = "eslint:recommended"; |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Private
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
debug = debug("eslint:autoconfig"); |
||||
|
|
||||
|
/** |
||||
|
* Information about a rule configuration, in the context of a Registry. |
||||
|
* |
||||
|
* @typedef {Object} registryItem |
||||
|
* @param {ruleConfig} config A valid configuration for the rule |
||||
|
* @param {number} specificity The number of elements in the ruleConfig array |
||||
|
* @param {number} errorCount The number of errors encountered when linting with the config |
||||
|
*/ |
||||
|
|
||||
|
/** |
||||
|
* This callback is used to measure execution status in a progress bar |
||||
|
* @callback progressCallback |
||||
|
* @param {number} The total number of times the callback will be called. |
||||
|
*/ |
||||
|
|
||||
|
/** |
||||
|
* Create registryItems for rules |
||||
|
* @param {rulesConfig} rulesConfig Hash of rule names and arrays of ruleConfig items |
||||
|
* @returns {Object} registryItems for each rule in provided rulesConfig |
||||
|
*/ |
||||
|
function makeRegistryItems(rulesConfig) { |
||||
|
return Object.keys(rulesConfig).reduce(function(accumulator, ruleId) { |
||||
|
accumulator[ruleId] = rulesConfig[ruleId].map(function(config) { |
||||
|
return { |
||||
|
config: config, |
||||
|
specificity: config.length || 1, |
||||
|
errorCount: void 0 |
||||
|
}; |
||||
|
}); |
||||
|
return accumulator; |
||||
|
}, {}); |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Creates an object in which to store rule configs and error counts |
||||
|
* |
||||
|
* Unless a rulesConfig is provided at construction, the registry will not contain |
||||
|
* any rules, only methods. This will be useful for building up registries manually. |
||||
|
* |
||||
|
* @constructor |
||||
|
* @class Registry |
||||
|
* @param {rulesConfig} [rulesConfig] Hash of rule names and arrays of possible configurations |
||||
|
*/ |
||||
|
function Registry(rulesConfig) { |
||||
|
this.rules = (rulesConfig) ? makeRegistryItems(rulesConfig) : {}; |
||||
|
} |
||||
|
|
||||
|
Registry.prototype = { |
||||
|
|
||||
|
constructor: Registry, |
||||
|
|
||||
|
/** |
||||
|
* Populate the registry with core rule configs. |
||||
|
* |
||||
|
* It will set the registry's `rule` property to an object having rule names |
||||
|
* as keys and an array of registryItems as values. |
||||
|
* |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
populateFromCoreRules: function() { |
||||
|
var rulesConfig = configRule.createCoreRuleConfigs(); |
||||
|
this.rules = makeRegistryItems(rulesConfig); |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Creates sets of rule configurations which can be used for linting |
||||
|
* and initializes registry errors to zero for those configurations (side effect). |
||||
|
* |
||||
|
* This combines as many rules together as possible, such that the first sets |
||||
|
* in the array will have the highest number of rules configured, and later sets |
||||
|
* will have fewer and fewer, as not all rules have the same number of possible |
||||
|
* configurations. |
||||
|
* |
||||
|
* The length of the returned array will be <= MAX_CONFIG_COMBINATIONS. |
||||
|
* |
||||
|
* @param {Object} registry The autoconfig registry |
||||
|
* @returns {Object[]} "rules" configurations to use for linting |
||||
|
*/ |
||||
|
buildRuleSets: function() { |
||||
|
var idx = 0, |
||||
|
ruleIds = Object.keys(this.rules), |
||||
|
ruleSets = []; |
||||
|
|
||||
|
/** |
||||
|
* Add a rule configuration from the registry to the ruleSets |
||||
|
* |
||||
|
* This is broken out into its own function so that it doesn't need to be |
||||
|
* created inside of the while loop. |
||||
|
* |
||||
|
* @param {string} rule The ruleId to add. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
var addRuleToRuleSet = function(rule) { |
||||
|
// This check ensures that there is a rule configuration, and that
|
||||
|
// it either has fewer than the max cominbations allowed, or if it has
|
||||
|
// too many configs, we will only use the most basic of them.
|
||||
|
var hasFewCombos = (this.rules[rule].length <= MAX_CONFIG_COMBINATIONS); |
||||
|
if (this.rules[rule][idx] && (hasFewCombos || this.rules[rule][idx].specificity <= 2)) { |
||||
|
// If the rule has too many possible combinations, only take simple ones, avoiding objects.
|
||||
|
if (!hasFewCombos && typeof this.rules[rule][idx].config[1] === "object") { |
||||
|
return; |
||||
|
} |
||||
|
ruleSets[idx] = ruleSets[idx] || {}; |
||||
|
ruleSets[idx][rule] = this.rules[rule][idx].config; |
||||
|
// Initialize errorCount to zero, since this is a config which will be linted
|
||||
|
this.rules[rule][idx].errorCount = 0; |
||||
|
} |
||||
|
}.bind(this); |
||||
|
|
||||
|
while (ruleSets.length === idx) { |
||||
|
ruleIds.forEach(addRuleToRuleSet); |
||||
|
idx += 1; |
||||
|
} |
||||
|
|
||||
|
return ruleSets; |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Remove all items from the registry with a non-zero number of errors |
||||
|
* |
||||
|
* Note: this also removes rule configurations which were not linted |
||||
|
* (meaning, they have an undefined errorCount). |
||||
|
* |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
stripFailingConfigs: function() { |
||||
|
var ruleIds = Object.keys(this.rules), |
||||
|
newRegistry = new Registry(); |
||||
|
|
||||
|
newRegistry.rules = lodash.assign({}, this.rules); |
||||
|
ruleIds.forEach(function(ruleId) { |
||||
|
var errorFreeItems = newRegistry.rules[ruleId].filter(function(registryItem) { |
||||
|
return (registryItem.errorCount === 0); |
||||
|
}); |
||||
|
if (errorFreeItems.length > 0) { |
||||
|
newRegistry.rules[ruleId] = errorFreeItems; |
||||
|
} else { |
||||
|
delete newRegistry.rules[ruleId]; |
||||
|
} |
||||
|
}); |
||||
|
|
||||
|
return newRegistry; |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Removes rule configurations which were not included in a ruleSet |
||||
|
* |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
stripExtraConfigs: function() { |
||||
|
var ruleIds = Object.keys(this.rules), |
||||
|
newRegistry = new Registry(); |
||||
|
|
||||
|
newRegistry.rules = lodash.assign({}, this.rules); |
||||
|
ruleIds.forEach(function(ruleId) { |
||||
|
newRegistry.rules[ruleId] = newRegistry.rules[ruleId].filter(function(registryItem) { |
||||
|
return (typeof registryItem.errorCount !== "undefined"); |
||||
|
}); |
||||
|
}); |
||||
|
|
||||
|
return newRegistry; |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Creates a registry of rules which had no error-free configs. |
||||
|
* The new registry is intended to be analyzed to determine whether its rules |
||||
|
* should be disabled or set to warning. |
||||
|
* |
||||
|
* @returns {Registry} A registry of failing rules. |
||||
|
*/ |
||||
|
getFailingRulesRegistry: function() { |
||||
|
var ruleIds = Object.keys(this.rules), |
||||
|
failingRegistry = new Registry(); |
||||
|
|
||||
|
ruleIds.forEach(function(ruleId) { |
||||
|
var failingConfigs = this.rules[ruleId].filter(function(registryItem) { |
||||
|
return (registryItem.errorCount > 0); |
||||
|
}); |
||||
|
if (failingConfigs && failingConfigs.length === this.rules[ruleId].length) { |
||||
|
failingRegistry.rules[ruleId] = failingConfigs; |
||||
|
} |
||||
|
}.bind(this)); |
||||
|
|
||||
|
return failingRegistry; |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Create an eslint config for any rules which only have one configuration |
||||
|
* in the registry. |
||||
|
* |
||||
|
* @returns {Object} An eslint config with rules section populated |
||||
|
*/ |
||||
|
createConfig: function() { |
||||
|
var ruleIds = Object.keys(this.rules), |
||||
|
config = {rules: {}}; |
||||
|
|
||||
|
ruleIds.forEach(function(ruleId) { |
||||
|
if (this.rules[ruleId].length === 1) { |
||||
|
config.rules[ruleId] = this.rules[ruleId][0].config; |
||||
|
} |
||||
|
}.bind(this)); |
||||
|
|
||||
|
return config; |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Return a cloned registry containing only configs with a desired specificity |
||||
|
* |
||||
|
* @param {number} specificity Only keep configs with this specificity |
||||
|
* @returns {Registry} A registry of rules |
||||
|
*/ |
||||
|
filterBySpecificity: function(specificity) { |
||||
|
var ruleIds = Object.keys(this.rules), |
||||
|
newRegistry = new Registry(); |
||||
|
|
||||
|
newRegistry.rules = lodash.assign({}, this.rules); |
||||
|
ruleIds.forEach(function(ruleId) { |
||||
|
newRegistry.rules[ruleId] = this.rules[ruleId].filter(function(registryItem) { |
||||
|
return (registryItem.specificity === specificity); |
||||
|
}); |
||||
|
}.bind(this)); |
||||
|
|
||||
|
return newRegistry; |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Lint SourceCodes against all configurations in the registry, and record results |
||||
|
* |
||||
|
* @param {Object[]} sourceCodes SourceCode objects for each filename |
||||
|
* @param {Object} config ESLint config object |
||||
|
* @param {progressCallback} [cb] Optional callback for reporting execution status |
||||
|
* @returns {Registry} New registry with errorCount populated |
||||
|
*/ |
||||
|
lintSourceCode: function(sourceCodes, config, cb) { |
||||
|
var totalFilesLinting, |
||||
|
lintConfig, |
||||
|
ruleSets, |
||||
|
ruleSetIdx, |
||||
|
filenames, |
||||
|
lintedRegistry; |
||||
|
|
||||
|
lintedRegistry = new Registry(); |
||||
|
lintedRegistry.rules = lodash.assign({}, this.rules); |
||||
|
ruleSets = lintedRegistry.buildRuleSets(); |
||||
|
lintedRegistry = lintedRegistry.stripExtraConfigs(); |
||||
|
|
||||
|
debug("Linting with all possible rule combinations"); |
||||
|
filenames = Object.keys(sourceCodes); |
||||
|
totalFilesLinting = filenames.length * ruleSets.length; |
||||
|
filenames.forEach(function(filename) { |
||||
|
debug("Linting file: " + filename); |
||||
|
ruleSetIdx = 0; |
||||
|
ruleSets.forEach(function(ruleSet) { |
||||
|
lintConfig = lodash.assign({}, config, {rules: ruleSet}); |
||||
|
var lintResults = eslint.verify(sourceCodes[filename], lintConfig); |
||||
|
lintResults.forEach(function(result) { |
||||
|
lintedRegistry.rules[result.ruleId][ruleSetIdx].errorCount += 1; |
||||
|
}); |
||||
|
ruleSetIdx += 1; |
||||
|
if (cb) { |
||||
|
cb(totalFilesLinting); // eslint-disable-line callback-return
|
||||
|
} |
||||
|
}); |
||||
|
// Deallocate for GC
|
||||
|
sourceCodes[filename] = null; |
||||
|
}); |
||||
|
|
||||
|
return lintedRegistry; |
||||
|
} |
||||
|
}; |
||||
|
|
||||
|
/** |
||||
|
* Extract rule configuration into eslint:recommended where possible. |
||||
|
* |
||||
|
* This will return a new config with `"extends": "eslint:recommended"` and |
||||
|
* only the rules which have configurations different from the recommended config. |
||||
|
* |
||||
|
* @param {Object} config config object |
||||
|
* @returns {Object} config object using `"extends": "eslint:recommended"` |
||||
|
*/ |
||||
|
function extendFromRecommended(config) { |
||||
|
var newConfig = lodash.assign({}, config); |
||||
|
var recRules = Object.keys(recConfig.rules).filter(function(ruleId) { |
||||
|
return (recConfig.rules[ruleId] === 2 || recConfig.rules[ruleId][0] === 2); |
||||
|
}); |
||||
|
|
||||
|
recRules.forEach(function(ruleId) { |
||||
|
if (lodash.isEqual(recConfig.rules[ruleId], newConfig.rules[ruleId])) { |
||||
|
delete newConfig.rules[ruleId]; |
||||
|
} |
||||
|
}); |
||||
|
newConfig.extends = RECOMMENDED_CONFIG_NAME; |
||||
|
return newConfig; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Public Interface
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
module.exports = { |
||||
|
Registry: Registry, |
||||
|
extendFromRecommended: extendFromRecommended |
||||
|
}; |
||||
@ -0,0 +1,308 @@ |
|||||
|
/** |
||||
|
* @fileoverview Create configurations for a rule |
||||
|
* @author Ian VanSchooten |
||||
|
* @copyright 2016 Ian VanSchooten. All rights reserved. |
||||
|
* See LICENSE in root directory for full license. |
||||
|
*/ |
||||
|
|
||||
|
"use strict"; |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Requirements
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
var rules = require("../rules"), |
||||
|
loadRules = require("../load-rules"); |
||||
|
|
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Helpers
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
/** |
||||
|
* Wrap all of the elements of an array into arrays. |
||||
|
* @param {*[]} xs Any array. |
||||
|
* @returns {Array[]} An array of arrays. |
||||
|
*/ |
||||
|
function explodeArray(xs) { |
||||
|
return xs.reduce(function(accumulator, x) { |
||||
|
accumulator.push([x]); |
||||
|
return accumulator; |
||||
|
}, []); |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Mix two arrays such that each element of the second array is concatenated |
||||
|
* onto each element of the first array. |
||||
|
* |
||||
|
* For example: |
||||
|
* combineArrays([a, [b, c]], [x, y]); // -> [[a, x], [a, y], [b, c, x], [b, c, y]]
|
||||
|
* |
||||
|
* @param {array} arr1 The first array to combine. |
||||
|
* @param {array} arr2 The second array to combine. |
||||
|
* @returns {array} A mixture of the elements of the first and second arrays. |
||||
|
*/ |
||||
|
function combineArrays(arr1, arr2) { |
||||
|
var res = []; |
||||
|
if (arr1.length === 0) { |
||||
|
return explodeArray(arr2); |
||||
|
} |
||||
|
if (arr2.length === 0) { |
||||
|
return explodeArray(arr1); |
||||
|
} |
||||
|
arr1.forEach(function(x1) { |
||||
|
arr2.forEach(function(x2) { |
||||
|
res.push([].concat(x1, x2)); |
||||
|
}); |
||||
|
}); |
||||
|
return res; |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Group together valid rule configurations based on object properties |
||||
|
* |
||||
|
* e.g.: |
||||
|
* groupByProperty([ |
||||
|
* {before: true}, |
||||
|
* {before: false}, |
||||
|
* {after: true}, |
||||
|
* {after: false} |
||||
|
* ]); |
||||
|
* |
||||
|
* will return: |
||||
|
* [ |
||||
|
* [{before: true}, {before: false}], |
||||
|
* [{after: true}, {after: false}] |
||||
|
* ] |
||||
|
* |
||||
|
* @param {Object[]} objects Array of objects, each with one property/value pair |
||||
|
* @returns {Array[]} Array of arrays of objects grouped by property |
||||
|
*/ |
||||
|
function groupByProperty(objects) { |
||||
|
var groupedObj = objects.reduce(function(accumulator, obj) { |
||||
|
var prop = Object.keys(obj)[0]; |
||||
|
accumulator[prop] = accumulator[prop] ? accumulator[prop].concat(obj) : [obj]; |
||||
|
return accumulator; |
||||
|
}, {}); |
||||
|
return Object.keys(groupedObj).map(function(prop) { |
||||
|
return groupedObj[prop]; |
||||
|
}); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Private
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
/** |
||||
|
* Configuration settings for a rule. |
||||
|
* |
||||
|
* A configuration can be a single number (severity), or an array where the first |
||||
|
* element in the array is the severity, and is the only required element. |
||||
|
* Configs may also have one or more additional elements to specify rule |
||||
|
* configuration or options. |
||||
|
* |
||||
|
* @typedef {array|number} ruleConfig |
||||
|
* @param {number} 0 The rule's severity (0, 1, 2). |
||||
|
*/ |
||||
|
|
||||
|
/** |
||||
|
* Object whose keys are rule names and values are arrays of valid ruleConfig items |
||||
|
* which should be linted against the target source code to determine error counts. |
||||
|
* (a ruleConfigSet.ruleConfigs). |
||||
|
* |
||||
|
* e.g. rulesConfig = { |
||||
|
* "comma-dangle": [2, [2, "always"], [2, "always-multiline"], [2, "never"]], |
||||
|
* "no-console": [2] |
||||
|
* } |
||||
|
* @typedef rulesConfig |
||||
|
*/ |
||||
|
|
||||
|
|
||||
|
/** |
||||
|
* Create valid rule configurations by combining two arrays, |
||||
|
* with each array containing multiple objects each with a |
||||
|
* single property/value pair and matching properties. |
||||
|
* |
||||
|
* e.g.: |
||||
|
* combinePropertyObjects( |
||||
|
* [{before: true}, {before: false}], |
||||
|
* [{after: true}, {after: false}] |
||||
|
* ); |
||||
|
* |
||||
|
* will return: |
||||
|
* [ |
||||
|
* {before: true, after: true}, |
||||
|
* {before: true, after: false}, |
||||
|
* {before: false, after: true}, |
||||
|
* {before: false, after: false} |
||||
|
* ] |
||||
|
* |
||||
|
* @param {Object[]} objArr1 Single key/value objects, all with the same key |
||||
|
* @param {Object[]} objArr2 Single key/value objects, all with another key |
||||
|
* @returns {Object[]} Combined objects for each combination of input properties and values |
||||
|
*/ |
||||
|
function combinePropertyObjects(objArr1, objArr2) { |
||||
|
var res = []; |
||||
|
if (objArr1.length === 0) { |
||||
|
return objArr2; |
||||
|
} |
||||
|
if (objArr2.length === 0) { |
||||
|
return objArr1; |
||||
|
} |
||||
|
objArr1.forEach(function(obj1) { |
||||
|
objArr2.forEach(function(obj2) { |
||||
|
var combinedObj = {}; |
||||
|
var obj1Props = Object.keys(obj1); |
||||
|
var obj2Props = Object.keys(obj2); |
||||
|
obj1Props.forEach(function(prop1) { |
||||
|
combinedObj[prop1] = obj1[prop1]; |
||||
|
}); |
||||
|
obj2Props.forEach(function(prop2) { |
||||
|
combinedObj[prop2] = obj2[prop2]; |
||||
|
}); |
||||
|
res.push(combinedObj); |
||||
|
}); |
||||
|
}); |
||||
|
return res; |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Creates a new instance of a rule configuration set |
||||
|
* |
||||
|
* A rule configuration set is an array of configurations that are valid for a |
||||
|
* given rule. For example, the configuration set for the "semi" rule could be: |
||||
|
* |
||||
|
* ruleConfigSet.ruleConfigs // -> [[2], [2, "always"], [2, "never"]]
|
||||
|
* |
||||
|
* @param {ruleConfig[]} configs Valid rule configurations |
||||
|
* @constructor |
||||
|
*/ |
||||
|
function RuleConfigSet(configs) { |
||||
|
|
||||
|
/** |
||||
|
* Stored valid rule configurations for this instance |
||||
|
* @type {array} |
||||
|
*/ |
||||
|
this.ruleConfigs = configs || []; |
||||
|
|
||||
|
} |
||||
|
|
||||
|
RuleConfigSet.prototype = { |
||||
|
|
||||
|
constructor: RuleConfigSet, |
||||
|
|
||||
|
/** |
||||
|
* Add a severity level to the front of all configs in the instance. |
||||
|
* This should only be called after all configs have been added to the instance. |
||||
|
* |
||||
|
* @param {number} [severity=2] The level of severity for the rule (0, 1, 2) |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
addErrorSeverity: function(severity) { |
||||
|
severity = severity || 2; |
||||
|
this.ruleConfigs = this.ruleConfigs.map(function(config) { |
||||
|
config.unshift(severity); |
||||
|
return config; |
||||
|
}); |
||||
|
// Add a single config at the beginning consisting of only the severity
|
||||
|
this.ruleConfigs.unshift(severity); |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Add rule configs from an array of strings (schema enums) |
||||
|
* @param {string[]} enums Array of valid rule options (e.g. ["always", "never"]) |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
addEnums: function(enums) { |
||||
|
this.ruleConfigs = this.ruleConfigs.concat(combineArrays(this.ruleConfigs, enums)); |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Add rule configurations from a schema object |
||||
|
* @param {Object} obj Schema item with type === "object" |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
addObject: function(obj) { |
||||
|
var objectConfigSet = { |
||||
|
objectConfigs: [], |
||||
|
add: function(property, values) { |
||||
|
var optionObj; |
||||
|
for (var idx = 0; idx < values.length; idx++) { |
||||
|
optionObj = {}; |
||||
|
optionObj[property] = values[idx]; |
||||
|
this.objectConfigs.push(optionObj); |
||||
|
} |
||||
|
}, |
||||
|
|
||||
|
combine: function() { |
||||
|
this.objectConfigs = groupByProperty(this.objectConfigs).reduce(function(accumulator, objArr) { |
||||
|
return combinePropertyObjects(accumulator, objArr); |
||||
|
}, []); |
||||
|
} |
||||
|
}; |
||||
|
// The object schema could have multiple independent properties.
|
||||
|
// If any contain enums or booleans, they can be added and then combined
|
||||
|
Object.keys(obj.properties).forEach(function(prop) { |
||||
|
if (obj.properties[prop].enum) { |
||||
|
objectConfigSet.add(prop, obj.properties[prop].enum); |
||||
|
} |
||||
|
if (obj.properties[prop].type && obj.properties[prop].type === "boolean") { |
||||
|
objectConfigSet.add(prop, [true, false]); |
||||
|
} |
||||
|
}); |
||||
|
objectConfigSet.combine(); |
||||
|
|
||||
|
if (objectConfigSet.objectConfigs.length > 0) { |
||||
|
this.ruleConfigs = this.ruleConfigs.concat(combineArrays(this.ruleConfigs, objectConfigSet.objectConfigs)); |
||||
|
} |
||||
|
} |
||||
|
}; |
||||
|
|
||||
|
/** |
||||
|
* Generate valid rule configurations based on a schema object |
||||
|
* @param {Object} schema A rule's schema object |
||||
|
* @returns {array[]} Valid rule configurations |
||||
|
*/ |
||||
|
function generateConfigsFromSchema(schema) { |
||||
|
var configSet = new RuleConfigSet(); |
||||
|
if (Array.isArray(schema)) { |
||||
|
schema.forEach(function(opt) { |
||||
|
if (opt.enum) { |
||||
|
configSet.addEnums(opt.enum); |
||||
|
} |
||||
|
if (opt.type && opt.type === "object") { |
||||
|
configSet.addObject(opt); |
||||
|
} |
||||
|
if (opt.oneOf) { |
||||
|
// TODO (IanVS): not yet implemented
|
||||
|
} |
||||
|
}); |
||||
|
} |
||||
|
configSet.addErrorSeverity(); |
||||
|
return configSet.ruleConfigs; |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Generate possible rule configurations for all of the core rules |
||||
|
* @returns {rulesConfig} Hash of rule names and arrays of possible configurations |
||||
|
*/ |
||||
|
function createCoreRuleConfigs() { |
||||
|
var ruleList = loadRules(); |
||||
|
return Object.keys(ruleList).reduce(function(accumulator, id) { |
||||
|
var rule = rules.get(id); |
||||
|
var schema = (typeof rule === "function") ? rule.schema : rule.meta.schema; |
||||
|
accumulator[id] = generateConfigsFromSchema(schema); |
||||
|
return accumulator; |
||||
|
}, {}); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Public Interface
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
module.exports = { |
||||
|
generateConfigsFromSchema: generateConfigsFromSchema, |
||||
|
createCoreRuleConfigs: createCoreRuleConfigs |
||||
|
}; |
||||
@ -0,0 +1,87 @@ |
|||||
|
/** |
||||
|
* @fileoverview Environments manager |
||||
|
* @author Nicholas C. Zakas |
||||
|
* @copyright 2016 Nicholas C. Zakas. All rights reserved. |
||||
|
* See LICENSE file in root directory for full license. |
||||
|
*/ |
||||
|
"use strict"; |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Requirements
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
var debug = require("debug"), |
||||
|
envs = require("../../conf/environments"); |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Private
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
debug = debug("eslint:enviroments"); |
||||
|
|
||||
|
var environments = Object.create(null); |
||||
|
|
||||
|
/** |
||||
|
* Loads the default environments. |
||||
|
* @returns {void} |
||||
|
* @private |
||||
|
*/ |
||||
|
function load() { |
||||
|
Object.keys(envs).forEach(function(envName) { |
||||
|
environments[envName] = envs[envName]; |
||||
|
}); |
||||
|
} |
||||
|
|
||||
|
// always load default environments upfront
|
||||
|
load(); |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Public Interface
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
module.exports = { |
||||
|
|
||||
|
load: load, |
||||
|
|
||||
|
/** |
||||
|
* Gets the environment with the given name. |
||||
|
* @param {string} name The name of the environment to retrieve. |
||||
|
* @returns {Object?} The environment object or null if not found. |
||||
|
*/ |
||||
|
get: function(name) { |
||||
|
return environments[name] || null; |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Defines an environment. |
||||
|
* @param {string} name The name of the environment. |
||||
|
* @param {Object} env The environment settings. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
define: function(name, env) { |
||||
|
environments[name] = env; |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Imports all environments from a plugin. |
||||
|
* @param {Object} plugin The plugin object. |
||||
|
* @param {string} pluginName The name of the plugin. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
importPlugin: function(plugin, pluginName) { |
||||
|
if (plugin.environments) { |
||||
|
Object.keys(plugin.environments).forEach(function(envName) { |
||||
|
this.define(pluginName + "/" + envName, plugin.environments[envName]); |
||||
|
}, this); |
||||
|
} |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Resets all environments. Only use for tests! |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
testReset: function() { |
||||
|
environments = Object.create(null); |
||||
|
load(); |
||||
|
} |
||||
|
}; |
||||
@ -0,0 +1,144 @@ |
|||||
|
/** |
||||
|
* @fileoverview Plugins manager |
||||
|
* @author Nicholas C. Zakas |
||||
|
* @copyright 2016 Nicholas C. Zakas. All rights reserved. |
||||
|
* See LICENSE file in root directory for full license. |
||||
|
*/ |
||||
|
"use strict"; |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Requirements
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
var debug = require("debug"), |
||||
|
Environments = require("./environments"), |
||||
|
rules = require("../rules"); |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Private
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
debug = debug("eslint:plugins"); |
||||
|
|
||||
|
var plugins = Object.create(null); |
||||
|
|
||||
|
var PLUGIN_NAME_PREFIX = "eslint-plugin-", |
||||
|
NAMESPACE_REGEX = /^@.*\//i; |
||||
|
|
||||
|
/** |
||||
|
* Removes the prefix `eslint-plugin-` from a plugin name. |
||||
|
* @param {string} pluginName The name of the plugin which may have the prefix. |
||||
|
* @returns {string} The name of the plugin without prefix. |
||||
|
*/ |
||||
|
function removePrefix(pluginName) { |
||||
|
return pluginName.indexOf(PLUGIN_NAME_PREFIX) === 0 ? pluginName.substring(PLUGIN_NAME_PREFIX.length) : pluginName; |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Gets the scope (namespace) of a plugin. |
||||
|
* @param {string} pluginName The name of the plugin which may have the prefix. |
||||
|
* @returns {string} The name of the plugins namepace if it has one. |
||||
|
*/ |
||||
|
function getNamespace(pluginName) { |
||||
|
return pluginName.match(NAMESPACE_REGEX) ? pluginName.match(NAMESPACE_REGEX)[0] : ""; |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Removes the namespace from a plugin name. |
||||
|
* @param {string} pluginName The name of the plugin which may have the prefix. |
||||
|
* @returns {string} The name of the plugin without the namespace. |
||||
|
*/ |
||||
|
function removeNamespace(pluginName) { |
||||
|
return pluginName.replace(NAMESPACE_REGEX, ""); |
||||
|
} |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Public Interface
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
module.exports = { |
||||
|
|
||||
|
removePrefix: removePrefix, |
||||
|
getNamespace: getNamespace, |
||||
|
removeNamespace: removeNamespace, |
||||
|
|
||||
|
/** |
||||
|
* Defines a plugin with a given name rather than loading from disk. |
||||
|
* @param {string} pluginName The name of the plugin to load. |
||||
|
* @param {Object} plugin The plugin object. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
define: function(pluginName, plugin) { |
||||
|
var pluginNameWithoutNamespace = removeNamespace(pluginName), |
||||
|
pluginNameWithoutPrefix = removePrefix(pluginNameWithoutNamespace); |
||||
|
|
||||
|
plugins[pluginNameWithoutPrefix] = plugin; |
||||
|
|
||||
|
// load up environments and rules
|
||||
|
Environments.importPlugin(plugin, pluginNameWithoutPrefix); |
||||
|
|
||||
|
if (plugin.rules) { |
||||
|
rules.import(plugin.rules, pluginNameWithoutPrefix); |
||||
|
} |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Gets a plugin with the given name. |
||||
|
* @param {string} pluginName The name of the plugin to retrieve. |
||||
|
* @returns {Object} The plugin or null if not loaded. |
||||
|
*/ |
||||
|
get: function(pluginName) { |
||||
|
return plugins[pluginName] || null; |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Returns all plugins that are loaded. |
||||
|
* @returns {Object} The plugins cache. |
||||
|
*/ |
||||
|
getAll: function() { |
||||
|
return plugins; |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Loads a plugin with the given name. |
||||
|
* @param {string} pluginName The name of the plugin to load. |
||||
|
* @returns {void} |
||||
|
* @throws {Error} If the plugin cannot be loaded. |
||||
|
*/ |
||||
|
load: function(pluginName) { |
||||
|
var pluginNamespace = getNamespace(pluginName), |
||||
|
pluginNameWithoutNamespace = removeNamespace(pluginName), |
||||
|
pluginNameWithoutPrefix = removePrefix(pluginNameWithoutNamespace), |
||||
|
plugin = null; |
||||
|
|
||||
|
if (!plugins[pluginNameWithoutPrefix]) { |
||||
|
try { |
||||
|
plugin = require(pluginNamespace + PLUGIN_NAME_PREFIX + pluginNameWithoutPrefix); |
||||
|
} catch (err) { |
||||
|
debug("Failed to load plugin eslint-plugin-" + pluginNameWithoutPrefix + ". Proceeding without it."); |
||||
|
err.message = "Failed to load plugin " + pluginName + ": " + err.message; |
||||
|
throw err; |
||||
|
} |
||||
|
|
||||
|
this.define(pluginName, plugin); |
||||
|
} |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Loads all plugins from an array. |
||||
|
* @param {string[]} pluginNames An array of plugins names. |
||||
|
* @returns {void} |
||||
|
* @throws {Error} If a plugin cannot be loaded. |
||||
|
*/ |
||||
|
loadAll: function(pluginNames) { |
||||
|
pluginNames.forEach(this.load, this); |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Resets plugin information. Use for tests only. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
testReset: function() { |
||||
|
plugins = Object.create(null); |
||||
|
} |
||||
|
}; |
||||
@ -0,0 +1,8 @@ |
|||||
|
<tr style="display:none" class="f-<%= parentIndex %>"> |
||||
|
<td><%= lineNumber %>:<%= columnNumber %></td> |
||||
|
<td class="clr-<%= severityNumber %>"><%= severityName %></td> |
||||
|
<td><%- message %></td> |
||||
|
<td> |
||||
|
<a href="http://eslint.org/docs/rules/<%= ruleId %>" target="_blank"><%= ruleId %></a> |
||||
|
</td> |
||||
|
</tr> |
||||
@ -0,0 +1,113 @@ |
|||||
|
<!DOCTYPE html> |
||||
|
<head> |
||||
|
<title>ESLint Report</title> |
||||
|
<style> |
||||
|
body { |
||||
|
font-family:Arial, "Helvetica Neue", Helvetica, sans-serif; |
||||
|
font-size:16px; |
||||
|
font-weight:normal; |
||||
|
margin:0; |
||||
|
padding:0; |
||||
|
color:#333 |
||||
|
} |
||||
|
#overview { |
||||
|
padding:20px 30px |
||||
|
} |
||||
|
td, th { |
||||
|
padding:5px 10px |
||||
|
} |
||||
|
h1 { |
||||
|
margin:0 |
||||
|
} |
||||
|
table { |
||||
|
margin:30px; |
||||
|
width:calc(100% - 60px); |
||||
|
max-width:1000px; |
||||
|
border-radius:5px; |
||||
|
border:1px solid #ddd; |
||||
|
border-spacing:0px; |
||||
|
} |
||||
|
th { |
||||
|
font-weight:400; |
||||
|
font-size:normal; |
||||
|
text-align:left; |
||||
|
cursor:pointer |
||||
|
} |
||||
|
td.clr-1, td.clr-2, th span { |
||||
|
font-weight:700 |
||||
|
} |
||||
|
th span { |
||||
|
float:right; |
||||
|
margin-left:20px |
||||
|
} |
||||
|
th span:after { |
||||
|
content:""; |
||||
|
clear:both; |
||||
|
display:block |
||||
|
} |
||||
|
tr:last-child td { |
||||
|
border-bottom:none |
||||
|
} |
||||
|
tr td:first-child, tr td:last-child { |
||||
|
color:#9da0a4 |
||||
|
} |
||||
|
#overview.bg-0, tr.bg-0 th { |
||||
|
color:#468847; |
||||
|
background:#dff0d8; |
||||
|
border-bottom:1px solid #d6e9c6 |
||||
|
} |
||||
|
#overview.bg-1, tr.bg-1 th { |
||||
|
color:#f0ad4e; |
||||
|
background:#fcf8e3; |
||||
|
border-bottom:1px solid #fbeed5 |
||||
|
} |
||||
|
#overview.bg-2, tr.bg-2 th { |
||||
|
color:#b94a48; |
||||
|
background:#f2dede; |
||||
|
border-bottom:1px solid #eed3d7 |
||||
|
} |
||||
|
td { |
||||
|
border-bottom:1px solid #ddd |
||||
|
} |
||||
|
td.clr-1 { |
||||
|
color:#f0ad4e |
||||
|
} |
||||
|
td.clr-2 { |
||||
|
color:#b94a48 |
||||
|
} |
||||
|
td a { |
||||
|
color:#3a33d1; |
||||
|
text-decoration:none |
||||
|
} |
||||
|
td a:hover { |
||||
|
color:#272296; |
||||
|
text-decoration:underline |
||||
|
} |
||||
|
</style> |
||||
|
</head> |
||||
|
<body> |
||||
|
<div id="overview" class="bg-<%= reportColor %>"> |
||||
|
<h1>ESLint Report</h1> |
||||
|
<div> |
||||
|
<span><%= reportSummary %></span> - Generated on <%= date %> |
||||
|
</div> |
||||
|
</div> |
||||
|
<table> |
||||
|
<tbody> |
||||
|
<%= results %> |
||||
|
</tbody> |
||||
|
</table> |
||||
|
<script type="text/javascript"> |
||||
|
var groups = document.querySelectorAll("tr[data-group]"); |
||||
|
for (i = 0; i < groups.length; i++) { |
||||
|
groups[i].addEventListener("click", function() { |
||||
|
var inGroup = document.getElementsByClassName(this.getAttribute("data-group")); |
||||
|
this.innerHTML = (this.innerHTML.indexOf("+") > -1) ? this.innerHTML.replace("+", "-") : this.innerHTML.replace("-", "+"); |
||||
|
for (var j = 0; j < inGroup.length; j++) { |
||||
|
inGroup[j].style.display = (inGroup[j].style.display !== "none") ? "none" : "table-row"; |
||||
|
} |
||||
|
}); |
||||
|
} |
||||
|
</script> |
||||
|
</body> |
||||
|
</html> |
||||
@ -0,0 +1,6 @@ |
|||||
|
<tr class="bg-<%- color %>" data-group="f-<%- index %>"> |
||||
|
<th colspan="4"> |
||||
|
[+] <%- filePath %> |
||||
|
<span><%- summary %></span> |
||||
|
</th> |
||||
|
</tr> |
||||
@ -1,130 +0,0 @@ |
|||||
<!DOCTYPE html> |
|
||||
<head> |
|
||||
<title>ESLint Report</title> |
|
||||
<style> |
|
||||
body { |
|
||||
font-family:Arial, "Helvetica Neue", Helvetica, sans-serif; |
|
||||
font-size:16px; |
|
||||
font-weight:normal; |
|
||||
margin:0; |
|
||||
padding:0; |
|
||||
color:#333 |
|
||||
} |
|
||||
#overview { |
|
||||
padding:20px 30px |
|
||||
} |
|
||||
td, th { |
|
||||
padding:5px 10px |
|
||||
} |
|
||||
h1 { |
|
||||
margin:0 |
|
||||
} |
|
||||
table { |
|
||||
margin:30px; |
|
||||
width:calc(100% - 60px); |
|
||||
max-width:1000px; |
|
||||
border-radius:5px; |
|
||||
border:1px solid #ddd; |
|
||||
border-spacing:0px; |
|
||||
} |
|
||||
th { |
|
||||
font-weight:400; |
|
||||
font-size:normal; |
|
||||
text-align:left; |
|
||||
cursor:pointer |
|
||||
} |
|
||||
td.clr-1, td.clr-2, th span { |
|
||||
font-weight:700 |
|
||||
} |
|
||||
th span { |
|
||||
float:right; |
|
||||
margin-left:20px |
|
||||
} |
|
||||
th span:after { |
|
||||
content:""; |
|
||||
clear:both; |
|
||||
display:block |
|
||||
} |
|
||||
tr:last-child td { |
|
||||
border-bottom:none |
|
||||
} |
|
||||
tr td:first-child, tr td:last-child { |
|
||||
color:#9da0a4 |
|
||||
} |
|
||||
#overview.bg-0, tr.bg-0 th { |
|
||||
color:#468847; |
|
||||
background:#dff0d8; |
|
||||
border-bottom:1px solid #d6e9c6 |
|
||||
} |
|
||||
#overview.bg-1, tr.bg-1 th { |
|
||||
color:#f0ad4e; |
|
||||
background:#fcf8e3; |
|
||||
border-bottom:1px solid #fbeed5 |
|
||||
} |
|
||||
#overview.bg-2, tr.bg-2 th { |
|
||||
color:#b94a48; |
|
||||
background:#f2dede; |
|
||||
border-bottom:1px solid #eed3d7 |
|
||||
} |
|
||||
td { |
|
||||
border-bottom:1px solid #ddd |
|
||||
} |
|
||||
td.clr-1 { |
|
||||
color:#f0ad4e |
|
||||
} |
|
||||
td.clr-2 { |
|
||||
color:#b94a48 |
|
||||
} |
|
||||
td a { |
|
||||
color:#3a33d1; |
|
||||
text-decoration:none |
|
||||
} |
|
||||
td a:hover { |
|
||||
color:#272296; |
|
||||
text-decoration:underline |
|
||||
} |
|
||||
</style> |
|
||||
</head> |
|
||||
<body> |
|
||||
<div id="overview" class="bg-{{getColor totalErrors totalWarnings}}"> |
|
||||
<h1>ESLint Report</h1> |
|
||||
<div> |
|
||||
<span>{{renderText totalErrors totalWarnings}}</span> - Generated on {{date}} |
|
||||
</div> |
|
||||
</div> |
|
||||
<table> |
|
||||
<tbody> |
|
||||
{{#each results}} |
|
||||
<tr class="bg-{{getColor this.errorCount this.warningCount}}" data-group="f-{{@index}}"> |
|
||||
<th colspan="4"> |
|
||||
[+] {{this.filePath}} |
|
||||
<span>{{renderText this.errorCount this.warningCount}}</span> |
|
||||
</th> |
|
||||
</tr> |
|
||||
{{#each this.messages}} |
|
||||
<tr class="f-{{@../index}}" style="display:none"> |
|
||||
<td>{{#if this.line}}{{this.line}}{{else}}0{{/if}}:{{#if this.column}}{{this.column}}{{else}}0{{/if}}</td> |
|
||||
{{getSeverity this.severity}} |
|
||||
<td>{{this.message}}</td> |
|
||||
<td> |
|
||||
<a href="http://eslint.org/docs/rules/{{this.ruleId}}" target="_blank">{{this.ruleId}}</a> |
|
||||
</td> |
|
||||
</tr> |
|
||||
{{/each}} |
|
||||
{{/each}} |
|
||||
</tbody> |
|
||||
</table> |
|
||||
<script type="text/javascript"> |
|
||||
var groups = document.querySelectorAll("tr[data-group]"); |
|
||||
for (i = 0; i < groups.length; i++) { |
|
||||
groups[i].addEventListener("click", function() { |
|
||||
var inGroup = document.getElementsByClassName(this.getAttribute("data-group")); |
|
||||
this.innerHTML = (this.innerHTML.indexOf("+") > -1) ? this.innerHTML.replace("+", "-") : this.innerHTML.replace("-", "+"); |
|
||||
for (var j = 0; j < inGroup.length; j++) { |
|
||||
inGroup[j].style.display = (inGroup[j].style.display !== "none") ? "none" : "table-row"; |
|
||||
} |
|
||||
}); |
|
||||
} |
|
||||
</script> |
|
||||
</body> |
|
||||
</html> |
|
||||
@ -0,0 +1,159 @@ |
|||||
|
/** |
||||
|
* @fileoverview "table reporter. |
||||
|
* @author Gajus Kuizinas <gajus@gajus.com> |
||||
|
* @copyright 2016 Gajus Kuizinas <gajus@gajus.com>. All rights reserved. |
||||
|
*/ |
||||
|
"use strict"; |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Requirements
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
var chalk, |
||||
|
table, |
||||
|
pluralize; |
||||
|
|
||||
|
chalk = require("chalk"); |
||||
|
table = require("table").default; |
||||
|
pluralize = require("pluralize"); |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Helpers
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
/** |
||||
|
* Draws text table. |
||||
|
* @param {Array<Object>} messages Error messages relating to a specific file. |
||||
|
* @returns {string} A text table. |
||||
|
*/ |
||||
|
function drawTable(messages) { |
||||
|
var rows; |
||||
|
|
||||
|
rows = []; |
||||
|
|
||||
|
if (messages.length === 0) { |
||||
|
return ""; |
||||
|
} |
||||
|
|
||||
|
rows.push([ |
||||
|
chalk.bold("Line"), |
||||
|
chalk.bold("Column"), |
||||
|
chalk.bold("Type"), |
||||
|
chalk.bold("Message"), |
||||
|
chalk.bold("Rule ID") |
||||
|
]); |
||||
|
|
||||
|
messages.forEach(function(message) { |
||||
|
var messageType; |
||||
|
|
||||
|
if (message.fatal || message.severity === 2) { |
||||
|
messageType = chalk.red("error"); |
||||
|
} else { |
||||
|
messageType = chalk.yellow("warning"); |
||||
|
} |
||||
|
|
||||
|
rows.push([ |
||||
|
message.line || 0, |
||||
|
message.column || 0, |
||||
|
messageType, |
||||
|
message.message, |
||||
|
message.ruleId || "" |
||||
|
]); |
||||
|
}); |
||||
|
|
||||
|
return table(rows, { |
||||
|
columns: { |
||||
|
0: { |
||||
|
width: 8, |
||||
|
wrapWord: true |
||||
|
}, |
||||
|
1: { |
||||
|
width: 8, |
||||
|
wrapWord: true |
||||
|
}, |
||||
|
2: { |
||||
|
width: 8, |
||||
|
wrapWord: true |
||||
|
}, |
||||
|
3: { |
||||
|
paddingRight: 5, |
||||
|
width: 50, |
||||
|
wrapWord: true |
||||
|
}, |
||||
|
4: { |
||||
|
width: 20, |
||||
|
wrapWord: true |
||||
|
} |
||||
|
}, |
||||
|
drawHorizontalLine: function(index) { |
||||
|
return index === 1; |
||||
|
} |
||||
|
}); |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Draws a report (multiple tables). |
||||
|
* @param {Array} results Report results for every file. |
||||
|
* @returns {string} A column of text tables. |
||||
|
*/ |
||||
|
function drawReport(results) { |
||||
|
var files; |
||||
|
|
||||
|
files = results.map(function(result) { |
||||
|
if (!result.messages.length) { |
||||
|
return ""; |
||||
|
} |
||||
|
|
||||
|
return "\n" + result.filePath + "\n\n" + drawTable(result.messages); |
||||
|
}); |
||||
|
|
||||
|
files = files.filter(function(content) { |
||||
|
return content.trim(); |
||||
|
}); |
||||
|
|
||||
|
return files.join(""); |
||||
|
} |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Public Interface
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
module.exports = function(report) { |
||||
|
var result, |
||||
|
errorCount, |
||||
|
warningCount; |
||||
|
|
||||
|
result = ""; |
||||
|
errorCount = 0; |
||||
|
warningCount = 0; |
||||
|
|
||||
|
report.forEach(function(fileReport) { |
||||
|
errorCount += fileReport.errorCount; |
||||
|
warningCount += fileReport.warningCount; |
||||
|
}); |
||||
|
|
||||
|
if (errorCount || warningCount) { |
||||
|
result = drawReport(report); |
||||
|
} |
||||
|
|
||||
|
result += "\n" + table([ |
||||
|
[ |
||||
|
chalk.red(pluralize("Error", errorCount, true)) |
||||
|
], |
||||
|
[ |
||||
|
chalk.yellow(pluralize("Warning", warningCount, true)) |
||||
|
] |
||||
|
], { |
||||
|
columns: { |
||||
|
0: { |
||||
|
width: 110, |
||||
|
wrapWord: true |
||||
|
} |
||||
|
}, |
||||
|
drawHorizontalLine: function() { |
||||
|
return true; |
||||
|
} |
||||
|
}); |
||||
|
|
||||
|
return result; |
||||
|
}; |
||||
@ -0,0 +1,64 @@ |
|||||
|
/** |
||||
|
* @fileoverview Visual Studio compatible formatter |
||||
|
* @author Ronald Pijnacker |
||||
|
* @copyright 2015 Ronald Pijnacker. All rights reserved. |
||||
|
* See LICENSE file in root directory for full license. |
||||
|
*/ |
||||
|
|
||||
|
"use strict"; |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Helper Functions
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
/** |
||||
|
* Returns the severity of warning or error |
||||
|
* @param {object} message message object to examine |
||||
|
* @returns {string} severity level |
||||
|
* @private |
||||
|
*/ |
||||
|
function getMessageType(message) { |
||||
|
if (message.fatal || message.severity === 2) { |
||||
|
return "error"; |
||||
|
} else { |
||||
|
return "warning"; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Public Interface
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
module.exports = function(results) { |
||||
|
|
||||
|
var output = "", |
||||
|
total = 0; |
||||
|
|
||||
|
results.forEach(function(result) { |
||||
|
|
||||
|
var messages = result.messages; |
||||
|
total += messages.length; |
||||
|
|
||||
|
messages.forEach(function(message) { |
||||
|
|
||||
|
output += result.filePath; |
||||
|
output += "(" + (message.line || 0); |
||||
|
output += message.column ? "," + message.column : ""; |
||||
|
output += "): " + getMessageType(message); |
||||
|
output += message.ruleId ? " " + message.ruleId : ""; |
||||
|
output += " : " + message.message; |
||||
|
output += "\n"; |
||||
|
|
||||
|
}); |
||||
|
|
||||
|
}); |
||||
|
|
||||
|
if (total === 0) { |
||||
|
output += "no problems"; |
||||
|
} else { |
||||
|
output += "\n" + total + " problem" + (total !== 1 ? "s" : ""); |
||||
|
} |
||||
|
|
||||
|
return output; |
||||
|
}; |
||||
@ -0,0 +1,236 @@ |
|||||
|
/** |
||||
|
* @fileoverview Rule to enforce return statements in callbacks of array's methods |
||||
|
* @author Toru Nagashima |
||||
|
* @copyright 2015 Toru Nagashima. All rights reserved. |
||||
|
* See LICENSE file in root directory for full license. |
||||
|
*/ |
||||
|
|
||||
|
"use strict"; |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Requirements
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
var astUtils = require("../ast-utils"); |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Helpers
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
var TARGET_NODE_TYPE = /^(?:Arrow)?FunctionExpression$/; |
||||
|
var TARGET_METHODS = /^(?:every|filter|find(?:Index)?|map|reduce(?:Right)?|some|sort)$/; |
||||
|
|
||||
|
/** |
||||
|
* Checks a given code path segment is reachable. |
||||
|
* |
||||
|
* @param {CodePathSegment} segment - A segment to check. |
||||
|
* @returns {boolean} `true` if the segment is reachable. |
||||
|
*/ |
||||
|
function isReachable(segment) { |
||||
|
return segment.reachable; |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Gets a readable location. |
||||
|
* |
||||
|
* - FunctionExpression -> the function name or `function` keyword. |
||||
|
* - ArrowFunctionExpression -> `=>` token. |
||||
|
* |
||||
|
* @param {ASTNode} node - A function node to get. |
||||
|
* @param {SourceCode} sourceCode - A source code to get tokens. |
||||
|
* @returns {ASTNode|Token} The node or the token of a location. |
||||
|
*/ |
||||
|
function getLocation(node, sourceCode) { |
||||
|
if (node.type === "ArrowFunctionExpression") { |
||||
|
return sourceCode.getTokenBefore(node.body); |
||||
|
} |
||||
|
return node.id || node; |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Gets the name of a given node if the node is a Identifier node. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node to get. |
||||
|
* @returns {string} The name of the node, or an empty string. |
||||
|
*/ |
||||
|
function getIdentifierName(node) { |
||||
|
return node.type === "Identifier" ? node.name : ""; |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Gets the value of a given node if the node is a Literal node or a |
||||
|
* TemplateLiteral node. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node to get. |
||||
|
* @returns {string} The value of the node, or an empty string. |
||||
|
*/ |
||||
|
function getConstantStringValue(node) { |
||||
|
switch (node.type) { |
||||
|
case "Literal": |
||||
|
return String(node.value); |
||||
|
|
||||
|
case "TemplateLiteral": |
||||
|
return node.expressions.length === 0 |
||||
|
? node.quasis[0].value.cooked |
||||
|
: ""; |
||||
|
|
||||
|
default: |
||||
|
return ""; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Checks a given node is a MemberExpression node which has the specified name's |
||||
|
* property. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node to check. |
||||
|
* @returns {boolean} `true` if the node is a MemberExpression node which has |
||||
|
* the specified name's property |
||||
|
*/ |
||||
|
function isTargetMethod(node) { |
||||
|
return ( |
||||
|
node.type === "MemberExpression" && |
||||
|
TARGET_METHODS.test( |
||||
|
(node.computed ? getConstantStringValue : getIdentifierName)(node.property) |
||||
|
) |
||||
|
); |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Checks whether or not a given node is a function expression which is the |
||||
|
* callback of an array method. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node to check. This is one of |
||||
|
* FunctionExpression or ArrowFunctionExpression. |
||||
|
* @returns {boolean} `true` if the node is the callback of an array method. |
||||
|
*/ |
||||
|
function isCallbackOfArrayMethod(node) { |
||||
|
while (node) { |
||||
|
var parent = node.parent; |
||||
|
switch (parent.type) { |
||||
|
// Looks up the destination.
|
||||
|
// e.g.
|
||||
|
// foo.every(nativeFoo || function foo() { ... });
|
||||
|
case "LogicalExpression": |
||||
|
case "ConditionalExpression": |
||||
|
node = parent; |
||||
|
break; |
||||
|
|
||||
|
// If the upper function is IIFE, checks the destination of the return value.
|
||||
|
// e.g.
|
||||
|
// foo.every((function() {
|
||||
|
// // setup...
|
||||
|
// return function callback() { ... };
|
||||
|
// })());
|
||||
|
case "ReturnStatement": |
||||
|
var func = astUtils.getUpperFunction(parent); |
||||
|
if (func === null || !astUtils.isCallee(func)) { |
||||
|
return false; |
||||
|
} |
||||
|
node = func.parent; |
||||
|
break; |
||||
|
|
||||
|
// e.g.
|
||||
|
// Array.from([], function() {});
|
||||
|
// list.every(function() {});
|
||||
|
case "CallExpression": |
||||
|
if (astUtils.isArrayFromMethod(parent.callee)) { |
||||
|
return ( |
||||
|
parent.arguments.length >= 2 && |
||||
|
parent.arguments[1] === node |
||||
|
); |
||||
|
} |
||||
|
if (isTargetMethod(parent.callee)) { |
||||
|
return ( |
||||
|
parent.arguments.length >= 1 && |
||||
|
parent.arguments[0] === node |
||||
|
); |
||||
|
} |
||||
|
return false; |
||||
|
|
||||
|
// Otherwise this node is not target.
|
||||
|
default: |
||||
|
return false; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/* istanbul ignore next: unreachable */ |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Rule Definition
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
module.exports = function(context) { |
||||
|
var funcInfo = { |
||||
|
upper: null, |
||||
|
codePath: null, |
||||
|
hasReturn: false, |
||||
|
shouldCheck: false |
||||
|
}; |
||||
|
|
||||
|
/** |
||||
|
* Checks whether or not the last code path segment is reachable. |
||||
|
* Then reports this function if the segment is reachable. |
||||
|
* |
||||
|
* If the last code path segment is reachable, there are paths which are not |
||||
|
* returned or thrown. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node to check. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function checkLastSegment(node) { |
||||
|
if (funcInfo.shouldCheck && |
||||
|
funcInfo.codePath.currentSegments.some(isReachable) |
||||
|
) { |
||||
|
context.report({ |
||||
|
node: node, |
||||
|
loc: getLocation(node, context.getSourceCode()).loc.start, |
||||
|
message: funcInfo.hasReturn |
||||
|
? "Expected to return a value at the end of this function." |
||||
|
: "Expected to return a value in this function." |
||||
|
}); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return { |
||||
|
// Stacks this function's information.
|
||||
|
"onCodePathStart": function(codePath, node) { |
||||
|
funcInfo = { |
||||
|
upper: funcInfo, |
||||
|
codePath: codePath, |
||||
|
hasReturn: false, |
||||
|
shouldCheck: |
||||
|
TARGET_NODE_TYPE.test(node.type) && |
||||
|
node.body.type === "BlockStatement" && |
||||
|
isCallbackOfArrayMethod(node) |
||||
|
}; |
||||
|
}, |
||||
|
|
||||
|
// Pops this function's information.
|
||||
|
"onCodePathEnd": function() { |
||||
|
funcInfo = funcInfo.upper; |
||||
|
}, |
||||
|
|
||||
|
// Checks the return statement is valid.
|
||||
|
"ReturnStatement": function(node) { |
||||
|
if (funcInfo.shouldCheck) { |
||||
|
funcInfo.hasReturn = true; |
||||
|
|
||||
|
if (!node.argument) { |
||||
|
context.report({ |
||||
|
node: node, |
||||
|
message: "Expected a return value." |
||||
|
}); |
||||
|
} |
||||
|
} |
||||
|
}, |
||||
|
|
||||
|
// Reports a given function if the last path is reachable.
|
||||
|
"FunctionExpression:exit": checkLastSegment, |
||||
|
"ArrowFunctionExpression:exit": checkLastSegment |
||||
|
}; |
||||
|
}; |
||||
|
|
||||
|
module.exports.schema = []; |
||||
@ -0,0 +1,110 @@ |
|||||
|
/** |
||||
|
* @fileoverview Rule that warns when identifier names that are |
||||
|
blacklisted in the configuration are used. |
||||
|
* @author Keith Cirkel (http://keithcirkel.co.uk)
|
||||
|
* Based on id-match rule: |
||||
|
* @author Matthieu Larcher |
||||
|
* @copyright 2015 Matthieu Larcher. All rights reserved. |
||||
|
* See LICENSE in root directory for full license. |
||||
|
*/ |
||||
|
|
||||
|
"use strict"; |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Rule Definition
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
module.exports = function(context) { |
||||
|
|
||||
|
|
||||
|
//--------------------------------------------------------------------------
|
||||
|
// Helpers
|
||||
|
//--------------------------------------------------------------------------
|
||||
|
|
||||
|
var blacklist = context.options; |
||||
|
|
||||
|
|
||||
|
/** |
||||
|
* Checks if a string matches the provided pattern |
||||
|
* @param {String} name The string to check. |
||||
|
* @returns {boolean} if the string is a match |
||||
|
* @private |
||||
|
*/ |
||||
|
function isInvalid(name) { |
||||
|
return blacklist.indexOf(name) !== -1; |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Verifies if we should report an error or not based on the effective |
||||
|
* parent node and the identifier name. |
||||
|
* @param {ASTNode} effectiveParent The effective parent node of the node to be reported |
||||
|
* @param {String} name The identifier name of the identifier node |
||||
|
* @returns {boolean} whether an error should be reported or not |
||||
|
*/ |
||||
|
function shouldReport(effectiveParent, name) { |
||||
|
return effectiveParent.type !== "CallExpression" |
||||
|
&& effectiveParent.type !== "NewExpression" && |
||||
|
isInvalid(name); |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Reports an AST node as a rule violation. |
||||
|
* @param {ASTNode} node The node to report. |
||||
|
* @returns {void} |
||||
|
* @private |
||||
|
*/ |
||||
|
function report(node) { |
||||
|
context.report(node, "Identifier '{{name}}' is blacklisted", { |
||||
|
name: node.name |
||||
|
}); |
||||
|
} |
||||
|
|
||||
|
return { |
||||
|
|
||||
|
"Identifier": function(node) { |
||||
|
var name = node.name, |
||||
|
effectiveParent = (node.parent.type === "MemberExpression") ? node.parent.parent : node.parent; |
||||
|
|
||||
|
// MemberExpressions get special rules
|
||||
|
if (node.parent.type === "MemberExpression") { |
||||
|
|
||||
|
// Always check object names
|
||||
|
if (node.parent.object.type === "Identifier" && |
||||
|
node.parent.object.name === node.name) { |
||||
|
if (isInvalid(name)) { |
||||
|
report(node); |
||||
|
} |
||||
|
|
||||
|
// Report AssignmentExpressions only if they are the left side of the assignment
|
||||
|
} else if (effectiveParent.type === "AssignmentExpression" && |
||||
|
(effectiveParent.right.type !== "MemberExpression" || |
||||
|
effectiveParent.left.type === "MemberExpression" && |
||||
|
effectiveParent.left.property.name === node.name)) { |
||||
|
if (isInvalid(name)) { |
||||
|
report(node); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Properties have their own rules
|
||||
|
} else if (node.parent.type === "Property") { |
||||
|
|
||||
|
if (shouldReport(effectiveParent, name)) { |
||||
|
report(node); |
||||
|
} |
||||
|
|
||||
|
// Report anything that is a match and not a CallExpression
|
||||
|
} else if (shouldReport(effectiveParent, name)) { |
||||
|
report(node); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
}; |
||||
|
|
||||
|
}; |
||||
|
module.exports.schema = { |
||||
|
"type": "array", |
||||
|
"items": { |
||||
|
"type": "string" |
||||
|
}, |
||||
|
"uniqueItems": true |
||||
|
}; |
||||
@ -0,0 +1,520 @@ |
|||||
|
/** |
||||
|
* @fileoverview Rule to enforce spacing before and after keywords. |
||||
|
* @author Toru Nagashima |
||||
|
* @copyright 2015 Toru Nagashima. All rights reserved. |
||||
|
* See LICENSE file in root directory for full license. |
||||
|
*/ |
||||
|
|
||||
|
"use strict"; |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Requirements
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
var astUtils = require("../ast-utils"), |
||||
|
keywords = require("../util/keywords"); |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Constants
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
var PREV_TOKEN = /^[\)\]\}>]$/; |
||||
|
var NEXT_TOKEN = /^(?:[\(\[\{<~!]|\+\+?|--?)$/; |
||||
|
var PREV_TOKEN_M = /^[\)\]\}>*]$/; |
||||
|
var NEXT_TOKEN_M = /^[\{*]$/; |
||||
|
var TEMPLATE_OPEN_PAREN = /\$\{$/; |
||||
|
var TEMPLATE_CLOSE_PAREN = /^\}/; |
||||
|
var CHECK_TYPE = /^(?:JSXElement|RegularExpression|String|Template)$/; |
||||
|
var KEYS = keywords.concat(["as", "await", "from", "get", "let", "of", "set", "yield"]); |
||||
|
|
||||
|
// check duplications.
|
||||
|
(function() { |
||||
|
KEYS.sort(); |
||||
|
for (var i = 1; i < KEYS.length; ++i) { |
||||
|
if (KEYS[i] === KEYS[i - 1]) { |
||||
|
throw new Error("Duplication was found in the keyword list: " + KEYS[i]); |
||||
|
} |
||||
|
} |
||||
|
}()); |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Helpers
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
/** |
||||
|
* Checks whether or not a given token is a "Template" token ends with "${". |
||||
|
* |
||||
|
* @param {Token} token - A token to check. |
||||
|
* @returns {boolean} `true` if the token is a "Template" token ends with "${". |
||||
|
*/ |
||||
|
function isOpenParenOfTemplate(token) { |
||||
|
return token.type === "Template" && TEMPLATE_OPEN_PAREN.test(token.value); |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Checks whether or not a given token is a "Template" token starts with "}". |
||||
|
* |
||||
|
* @param {Token} token - A token to check. |
||||
|
* @returns {boolean} `true` if the token is a "Template" token starts with "}". |
||||
|
*/ |
||||
|
function isCloseParenOfTemplate(token) { |
||||
|
return token.type === "Template" && TEMPLATE_CLOSE_PAREN.test(token.value); |
||||
|
} |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Rule Definition
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
module.exports = function(context) { |
||||
|
var sourceCode = context.getSourceCode(); |
||||
|
|
||||
|
/** |
||||
|
* Reports a given token if there are not space(s) before the token. |
||||
|
* |
||||
|
* @param {Token} token - A token to report. |
||||
|
* @param {RegExp|undefined} pattern - Optional. A pattern of the previous |
||||
|
* token to check. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function expectSpaceBefore(token, pattern) { |
||||
|
pattern = pattern || PREV_TOKEN; |
||||
|
|
||||
|
var prevToken = sourceCode.getTokenBefore(token); |
||||
|
if (prevToken && |
||||
|
(CHECK_TYPE.test(prevToken.type) || pattern.test(prevToken.value)) && |
||||
|
!isOpenParenOfTemplate(prevToken) && |
||||
|
astUtils.isTokenOnSameLine(prevToken, token) && |
||||
|
!sourceCode.isSpaceBetweenTokens(prevToken, token) |
||||
|
) { |
||||
|
context.report({ |
||||
|
loc: token.loc.start, |
||||
|
message: "Expected space(s) before \"{{value}}\".", |
||||
|
data: token, |
||||
|
fix: function(fixer) { |
||||
|
return fixer.insertTextBefore(token, " "); |
||||
|
} |
||||
|
}); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Reports a given token if there are space(s) before the token. |
||||
|
* |
||||
|
* @param {Token} token - A token to report. |
||||
|
* @param {RegExp|undefined} pattern - Optional. A pattern of the previous |
||||
|
* token to check. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function unexpectSpaceBefore(token, pattern) { |
||||
|
pattern = pattern || PREV_TOKEN; |
||||
|
|
||||
|
var prevToken = sourceCode.getTokenBefore(token); |
||||
|
if (prevToken && |
||||
|
(CHECK_TYPE.test(prevToken.type) || pattern.test(prevToken.value)) && |
||||
|
!isOpenParenOfTemplate(prevToken) && |
||||
|
astUtils.isTokenOnSameLine(prevToken, token) && |
||||
|
sourceCode.isSpaceBetweenTokens(prevToken, token) |
||||
|
) { |
||||
|
context.report({ |
||||
|
loc: token.loc.start, |
||||
|
message: "Unexpected space(s) before \"{{value}}\".", |
||||
|
data: token, |
||||
|
fix: function(fixer) { |
||||
|
return fixer.removeRange([prevToken.range[1], token.range[0]]); |
||||
|
} |
||||
|
}); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Reports a given token if there are not space(s) after the token. |
||||
|
* |
||||
|
* @param {Token} token - A token to report. |
||||
|
* @param {RegExp|undefined} pattern - Optional. A pattern of the next |
||||
|
* token to check. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function expectSpaceAfter(token, pattern) { |
||||
|
pattern = pattern || NEXT_TOKEN; |
||||
|
|
||||
|
var nextToken = sourceCode.getTokenAfter(token); |
||||
|
if (nextToken && |
||||
|
(CHECK_TYPE.test(nextToken.type) || pattern.test(nextToken.value)) && |
||||
|
!isCloseParenOfTemplate(nextToken) && |
||||
|
astUtils.isTokenOnSameLine(token, nextToken) && |
||||
|
!sourceCode.isSpaceBetweenTokens(token, nextToken) |
||||
|
) { |
||||
|
context.report({ |
||||
|
loc: token.loc.start, |
||||
|
message: "Expected space(s) after \"{{value}}\".", |
||||
|
data: token, |
||||
|
fix: function(fixer) { |
||||
|
return fixer.insertTextAfter(token, " "); |
||||
|
} |
||||
|
}); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Reports a given token if there are space(s) after the token. |
||||
|
* |
||||
|
* @param {Token} token - A token to report. |
||||
|
* @param {RegExp|undefined} pattern - Optional. A pattern of the next |
||||
|
* token to check. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function unexpectSpaceAfter(token, pattern) { |
||||
|
pattern = pattern || NEXT_TOKEN; |
||||
|
|
||||
|
var nextToken = sourceCode.getTokenAfter(token); |
||||
|
if (nextToken && |
||||
|
(CHECK_TYPE.test(nextToken.type) || pattern.test(nextToken.value)) && |
||||
|
!isCloseParenOfTemplate(nextToken) && |
||||
|
astUtils.isTokenOnSameLine(token, nextToken) && |
||||
|
sourceCode.isSpaceBetweenTokens(token, nextToken) |
||||
|
) { |
||||
|
context.report({ |
||||
|
loc: token.loc.start, |
||||
|
message: "Unexpected space(s) after \"{{value}}\".", |
||||
|
data: token, |
||||
|
fix: function(fixer) { |
||||
|
return fixer.removeRange([token.range[1], nextToken.range[0]]); |
||||
|
} |
||||
|
}); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Parses the option object and determines check methods for each keyword. |
||||
|
* |
||||
|
* @param {object|undefined} options - The option object to parse. |
||||
|
* @returns {object} - Normalized option object. |
||||
|
* Keys are keywords (there are for every keyword). |
||||
|
* Values are instances of `{"before": function, "after": function}`. |
||||
|
*/ |
||||
|
function parseOptions(options) { |
||||
|
var before = !options || options.before !== false; |
||||
|
var after = !options || options.after !== false; |
||||
|
var defaultValue = { |
||||
|
before: before ? expectSpaceBefore : unexpectSpaceBefore, |
||||
|
after: after ? expectSpaceAfter : unexpectSpaceAfter |
||||
|
}; |
||||
|
var overrides = (options && options.overrides) || {}; |
||||
|
var retv = Object.create(null); |
||||
|
|
||||
|
for (var i = 0; i < KEYS.length; ++i) { |
||||
|
var key = KEYS[i]; |
||||
|
var override = overrides[key]; |
||||
|
|
||||
|
if (override) { |
||||
|
var thisBefore = ("before" in override) ? override.before : before; |
||||
|
var thisAfter = ("after" in override) ? override.after : after; |
||||
|
retv[key] = { |
||||
|
before: thisBefore ? expectSpaceBefore : unexpectSpaceBefore, |
||||
|
after: thisAfter ? expectSpaceAfter : unexpectSpaceAfter |
||||
|
}; |
||||
|
} else { |
||||
|
retv[key] = defaultValue; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return retv; |
||||
|
} |
||||
|
|
||||
|
var checkMethodMap = parseOptions(context.options[0]); |
||||
|
|
||||
|
/** |
||||
|
* Reports a given token if usage of spacing followed by the token is |
||||
|
* invalid. |
||||
|
* |
||||
|
* @param {Token} token - A token to report. |
||||
|
* @param {RegExp|undefined} pattern - Optional. A pattern of the previous |
||||
|
* token to check. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function checkSpacingBefore(token, pattern) { |
||||
|
checkMethodMap[token.value].before(token, pattern); |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Reports a given token if usage of spacing preceded by the token is |
||||
|
* invalid. |
||||
|
* |
||||
|
* @param {Token} token - A token to report. |
||||
|
* @param {RegExp|undefined} pattern - Optional. A pattern of the next |
||||
|
* token to check. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function checkSpacingAfter(token, pattern) { |
||||
|
checkMethodMap[token.value].after(token, pattern); |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Reports a given token if usage of spacing around the token is invalid. |
||||
|
* |
||||
|
* @param {Token} token - A token to report. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function checkSpacingAround(token) { |
||||
|
checkSpacingBefore(token); |
||||
|
checkSpacingAfter(token); |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Reports the first token of a given node if the first token is a keyword |
||||
|
* and usage of spacing around the token is invalid. |
||||
|
* |
||||
|
* @param {ASTNode|null} node - A node to report. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function checkSpacingAroundFirstToken(node) { |
||||
|
var firstToken = node && sourceCode.getFirstToken(node); |
||||
|
if (firstToken && firstToken.type === "Keyword") { |
||||
|
checkSpacingAround(firstToken); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Reports the first token of a given node if the first token is a keyword |
||||
|
* and usage of spacing followed by the token is invalid. |
||||
|
* |
||||
|
* This is used for unary operators (e.g. `typeof`), `function`, and `super`. |
||||
|
* Other rules are handling usage of spacing preceded by those keywords. |
||||
|
* |
||||
|
* @param {ASTNode|null} node - A node to report. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function checkSpacingBeforeFirstToken(node) { |
||||
|
var firstToken = node && sourceCode.getFirstToken(node); |
||||
|
if (firstToken && firstToken.type === "Keyword") { |
||||
|
checkSpacingBefore(firstToken); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Reports the previous token of a given node if the token is a keyword and |
||||
|
* usage of spacing around the token is invalid. |
||||
|
* |
||||
|
* @param {ASTNode|null} node - A node to report. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function checkSpacingAroundTokenBefore(node) { |
||||
|
if (node) { |
||||
|
var token = sourceCode.getTokenBefore(node); |
||||
|
while (token.type !== "Keyword") { |
||||
|
token = sourceCode.getTokenBefore(token); |
||||
|
} |
||||
|
|
||||
|
checkSpacingAround(token); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Reports `class` and `extends` keywords of a given node if usage of |
||||
|
* spacing around those keywords is invalid. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node to report. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function checkSpacingForClass(node) { |
||||
|
checkSpacingAroundFirstToken(node); |
||||
|
checkSpacingAroundTokenBefore(node.superClass); |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Reports `if` and `else` keywords of a given node if usage of spacing |
||||
|
* around those keywords is invalid. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node to report. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function checkSpacingForIfStatement(node) { |
||||
|
checkSpacingAroundFirstToken(node); |
||||
|
checkSpacingAroundTokenBefore(node.alternate); |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Reports `try`, `catch`, and `finally` keywords of a given node if usage |
||||
|
* of spacing around those keywords is invalid. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node to report. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function checkSpacingForTryStatement(node) { |
||||
|
checkSpacingAroundFirstToken(node); |
||||
|
checkSpacingAroundFirstToken(node.handler); |
||||
|
checkSpacingAroundTokenBefore(node.finalizer); |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Reports `do` and `while` keywords of a given node if usage of spacing |
||||
|
* around those keywords is invalid. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node to report. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function checkSpacingForDoWhileStatement(node) { |
||||
|
checkSpacingAroundFirstToken(node); |
||||
|
checkSpacingAroundTokenBefore(node.test); |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Reports `for` and `in` keywords of a given node if usage of spacing |
||||
|
* around those keywords is invalid. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node to report. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function checkSpacingForForInStatement(node) { |
||||
|
checkSpacingAroundFirstToken(node); |
||||
|
checkSpacingAroundTokenBefore(node.right); |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Reports `for` and `of` keywords of a given node if usage of spacing |
||||
|
* around those keywords is invalid. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node to report. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function checkSpacingForForOfStatement(node) { |
||||
|
checkSpacingAroundFirstToken(node); |
||||
|
|
||||
|
// `of` is not a keyword token.
|
||||
|
var token = sourceCode.getTokenBefore(node.right); |
||||
|
while (token.value !== "of") { |
||||
|
token = sourceCode.getTokenBefore(token); |
||||
|
} |
||||
|
checkSpacingAround(token); |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Reports `import`, `export`, `as`, and `from` keywords of a given node if |
||||
|
* usage of spacing around those keywords is invalid. |
||||
|
* |
||||
|
* This rule handles the `*` token in module declarations. |
||||
|
* |
||||
|
* import*as A from "./a"; /*error Expected space(s) after "import". |
||||
|
* error Expected space(s) before "as". |
||||
|
* |
||||
|
* @param {ASTNode} node - A node to report. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function checkSpacingForModuleDeclaration(node) { |
||||
|
var firstToken = sourceCode.getFirstToken(node); |
||||
|
checkSpacingBefore(firstToken, PREV_TOKEN_M); |
||||
|
checkSpacingAfter(firstToken, NEXT_TOKEN_M); |
||||
|
|
||||
|
if (node.source) { |
||||
|
var fromToken = sourceCode.getTokenBefore(node.source); |
||||
|
checkSpacingBefore(fromToken, PREV_TOKEN_M); |
||||
|
checkSpacingAfter(fromToken, NEXT_TOKEN_M); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Reports `as` keyword of a given node if usage of spacing around this |
||||
|
* keyword is invalid. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node to report. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function checkSpacingForImportNamespaceSpecifier(node) { |
||||
|
var asToken = sourceCode.getFirstToken(node, 1); |
||||
|
checkSpacingBefore(asToken, PREV_TOKEN_M); |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Reports `static`, `get`, and `set` keywords of a given node if usage of |
||||
|
* spacing around those keywords is invalid. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node to report. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function checkSpacingForProperty(node) { |
||||
|
if (node.static) { |
||||
|
checkSpacingAroundFirstToken(node); |
||||
|
} |
||||
|
if (node.kind === "get" || node.kind === "set") { |
||||
|
var token = sourceCode.getFirstToken( |
||||
|
node, |
||||
|
node.static ? 1 : 0 |
||||
|
); |
||||
|
checkSpacingAround(token); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return { |
||||
|
// Statements
|
||||
|
DebuggerStatement: checkSpacingAroundFirstToken, |
||||
|
WithStatement: checkSpacingAroundFirstToken, |
||||
|
|
||||
|
// Statements - Control flow
|
||||
|
BreakStatement: checkSpacingAroundFirstToken, |
||||
|
ContinueStatement: checkSpacingAroundFirstToken, |
||||
|
ReturnStatement: checkSpacingAroundFirstToken, |
||||
|
ThrowStatement: checkSpacingAroundFirstToken, |
||||
|
TryStatement: checkSpacingForTryStatement, |
||||
|
|
||||
|
// Statements - Choice
|
||||
|
IfStatement: checkSpacingForIfStatement, |
||||
|
SwitchStatement: checkSpacingAroundFirstToken, |
||||
|
SwitchCase: checkSpacingAroundFirstToken, |
||||
|
|
||||
|
// Statements - Loops
|
||||
|
DoWhileStatement: checkSpacingForDoWhileStatement, |
||||
|
ForInStatement: checkSpacingForForInStatement, |
||||
|
ForOfStatement: checkSpacingForForOfStatement, |
||||
|
ForStatement: checkSpacingAroundFirstToken, |
||||
|
WhileStatement: checkSpacingAroundFirstToken, |
||||
|
|
||||
|
// Statements - Declarations
|
||||
|
ClassDeclaration: checkSpacingForClass, |
||||
|
ExportNamedDeclaration: checkSpacingForModuleDeclaration, |
||||
|
ExportDefaultDeclaration: checkSpacingAroundFirstToken, |
||||
|
ExportAllDeclaration: checkSpacingForModuleDeclaration, |
||||
|
FunctionDeclaration: checkSpacingBeforeFirstToken, |
||||
|
ImportDeclaration: checkSpacingForModuleDeclaration, |
||||
|
VariableDeclaration: checkSpacingAroundFirstToken, |
||||
|
|
||||
|
// Expressions
|
||||
|
ClassExpression: checkSpacingForClass, |
||||
|
FunctionExpression: checkSpacingBeforeFirstToken, |
||||
|
NewExpression: checkSpacingBeforeFirstToken, |
||||
|
Super: checkSpacingBeforeFirstToken, |
||||
|
ThisExpression: checkSpacingBeforeFirstToken, |
||||
|
UnaryExpression: checkSpacingBeforeFirstToken, |
||||
|
YieldExpression: checkSpacingBeforeFirstToken, |
||||
|
|
||||
|
// Others
|
||||
|
ImportNamespaceSpecifier: checkSpacingForImportNamespaceSpecifier, |
||||
|
MethodDefinition: checkSpacingForProperty, |
||||
|
Property: checkSpacingForProperty |
||||
|
}; |
||||
|
}; |
||||
|
|
||||
|
module.exports.schema = [ |
||||
|
{ |
||||
|
"type": "object", |
||||
|
"properties": { |
||||
|
"before": {"type": "boolean"}, |
||||
|
"after": {"type": "boolean"}, |
||||
|
"overrides": { |
||||
|
"type": "object", |
||||
|
"properties": KEYS.reduce(function(retv, key) { |
||||
|
retv[key] = { |
||||
|
"type": "object", |
||||
|
"properties": { |
||||
|
"before": {"type": "boolean"}, |
||||
|
"after": {"type": "boolean"} |
||||
|
}, |
||||
|
"additionalProperties": false |
||||
|
}; |
||||
|
return retv; |
||||
|
}, {}), |
||||
|
"additionalProperties": false |
||||
|
} |
||||
|
}, |
||||
|
"additionalProperties": false |
||||
|
} |
||||
|
]; |
||||
@ -0,0 +1,113 @@ |
|||||
|
/** |
||||
|
* @fileoverview Rule to ensure newline per method call when chaining calls |
||||
|
* @author Rajendra Patil |
||||
|
* @copyright 2016 Rajendra Patil. All rights reserved. |
||||
|
*/ |
||||
|
|
||||
|
"use strict"; |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Rule Definition
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
module.exports = function(context) { |
||||
|
|
||||
|
var options = context.options[0] || {}, |
||||
|
codeStateMap = {}, |
||||
|
ignoreChainWithDepth = options.ignoreChainWithDepth || 2; |
||||
|
|
||||
|
/** |
||||
|
* Check and Capture State if the chained calls/members |
||||
|
* @param {ASTNode} node The node to check |
||||
|
* @param {object} codeState The state of the code current code to be filled |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function checkAndCaptureStateRecursively(node, codeState) { |
||||
|
var valid = false, |
||||
|
objectLineNumber, |
||||
|
propertyLineNumber; |
||||
|
if (node.callee) { |
||||
|
node = node.callee; |
||||
|
codeState.hasFunctionCall = true; |
||||
|
} |
||||
|
|
||||
|
if (node.object) { |
||||
|
codeState.depth++; |
||||
|
|
||||
|
objectLineNumber = node.object.loc.end.line; |
||||
|
propertyLineNumber = node.property.loc.end.line; |
||||
|
valid = node.computed || propertyLineNumber > objectLineNumber; |
||||
|
|
||||
|
if (!valid) { |
||||
|
codeState.reports.push({ |
||||
|
node: node, |
||||
|
text: "Expected line break after `{{code}}`.", |
||||
|
depth: codeState.depth |
||||
|
}); |
||||
|
} |
||||
|
// Recurse
|
||||
|
checkAndCaptureStateRecursively(node.object, codeState); |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
/** |
||||
|
* Verify and report the captured state report |
||||
|
* @param {object} codeState contains the captured state with `hasFunctionCall, reports and depth` |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function reportState(codeState) { |
||||
|
var report; |
||||
|
if (codeState.hasFunctionCall && codeState.depth > ignoreChainWithDepth && codeState.reports) { |
||||
|
while (codeState.reports.length) { |
||||
|
report = codeState.reports.shift(); |
||||
|
context.report(report.node, report.text, { |
||||
|
code: context.getSourceCode().getText(report.node.object).replace(/\r\n|\r|\n/g, "\\n") // Not to print newlines in error report
|
||||
|
}); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Initialize the node state object with default values. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function initializeState() { |
||||
|
return { |
||||
|
visited: false, |
||||
|
hasFunctionCall: false, |
||||
|
depth: 1, |
||||
|
reports: [] |
||||
|
}; |
||||
|
} |
||||
|
/** |
||||
|
* Process the said node and recurse internally |
||||
|
* @param {ASTNode} node The node to check |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function processNode(node) { |
||||
|
var stateKey = [node.loc.start.line, node.loc.start.column].join("@"), |
||||
|
codeState = codeStateMap[stateKey] = (codeStateMap[stateKey] || initializeState()); |
||||
|
if (!codeState.visited) { |
||||
|
codeState.visited = true; |
||||
|
checkAndCaptureStateRecursively(node, codeState); |
||||
|
} |
||||
|
reportState(codeState); |
||||
|
} |
||||
|
|
||||
|
return { |
||||
|
"CallExpression": processNode, |
||||
|
"MemberExpression": processNode |
||||
|
}; |
||||
|
}; |
||||
|
|
||||
|
module.exports.schema = [{ |
||||
|
"type": "object", |
||||
|
"properties": { |
||||
|
"ignoreChainWithDepth": { |
||||
|
"type": "integer", |
||||
|
"minimum": 1, |
||||
|
"maximum": 10 |
||||
|
} |
||||
|
}, |
||||
|
"additionalProperties": false |
||||
|
}]; |
||||
@ -1,88 +0,0 @@ |
|||||
/** |
|
||||
* @fileoverview A rule to warn against using arrow functions in conditions. |
|
||||
* @author Jxck <https://github.com/Jxck>
|
|
||||
* @copyright 2015 Luke Karrys. All rights reserved. |
|
||||
* The MIT License (MIT) |
|
||||
|
|
||||
* Copyright (c) 2015 Jxck |
|
||||
|
|
||||
* 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. |
|
||||
*/ |
|
||||
|
|
||||
"use strict"; |
|
||||
|
|
||||
//------------------------------------------------------------------------------
|
|
||||
// Helpers
|
|
||||
//------------------------------------------------------------------------------
|
|
||||
|
|
||||
/** |
|
||||
* Checks whether or not a node is an arrow function expression. |
|
||||
* @param {ASTNode} node - node to test |
|
||||
* @returns {boolean} `true` if the node is an arrow function expression. |
|
||||
*/ |
|
||||
function isArrowFunction(node) { |
|
||||
return node.test && node.test.type === "ArrowFunctionExpression"; |
|
||||
} |
|
||||
|
|
||||
/** |
|
||||
* Checks whether or not a node is a conditional expression. |
|
||||
* @param {ASTNode} node - node to test |
|
||||
* @returns {boolean} `true` if the node is a conditional expression. |
|
||||
*/ |
|
||||
function isConditional(node) { |
|
||||
return node.body && node.body.type === "ConditionalExpression"; |
|
||||
} |
|
||||
|
|
||||
//------------------------------------------------------------------------------
|
|
||||
// Rule Definition
|
|
||||
//------------------------------------------------------------------------------
|
|
||||
|
|
||||
module.exports = function(context) { |
|
||||
/** |
|
||||
* Reports if a conditional statement is an arrow function. |
|
||||
* @param {ASTNode} node - A node to check and report. |
|
||||
* @returns {void} |
|
||||
*/ |
|
||||
function checkCondition(node) { |
|
||||
if (isArrowFunction(node)) { |
|
||||
context.report(node, "Arrow function `=>` used inside {{statementType}} instead of comparison operator.", {statementType: node.type}); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
/** |
|
||||
* Reports if an arrow function contains an ambiguous conditional. |
|
||||
* @param {ASTNode} node - A node to check and report. |
|
||||
* @returns {void} |
|
||||
*/ |
|
||||
function checkArrowFunc(node) { |
|
||||
if (isConditional(node)) { |
|
||||
context.report(node, "Arrow function used ambiguously with a conditional expression."); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
return { |
|
||||
"IfStatement": checkCondition, |
|
||||
"WhileStatement": checkCondition, |
|
||||
"ForStatement": checkCondition, |
|
||||
"ConditionalExpression": checkCondition, |
|
||||
"ArrowFunctionExpression": checkArrowFunc |
|
||||
}; |
|
||||
}; |
|
||||
|
|
||||
module.exports.schema = []; |
|
||||
@ -0,0 +1,65 @@ |
|||||
|
/** |
||||
|
* @fileoverview A rule to warn against using arrow functions when they could be |
||||
|
* confused with comparisions |
||||
|
* @author Jxck <https://github.com/Jxck>
|
||||
|
* @copyright 2015 Luke Karrys. All rights reserved. |
||||
|
* The MIT License (MIT) |
||||
|
|
||||
|
* Copyright (c) 2015 Jxck |
||||
|
|
||||
|
* 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. |
||||
|
*/ |
||||
|
|
||||
|
"use strict"; |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Helpers
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
/** |
||||
|
* Checks whether or not a node is a conditional expression. |
||||
|
* @param {ASTNode} node - node to test |
||||
|
* @returns {boolean} `true` if the node is a conditional expression. |
||||
|
*/ |
||||
|
function isConditional(node) { |
||||
|
return node.body && node.body.type === "ConditionalExpression"; |
||||
|
} |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Rule Definition
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
module.exports = function(context) { |
||||
|
/** |
||||
|
* Reports if an arrow function contains an ambiguous conditional. |
||||
|
* @param {ASTNode} node - A node to check and report. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function checkArrowFunc(node) { |
||||
|
if (isConditional(node)) { |
||||
|
context.report(node, "Arrow function used ambiguously with a conditional expression."); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return { |
||||
|
"ArrowFunctionExpression": checkArrowFunc |
||||
|
}; |
||||
|
}; |
||||
|
|
||||
|
module.exports.schema = []; |
||||
@ -0,0 +1,149 @@ |
|||||
|
/** |
||||
|
* @fileoverview Rule to disallow empty functions. |
||||
|
* @author Toru Nagashima |
||||
|
* @copyright 2016 Toru Nagashima. All rights reserved. |
||||
|
* See LICENSE file in root directory for full license. |
||||
|
*/ |
||||
|
|
||||
|
"use strict"; |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Helpers
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
var ALLOW_OPTIONS = Object.freeze([ |
||||
|
"functions", |
||||
|
"arrowFunctions", |
||||
|
"generatorFunctions", |
||||
|
"methods", |
||||
|
"generatorMethods", |
||||
|
"getters", |
||||
|
"setters", |
||||
|
"constructors" |
||||
|
]); |
||||
|
var SHOW_KIND = Object.freeze({ |
||||
|
functions: "function", |
||||
|
arrowFunctions: "arrow function", |
||||
|
generatorFunctions: "generator function", |
||||
|
asyncFunctions: "async function", |
||||
|
methods: "method", |
||||
|
generatorMethods: "generator method", |
||||
|
asyncMethods: "async method", |
||||
|
getters: "getter", |
||||
|
setters: "setter", |
||||
|
constructors: "constructor" |
||||
|
}); |
||||
|
|
||||
|
/** |
||||
|
* Gets the kind of a given function node. |
||||
|
* |
||||
|
* @param {ASTNode} node - A function node to get. This is one of |
||||
|
* an ArrowFunctionExpression, a FunctionDeclaration, or a |
||||
|
* FunctionExpression. |
||||
|
* @returns {string} The kind of the function. This is one of "functions", |
||||
|
* "arrowFunctions", "generatorFunctions", "asyncFunctions", "methods", |
||||
|
* "generatorMethods", "asyncMethods", "getters", "setters", and |
||||
|
* "constructors". |
||||
|
*/ |
||||
|
function getKind(node) { |
||||
|
var parent = node.parent; |
||||
|
var kind = ""; |
||||
|
|
||||
|
if (node.type === "ArrowFunctionExpression") { |
||||
|
return "arrowFunctions"; |
||||
|
} |
||||
|
|
||||
|
// Detects main kind.
|
||||
|
if (parent.type === "Property") { |
||||
|
if (parent.kind === "get") { |
||||
|
return "getters"; |
||||
|
} |
||||
|
if (parent.kind === "set") { |
||||
|
return "setters"; |
||||
|
} |
||||
|
kind = parent.method ? "methods" : "functions"; |
||||
|
|
||||
|
} else if (parent.type === "MethodDefinition") { |
||||
|
if (parent.kind === "get") { |
||||
|
return "getters"; |
||||
|
} |
||||
|
if (parent.kind === "set") { |
||||
|
return "setters"; |
||||
|
} |
||||
|
if (parent.kind === "constructor") { |
||||
|
return "constructors"; |
||||
|
} |
||||
|
kind = "methods"; |
||||
|
|
||||
|
} else { |
||||
|
kind = "functions"; |
||||
|
} |
||||
|
|
||||
|
// Detects prefix.
|
||||
|
var prefix = ""; |
||||
|
if (node.generator) { |
||||
|
prefix = "generator"; |
||||
|
} else if (node.async) { |
||||
|
prefix = "async"; |
||||
|
} else { |
||||
|
return kind; |
||||
|
} |
||||
|
return prefix + kind[0].toUpperCase() + kind.slice(1); |
||||
|
} |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Rule Definition
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
module.exports = function(context) { |
||||
|
var options = context.options[0] || {}; |
||||
|
var allowed = options.allow || []; |
||||
|
|
||||
|
/** |
||||
|
* Reports a given function node if the node matches the following patterns. |
||||
|
* |
||||
|
* - Not allowed by options. |
||||
|
* - The body is empty. |
||||
|
* - The body doesn't have any comments. |
||||
|
* |
||||
|
* @param {ASTNode} node - A function node to report. This is one of |
||||
|
* an ArrowFunctionExpression, a FunctionDeclaration, or a |
||||
|
* FunctionExpression. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function reportIfEmpty(node) { |
||||
|
var kind = getKind(node); |
||||
|
|
||||
|
if (allowed.indexOf(kind) === -1 && |
||||
|
node.body.type === "BlockStatement" && |
||||
|
node.body.body.length === 0 && |
||||
|
context.getComments(node.body).trailing.length === 0 |
||||
|
) { |
||||
|
context.report({ |
||||
|
node: node, |
||||
|
loc: node.body.loc.start, |
||||
|
message: "Unexpected empty " + SHOW_KIND[kind] + "." |
||||
|
}); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return { |
||||
|
ArrowFunctionExpression: reportIfEmpty, |
||||
|
FunctionDeclaration: reportIfEmpty, |
||||
|
FunctionExpression: reportIfEmpty |
||||
|
}; |
||||
|
}; |
||||
|
|
||||
|
module.exports.schema = [ |
||||
|
{ |
||||
|
type: "object", |
||||
|
properties: { |
||||
|
allow: { |
||||
|
type: "array", |
||||
|
items: {enum: ALLOW_OPTIONS}, |
||||
|
uniqueItems: true |
||||
|
} |
||||
|
}, |
||||
|
additionalProperties: false |
||||
|
} |
||||
|
]; |
||||
@ -1,27 +0,0 @@ |
|||||
/** |
|
||||
* @fileoverview Rule to flag when label is not used for a loop or switch |
|
||||
* @author Ilya Volodin |
|
||||
*/ |
|
||||
|
|
||||
"use strict"; |
|
||||
|
|
||||
//------------------------------------------------------------------------------
|
|
||||
// Rule Definition
|
|
||||
//------------------------------------------------------------------------------
|
|
||||
|
|
||||
module.exports = function(context) { |
|
||||
|
|
||||
return { |
|
||||
|
|
||||
"LabeledStatement": function(node) { |
|
||||
var type = node.body.type; |
|
||||
|
|
||||
if (type !== "ForStatement" && type !== "WhileStatement" && type !== "DoWhileStatement" && type !== "SwitchStatement" && type !== "ForInStatement" && type !== "ForOfStatement") { |
|
||||
context.report(node, "Unexpected label \"{{l}}\"", {l: node.label.name}); |
|
||||
} |
|
||||
} |
|
||||
}; |
|
||||
|
|
||||
}; |
|
||||
|
|
||||
module.exports.schema = []; |
|
||||
@ -1,26 +1,290 @@ |
|||||
/** |
/** |
||||
* @fileoverview Rule to flag use of eval() statement |
* @fileoverview Rule to flag use of eval() statement |
||||
* @author Nicholas C. Zakas |
* @author Nicholas C. Zakas |
||||
|
* @copyright 2015 Toru Nagashima. All rights reserved. |
||||
* @copyright 2015 Mathias Schreck. All rights reserved. |
* @copyright 2015 Mathias Schreck. All rights reserved. |
||||
* @copyright 2013 Nicholas C. Zakas. All rights reserved. |
* @copyright 2013 Nicholas C. Zakas. All rights reserved. |
||||
*/ |
*/ |
||||
|
|
||||
"use strict"; |
"use strict"; |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Requirements
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
var astUtils = require("../ast-utils"); |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Helpers
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
var candidatesOfGlobalObject = Object.freeze([ |
||||
|
"global", |
||||
|
"window" |
||||
|
]); |
||||
|
|
||||
|
/** |
||||
|
* Checks a given node is a Identifier node of the specified name. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node to check. |
||||
|
* @param {string} name - A name to check. |
||||
|
* @returns {boolean} `true` if the node is a Identifier node of the name. |
||||
|
*/ |
||||
|
function isIdentifier(node, name) { |
||||
|
return node.type === "Identifier" && node.name === name; |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Checks a given node is a Literal node of the specified string value. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node to check. |
||||
|
* @param {string} name - A name to check. |
||||
|
* @returns {boolean} `true` if the node is a Literal node of the name. |
||||
|
*/ |
||||
|
function isConstant(node, name) { |
||||
|
switch (node.type) { |
||||
|
case "Literal": |
||||
|
return node.value === name; |
||||
|
|
||||
|
case "TemplateLiteral": |
||||
|
return ( |
||||
|
node.expressions.length === 0 && |
||||
|
node.quasis[0].value.cooked === name |
||||
|
); |
||||
|
|
||||
|
default: |
||||
|
return false; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Checks a given node is a MemberExpression node which has the specified name's |
||||
|
* property. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node to check. |
||||
|
* @param {string} name - A name to check. |
||||
|
* @returns {boolean} `true` if the node is a MemberExpression node which has |
||||
|
* the specified name's property |
||||
|
*/ |
||||
|
function isMember(node, name) { |
||||
|
return ( |
||||
|
node.type === "MemberExpression" && |
||||
|
(node.computed ? isConstant : isIdentifier)(node.property, name) |
||||
|
); |
||||
|
} |
||||
|
|
||||
//------------------------------------------------------------------------------
|
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
module.exports = function(context) { |
module.exports = function(context) { |
||||
|
var allowIndirect = Boolean( |
||||
|
context.options[0] && |
||||
|
context.options[0].allowIndirect |
||||
|
); |
||||
|
var sourceCode = context.getSourceCode(); |
||||
|
var funcInfo = null; |
||||
|
|
||||
|
/** |
||||
|
* Pushs a variable scope (Program or Function) information to the stack. |
||||
|
* |
||||
|
* This is used in order to check whether or not `this` binding is a |
||||
|
* reference to the global object. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node of the scope. This is one of Program, |
||||
|
* FunctionDeclaration, FunctionExpression, and ArrowFunctionExpression. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function enterVarScope(node) { |
||||
|
var strict = context.getScope().isStrict; |
||||
|
|
||||
|
funcInfo = { |
||||
|
upper: funcInfo, |
||||
|
node: node, |
||||
|
strict: strict, |
||||
|
defaultThis: false, |
||||
|
initialized: strict |
||||
|
}; |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Pops a variable scope from the stack. |
||||
|
* |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function exitVarScope() { |
||||
|
funcInfo = funcInfo.upper; |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Reports a given node. |
||||
|
* |
||||
|
* `node` is `Identifier` or `MemberExpression`. |
||||
|
* The parent of `node` might be `CallExpression`. |
||||
|
* |
||||
|
* The location of the report is always `eval` `Identifier` (or possibly |
||||
|
* `Literal`). The type of the report is `CallExpression` if the parent is |
||||
|
* `CallExpression`. Otherwise, it's the given node type. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node to report. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function report(node) { |
||||
|
var locationNode = node; |
||||
|
var parent = node.parent; |
||||
|
|
||||
|
if (node.type === "MemberExpression") { |
||||
|
locationNode = node.property; |
||||
|
} |
||||
|
if (parent.type === "CallExpression" && parent.callee === node) { |
||||
|
node = parent; |
||||
|
} |
||||
|
|
||||
|
context.report({ |
||||
|
node: node, |
||||
|
loc: locationNode.loc.start, |
||||
|
message: "eval can be harmful." |
||||
|
}); |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Reports accesses of `eval` via the global object. |
||||
|
* |
||||
|
* @param {escope.Scope} globalScope - The global scope. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function reportAccessingEvalViaGlobalObject(globalScope) { |
||||
|
for (var i = 0; i < candidatesOfGlobalObject.length; ++i) { |
||||
|
var name = candidatesOfGlobalObject[i]; |
||||
|
var variable = astUtils.getVariableByName(globalScope, name); |
||||
|
if (!variable) { |
||||
|
continue; |
||||
|
} |
||||
|
|
||||
|
var references = variable.references; |
||||
|
for (var j = 0; j < references.length; ++j) { |
||||
|
var identifier = references[j].identifier; |
||||
|
var node = identifier.parent; |
||||
|
|
||||
|
// To detect code like `window.window.eval`.
|
||||
|
while (isMember(node, name)) { |
||||
|
node = node.parent; |
||||
|
} |
||||
|
|
||||
|
// Reports.
|
||||
|
if (isMember(node, "eval")) { |
||||
|
report(node); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Reports all accesses of `eval` (excludes direct calls to eval). |
||||
|
* |
||||
|
* @param {escope.Scope} globalScope - The global scope. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function reportAccessingEval(globalScope) { |
||||
|
var variable = astUtils.getVariableByName(globalScope, "eval"); |
||||
|
if (!variable) { |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
var references = variable.references; |
||||
|
for (var i = 0; i < references.length; ++i) { |
||||
|
var reference = references[i]; |
||||
|
var id = reference.identifier; |
||||
|
|
||||
|
if (id.name === "eval" && !astUtils.isCallee(id)) { |
||||
|
// Is accessing to eval (excludes direct calls to eval)
|
||||
|
report(id); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (allowIndirect) { |
||||
|
// Checks only direct calls to eval.
|
||||
|
// It's simple!
|
||||
|
return { |
||||
|
"CallExpression:exit": function(node) { |
||||
|
var callee = node.callee; |
||||
|
if (isIdentifier(callee, "eval")) { |
||||
|
report(callee); |
||||
|
} |
||||
|
} |
||||
|
}; |
||||
|
} |
||||
|
|
||||
return { |
return { |
||||
"CallExpression": function(node) { |
"CallExpression:exit": function(node) { |
||||
if (node.callee.name === "eval") { |
var callee = node.callee; |
||||
context.report(node, "eval can be harmful."); |
if (isIdentifier(callee, "eval")) { |
||||
|
report(callee); |
||||
|
} |
||||
|
}, |
||||
|
|
||||
|
"Program": function(node) { |
||||
|
var scope = context.getScope(), |
||||
|
features = context.parserOptions.ecmaFeatures || {}, |
||||
|
strict = |
||||
|
scope.isStrict || |
||||
|
node.sourceType === "module" || |
||||
|
(features.globalReturn && scope.childScopes[0].isStrict); |
||||
|
|
||||
|
funcInfo = { |
||||
|
upper: null, |
||||
|
node: node, |
||||
|
strict: strict, |
||||
|
defaultThis: true, |
||||
|
initialized: true |
||||
|
}; |
||||
|
}, |
||||
|
|
||||
|
"Program:exit": function() { |
||||
|
var globalScope = context.getScope(); |
||||
|
|
||||
|
exitVarScope(); |
||||
|
reportAccessingEval(globalScope); |
||||
|
reportAccessingEvalViaGlobalObject(globalScope); |
||||
|
}, |
||||
|
|
||||
|
"FunctionDeclaration": enterVarScope, |
||||
|
"FunctionDeclaration:exit": exitVarScope, |
||||
|
"FunctionExpression": enterVarScope, |
||||
|
"FunctionExpression:exit": exitVarScope, |
||||
|
"ArrowFunctionExpression": enterVarScope, |
||||
|
"ArrowFunctionExpression:exit": exitVarScope, |
||||
|
|
||||
|
"ThisExpression": function(node) { |
||||
|
if (!isMember(node.parent, "eval")) { |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
// `this.eval` is found.
|
||||
|
// Checks whether or not the value of `this` is the global object.
|
||||
|
if (!funcInfo.initialized) { |
||||
|
funcInfo.initialized = true; |
||||
|
funcInfo.defaultThis = astUtils.isDefaultThisBinding( |
||||
|
funcInfo.node, |
||||
|
sourceCode |
||||
|
); |
||||
|
} |
||||
|
if (!funcInfo.strict && funcInfo.defaultThis) { |
||||
|
// `this.eval` is possible built-in `eval`.
|
||||
|
report(node.parent); |
||||
} |
} |
||||
} |
} |
||||
}; |
}; |
||||
|
|
||||
}; |
}; |
||||
|
|
||||
module.exports.schema = []; |
module.exports.schema = [ |
||||
|
{ |
||||
|
"type": "object", |
||||
|
"properties": { |
||||
|
"allowIndirect": {"type": "boolean"} |
||||
|
}, |
||||
|
"additionalProperties": false |
||||
|
} |
||||
|
]; |
||||
|
|||||
@ -0,0 +1,132 @@ |
|||||
|
/** |
||||
|
* @fileoverview Rule to disallow unnecessary labels |
||||
|
* @author Toru Nagashima |
||||
|
* @copyright 2016 Toru Nagashima. All rights reserved. |
||||
|
* See LICENSE file in root directory for full license. |
||||
|
*/ |
||||
|
|
||||
|
"use strict"; |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Requirements
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
var astUtils = require("../ast-utils"); |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Rule Definition
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
module.exports = function(context) { |
||||
|
var scopeInfo = null; |
||||
|
|
||||
|
/** |
||||
|
* Creates a new scope with a breakable statement. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node to create. This is a BreakableStatement. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function enterBreakableStatement(node) { |
||||
|
scopeInfo = { |
||||
|
label: astUtils.getLabel(node), |
||||
|
breakable: true, |
||||
|
upper: scopeInfo |
||||
|
}; |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Removes the top scope of the stack. |
||||
|
* |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function exitBreakableStatement() { |
||||
|
scopeInfo = scopeInfo.upper; |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Creates a new scope with a labeled statement. |
||||
|
* |
||||
|
* This ignores it if the body is a breakable statement. |
||||
|
* In this case it's handled in the `enterBreakableStatement` function. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node to create. This is a LabeledStatement. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function enterLabeledStatement(node) { |
||||
|
if (!astUtils.isBreakableStatement(node.body)) { |
||||
|
scopeInfo = { |
||||
|
label: node.label.name, |
||||
|
breakable: false, |
||||
|
upper: scopeInfo |
||||
|
}; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Removes the top scope of the stack. |
||||
|
* |
||||
|
* This ignores it if the body is a breakable statement. |
||||
|
* In this case it's handled in the `exitBreakableStatement` function. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node. This is a LabeledStatement. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function exitLabeledStatement(node) { |
||||
|
if (!astUtils.isBreakableStatement(node.body)) { |
||||
|
scopeInfo = scopeInfo.upper; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Reports a given control node if it's unnecessary. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node. This is a BreakStatement or a |
||||
|
* ContinueStatement. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function reportIfUnnecessary(node) { |
||||
|
if (!node.label) { |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
var labelNode = node.label; |
||||
|
var label = labelNode.name; |
||||
|
var info = scopeInfo; |
||||
|
|
||||
|
while (info) { |
||||
|
if (info.breakable || info.label === label) { |
||||
|
if (info.breakable && info.label === label) { |
||||
|
context.report({ |
||||
|
node: labelNode, |
||||
|
message: "This label '{{name}}' is unnecessary.", |
||||
|
data: labelNode |
||||
|
}); |
||||
|
} |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
info = info.upper; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return { |
||||
|
"WhileStatement": enterBreakableStatement, |
||||
|
"WhileStatement:exit": exitBreakableStatement, |
||||
|
"DoWhileStatement": enterBreakableStatement, |
||||
|
"DoWhileStatement:exit": exitBreakableStatement, |
||||
|
"ForStatement": enterBreakableStatement, |
||||
|
"ForStatement:exit": exitBreakableStatement, |
||||
|
"ForInStatement": enterBreakableStatement, |
||||
|
"ForInStatement:exit": exitBreakableStatement, |
||||
|
"ForOfStatement": enterBreakableStatement, |
||||
|
"ForOfStatement:exit": exitBreakableStatement, |
||||
|
"SwitchStatement": enterBreakableStatement, |
||||
|
"SwitchStatement:exit": exitBreakableStatement, |
||||
|
"LabeledStatement": enterLabeledStatement, |
||||
|
"LabeledStatement:exit": exitLabeledStatement, |
||||
|
"BreakStatement": reportIfUnnecessary, |
||||
|
"ContinueStatement": reportIfUnnecessary |
||||
|
}; |
||||
|
}; |
||||
|
|
||||
|
module.exports.schema = []; |
||||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue