Permalink
Cannot retrieve contributors at this time
| /** | |
| * @fileoverview Disallows or enforces spaces inside of object literals. | |
| * @author Jamund Ferguson | |
| */ | |
| "use strict"; | |
| const astUtils = require("./utils/ast-utils"); | |
| //------------------------------------------------------------------------------ | |
| // Rule Definition | |
| //------------------------------------------------------------------------------ | |
| module.exports = { | |
| meta: { | |
| type: "layout", | |
| docs: { | |
| description: "enforce consistent spacing inside braces", | |
| category: "Stylistic Issues", | |
| recommended: false, | |
| url: "https://eslint.org/docs/rules/object-curly-spacing" | |
| }, | |
| fixable: "whitespace", | |
| schema: [ | |
| { | |
| enum: ["always", "never"] | |
| }, | |
| { | |
| type: "object", | |
| properties: { | |
| arraysInObjects: { | |
| type: "boolean" | |
| }, | |
| objectsInObjects: { | |
| type: "boolean" | |
| } | |
| }, | |
| additionalProperties: false | |
| } | |
| ] | |
| }, | |
| create(context) { | |
| const spaced = context.options[0] === "always", | |
| sourceCode = context.getSourceCode(); | |
| /** | |
| * Determines whether an option is set, relative to the spacing option. | |
| * If spaced is "always", then check whether option is set to false. | |
| * If spaced is "never", then check whether option is set to true. | |
| * @param {Object} option The option to exclude. | |
| * @returns {boolean} Whether or not the property is excluded. | |
| */ | |
| function isOptionSet(option) { | |
| return context.options[1] ? context.options[1][option] === !spaced : false; | |
| } | |
| const options = { | |
| spaced, | |
| arraysInObjectsException: isOptionSet("arraysInObjects"), | |
| objectsInObjectsException: isOptionSet("objectsInObjects") | |
| }; | |
| //-------------------------------------------------------------------------- | |
| // Helpers | |
| //-------------------------------------------------------------------------- | |
| /** | |
| * Reports that there shouldn't be a space 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 reportNoBeginningSpace(node, token) { | |
| context.report({ | |
| node, | |
| loc: token.loc.start, | |
| message: "There should be no space after '{{token}}'.", | |
| data: { | |
| token: token.value | |
| }, | |
| fix(fixer) { | |
| const nextToken = context.getSourceCode().getTokenAfter(token, { includeComments: true }); | |
| return fixer.removeRange([token.range[1], nextToken.range[0]]); | |
| } | |
| }); | |
| } | |
| /** | |
| * Reports that there shouldn't be a space 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 reportNoEndingSpace(node, token) { | |
| context.report({ | |
| node, | |
| loc: token.loc.start, | |
| message: "There should be no space before '{{token}}'.", | |
| data: { | |
| token: token.value | |
| }, | |
| fix(fixer) { | |
| const previousToken = context.getSourceCode().getTokenBefore(token, { includeComments: true }); | |
| return fixer.removeRange([previousToken.range[1], token.range[0]]); | |
| } | |
| }); | |
| } | |
| /** | |
| * Reports that there should be a space 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 reportRequiredBeginningSpace(node, token) { | |
| context.report({ | |
| node, | |
| loc: token.loc.start, | |
| message: "A space is required after '{{token}}'.", | |
| data: { | |
| token: token.value | |
| }, | |
| fix(fixer) { | |
| return fixer.insertTextAfter(token, " "); | |
| } | |
| }); | |
| } | |
| /** | |
| * Reports that there should be a space 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 reportRequiredEndingSpace(node, token) { | |
| context.report({ | |
| node, | |
| loc: token.loc.start, | |
| message: "A space is required before '{{token}}'.", | |
| data: { | |
| token: token.value | |
| }, | |
| fix(fixer) { | |
| return fixer.insertTextBefore(token, " "); | |
| } | |
| }); | |
| } | |
| /** | |
| * Determines if spacing in curly braces is valid. | |
| * @param {ASTNode} node The AST node to check. | |
| * @param {Token} first The first token to check (should be the opening brace) | |
| * @param {Token} second The second token to check (should be first after the opening brace) | |
| * @param {Token} penultimate The penultimate token to check (should be last before closing brace) | |
| * @param {Token} last The last token to check (should be closing brace) | |
| * @returns {void} | |
| */ | |
| function validateBraceSpacing(node, first, second, penultimate, last) { | |
| if (astUtils.isTokenOnSameLine(first, second)) { | |
| const firstSpaced = sourceCode.isSpaceBetweenTokens(first, second); | |
| if (options.spaced && !firstSpaced) { | |
| reportRequiredBeginningSpace(node, first); | |
| } | |
| if (!options.spaced && firstSpaced && second.type !== "Line") { | |
| reportNoBeginningSpace(node, first); | |
| } | |
| } | |
| if (astUtils.isTokenOnSameLine(penultimate, last)) { | |
| const shouldCheckPenultimate = ( | |
| options.arraysInObjectsException && astUtils.isClosingBracketToken(penultimate) || | |
| options.objectsInObjectsException && astUtils.isClosingBraceToken(penultimate) | |
| ); | |
| const penultimateType = shouldCheckPenultimate && sourceCode.getNodeByRangeIndex(penultimate.range[0]).type; | |
| const closingCurlyBraceMustBeSpaced = ( | |
| options.arraysInObjectsException && penultimateType === "ArrayExpression" || | |
| options.objectsInObjectsException && (penultimateType === "ObjectExpression" || penultimateType === "ObjectPattern") | |
| ) ? !options.spaced : options.spaced; | |
| const lastSpaced = sourceCode.isSpaceBetweenTokens(penultimate, last); | |
| if (closingCurlyBraceMustBeSpaced && !lastSpaced) { | |
| reportRequiredEndingSpace(node, last); | |
| } | |
| if (!closingCurlyBraceMustBeSpaced && lastSpaced) { | |
| reportNoEndingSpace(node, last); | |
| } | |
| } | |
| } | |
| /** | |
| * Gets '}' token of an object node. | |
| * | |
| * Because the last token of object patterns might be a type annotation, | |
| * this traverses tokens preceded by the last property, then returns the | |
| * first '}' token. | |
| * @param {ASTNode} node The node to get. This node is an | |
| * ObjectExpression or an ObjectPattern. And this node has one or | |
| * more properties. | |
| * @returns {Token} '}' token. | |
| */ | |
| function getClosingBraceOfObject(node) { | |
| const lastProperty = node.properties[node.properties.length - 1]; | |
| return sourceCode.getTokenAfter(lastProperty, astUtils.isClosingBraceToken); | |
| } | |
| /** | |
| * Reports a given object node if spacing in curly braces is invalid. | |
| * @param {ASTNode} node An ObjectExpression or ObjectPattern node to check. | |
| * @returns {void} | |
| */ | |
| function checkForObject(node) { | |
| if (node.properties.length === 0) { | |
| return; | |
| } | |
| const first = sourceCode.getFirstToken(node), | |
| last = getClosingBraceOfObject(node), | |
| second = sourceCode.getTokenAfter(first, { includeComments: true }), | |
| penultimate = sourceCode.getTokenBefore(last, { includeComments: true }); | |
| validateBraceSpacing(node, first, second, penultimate, last); | |
| } | |
| /** | |
| * Reports a given import node if spacing in curly braces is invalid. | |
| * @param {ASTNode} node An ImportDeclaration node to check. | |
| * @returns {void} | |
| */ | |
| function checkForImport(node) { | |
| if (node.specifiers.length === 0) { | |
| return; | |
| } | |
| let firstSpecifier = node.specifiers[0]; | |
| const lastSpecifier = node.specifiers[node.specifiers.length - 1]; | |
| if (lastSpecifier.type !== "ImportSpecifier") { | |
| return; | |
| } | |
| if (firstSpecifier.type !== "ImportSpecifier") { | |
| firstSpecifier = node.specifiers[1]; | |
| } | |
| const first = sourceCode.getTokenBefore(firstSpecifier), | |
| last = sourceCode.getTokenAfter(lastSpecifier, astUtils.isNotCommaToken), | |
| second = sourceCode.getTokenAfter(first, { includeComments: true }), | |
| penultimate = sourceCode.getTokenBefore(last, { includeComments: true }); | |
| validateBraceSpacing(node, first, second, penultimate, last); | |
| } | |
| /** | |
| * Reports a given export node if spacing in curly braces is invalid. | |
| * @param {ASTNode} node An ExportNamedDeclaration node to check. | |
| * @returns {void} | |
| */ | |
| function checkForExport(node) { | |
| if (node.specifiers.length === 0) { | |
| return; | |
| } | |
| const firstSpecifier = node.specifiers[0], | |
| lastSpecifier = node.specifiers[node.specifiers.length - 1], | |
| first = sourceCode.getTokenBefore(firstSpecifier), | |
| last = sourceCode.getTokenAfter(lastSpecifier, astUtils.isNotCommaToken), | |
| second = sourceCode.getTokenAfter(first, { includeComments: true }), | |
| penultimate = sourceCode.getTokenBefore(last, { includeComments: true }); | |
| validateBraceSpacing(node, first, second, penultimate, last); | |
| } | |
| //-------------------------------------------------------------------------- | |
| // Public | |
| //-------------------------------------------------------------------------- | |
| return { | |
| // var {x} = y; | |
| ObjectPattern: checkForObject, | |
| // var y = {x: 'y'} | |
| ObjectExpression: checkForObject, | |
| // import {y} from 'x'; | |
| ImportDeclaration: checkForImport, | |
| // export {name} from 'yo'; | |
| ExportNamedDeclaration: checkForExport | |
| }; | |
| } | |
| }; |