mirror of https://github.com/lukechilds/node.git
Browse Source
Update ESLint to 3.0.0. This includes an enhancement to `no-unused-vars` such that it finds a few instances in our code base that it did not find previously (fixed in previous commits readying this for landing). PR-URL: https://github.com/nodejs/node/pull/7601 Reviewed-By: Michaël Zasso <mic.besace@gmail.com> Reviewed-By: Roman Reiss <me@silverwind.io>v4.x
Rich Trott
9 years ago
committed by
Myles Borins
Myles Borins
546 changed files with 9689 additions and 10543 deletions
File diff suppressed because it is too large
@ -0,0 +1,29 @@ |
|||||
|
/** |
||||
|
* @fileoverview Config to enable all rules. |
||||
|
* @author Robert Fletcher |
||||
|
*/ |
||||
|
|
||||
|
"use strict"; |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Requirements
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
var fs = require("fs"), |
||||
|
path = require("path"); |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Helpers
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
var ruleFiles = fs.readdirSync(path.resolve(__dirname, "../lib/rules")); |
||||
|
var enabledRules = ruleFiles.reduce(function(result, filename) { |
||||
|
result[path.basename(filename, ".js")] = "error"; |
||||
|
return result; |
||||
|
}, {}); |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Public Interface
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
module.exports = { rules: enabledRules }; |
||||
@ -0,0 +1,148 @@ |
|||||
|
/** |
||||
|
* @fileoverview enforce a maximum file length |
||||
|
* @author Alberto Rodríguez |
||||
|
*/ |
||||
|
"use strict"; |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Requirements
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
var lodash = require("lodash"); |
||||
|
var astUtils = require("../ast-utils"); |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Rule Definition
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
module.exports = { |
||||
|
meta: { |
||||
|
docs: { |
||||
|
description: "enforce a maximum number of lines per file", |
||||
|
category: "Stylistic Issues", |
||||
|
recommended: false |
||||
|
}, |
||||
|
|
||||
|
schema: [ |
||||
|
{ |
||||
|
oneOf: [ |
||||
|
{ |
||||
|
type: "integer", |
||||
|
minimum: 0 |
||||
|
}, |
||||
|
{ |
||||
|
type: "object", |
||||
|
properties: { |
||||
|
max: { |
||||
|
type: "integer", |
||||
|
minimum: 0 |
||||
|
}, |
||||
|
skipComments: { |
||||
|
type: "boolean" |
||||
|
}, |
||||
|
skipBlankLines: { |
||||
|
type: "boolean" |
||||
|
} |
||||
|
}, |
||||
|
additionalProperties: false |
||||
|
} |
||||
|
] |
||||
|
} |
||||
|
] |
||||
|
}, |
||||
|
|
||||
|
create: function(context) { |
||||
|
var option = context.options[0], |
||||
|
max = 300; |
||||
|
|
||||
|
if (typeof option === "object" && option.hasOwnProperty("max") && typeof option.max === "number") { |
||||
|
max = option.max; |
||||
|
} |
||||
|
|
||||
|
if (typeof option === "number") { |
||||
|
max = option; |
||||
|
} |
||||
|
|
||||
|
var skipComments = option && option.skipComments; |
||||
|
var skipBlankLines = option && option.skipBlankLines; |
||||
|
|
||||
|
var sourceCode = context.getSourceCode(); |
||||
|
|
||||
|
/** |
||||
|
* Returns whether or not a token is a comment node type |
||||
|
* @param {Token} token The token to check |
||||
|
* @returns {boolean} True if the token is a comment node |
||||
|
*/ |
||||
|
function isCommentNodeType(token) { |
||||
|
return token && (token.type === "Block" || token.type === "Line"); |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Returns the line numbers of a comment that don't have any code on the same line |
||||
|
* @param {Node} comment The comment node to check |
||||
|
* @returns {int[]} The line numbers |
||||
|
*/ |
||||
|
function getLinesWithoutCode(comment) { |
||||
|
var start = comment.loc.start.line; |
||||
|
var end = comment.loc.end.line; |
||||
|
|
||||
|
var token; |
||||
|
|
||||
|
token = comment; |
||||
|
do { |
||||
|
token = sourceCode.getTokenOrCommentBefore(token); |
||||
|
} while (isCommentNodeType(token)); |
||||
|
|
||||
|
if (token && astUtils.isTokenOnSameLine(token, comment)) { |
||||
|
start += 1; |
||||
|
} |
||||
|
|
||||
|
token = comment; |
||||
|
do { |
||||
|
token = sourceCode.getTokenOrCommentAfter(token); |
||||
|
} while (isCommentNodeType(token)); |
||||
|
|
||||
|
if (token && astUtils.isTokenOnSameLine(comment, token)) { |
||||
|
end -= 1; |
||||
|
} |
||||
|
|
||||
|
if (start <= end) { |
||||
|
return lodash.range(start, end + 1); |
||||
|
} |
||||
|
return []; |
||||
|
} |
||||
|
|
||||
|
return { |
||||
|
"Program:exit": function() { |
||||
|
var lines = sourceCode.lines.map(function(text, i) { |
||||
|
return { lineNumber: i + 1, text: text }; |
||||
|
}); |
||||
|
|
||||
|
if (skipBlankLines) { |
||||
|
lines = lines.filter(function(l) { |
||||
|
return l.text.trim() !== ""; |
||||
|
}); |
||||
|
} |
||||
|
|
||||
|
if (skipComments) { |
||||
|
var comments = sourceCode.getAllComments(); |
||||
|
|
||||
|
var commentLines = lodash.flatten(comments.map(function(comment) { |
||||
|
return getLinesWithoutCode(comment); |
||||
|
})); |
||||
|
|
||||
|
lines = lines.filter(function(l) { |
||||
|
return !lodash.includes(commentLines, l.lineNumber); |
||||
|
}); |
||||
|
} |
||||
|
|
||||
|
if (lines.length > max) { |
||||
|
context.report({ |
||||
|
loc: { line: 1, column: 0 }, |
||||
|
message: "File must be at most " + max + " lines long" |
||||
|
}); |
||||
|
} |
||||
|
} |
||||
|
}; |
||||
|
} |
||||
|
}; |
||||
@ -0,0 +1,212 @@ |
|||||
|
/** |
||||
|
* @fileoverview Rule to disallow mixed binary operators. |
||||
|
* @author Toru Nagashima |
||||
|
*/ |
||||
|
|
||||
|
"use strict"; |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Requirements
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
var astUtils = require("../ast-utils.js"); |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Helpers
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
var ARITHMETIC_OPERATORS = ["+", "-", "*", "/", "%", "**"]; |
||||
|
var BITWISE_OPERATORS = ["&", "|", "^", "~", "<<", ">>", ">>>"]; |
||||
|
var COMPARISON_OPERATORS = ["==", "!=", "===", "!==", ">", ">=", "<", "<="]; |
||||
|
var LOGICAL_OPERATORS = ["&&", "||"]; |
||||
|
var RELATIONAL_OPERATORS = ["in", "instanceof"]; |
||||
|
var ALL_OPERATORS = [].concat( |
||||
|
ARITHMETIC_OPERATORS, |
||||
|
BITWISE_OPERATORS, |
||||
|
COMPARISON_OPERATORS, |
||||
|
LOGICAL_OPERATORS, |
||||
|
RELATIONAL_OPERATORS |
||||
|
); |
||||
|
var DEFAULT_GROUPS = [ |
||||
|
ARITHMETIC_OPERATORS, |
||||
|
BITWISE_OPERATORS, |
||||
|
COMPARISON_OPERATORS, |
||||
|
LOGICAL_OPERATORS, |
||||
|
RELATIONAL_OPERATORS |
||||
|
]; |
||||
|
var TARGET_NODE_TYPE = /^(?:Binary|Logical)Expression$/; |
||||
|
|
||||
|
/** |
||||
|
* Normalizes options. |
||||
|
* |
||||
|
* @param {object|undefined} options - A options object to normalize. |
||||
|
* @returns {object} Normalized option object. |
||||
|
*/ |
||||
|
function normalizeOptions(options) { |
||||
|
var hasGroups = (options && options.groups && options.groups.length > 0); |
||||
|
var groups = hasGroups ? options.groups : DEFAULT_GROUPS; |
||||
|
var allowSamePrecedence = (options && options.allowSamePrecedence) !== false; |
||||
|
|
||||
|
return { |
||||
|
groups: groups, |
||||
|
allowSamePrecedence: allowSamePrecedence |
||||
|
}; |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Checks whether any group which includes both given operator exists or not. |
||||
|
* |
||||
|
* @param {Array.<string[]>} groups - A list of groups to check. |
||||
|
* @param {string} left - An operator. |
||||
|
* @param {string} right - Another operator. |
||||
|
* @returns {boolean} `true` if such group existed. |
||||
|
*/ |
||||
|
function includesBothInAGroup(groups, left, right) { |
||||
|
return groups.some(function(group) { |
||||
|
return group.indexOf(left) !== -1 && group.indexOf(right) !== -1; |
||||
|
}); |
||||
|
} |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Rule Definition
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
module.exports = { |
||||
|
meta: { |
||||
|
docs: { |
||||
|
description: "disallow mixed binary operators", |
||||
|
category: "Stylistic Issues", |
||||
|
recommended: false |
||||
|
}, |
||||
|
schema: [ |
||||
|
{ |
||||
|
type: "object", |
||||
|
properties: { |
||||
|
groups: { |
||||
|
type: "array", |
||||
|
items: { |
||||
|
type: "array", |
||||
|
items: {enum: ALL_OPERATORS}, |
||||
|
minItems: 2, |
||||
|
uniqueItems: true |
||||
|
}, |
||||
|
uniqueItems: true |
||||
|
}, |
||||
|
allowSamePrecedence: { |
||||
|
type: "boolean" |
||||
|
} |
||||
|
}, |
||||
|
additionalProperties: false |
||||
|
} |
||||
|
] |
||||
|
}, |
||||
|
|
||||
|
create: function(context) { |
||||
|
var sourceCode = context.getSourceCode(); |
||||
|
var options = normalizeOptions(context.options[0]); |
||||
|
|
||||
|
/** |
||||
|
* Checks whether a given node should be ignored by options or not. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node to check. This is a BinaryExpression |
||||
|
* node or a LogicalExpression node. This parent node is one of |
||||
|
* them, too. |
||||
|
* @returns {boolean} `true` if the node should be ignored. |
||||
|
*/ |
||||
|
function shouldIgnore(node) { |
||||
|
var a = node; |
||||
|
var b = node.parent; |
||||
|
|
||||
|
return ( |
||||
|
!includesBothInAGroup(options.groups, a.operator, b.operator) || |
||||
|
( |
||||
|
options.allowSamePrecedence && |
||||
|
astUtils.getPrecedence(a) === astUtils.getPrecedence(b) |
||||
|
) |
||||
|
); |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Checks whether the operator of a given node is mixed with parent |
||||
|
* node's operator or not. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node to check. This is a BinaryExpression |
||||
|
* node or a LogicalExpression node. This parent node is one of |
||||
|
* them, too. |
||||
|
* @returns {boolean} `true` if the node was mixed. |
||||
|
*/ |
||||
|
function isMixedWithParent(node) { |
||||
|
return ( |
||||
|
node.operator !== node.parent.operator && |
||||
|
!astUtils.isParenthesised(sourceCode, node) |
||||
|
); |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Gets the operator token of a given node. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node to check. This is a BinaryExpression |
||||
|
* node or a LogicalExpression node. |
||||
|
* @returns {Token} The operator token of the node. |
||||
|
*/ |
||||
|
function getOperatorToken(node) { |
||||
|
var token = sourceCode.getTokenAfter(node.left); |
||||
|
|
||||
|
while (token.value === ")") { |
||||
|
token = sourceCode.getTokenAfter(token); |
||||
|
} |
||||
|
|
||||
|
return token; |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Reports both the operator of a given node and the operator of the |
||||
|
* parent node. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node to check. This is a BinaryExpression |
||||
|
* node or a LogicalExpression node. This parent node is one of |
||||
|
* them, too. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function reportBothOperators(node) { |
||||
|
var parent = node.parent; |
||||
|
var left = (parent.left === node) ? node : parent; |
||||
|
var right = (parent.left !== node) ? node : parent; |
||||
|
var message = |
||||
|
"Unexpected mix of '" + left.operator + "' and '" + |
||||
|
right.operator + "'."; |
||||
|
|
||||
|
context.report({ |
||||
|
node: left, |
||||
|
loc: getOperatorToken(left).loc.start, |
||||
|
message: message |
||||
|
}); |
||||
|
context.report({ |
||||
|
node: right, |
||||
|
loc: getOperatorToken(right).loc.start, |
||||
|
message: message |
||||
|
}); |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Checks between the operator of this node and the operator of the |
||||
|
* parent node. |
||||
|
* |
||||
|
* @param {ASTNode} node - A node to check. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function check(node) { |
||||
|
if (TARGET_NODE_TYPE.test(node.parent.type) && |
||||
|
isMixedWithParent(node) && |
||||
|
!shouldIgnore(node) |
||||
|
) { |
||||
|
reportBothOperators(node); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return { |
||||
|
BinaryExpression: check, |
||||
|
LogicalExpression: check |
||||
|
}; |
||||
|
} |
||||
|
}; |
||||
@ -0,0 +1,52 @@ |
|||||
|
/** |
||||
|
* @fileoverview Rule to disallow use of Object.prototype builtins on objects |
||||
|
* @author Andrew Levine |
||||
|
*/ |
||||
|
"use strict"; |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Rule Definition
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
module.exports = { |
||||
|
meta: { |
||||
|
docs: { |
||||
|
description: "disallow calling some `Object.prototype` methods directly on objects", |
||||
|
category: "Possible Errors", |
||||
|
recommended: false |
||||
|
} |
||||
|
}, |
||||
|
|
||||
|
create: function(context) { |
||||
|
var DISALLOWED_PROPS = [ |
||||
|
"hasOwnProperty", |
||||
|
"isPrototypeOf", |
||||
|
"propertyIsEnumerable" |
||||
|
]; |
||||
|
|
||||
|
/** |
||||
|
* Reports if a disallowed property is used in a CallExpression |
||||
|
* @param {ASTNode} node The CallExpression node. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function disallowBuiltIns(node) { |
||||
|
if (node.callee.type !== "MemberExpression" || node.callee.computed) { |
||||
|
return; |
||||
|
} |
||||
|
var propName = node.callee.property.name; |
||||
|
|
||||
|
if (DISALLOWED_PROPS.indexOf(propName) > -1) { |
||||
|
context.report({ |
||||
|
message: "Do not access Object.prototype method '{{prop}}' from target object.", |
||||
|
loc: node.callee.property.loc.start, |
||||
|
data: {prop: propName}, |
||||
|
node: node |
||||
|
}); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return { |
||||
|
CallExpression: disallowBuiltIns |
||||
|
}; |
||||
|
} |
||||
|
}; |
||||
@ -0,0 +1,150 @@ |
|||||
|
/** |
||||
|
* @fileoverview Disallow renaming import, export, and destructured assignments to the same name. |
||||
|
* @author Kai Cataldo |
||||
|
*/ |
||||
|
|
||||
|
"use strict"; |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Rule Definition
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
module.exports = { |
||||
|
meta: { |
||||
|
docs: { |
||||
|
description: "disallow renaming import, export, and destructured assignments to the same name", |
||||
|
category: "ECMAScript 6", |
||||
|
recommended: false |
||||
|
}, |
||||
|
fixable: "code", |
||||
|
schema: [ |
||||
|
{ |
||||
|
type: "object", |
||||
|
properties: { |
||||
|
ignoreDestructuring: { type: "boolean" }, |
||||
|
ignoreImport: { type: "boolean" }, |
||||
|
ignoreExport: { type: "boolean" } |
||||
|
}, |
||||
|
additionalProperties: false |
||||
|
} |
||||
|
] |
||||
|
}, |
||||
|
|
||||
|
create: function(context) { |
||||
|
var options = context.options[0] || {}, |
||||
|
ignoreDestructuring = options.ignoreDestructuring === true, |
||||
|
ignoreImport = options.ignoreImport === true, |
||||
|
ignoreExport = options.ignoreExport === true; |
||||
|
|
||||
|
//--------------------------------------------------------------------------
|
||||
|
// Helpers
|
||||
|
//--------------------------------------------------------------------------
|
||||
|
|
||||
|
/** |
||||
|
* Reports error for unnecessarily renamed assignments |
||||
|
* @param {ASTNode} node - node to report |
||||
|
* @param {ASTNode} initial - node with initial name value |
||||
|
* @param {ASTNode} result - node with new name value |
||||
|
* @param {string} type - the type of the offending node |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function reportError(node, initial, result, type) { |
||||
|
var name = initial.type === "Identifier" ? initial.name : initial.value; |
||||
|
|
||||
|
return context.report({ |
||||
|
node: node, |
||||
|
message: "{{type}} {{name}} unnecessarily renamed.", |
||||
|
data: { |
||||
|
name: name, |
||||
|
type: type |
||||
|
}, |
||||
|
fix: function(fixer) { |
||||
|
return fixer.replaceTextRange([ |
||||
|
initial.range[0], |
||||
|
result.range[1] |
||||
|
], name); |
||||
|
} |
||||
|
}); |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Checks whether a destructured assignment is unnecessarily renamed |
||||
|
* @param {ASTNode} node - node to check |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function checkDestructured(node) { |
||||
|
var properties, |
||||
|
i; |
||||
|
|
||||
|
if (ignoreDestructuring) { |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
properties = node.properties; |
||||
|
|
||||
|
for (i = 0; i < properties.length; i++) { |
||||
|
if (properties[i].shorthand) { |
||||
|
continue; |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* If an ObjectPattern property is computed, we have no idea |
||||
|
* if a rename is useless or not. If an ObjectPattern property |
||||
|
* lacks a key, it is likely an ExperimentalRestProperty and |
||||
|
* so there is no "renaming" occurring here. |
||||
|
*/ |
||||
|
if (properties[i].computed || !properties[i].key) { |
||||
|
continue; |
||||
|
} |
||||
|
|
||||
|
if (properties[i].key.type === "Identifier" && properties[i].key.name === properties[i].value.name || |
||||
|
properties[i].key.type === "Literal" && properties[i].key.value === properties[i].value.name) { |
||||
|
reportError(properties[i], properties[i].key, properties[i].value, "Destructuring assignment"); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Checks whether an import is unnecessarily renamed |
||||
|
* @param {ASTNode} node - node to check |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function checkImport(node) { |
||||
|
if (ignoreImport) { |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
if (node.imported.name === node.local.name && |
||||
|
node.imported.range[0] !== node.local.range[0]) { |
||||
|
reportError(node, node.imported, node.local, "Import"); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Checks whether an export is unnecessarily renamed |
||||
|
* @param {ASTNode} node - node to check |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function checkExport(node) { |
||||
|
if (ignoreExport) { |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
if (node.local.name === node.exported.name && |
||||
|
node.local.range[0] !== node.exported.range[0]) { |
||||
|
reportError(node, node.local, node.exported, "Export"); |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
|
||||
|
//--------------------------------------------------------------------------
|
||||
|
// Public
|
||||
|
//--------------------------------------------------------------------------
|
||||
|
|
||||
|
return { |
||||
|
ObjectPattern: checkDestructured, |
||||
|
ImportSpecifier: checkImport, |
||||
|
ExportSpecifier: checkExport |
||||
|
}; |
||||
|
} |
||||
|
}; |
||||
@ -0,0 +1,209 @@ |
|||||
|
/** |
||||
|
* @fileoverview Rule to require or disallow line breaks inside braces. |
||||
|
* @author Toru Nagashima |
||||
|
*/ |
||||
|
|
||||
|
"use strict"; |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Requirements
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
var astUtils = require("../ast-utils"); |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Helpers
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
// Schema objects.
|
||||
|
var OPTION_VALUE = { |
||||
|
oneOf: [ |
||||
|
{ |
||||
|
enum: ["always", "never"] |
||||
|
}, |
||||
|
{ |
||||
|
type: "object", |
||||
|
properties: { |
||||
|
multiline: { |
||||
|
type: "boolean" |
||||
|
}, |
||||
|
minProperties: { |
||||
|
type: "integer", |
||||
|
minimum: 0 |
||||
|
} |
||||
|
}, |
||||
|
additionalProperties: false, |
||||
|
minProperties: 1 |
||||
|
} |
||||
|
] |
||||
|
}; |
||||
|
|
||||
|
/** |
||||
|
* Normalizes a given option value. |
||||
|
* |
||||
|
* @param {string|object|undefined} value - An option value to parse. |
||||
|
* @returns {{multiline: boolean, minProperties: number}} Normalized option object. |
||||
|
*/ |
||||
|
function normalizeOptionValue(value) { |
||||
|
var multiline = false; |
||||
|
var minProperties = Number.POSITIVE_INFINITY; |
||||
|
|
||||
|
if (value) { |
||||
|
if (value === "always") { |
||||
|
minProperties = 0; |
||||
|
} else if (value === "never") { |
||||
|
minProperties = Number.POSITIVE_INFINITY; |
||||
|
} else { |
||||
|
multiline = Boolean(value.multiline); |
||||
|
minProperties = value.minProperties || Number.POSITIVE_INFINITY; |
||||
|
} |
||||
|
} else { |
||||
|
multiline = true; |
||||
|
} |
||||
|
|
||||
|
return {multiline: multiline, minProperties: minProperties}; |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Normalizes a given option value. |
||||
|
* |
||||
|
* @param {string|object|undefined} options - An option value to parse. |
||||
|
* @returns {{ObjectExpression: {multiline: boolean, minProperties: number}, ObjectPattern: {multiline: boolean, minProperties: number}}} Normalized option object. |
||||
|
*/ |
||||
|
function normalizeOptions(options) { |
||||
|
if (options && (options.ObjectExpression || options.ObjectPattern)) { |
||||
|
return { |
||||
|
ObjectExpression: normalizeOptionValue(options.ObjectExpression), |
||||
|
ObjectPattern: normalizeOptionValue(options.ObjectPattern) |
||||
|
}; |
||||
|
} |
||||
|
|
||||
|
var value = normalizeOptionValue(options); |
||||
|
|
||||
|
return {ObjectExpression: value, ObjectPattern: value}; |
||||
|
} |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Rule Definition
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
module.exports = { |
||||
|
meta: { |
||||
|
docs: { |
||||
|
description: "enforce consistent line breaks inside braces", |
||||
|
category: "Stylistic Issues", |
||||
|
recommended: false |
||||
|
}, |
||||
|
fixable: "whitespace", |
||||
|
schema: [ |
||||
|
{ |
||||
|
oneOf: [ |
||||
|
OPTION_VALUE, |
||||
|
{ |
||||
|
type: "object", |
||||
|
properties: { |
||||
|
ObjectExpression: OPTION_VALUE, |
||||
|
ObjectPattern: OPTION_VALUE |
||||
|
}, |
||||
|
additionalProperties: false, |
||||
|
minProperties: 1 |
||||
|
} |
||||
|
] |
||||
|
} |
||||
|
] |
||||
|
}, |
||||
|
|
||||
|
create: function(context) { |
||||
|
var sourceCode = context.getSourceCode(); |
||||
|
var normalizedOptions = normalizeOptions(context.options[0]); |
||||
|
|
||||
|
/** |
||||
|
* 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, minProperties: number}} options - An option object. |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function check(node) { |
||||
|
var options = normalizedOptions[node.type]; |
||||
|
var openBrace = sourceCode.getFirstToken(node); |
||||
|
var closeBrace = sourceCode.getLastToken(node); |
||||
|
var first = sourceCode.getTokenOrCommentAfter(openBrace); |
||||
|
var last = sourceCode.getTokenOrCommentBefore(closeBrace); |
||||
|
var needsLinebreaks = ( |
||||
|
node.properties.length >= options.minProperties || |
||||
|
( |
||||
|
options.multiline && |
||||
|
node.properties.length > 0 && |
||||
|
first.loc.start.line !== last.loc.end.line |
||||
|
) |
||||
|
); |
||||
|
|
||||
|
/* |
||||
|
* Use tokens or comments to check multiline or not. |
||||
|
* But use only tokens to check whether line breaks are needed. |
||||
|
* This allows: |
||||
|
* var obj = { // eslint-disable-line foo
|
||||
|
* a: 1 |
||||
|
* } |
||||
|
*/ |
||||
|
first = sourceCode.getTokenAfter(openBrace); |
||||
|
last = sourceCode.getTokenBefore(closeBrace); |
||||
|
|
||||
|
if (needsLinebreaks) { |
||||
|
if (astUtils.isTokenOnSameLine(openBrace, first)) { |
||||
|
context.report({ |
||||
|
message: "Expected a line break after this open brace.", |
||||
|
node: node, |
||||
|
loc: openBrace.loc.start, |
||||
|
fix: function(fixer) { |
||||
|
return fixer.insertTextAfter(openBrace, "\n"); |
||||
|
} |
||||
|
}); |
||||
|
} |
||||
|
if (astUtils.isTokenOnSameLine(last, closeBrace)) { |
||||
|
context.report({ |
||||
|
message: "Expected a line break before this close brace.", |
||||
|
node: node, |
||||
|
loc: closeBrace.loc.start, |
||||
|
fix: function(fixer) { |
||||
|
return fixer.insertTextBefore(closeBrace, "\n"); |
||||
|
} |
||||
|
}); |
||||
|
} |
||||
|
} else { |
||||
|
if (!astUtils.isTokenOnSameLine(openBrace, first)) { |
||||
|
context.report({ |
||||
|
message: "Unexpected a line break after this open brace.", |
||||
|
node: node, |
||||
|
loc: openBrace.loc.start, |
||||
|
fix: function(fixer) { |
||||
|
return fixer.removeRange([ |
||||
|
openBrace.range[1], |
||||
|
first.range[0] |
||||
|
]); |
||||
|
} |
||||
|
}); |
||||
|
} |
||||
|
if (!astUtils.isTokenOnSameLine(last, closeBrace)) { |
||||
|
context.report({ |
||||
|
message: "Unexpected a line break before this close brace.", |
||||
|
node: node, |
||||
|
loc: closeBrace.loc.start, |
||||
|
fix: function(fixer) { |
||||
|
return fixer.removeRange([ |
||||
|
last.range[1], |
||||
|
closeBrace.range[0] |
||||
|
]); |
||||
|
} |
||||
|
}); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return { |
||||
|
ObjectExpression: check, |
||||
|
ObjectPattern: check |
||||
|
}; |
||||
|
} |
||||
|
}; |
||||
@ -0,0 +1,73 @@ |
|||||
|
/** |
||||
|
* @fileoverview Rule to enforce placing object properties on separate lines. |
||||
|
* @author Vitor Balocco |
||||
|
*/ |
||||
|
|
||||
|
"use strict"; |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Rule Definition
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
module.exports = { |
||||
|
meta: { |
||||
|
docs: { |
||||
|
description: "enforce placing object properties on separate lines", |
||||
|
category: "Stylistic Issues", |
||||
|
recommended: false |
||||
|
}, |
||||
|
|
||||
|
schema: [ |
||||
|
{ |
||||
|
type: "object", |
||||
|
properties: { |
||||
|
allowMultiplePropertiesPerLine: { |
||||
|
type: "boolean" |
||||
|
} |
||||
|
}, |
||||
|
additionalProperties: false |
||||
|
} |
||||
|
] |
||||
|
}, |
||||
|
|
||||
|
create: function(context) { |
||||
|
var allowSameLine = context.options[0] && Boolean(context.options[0].allowMultiplePropertiesPerLine); |
||||
|
var errorMessage = allowSameLine ? |
||||
|
"Object properties must go on a new line if they aren't all on the same line" : |
||||
|
"Object properties must go on a new line"; |
||||
|
|
||||
|
var sourceCode = context.getSourceCode(); |
||||
|
|
||||
|
return { |
||||
|
ObjectExpression: function(node) { |
||||
|
var lastTokenOfPreviousProperty, firstTokenOfCurrentProperty; |
||||
|
|
||||
|
if (allowSameLine) { |
||||
|
if (node.properties.length > 1) { |
||||
|
var firstTokenOfFirstProperty = sourceCode.getFirstToken(node.properties[0]); |
||||
|
var lastTokenOfLastProperty = sourceCode.getLastToken(node.properties[node.properties.length - 1]); |
||||
|
|
||||
|
if (firstTokenOfFirstProperty.loc.end.line === lastTokenOfLastProperty.loc.start.line) { |
||||
|
|
||||
|
// All keys and values are on the same line
|
||||
|
return; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
for (var i = 1; i < node.properties.length; i++) { |
||||
|
lastTokenOfPreviousProperty = sourceCode.getLastToken(node.properties[i - 1]); |
||||
|
firstTokenOfCurrentProperty = sourceCode.getFirstToken(node.properties[i]); |
||||
|
|
||||
|
if (lastTokenOfPreviousProperty.loc.end.line === firstTokenOfCurrentProperty.loc.start.line) { |
||||
|
context.report({ |
||||
|
node: node, |
||||
|
loc: firstTokenOfCurrentProperty.loc.start, |
||||
|
message: errorMessage |
||||
|
}); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
}; |
||||
|
} |
||||
|
}; |
||||
@ -0,0 +1,107 @@ |
|||||
|
/** |
||||
|
* @fileoverview Enforce spacing between rest and spread operators and their expressions. |
||||
|
* @author Kai Cataldo |
||||
|
*/ |
||||
|
|
||||
|
"use strict"; |
||||
|
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
// Rule Definition
|
||||
|
//------------------------------------------------------------------------------
|
||||
|
|
||||
|
module.exports = { |
||||
|
meta: { |
||||
|
docs: { |
||||
|
description: "enforce spacing between rest and spread operators and their expressions", |
||||
|
category: "ECMAScript 6", |
||||
|
recommended: false |
||||
|
}, |
||||
|
fixable: "whitespace", |
||||
|
schema: [ |
||||
|
{ |
||||
|
enum: ["always", "never"] |
||||
|
} |
||||
|
] |
||||
|
}, |
||||
|
|
||||
|
create: function(context) { |
||||
|
var sourceCode = context.getSourceCode(), |
||||
|
alwaysSpace = context.options[0] === "always"; |
||||
|
|
||||
|
//--------------------------------------------------------------------------
|
||||
|
// Helpers
|
||||
|
//--------------------------------------------------------------------------
|
||||
|
|
||||
|
/** |
||||
|
* Checks whitespace between rest/spread operators and their expressions |
||||
|
* @param {ASTNode} node - The node to check |
||||
|
* @returns {void} |
||||
|
*/ |
||||
|
function checkWhiteSpace(node) { |
||||
|
var operator = sourceCode.getFirstToken(node), |
||||
|
nextToken = sourceCode.getTokenAfter(operator), |
||||
|
hasWhitespace = sourceCode.isSpaceBetweenTokens(operator, nextToken), |
||||
|
type; |
||||
|
|
||||
|
switch (node.type) { |
||||
|
case "SpreadElement": |
||||
|
type = "spread"; |
||||
|
break; |
||||
|
case "RestElement": |
||||
|
type = "rest"; |
||||
|
break; |
||||
|
case "ExperimentalSpreadProperty": |
||||
|
type = "spread property"; |
||||
|
break; |
||||
|
case "ExperimentalRestProperty": |
||||
|
type = "rest property"; |
||||
|
break; |
||||
|
default: |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
if (alwaysSpace && !hasWhitespace) { |
||||
|
context.report({ |
||||
|
node: node, |
||||
|
loc: { |
||||
|
line: operator.loc.end.line, |
||||
|
column: operator.loc.end.column |
||||
|
}, |
||||
|
message: "Expected whitespace after {{type}} operator", |
||||
|
data: { |
||||
|
type: type |
||||
|
}, |
||||
|
fix: function(fixer) { |
||||
|
return fixer.replaceTextRange([operator.range[1], nextToken.range[0]], " "); |
||||
|
} |
||||
|
}); |
||||
|
} else if (!alwaysSpace && hasWhitespace) { |
||||
|
context.report({ |
||||
|
node: node, |
||||
|
loc: { |
||||
|
line: operator.loc.end.line, |
||||
|
column: operator.loc.end.column |
||||
|
}, |
||||
|
message: "Unexpected whitespace after {{type}} operator", |
||||
|
data: { |
||||
|
type: type |
||||
|
}, |
||||
|
fix: function(fixer) { |
||||
|
return fixer.removeRange([operator.range[1], nextToken.range[0]]); |
||||
|
} |
||||
|
}); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
//--------------------------------------------------------------------------
|
||||
|
// Public
|
||||
|
//--------------------------------------------------------------------------
|
||||
|
|
||||
|
return { |
||||
|
SpreadElement: checkWhiteSpace, |
||||
|
RestElement: checkWhiteSpace, |
||||
|
ExperimentalSpreadProperty: checkWhiteSpace, |
||||
|
ExperimentalRestProperty: checkWhiteSpace |
||||
|
}; |
||||
|
} |
||||
|
}; |
||||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue