mirror of https://github.com/lukechilds/node.git
Browse Source
Update ESLint and configuration to version 4.0.0. Backport-PR-URL: https://github.com/nodejs/node/pull/14340 PR-URL: https://github.com/nodejs/node/pull/13645 Reviewed-By: Teddy Katz <teddy.katz@gmail.com> Reviewed-By: Colin Ihrig <cjihrig@gmail.com> Reviewed-By: Refael Ackermann <refack@gmail.com> Reviewed-By: Sam Roberts <vieuxtech@gmail.com> Reviewed-By: Alexey Orlenko <eaglexrlnk@gmail.com> Reviewed-By: James M Snell <jasnell@gmail.com>v6.x
Rich Trott
8 years ago
committed by
Myles Borins
Myles Borins
1031 changed files with 36736 additions and 42098 deletions
File diff suppressed because it is too large
@ -0,0 +1,15 @@ |
|||
{ |
|||
"type": "object", |
|||
"properties": { |
|||
"root": { "type": "boolean" }, |
|||
"globals": { "type": ["object"] }, |
|||
"parser": { "type": ["string", "null"] }, |
|||
"env": { "type": "object" }, |
|||
"plugins": { "type": ["array"] }, |
|||
"settings": { "type": "object" }, |
|||
"extends": { "type": ["string", "array"] }, |
|||
"rules": { "type": "object" }, |
|||
"parserOptions": { "type": "object" } |
|||
}, |
|||
"additionalProperties": false |
|||
} |
|||
@ -0,0 +1,33 @@ |
|||
/** |
|||
* @fileoverview Default config options |
|||
* @author Teddy Katz |
|||
*/ |
|||
|
|||
"use strict"; |
|||
|
|||
/** |
|||
* Freezes an object and all its nested properties |
|||
* @param {Object} obj The object to deeply freeze |
|||
* @returns {Object} `obj` after freezing it |
|||
*/ |
|||
function deepFreeze(obj) { |
|||
if (obj === null || typeof obj !== "object") { |
|||
return obj; |
|||
} |
|||
|
|||
Object.keys(obj).map(key => obj[key]).forEach(deepFreeze); |
|||
return Object.freeze(obj); |
|||
} |
|||
|
|||
module.exports = deepFreeze({ |
|||
env: {}, |
|||
globals: {}, |
|||
rules: {}, |
|||
settings: {}, |
|||
parser: "espree", |
|||
parserOptions: { |
|||
ecmaVersion: 5, |
|||
sourceType: "script", |
|||
ecmaFeatures: {} |
|||
} |
|||
}); |
|||
@ -0,0 +1,235 @@ |
|||
/** |
|||
* @fileoverview Rule to enforce linebreaks after open and before close array brackets |
|||
* @author Jan Peer Stöcklmair <https://github.com/JPeer264>
|
|||
*/ |
|||
|
|||
"use strict"; |
|||
|
|||
const astUtils = require("../ast-utils"); |
|||
|
|||
//------------------------------------------------------------------------------
|
|||
// Rule Definition
|
|||
//------------------------------------------------------------------------------
|
|||
|
|||
module.exports = { |
|||
meta: { |
|||
docs: { |
|||
description: "enforce linebreaks after opening and before closing array brackets", |
|||
category: "Stylistic Issues", |
|||
recommended: false |
|||
}, |
|||
fixable: "whitespace", |
|||
schema: [ |
|||
{ |
|||
oneOf: [ |
|||
{ |
|||
enum: ["always", "never"] |
|||
}, |
|||
{ |
|||
type: "object", |
|||
properties: { |
|||
multiline: { |
|||
type: "boolean" |
|||
}, |
|||
minItems: { |
|||
type: ["integer", "null"], |
|||
minimum: 0 |
|||
} |
|||
}, |
|||
additionalProperties: false |
|||
} |
|||
] |
|||
} |
|||
] |
|||
}, |
|||
|
|||
create(context) { |
|||
const sourceCode = context.getSourceCode(); |
|||
|
|||
|
|||
//----------------------------------------------------------------------
|
|||
// Helpers
|
|||
//----------------------------------------------------------------------
|
|||
|
|||
/** |
|||
* Normalizes a given option value. |
|||
* |
|||
* @param {string|Object|undefined} option - An option value to parse. |
|||
* @returns {{multiline: boolean, minItems: number}} Normalized option object. |
|||
*/ |
|||
function normalizeOptionValue(option) { |
|||
let multiline = false; |
|||
let minItems = 0; |
|||
|
|||
if (option) { |
|||
if (option === "always" || option.minItems === 0) { |
|||
minItems = 0; |
|||
} else if (option === "never") { |
|||
minItems = Number.POSITIVE_INFINITY; |
|||
} else { |
|||
multiline = Boolean(option.multiline); |
|||
minItems = option.minItems || Number.POSITIVE_INFINITY; |
|||
} |
|||
} else { |
|||
multiline = true; |
|||
minItems = Number.POSITIVE_INFINITY; |
|||
} |
|||
|
|||
return { multiline, minItems }; |
|||
} |
|||
|
|||
/** |
|||
* Normalizes a given option value. |
|||
* |
|||
* @param {string|Object|undefined} options - An option value to parse. |
|||
* @returns {{ArrayExpression: {multiline: boolean, minItems: number}, ArrayPattern: {multiline: boolean, minItems: number}}} Normalized option object. |
|||
*/ |
|||
function normalizeOptions(options) { |
|||
const value = normalizeOptionValue(options); |
|||
|
|||
return { ArrayExpression: value, ArrayPattern: value }; |
|||
} |
|||
|
|||
/** |
|||
* Reports that there shouldn't be a linebreak after the first token |
|||
* @param {ASTNode} node - The node to report in the event of an error. |
|||
* @param {Token} token - The token to use for the report. |
|||
* @returns {void} |
|||
*/ |
|||
function reportNoBeginningLinebreak(node, token) { |
|||
context.report({ |
|||
node, |
|||
loc: token.loc, |
|||
message: "There should be no linebreak after '['.", |
|||
fix(fixer) { |
|||
const nextToken = sourceCode.getTokenAfter(token, { includeComments: true }); |
|||
|
|||
if (astUtils.isCommentToken(nextToken)) { |
|||
return null; |
|||
} |
|||
|
|||
return fixer.removeRange([token.range[1], nextToken.range[0]]); |
|||
} |
|||
}); |
|||
} |
|||
|
|||
/** |
|||
* Reports that there shouldn't be a linebreak before the last token |
|||
* @param {ASTNode} node - The node to report in the event of an error. |
|||
* @param {Token} token - The token to use for the report. |
|||
* @returns {void} |
|||
*/ |
|||
function reportNoEndingLinebreak(node, token) { |
|||
context.report({ |
|||
node, |
|||
loc: token.loc, |
|||
message: "There should be no linebreak before ']'.", |
|||
fix(fixer) { |
|||
const previousToken = sourceCode.getTokenBefore(token, { includeComments: true }); |
|||
|
|||
if (astUtils.isCommentToken(previousToken)) { |
|||
return null; |
|||
} |
|||
|
|||
return fixer.removeRange([previousToken.range[1], token.range[0]]); |
|||
} |
|||
}); |
|||
} |
|||
|
|||
/** |
|||
* Reports that there should be a linebreak after the first token |
|||
* @param {ASTNode} node - The node to report in the event of an error. |
|||
* @param {Token} token - The token to use for the report. |
|||
* @returns {void} |
|||
*/ |
|||
function reportRequiredBeginningLinebreak(node, token) { |
|||
context.report({ |
|||
node, |
|||
loc: token.loc, |
|||
message: "A linebreak is required after '['.", |
|||
fix(fixer) { |
|||
return fixer.insertTextAfter(token, "\n"); |
|||
} |
|||
}); |
|||
} |
|||
|
|||
/** |
|||
* Reports that there should be a linebreak before the last token |
|||
* @param {ASTNode} node - The node to report in the event of an error. |
|||
* @param {Token} token - The token to use for the report. |
|||
* @returns {void} |
|||
*/ |
|||
function reportRequiredEndingLinebreak(node, token) { |
|||
context.report({ |
|||
node, |
|||
loc: token.loc, |
|||
message: "A linebreak is required before ']'.", |
|||
fix(fixer) { |
|||
return fixer.insertTextBefore(token, "\n"); |
|||
} |
|||
}); |
|||
} |
|||
|
|||
/** |
|||
* Reports a given node if it violated this rule. |
|||
* |
|||
* @param {ASTNode} node - A node to check. This is an ObjectExpression node or an ObjectPattern node. |
|||
* @param {{multiline: boolean, minItems: number}} options - An option object. |
|||
* @returns {void} |
|||
*/ |
|||
function check(node) { |
|||
const elements = node.elements; |
|||
const normalizedOptions = normalizeOptions(context.options[0]); |
|||
const options = normalizedOptions[node.type]; |
|||
const openBracket = sourceCode.getFirstToken(node); |
|||
const closeBracket = sourceCode.getLastToken(node); |
|||
const firstIncComment = sourceCode.getTokenAfter(openBracket, { includeComments: true }); |
|||
const lastIncComment = sourceCode.getTokenBefore(closeBracket, { includeComments: true }); |
|||
const first = sourceCode.getTokenAfter(openBracket); |
|||
const last = sourceCode.getTokenBefore(closeBracket); |
|||
|
|||
const needsLinebreaks = ( |
|||
elements.length >= options.minItems || |
|||
( |
|||
options.multiline && |
|||
elements.length > 0 && |
|||
firstIncComment.loc.start.line !== lastIncComment.loc.end.line |
|||
) |
|||
); |
|||
|
|||
/* |
|||
* Use tokens or comments to check multiline or not. |
|||
* But use only tokens to check whether linebreaks are needed. |
|||
* This allows: |
|||
* var arr = [ // eslint-disable-line foo
|
|||
* 'a' |
|||
* ] |
|||
*/ |
|||
|
|||
if (needsLinebreaks) { |
|||
if (astUtils.isTokenOnSameLine(openBracket, first)) { |
|||
reportRequiredBeginningLinebreak(node, openBracket); |
|||
} |
|||
if (astUtils.isTokenOnSameLine(last, closeBracket)) { |
|||
reportRequiredEndingLinebreak(node, closeBracket); |
|||
} |
|||
} else { |
|||
if (!astUtils.isTokenOnSameLine(openBracket, first)) { |
|||
reportNoBeginningLinebreak(node, openBracket); |
|||
} |
|||
if (!astUtils.isTokenOnSameLine(last, closeBracket)) { |
|||
reportNoEndingLinebreak(node, closeBracket); |
|||
} |
|||
} |
|||
} |
|||
|
|||
//----------------------------------------------------------------------
|
|||
// Public
|
|||
//----------------------------------------------------------------------
|
|||
|
|||
return { |
|||
ArrayPattern: check, |
|||
ArrayExpression: check |
|||
}; |
|||
} |
|||
}; |
|||
@ -0,0 +1,230 @@ |
|||
/** |
|||
* @fileoverview Rule to enforce line breaks after each array element |
|||
* @author Jan Peer Stöcklmair <https://github.com/JPeer264>
|
|||
*/ |
|||
|
|||
"use strict"; |
|||
|
|||
const astUtils = require("../ast-utils"); |
|||
|
|||
//------------------------------------------------------------------------------
|
|||
// Rule Definition
|
|||
//------------------------------------------------------------------------------
|
|||
|
|||
module.exports = { |
|||
meta: { |
|||
docs: { |
|||
description: "enforce line breaks after each array element", |
|||
category: "Stylistic Issues", |
|||
recommended: false |
|||
}, |
|||
fixable: "whitespace", |
|||
schema: [ |
|||
{ |
|||
oneOf: [ |
|||
{ |
|||
enum: ["always", "never"] |
|||
}, |
|||
{ |
|||
type: "object", |
|||
properties: { |
|||
multiline: { |
|||
type: "boolean" |
|||
}, |
|||
minItems: { |
|||
type: ["integer", "null"], |
|||
minimum: 0 |
|||
} |
|||
}, |
|||
additionalProperties: false |
|||
} |
|||
] |
|||
} |
|||
] |
|||
}, |
|||
|
|||
create(context) { |
|||
const sourceCode = context.getSourceCode(); |
|||
|
|||
//----------------------------------------------------------------------
|
|||
// Helpers
|
|||
//----------------------------------------------------------------------
|
|||
|
|||
/** |
|||
* Normalizes a given option value. |
|||
* |
|||
* @param {string|Object|undefined} option - An option value to parse. |
|||
* @returns {{multiline: boolean, minItems: number}} Normalized option object. |
|||
*/ |
|||
function normalizeOptionValue(option) { |
|||
let multiline = false; |
|||
let minItems; |
|||
|
|||
option = option || "always"; |
|||
|
|||
if (option === "always" || option.minItems === 0) { |
|||
minItems = 0; |
|||
} else if (option === "never") { |
|||
minItems = Number.POSITIVE_INFINITY; |
|||
} else { |
|||
multiline = Boolean(option.multiline); |
|||
minItems = option.minItems || Number.POSITIVE_INFINITY; |
|||
} |
|||
|
|||
return { multiline, minItems }; |
|||
} |
|||
|
|||
/** |
|||
* Normalizes a given option value. |
|||
* |
|||
* @param {string|Object|undefined} options - An option value to parse. |
|||
* @returns {{ArrayExpression: {multiline: boolean, minItems: number}, ArrayPattern: {multiline: boolean, minItems: number}}} Normalized option object. |
|||
*/ |
|||
function normalizeOptions(options) { |
|||
const value = normalizeOptionValue(options); |
|||
|
|||
return { ArrayExpression: value, ArrayPattern: value }; |
|||
} |
|||
|
|||
/** |
|||
* Reports that there shouldn't be a line break after the first token |
|||
* @param {Token} token - The token to use for the report. |
|||
* @returns {void} |
|||
*/ |
|||
function reportNoLineBreak(token) { |
|||
const tokenBefore = sourceCode.getTokenBefore(token, { includeComments: true }); |
|||
|
|||
context.report({ |
|||
loc: { |
|||
start: tokenBefore.loc.end, |
|||
end: token.loc.start |
|||
}, |
|||
message: "There should be no linebreak here.", |
|||
fix(fixer) { |
|||
if (astUtils.isCommentToken(tokenBefore)) { |
|||
return null; |
|||
} |
|||
|
|||
if (!astUtils.isTokenOnSameLine(tokenBefore, token)) { |
|||
return fixer.replaceTextRange([tokenBefore.range[1], token.range[0]], " "); |
|||
} |
|||
|
|||
/* |
|||
* This will check if the comma is on the same line as the next element |
|||
* Following array: |
|||
* [ |
|||
* 1 |
|||
* , 2 |
|||
* , 3 |
|||
* ] |
|||
* |
|||
* will be fixed to: |
|||
* [ |
|||
* 1, 2, 3 |
|||
* ] |
|||
*/ |
|||
const twoTokensBefore = sourceCode.getTokenBefore(tokenBefore, { includeComments: true }); |
|||
|
|||
if (astUtils.isCommentToken(twoTokensBefore)) { |
|||
return null; |
|||
} |
|||
|
|||
return fixer.replaceTextRange([twoTokensBefore.range[1], tokenBefore.range[0]], ""); |
|||
|
|||
} |
|||
}); |
|||
} |
|||
|
|||
/** |
|||
* Reports that there should be a line break after the first token |
|||
* @param {Token} token - The token to use for the report. |
|||
* @returns {void} |
|||
*/ |
|||
function reportRequiredLineBreak(token) { |
|||
const tokenBefore = sourceCode.getTokenBefore(token, { includeComments: true }); |
|||
|
|||
context.report({ |
|||
loc: { |
|||
start: tokenBefore.loc.end, |
|||
end: token.loc.start |
|||
}, |
|||
message: "There should be a linebreak after this element.", |
|||
fix(fixer) { |
|||
return fixer.replaceTextRange([tokenBefore.range[1], token.range[0]], "\n"); |
|||
} |
|||
}); |
|||
} |
|||
|
|||
/** |
|||
* Reports a given node if it violated this rule. |
|||
* |
|||
* @param {ASTNode} node - A node to check. This is an ObjectExpression node or an ObjectPattern node. |
|||
* @param {{multiline: boolean, minItems: number}} options - An option object. |
|||
* @returns {void} |
|||
*/ |
|||
function check(node) { |
|||
const elements = node.elements; |
|||
const normalizedOptions = normalizeOptions(context.options[0]); |
|||
const options = normalizedOptions[node.type]; |
|||
|
|||
let elementBreak = false; |
|||
|
|||
/* |
|||
* MULTILINE: true |
|||
* loop through every element and check |
|||
* if at least one element has linebreaks inside |
|||
* this ensures that following is not valid (due to elements are on the same line): |
|||
* |
|||
* [ |
|||
* 1, |
|||
* 2, |
|||
* 3 |
|||
* ] |
|||
*/ |
|||
if (options.multiline) { |
|||
elementBreak = elements |
|||
.filter(element => element !== null) |
|||
.some(element => element.loc.start.line !== element.loc.end.line); |
|||
} |
|||
|
|||
const needsLinebreaks = ( |
|||
elements.length >= options.minItems || |
|||
( |
|||
options.multiline && |
|||
elementBreak |
|||
) |
|||
); |
|||
|
|||
elements.forEach((element, i) => { |
|||
const previousElement = elements[i - 1]; |
|||
|
|||
if (i === 0 || element === null || previousElement === null) { |
|||
return; |
|||
} |
|||
|
|||
const commaToken = sourceCode.getFirstTokenBetween(previousElement, element, astUtils.isCommaToken); |
|||
const lastTokenOfPreviousElement = sourceCode.getTokenBefore(commaToken); |
|||
const firstTokenOfCurrentElement = sourceCode.getTokenAfter(commaToken); |
|||
|
|||
if (needsLinebreaks) { |
|||
if (astUtils.isTokenOnSameLine(lastTokenOfPreviousElement, firstTokenOfCurrentElement)) { |
|||
reportRequiredLineBreak(firstTokenOfCurrentElement); |
|||
} |
|||
} else { |
|||
if (!astUtils.isTokenOnSameLine(lastTokenOfPreviousElement, firstTokenOfCurrentElement)) { |
|||
reportNoLineBreak(firstTokenOfCurrentElement); |
|||
} |
|||
} |
|||
}); |
|||
} |
|||
|
|||
//----------------------------------------------------------------------
|
|||
// Public
|
|||
//----------------------------------------------------------------------
|
|||
|
|||
return { |
|||
ArrayPattern: check, |
|||
ArrayExpression: check |
|||
}; |
|||
} |
|||
}; |
|||
@ -0,0 +1,105 @@ |
|||
/** |
|||
* @fileoverview enforce "for" loop update clause moving the counter in the right direction.(for-direction) |
|||
* @author Aladdin-ADD<hh_2013@foxmail.com> |
|||
*/ |
|||
|
|||
"use strict"; |
|||
|
|||
//------------------------------------------------------------------------------
|
|||
// Rule Definition
|
|||
//------------------------------------------------------------------------------
|
|||
|
|||
module.exports = { |
|||
meta: { |
|||
docs: { |
|||
description: "enforce \"for\" loop update clause moving the counter in the right direction.", |
|||
category: "Possible Errors", |
|||
recommended: false |
|||
}, |
|||
fixable: null, |
|||
schema: [] |
|||
}, |
|||
|
|||
create(context) { |
|||
|
|||
/** |
|||
* report an error. |
|||
* @param {ASTNode} node the node to report. |
|||
* @returns {void} |
|||
*/ |
|||
function report(node) { |
|||
context.report({ |
|||
node, |
|||
message: "The update clause in this loop moves the variable in the wrong direction." |
|||
}); |
|||
} |
|||
|
|||
/** |
|||
* check UpdateExpression add/sub the counter |
|||
* @param {ASTNode} update UpdateExpression to check |
|||
* @param {string} counter variable name to check |
|||
* @returns {int} if add return 1, if sub return -1, if nochange, return 0 |
|||
*/ |
|||
function getUpdateDirection(update, counter) { |
|||
if (update.argument.type === "Identifier" && update.argument.name === counter) { |
|||
if (update.operator === "++") { |
|||
return 1; |
|||
} |
|||
if (update.operator === "--") { |
|||
return -1; |
|||
} |
|||
} |
|||
return 0; |
|||
} |
|||
|
|||
/** |
|||
* check AssignmentExpression add/sub the counter |
|||
* @param {ASTNode} update AssignmentExpression to check |
|||
* @param {string} counter variable name to check |
|||
* @returns {int} if add return 1, if sub return -1, if nochange, return 0 |
|||
*/ |
|||
function getAssignmentDirection(update, counter) { |
|||
if (update.left.name === counter) { |
|||
if (update.operator === "+=") { |
|||
return 1; |
|||
} |
|||
if (update.operator === "-=") { |
|||
return -1; |
|||
} |
|||
} |
|||
return 0; |
|||
} |
|||
return { |
|||
ForStatement(node) { |
|||
|
|||
if (node.test && node.test.type === "BinaryExpression" && node.test.left.type === "Identifier" && node.update) { |
|||
const counter = node.test.left.name; |
|||
const operator = node.test.operator; |
|||
const update = node.update; |
|||
|
|||
if (operator === "<" || operator === "<=") { |
|||
|
|||
// report error if update sub the counter (--, -=)
|
|||
if (update.type === "UpdateExpression" && getUpdateDirection(update, counter) < 0) { |
|||
report(node); |
|||
} |
|||
|
|||
if (update.type === "AssignmentExpression" && getAssignmentDirection(update, counter) < 0) { |
|||
report(node); |
|||
} |
|||
} else if (operator === ">" || operator === ">=") { |
|||
|
|||
// report error if update add the counter (++, +=)
|
|||
if (update.type === "UpdateExpression" && getUpdateDirection(update, counter) > 0) { |
|||
report(node); |
|||
} |
|||
|
|||
if (update.type === "AssignmentExpression" && getAssignmentDirection(update, counter) > 0) { |
|||
report(node); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
}; |
|||
} |
|||
}; |
|||
File diff suppressed because it is too large
File diff suppressed because it is too large
@ -0,0 +1,37 @@ |
|||
/** |
|||
* @fileoverview disallow use of the Buffer() constructor |
|||
* @author Teddy Katz |
|||
*/ |
|||
"use strict"; |
|||
|
|||
//------------------------------------------------------------------------------
|
|||
// Rule Definition
|
|||
//------------------------------------------------------------------------------
|
|||
|
|||
module.exports = { |
|||
meta: { |
|||
docs: { |
|||
description: "disallow use of the Buffer() constructor", |
|||
category: "Node.js and CommonJS", |
|||
recommended: false |
|||
}, |
|||
schema: [] |
|||
}, |
|||
|
|||
create(context) { |
|||
|
|||
//----------------------------------------------------------------------
|
|||
// Public
|
|||
//----------------------------------------------------------------------
|
|||
|
|||
return { |
|||
"CallExpression[callee.name='Buffer'], NewExpression[callee.name='Buffer']"(node) { |
|||
context.report({ |
|||
node, |
|||
message: "{{example}} is deprecated. Use Buffer.from(), Buffer.alloc(), or Buffer.allocUnsafe() instead.", |
|||
data: { example: node.type === "CallExpression" ? "Buffer()" : "new Buffer()" } |
|||
}); |
|||
} |
|||
}; |
|||
} |
|||
}; |
|||
@ -0,0 +1,587 @@ |
|||
/** |
|||
* @fileoverview Rule to require or disallow newlines between statements |
|||
* @author Toru Nagashima |
|||
*/ |
|||
|
|||
"use strict"; |
|||
|
|||
//------------------------------------------------------------------------------
|
|||
// Requirements
|
|||
//------------------------------------------------------------------------------
|
|||
|
|||
const astUtils = require("../ast-utils"); |
|||
|
|||
//------------------------------------------------------------------------------
|
|||
// Helpers
|
|||
//------------------------------------------------------------------------------
|
|||
|
|||
const LT = `[${Array.from(astUtils.LINEBREAKS).join("")}]`; |
|||
const PADDING_LINE_SEQUENCE = new RegExp( |
|||
String.raw`^(\s*?${LT})\s*${LT}(\s*;?)$` |
|||
); |
|||
const CJS_EXPORT = /^(?:module\s*\.\s*)?exports(?:\s*\.|\s*\[|$)/; |
|||
const CJS_IMPORT = /^require\(/; |
|||
|
|||
/** |
|||
* Creates tester which check if a node starts with specific keyword. |
|||
* |
|||
* @param {string} keyword The keyword to test. |
|||
* @returns {Object} the created tester. |
|||
* @private |
|||
*/ |
|||
function newKeywordTester(keyword) { |
|||
return { |
|||
test: (node, sourceCode) => |
|||
sourceCode.getFirstToken(node).value === keyword |
|||
}; |
|||
} |
|||
|
|||
/** |
|||
* Creates tester which check if a node is specific type. |
|||
* |
|||
* @param {string} type The node type to test. |
|||
* @returns {Object} the created tester. |
|||
* @private |
|||
*/ |
|||
function newNodeTypeTester(type) { |
|||
return { |
|||
test: node => |
|||
node.type === type |
|||
}; |
|||
} |
|||
|
|||
/** |
|||
* Checks the given node is an expression statement of IIFE. |
|||
* |
|||
* @param {ASTNode} node The node to check. |
|||
* @returns {boolean} `true` if the node is an expression statement of IIFE. |
|||
* @private |
|||
*/ |
|||
function isIIFEStatement(node) { |
|||
if (node.type === "ExpressionStatement") { |
|||
let call = node.expression; |
|||
|
|||
if (call.type === "UnaryExpression") { |
|||
call = call.argument; |
|||
} |
|||
return call.type === "CallExpression" && astUtils.isFunction(call.callee); |
|||
} |
|||
return false; |
|||
} |
|||
|
|||
/** |
|||
* Checks whether the given node is a block-like statement. |
|||
* This checks the last token of the node is the closing brace of a block. |
|||
* |
|||
* @param {SourceCode} sourceCode The source code to get tokens. |
|||
* @param {ASTNode} node The node to check. |
|||
* @returns {boolean} `true` if the node is a block-like statement. |
|||
* @private |
|||
*/ |
|||
function isBlockLikeStatement(sourceCode, node) { |
|||
|
|||
// do-while with a block is a block-like statement.
|
|||
if (node.type === "DoWhileStatement" && node.body.type === "BlockStatement") { |
|||
return true; |
|||
} |
|||
|
|||
// IIFE is a block-like statement specially from
|
|||
// JSCS#disallowPaddingNewLinesAfterBlocks.
|
|||
if (isIIFEStatement(node)) { |
|||
return true; |
|||
} |
|||
|
|||
// Checks the last token is a closing brace of blocks.
|
|||
const lastToken = sourceCode.getLastToken(node, astUtils.isNotSemicolonToken); |
|||
const belongingNode = astUtils.isClosingBraceToken(lastToken) |
|||
? sourceCode.getNodeByRangeIndex(lastToken.range[0]) |
|||
: null; |
|||
|
|||
return Boolean(belongingNode) && ( |
|||
belongingNode.type === "BlockStatement" || |
|||
belongingNode.type === "SwitchStatement" |
|||
); |
|||
} |
|||
|
|||
/** |
|||
* Check whether the given node is a directive or not. |
|||
* @param {ASTNode} node The node to check. |
|||
* @param {SourceCode} sourceCode The source code object to get tokens. |
|||
* @returns {boolean} `true` if the node is a directive. |
|||
*/ |
|||
function isDirective(node, sourceCode) { |
|||
return ( |
|||
node.type === "ExpressionStatement" && |
|||
( |
|||
node.parent.type === "Program" || |
|||
( |
|||
node.parent.type === "BlockStatement" && |
|||
astUtils.isFunction(node.parent.parent) |
|||
) |
|||
) && |
|||
node.expression.type === "Literal" && |
|||
typeof node.expression.value === "string" && |
|||
!astUtils.isParenthesised(sourceCode, node.expression) |
|||
); |
|||
} |
|||
|
|||
/** |
|||
* Check whether the given node is a part of directive prologue or not. |
|||
* @param {ASTNode} node The node to check. |
|||
* @param {SourceCode} sourceCode The source code object to get tokens. |
|||
* @returns {boolean} `true` if the node is a part of directive prologue. |
|||
*/ |
|||
function isDirectivePrologue(node, sourceCode) { |
|||
if (isDirective(node, sourceCode)) { |
|||
for (const sibling of node.parent.body) { |
|||
if (sibling === node) { |
|||
break; |
|||
} |
|||
if (!isDirective(sibling, sourceCode)) { |
|||
return false; |
|||
} |
|||
} |
|||
return true; |
|||
} |
|||
return false; |
|||
} |
|||
|
|||
/** |
|||
* Gets the actual last token. |
|||
* |
|||
* If a semicolon is semicolon-less style's semicolon, this ignores it. |
|||
* For example: |
|||
* |
|||
* foo() |
|||
* ;[1, 2, 3].forEach(bar) |
|||
* |
|||
* @param {SourceCode} sourceCode The source code to get tokens. |
|||
* @param {ASTNode} node The node to get. |
|||
* @returns {Token} The actual last token. |
|||
* @private |
|||
*/ |
|||
function getActualLastToken(sourceCode, node) { |
|||
const semiToken = sourceCode.getLastToken(node); |
|||
const prevToken = sourceCode.getTokenBefore(semiToken); |
|||
const nextToken = sourceCode.getTokenAfter(semiToken); |
|||
const isSemicolonLessStyle = Boolean( |
|||
prevToken && |
|||
nextToken && |
|||
prevToken.range[0] >= node.range[0] && |
|||
astUtils.isSemicolonToken(semiToken) && |
|||
semiToken.loc.start.line !== prevToken.loc.end.line && |
|||
semiToken.loc.end.line === nextToken.loc.start.line |
|||
); |
|||
|
|||
return isSemicolonLessStyle ? prevToken : semiToken; |
|||
} |
|||
|
|||
/** |
|||
* This returns the concatenation of the first 2 captured strings. |
|||
* @param {string} _ Unused. Whole matched string. |
|||
* @param {string} trailingSpaces The trailing spaces of the first line. |
|||
* @param {string} indentSpaces The indentation spaces of the last line. |
|||
* @returns {string} The concatenation of trailingSpaces and indentSpaces. |
|||
* @private |
|||
*/ |
|||
function replacerToRemovePaddingLines(_, trailingSpaces, indentSpaces) { |
|||
return trailingSpaces + indentSpaces; |
|||
} |
|||
|
|||
/** |
|||
* Check and report statements for `any` configuration. |
|||
* It does nothing. |
|||
* |
|||
* @returns {void} |
|||
* @private |
|||
*/ |
|||
function verifyForAny() { |
|||
} |
|||
|
|||
/** |
|||
* Check and report statements for `never` configuration. |
|||
* This autofix removes blank lines between the given 2 statements. |
|||
* However, if comments exist between 2 blank lines, it does not remove those |
|||
* blank lines automatically. |
|||
* |
|||
* @param {RuleContext} context The rule context to report. |
|||
* @param {ASTNode} prevNode The previous node to check. |
|||
* @param {ASTNode} nextNode The next node to check. |
|||
* @param {Array<Token[]>} paddingLines The array of token pairs that blank |
|||
* lines exist between the pair. |
|||
* @returns {void} |
|||
* @private |
|||
*/ |
|||
function verifyForNever(context, prevNode, nextNode, paddingLines) { |
|||
if (paddingLines.length === 0) { |
|||
return; |
|||
} |
|||
|
|||
context.report({ |
|||
node: nextNode, |
|||
message: "Unexpected blank line before this statement.", |
|||
fix(fixer) { |
|||
if (paddingLines.length >= 2) { |
|||
return null; |
|||
} |
|||
|
|||
const prevToken = paddingLines[0][0]; |
|||
const nextToken = paddingLines[0][1]; |
|||
const start = prevToken.range[1]; |
|||
const end = nextToken.range[0]; |
|||
const text = context.getSourceCode().text |
|||
.slice(start, end) |
|||
.replace(PADDING_LINE_SEQUENCE, replacerToRemovePaddingLines); |
|||
|
|||
return fixer.replaceTextRange([start, end], text); |
|||
} |
|||
}); |
|||
} |
|||
|
|||
/** |
|||
* Check and report statements for `always` configuration. |
|||
* This autofix inserts a blank line between the given 2 statements. |
|||
* If the `prevNode` has trailing comments, it inserts a blank line after the |
|||
* trailing comments. |
|||
* |
|||
* @param {RuleContext} context The rule context to report. |
|||
* @param {ASTNode} prevNode The previous node to check. |
|||
* @param {ASTNode} nextNode The next node to check. |
|||
* @param {Array<Token[]>} paddingLines The array of token pairs that blank |
|||
* lines exist between the pair. |
|||
* @returns {void} |
|||
* @private |
|||
*/ |
|||
function verifyForAlways(context, prevNode, nextNode, paddingLines) { |
|||
if (paddingLines.length > 0) { |
|||
return; |
|||
} |
|||
|
|||
context.report({ |
|||
node: nextNode, |
|||
message: "Expected blank line before this statement.", |
|||
fix(fixer) { |
|||
const sourceCode = context.getSourceCode(); |
|||
let prevToken = getActualLastToken(sourceCode, prevNode); |
|||
const nextToken = sourceCode.getFirstTokenBetween( |
|||
prevToken, |
|||
nextNode, |
|||
{ |
|||
includeComments: true, |
|||
|
|||
/** |
|||
* Skip the trailing comments of the previous node. |
|||
* This inserts a blank line after the last trailing comment. |
|||
* |
|||
* For example: |
|||
* |
|||
* foo(); // trailing comment.
|
|||
* // comment.
|
|||
* bar(); |
|||
* |
|||
* Get fixed to: |
|||
* |
|||
* foo(); // trailing comment.
|
|||
* |
|||
* // comment.
|
|||
* bar(); |
|||
* |
|||
* @param {Token} token The token to check. |
|||
* @returns {boolean} `true` if the token is not a trailing comment. |
|||
* @private |
|||
*/ |
|||
filter(token) { |
|||
if (astUtils.isTokenOnSameLine(prevToken, token)) { |
|||
prevToken = token; |
|||
return false; |
|||
} |
|||
return true; |
|||
} |
|||
} |
|||
) || nextNode; |
|||
const insertText = astUtils.isTokenOnSameLine(prevToken, nextToken) |
|||
? "\n\n" |
|||
: "\n"; |
|||
|
|||
return fixer.insertTextAfter(prevToken, insertText); |
|||
} |
|||
}); |
|||
} |
|||
|
|||
/** |
|||
* Types of blank lines. |
|||
* `any`, `never`, and `always` are defined. |
|||
* Those have `verify` method to check and report statements. |
|||
* @private |
|||
*/ |
|||
const PaddingTypes = { |
|||
any: { verify: verifyForAny }, |
|||
never: { verify: verifyForNever }, |
|||
always: { verify: verifyForAlways } |
|||
}; |
|||
|
|||
/** |
|||
* Types of statements. |
|||
* Those have `test` method to check it matches to the given statement. |
|||
* @private |
|||
*/ |
|||
const StatementTypes = { |
|||
"*": { test: () => true }, |
|||
"block-like": { |
|||
test: (node, sourceCode) => isBlockLikeStatement(sourceCode, node) |
|||
}, |
|||
"cjs-export": { |
|||
test: (node, sourceCode) => |
|||
node.type === "ExpressionStatement" && |
|||
node.expression.type === "AssignmentExpression" && |
|||
CJS_EXPORT.test(sourceCode.getText(node.expression.left)) |
|||
}, |
|||
"cjs-import": { |
|||
test: (node, sourceCode) => |
|||
node.type === "VariableDeclaration" && |
|||
node.declarations.length > 0 && |
|||
Boolean(node.declarations[0].init) && |
|||
CJS_IMPORT.test(sourceCode.getText(node.declarations[0].init)) |
|||
}, |
|||
directive: { |
|||
test: isDirectivePrologue |
|||
}, |
|||
expression: { |
|||
test: (node, sourceCode) => |
|||
node.type === "ExpressionStatement" && |
|||
!isDirectivePrologue(node, sourceCode) |
|||
}, |
|||
"multiline-block-like": { |
|||
test: (node, sourceCode) => |
|||
node.loc.start.line !== node.loc.end.line && |
|||
isBlockLikeStatement(sourceCode, node) |
|||
}, |
|||
|
|||
block: newNodeTypeTester("BlockStatement"), |
|||
empty: newNodeTypeTester("EmptyStatement"), |
|||
|
|||
break: newKeywordTester("break"), |
|||
case: newKeywordTester("case"), |
|||
class: newKeywordTester("class"), |
|||
const: newKeywordTester("const"), |
|||
continue: newKeywordTester("continue"), |
|||
debugger: newKeywordTester("debugger"), |
|||
default: newKeywordTester("default"), |
|||
do: newKeywordTester("do"), |
|||
export: newKeywordTester("export"), |
|||
for: newKeywordTester("for"), |
|||
function: newKeywordTester("function"), |
|||
if: newKeywordTester("if"), |
|||
import: newKeywordTester("import"), |
|||
let: newKeywordTester("let"), |
|||
return: newKeywordTester("return"), |
|||
switch: newKeywordTester("switch"), |
|||
throw: newKeywordTester("throw"), |
|||
try: newKeywordTester("try"), |
|||
var: newKeywordTester("var"), |
|||
while: newKeywordTester("while"), |
|||
with: newKeywordTester("with") |
|||
}; |
|||
|
|||
//------------------------------------------------------------------------------
|
|||
// Rule Definition
|
|||
//------------------------------------------------------------------------------
|
|||
|
|||
module.exports = { |
|||
meta: { |
|||
docs: { |
|||
description: "require or disallow padding lines between statements", |
|||
category: "Stylistic Issues", |
|||
recommended: false |
|||
}, |
|||
fixable: "whitespace", |
|||
schema: { |
|||
definitions: { |
|||
paddingType: { |
|||
enum: Object.keys(PaddingTypes) |
|||
}, |
|||
statementType: { |
|||
anyOf: [ |
|||
{ enum: Object.keys(StatementTypes) }, |
|||
{ |
|||
type: "array", |
|||
items: { enum: Object.keys(StatementTypes) }, |
|||
minItems: 1, |
|||
uniqueItems: true, |
|||
additionalItems: false |
|||
} |
|||
] |
|||
} |
|||
}, |
|||
type: "array", |
|||
items: { |
|||
type: "object", |
|||
properties: { |
|||
blankLine: { $ref: "#/definitions/paddingType" }, |
|||
prev: { $ref: "#/definitions/statementType" }, |
|||
next: { $ref: "#/definitions/statementType" } |
|||
}, |
|||
additionalProperties: false, |
|||
required: ["blankLine", "prev", "next"] |
|||
}, |
|||
additionalItems: false |
|||
} |
|||
}, |
|||
|
|||
create(context) { |
|||
const sourceCode = context.getSourceCode(); |
|||
const configureList = context.options || []; |
|||
let scopeInfo = null; |
|||
|
|||
/** |
|||
* Processes to enter to new scope. |
|||
* This manages the current previous statement. |
|||
* @returns {void} |
|||
* @private |
|||
*/ |
|||
function enterScope() { |
|||
scopeInfo = { |
|||
upper: scopeInfo, |
|||
prevNode: null |
|||
}; |
|||
} |
|||
|
|||
/** |
|||
* Processes to exit from the current scope. |
|||
* @returns {void} |
|||
* @private |
|||
*/ |
|||
function exitScope() { |
|||
scopeInfo = scopeInfo.upper; |
|||
} |
|||
|
|||
/** |
|||
* Checks whether the given node matches the given type. |
|||
* |
|||
* @param {ASTNode} node The statement node to check. |
|||
* @param {string|string[]} type The statement type to check. |
|||
* @returns {boolean} `true` if the statement node matched the type. |
|||
* @private |
|||
*/ |
|||
function match(node, type) { |
|||
while (node.type === "LabeledStatement") { |
|||
node = node.body; |
|||
} |
|||
if (Array.isArray(type)) { |
|||
return type.some(match.bind(null, node)); |
|||
} |
|||
return StatementTypes[type].test(node, sourceCode); |
|||
} |
|||
|
|||
/** |
|||
* Finds the last matched configure from configureList. |
|||
* |
|||
* @param {ASTNode} prevNode The previous statement to match. |
|||
* @param {ASTNode} nextNode The current statement to match. |
|||
* @returns {Object} The tester of the last matched configure. |
|||
* @private |
|||
*/ |
|||
function getPaddingType(prevNode, nextNode) { |
|||
for (let i = configureList.length - 1; i >= 0; --i) { |
|||
const configure = configureList[i]; |
|||
const matched = |
|||
match(prevNode, configure.prev) && |
|||
match(nextNode, configure.next); |
|||
|
|||
if (matched) { |
|||
return PaddingTypes[configure.blankLine]; |
|||
} |
|||
} |
|||
return PaddingTypes.any; |
|||
} |
|||
|
|||
/** |
|||
* Gets padding line sequences between the given 2 statements. |
|||
* Comments are separators of the padding line sequences. |
|||
* |
|||
* @param {ASTNode} prevNode The previous statement to count. |
|||
* @param {ASTNode} nextNode The current statement to count. |
|||
* @returns {Array<Token[]>} The array of token pairs. |
|||
* @private |
|||
*/ |
|||
function getPaddingLineSequences(prevNode, nextNode) { |
|||
const pairs = []; |
|||
let prevToken = getActualLastToken(sourceCode, prevNode); |
|||
|
|||
if (nextNode.loc.start.line - prevToken.loc.end.line >= 2) { |
|||
do { |
|||
const token = sourceCode.getTokenAfter( |
|||
prevToken, |
|||
{ includeComments: true } |
|||
); |
|||
|
|||
if (token.loc.start.line - prevToken.loc.end.line >= 2) { |
|||
pairs.push([prevToken, token]); |
|||
} |
|||
prevToken = token; |
|||
|
|||
} while (prevToken.range[0] < nextNode.range[0]); |
|||
} |
|||
|
|||
return pairs; |
|||
} |
|||
|
|||
/** |
|||
* Verify padding lines between the given node and the previous node. |
|||
* |
|||
* @param {ASTNode} node The node to verify. |
|||
* @returns {void} |
|||
* @private |
|||
*/ |
|||
function verify(node) { |
|||
const parentType = node.parent.type; |
|||
const validParent = |
|||
astUtils.STATEMENT_LIST_PARENTS.has(parentType) || |
|||
parentType === "SwitchStatement"; |
|||
|
|||
if (!validParent) { |
|||
return; |
|||
} |
|||
|
|||
// Save this node as the current previous statement.
|
|||
const prevNode = scopeInfo.prevNode; |
|||
|
|||
// Verify.
|
|||
if (prevNode) { |
|||
const type = getPaddingType(prevNode, node); |
|||
const paddingLines = getPaddingLineSequences(prevNode, node); |
|||
|
|||
type.verify(context, prevNode, node, paddingLines); |
|||
} |
|||
|
|||
scopeInfo.prevNode = node; |
|||
} |
|||
|
|||
/** |
|||
* Verify padding lines between the given node and the previous node. |
|||
* Then process to enter to new scope. |
|||
* |
|||
* @param {ASTNode} node The node to verify. |
|||
* @returns {void} |
|||
* @private |
|||
*/ |
|||
function verifyThenEnterScope(node) { |
|||
verify(node); |
|||
enterScope(); |
|||
} |
|||
|
|||
return { |
|||
Program: enterScope, |
|||
BlockStatement: enterScope, |
|||
SwitchStatement: enterScope, |
|||
"Program:exit": exitScope, |
|||
"BlockStatement:exit": exitScope, |
|||
"SwitchStatement:exit": exitScope, |
|||
|
|||
":statement": verify, |
|||
|
|||
SwitchCase: verifyThenEnterScope, |
|||
"SwitchCase:exit": exitScope |
|||
}; |
|||
} |
|||
}; |
|||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue