Permalink
Cannot retrieve contributors at this time
| /** | |
| * @fileoverview Prefer destructuring from arrays and objects | |
| * @author Alex LaFroscia | |
| */ | |
| "use strict"; | |
| //------------------------------------------------------------------------------ | |
| // Rule Definition | |
| //------------------------------------------------------------------------------ | |
| module.exports = { | |
| meta: { | |
| type: "suggestion", | |
| docs: { | |
| description: "require destructuring from arrays and/or objects", | |
| category: "ECMAScript 6", | |
| recommended: false, | |
| url: "https://eslint.org/docs/rules/prefer-destructuring" | |
| }, | |
| fixable: "code", | |
| schema: [ | |
| { | |
| /* | |
| * old support {array: Boolean, object: Boolean} | |
| * new support {VariableDeclarator: {}, AssignmentExpression: {}} | |
| */ | |
| oneOf: [ | |
| { | |
| type: "object", | |
| properties: { | |
| VariableDeclarator: { | |
| type: "object", | |
| properties: { | |
| array: { | |
| type: "boolean" | |
| }, | |
| object: { | |
| type: "boolean" | |
| } | |
| }, | |
| additionalProperties: false | |
| }, | |
| AssignmentExpression: { | |
| type: "object", | |
| properties: { | |
| array: { | |
| type: "boolean" | |
| }, | |
| object: { | |
| type: "boolean" | |
| } | |
| }, | |
| additionalProperties: false | |
| } | |
| }, | |
| additionalProperties: false | |
| }, | |
| { | |
| type: "object", | |
| properties: { | |
| array: { | |
| type: "boolean" | |
| }, | |
| object: { | |
| type: "boolean" | |
| } | |
| }, | |
| additionalProperties: false | |
| } | |
| ] | |
| }, | |
| { | |
| type: "object", | |
| properties: { | |
| enforceForRenamedProperties: { | |
| type: "boolean" | |
| } | |
| }, | |
| additionalProperties: false | |
| } | |
| ] | |
| }, | |
| create(context) { | |
| const enabledTypes = context.options[0]; | |
| const enforceForRenamedProperties = context.options[1] && context.options[1].enforceForRenamedProperties; | |
| let normalizedOptions = { | |
| VariableDeclarator: { array: true, object: true }, | |
| AssignmentExpression: { array: true, object: true } | |
| }; | |
| if (enabledTypes) { | |
| normalizedOptions = typeof enabledTypes.array !== "undefined" || typeof enabledTypes.object !== "undefined" | |
| ? { VariableDeclarator: enabledTypes, AssignmentExpression: enabledTypes } | |
| : enabledTypes; | |
| } | |
| //-------------------------------------------------------------------------- | |
| // Helpers | |
| //-------------------------------------------------------------------------- | |
| // eslint-disable-next-line jsdoc/require-description | |
| /** | |
| * @param {string} nodeType "AssignmentExpression" or "VariableDeclarator" | |
| * @param {string} destructuringType "array" or "object" | |
| * @returns {boolean} `true` if the destructuring type should be checked for the given node | |
| */ | |
| function shouldCheck(nodeType, destructuringType) { | |
| return normalizedOptions && | |
| normalizedOptions[nodeType] && | |
| normalizedOptions[nodeType][destructuringType]; | |
| } | |
| /** | |
| * Determines if the given node is accessing an array index | |
| * | |
| * This is used to differentiate array index access from object property | |
| * access. | |
| * @param {ASTNode} node the node to evaluate | |
| * @returns {boolean} whether or not the node is an integer | |
| */ | |
| function isArrayIndexAccess(node) { | |
| return Number.isInteger(node.property.value); | |
| } | |
| /** | |
| * Report that the given node should use destructuring | |
| * @param {ASTNode} reportNode the node to report | |
| * @param {string} type the type of destructuring that should have been done | |
| * @param {Function|null} fix the fix function or null to pass to context.report | |
| * @returns {void} | |
| */ | |
| function report(reportNode, type, fix) { | |
| context.report({ | |
| node: reportNode, | |
| message: "Use {{type}} destructuring.", | |
| data: { type }, | |
| fix | |
| }); | |
| } | |
| /** | |
| * Determines if a node should be fixed into object destructuring | |
| * | |
| * The fixer only fixes the simplest case of object destructuring, | |
| * like: `let x = a.x`; | |
| * | |
| * Assignment expression is not fixed. | |
| * Array destructuring is not fixed. | |
| * Renamed property is not fixed. | |
| * @param {ASTNode} node the the node to evaluate | |
| * @returns {boolean} whether or not the node should be fixed | |
| */ | |
| function shouldFix(node) { | |
| return node.type === "VariableDeclarator" && | |
| node.id.type === "Identifier" && | |
| node.init.type === "MemberExpression" && | |
| node.id.name === node.init.property.name; | |
| } | |
| /** | |
| * Fix a node into object destructuring. | |
| * This function only handles the simplest case of object destructuring, | |
| * see {@link shouldFix}. | |
| * @param {SourceCodeFixer} fixer the fixer object | |
| * @param {ASTNode} node the node to be fixed. | |
| * @returns {Object} a fix for the node | |
| */ | |
| function fixIntoObjectDestructuring(fixer, node) { | |
| const rightNode = node.init; | |
| const sourceCode = context.getSourceCode(); | |
| return fixer.replaceText( | |
| node, | |
| `{${rightNode.property.name}} = ${sourceCode.getText(rightNode.object)}` | |
| ); | |
| } | |
| /** | |
| * Check that the `prefer-destructuring` rules are followed based on the | |
| * given left- and right-hand side of the assignment. | |
| * | |
| * Pulled out into a separate method so that VariableDeclarators and | |
| * AssignmentExpressions can share the same verification logic. | |
| * @param {ASTNode} leftNode the left-hand side of the assignment | |
| * @param {ASTNode} rightNode the right-hand side of the assignment | |
| * @param {ASTNode} reportNode the node to report the error on | |
| * @returns {void} | |
| */ | |
| function performCheck(leftNode, rightNode, reportNode) { | |
| if (rightNode.type !== "MemberExpression" || rightNode.object.type === "Super") { | |
| return; | |
| } | |
| if (isArrayIndexAccess(rightNode)) { | |
| if (shouldCheck(reportNode.type, "array")) { | |
| report(reportNode, "array", null); | |
| } | |
| return; | |
| } | |
| const fix = shouldFix(reportNode) | |
| ? fixer => fixIntoObjectDestructuring(fixer, reportNode) | |
| : null; | |
| if (shouldCheck(reportNode.type, "object") && enforceForRenamedProperties) { | |
| report(reportNode, "object", fix); | |
| return; | |
| } | |
| if (shouldCheck(reportNode.type, "object")) { | |
| const property = rightNode.property; | |
| if ( | |
| (property.type === "Literal" && leftNode.name === property.value) || | |
| (property.type === "Identifier" && leftNode.name === property.name && !rightNode.computed) | |
| ) { | |
| report(reportNode, "object", fix); | |
| } | |
| } | |
| } | |
| /** | |
| * Check if a given variable declarator is coming from an property access | |
| * that should be using destructuring instead | |
| * @param {ASTNode} node the variable declarator to check | |
| * @returns {void} | |
| */ | |
| function checkVariableDeclarator(node) { | |
| // Skip if variable is declared without assignment | |
| if (!node.init) { | |
| return; | |
| } | |
| // We only care about member expressions past this point | |
| if (node.init.type !== "MemberExpression") { | |
| return; | |
| } | |
| performCheck(node.id, node.init, node); | |
| } | |
| /** | |
| * Run the `prefer-destructuring` check on an AssignmentExpression | |
| * @param {ASTNode} node the AssignmentExpression node | |
| * @returns {void} | |
| */ | |
| function checkAssigmentExpression(node) { | |
| if (node.operator === "=") { | |
| performCheck(node.left, node.right, node); | |
| } | |
| } | |
| //-------------------------------------------------------------------------- | |
| // Public | |
| //-------------------------------------------------------------------------- | |
| return { | |
| VariableDeclarator: checkVariableDeclarator, | |
| AssignmentExpression: checkAssigmentExpression | |
| }; | |
| } | |
| }; |