+++ /dev/null
-/**
- * @fileoverview Disallows or enforces spaces inside of parentheses.
- * @author Jonathan Rajavuori
- */
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = {
- meta: {
- type: "layout",
-
- docs: {
- description: "enforce consistent spacing inside parentheses",
- category: "Stylistic Issues",
- recommended: false,
- url: "https://eslint.org/docs/rules/space-in-parens"
- },
-
- fixable: "whitespace",
-
- schema: [
- {
- enum: ["always", "never"]
- },
- {
- type: "object",
- properties: {
- exceptions: {
- type: "array",
- items: {
- enum: ["{}", "[]", "()", "empty"]
- },
- uniqueItems: true
- }
- },
- additionalProperties: false
- }
- ],
-
- messages: {
- missingOpeningSpace: "There must be a space after this paren.",
- missingClosingSpace: "There must be a space before this paren.",
- rejectedOpeningSpace: "There should be no space after this paren.",
- rejectedClosingSpace: "There should be no space before this paren."
- }
- },
-
- create(context) {
- const ALWAYS = context.options[0] === "always",
- exceptionsArrayOptions = (context.options[1] && context.options[1].exceptions) || [],
- options = {};
-
- let exceptions;
-
- if (exceptionsArrayOptions.length) {
- options.braceException = exceptionsArrayOptions.includes("{}");
- options.bracketException = exceptionsArrayOptions.includes("[]");
- options.parenException = exceptionsArrayOptions.includes("()");
- options.empty = exceptionsArrayOptions.includes("empty");
- }
-
- /**
- * Produces an object with the opener and closer exception values
- * @returns {Object} `openers` and `closers` exception values
- * @private
- */
- function getExceptions() {
- const openers = [],
- closers = [];
-
- if (options.braceException) {
- openers.push("{");
- closers.push("}");
- }
-
- if (options.bracketException) {
- openers.push("[");
- closers.push("]");
- }
-
- if (options.parenException) {
- openers.push("(");
- closers.push(")");
- }
-
- if (options.empty) {
- openers.push(")");
- closers.push("(");
- }
-
- return {
- openers,
- closers
- };
- }
-
- //--------------------------------------------------------------------------
- // Helpers
- //--------------------------------------------------------------------------
- const sourceCode = context.getSourceCode();
-
- /**
- * Determines if a token is one of the exceptions for the opener paren
- * @param {Object} token The token to check
- * @returns {boolean} True if the token is one of the exceptions for the opener paren
- */
- function isOpenerException(token) {
- return exceptions.openers.includes(token.value);
- }
-
- /**
- * Determines if a token is one of the exceptions for the closer paren
- * @param {Object} token The token to check
- * @returns {boolean} True if the token is one of the exceptions for the closer paren
- */
- function isCloserException(token) {
- return exceptions.closers.includes(token.value);
- }
-
- /**
- * Determines if an opening paren is immediately followed by a required space
- * @param {Object} openingParenToken The paren token
- * @param {Object} tokenAfterOpeningParen The token after it
- * @returns {boolean} True if the opening paren is missing a required space
- */
- function openerMissingSpace(openingParenToken, tokenAfterOpeningParen) {
- if (sourceCode.isSpaceBetweenTokens(openingParenToken, tokenAfterOpeningParen)) {
- return false;
- }
-
- if (!options.empty && astUtils.isClosingParenToken(tokenAfterOpeningParen)) {
- return false;
- }
-
- if (ALWAYS) {
- return !isOpenerException(tokenAfterOpeningParen);
- }
- return isOpenerException(tokenAfterOpeningParen);
- }
-
- /**
- * Determines if an opening paren is immediately followed by a disallowed space
- * @param {Object} openingParenToken The paren token
- * @param {Object} tokenAfterOpeningParen The token after it
- * @returns {boolean} True if the opening paren has a disallowed space
- */
- function openerRejectsSpace(openingParenToken, tokenAfterOpeningParen) {
- if (!astUtils.isTokenOnSameLine(openingParenToken, tokenAfterOpeningParen)) {
- return false;
- }
-
- if (tokenAfterOpeningParen.type === "Line") {
- return false;
- }
-
- if (!sourceCode.isSpaceBetweenTokens(openingParenToken, tokenAfterOpeningParen)) {
- return false;
- }
-
- if (ALWAYS) {
- return isOpenerException(tokenAfterOpeningParen);
- }
- return !isOpenerException(tokenAfterOpeningParen);
- }
-
- /**
- * Determines if a closing paren is immediately preceeded by a required space
- * @param {Object} tokenBeforeClosingParen The token before the paren
- * @param {Object} closingParenToken The paren token
- * @returns {boolean} True if the closing paren is missing a required space
- */
- function closerMissingSpace(tokenBeforeClosingParen, closingParenToken) {
- if (sourceCode.isSpaceBetweenTokens(tokenBeforeClosingParen, closingParenToken)) {
- return false;
- }
-
- if (!options.empty && astUtils.isOpeningParenToken(tokenBeforeClosingParen)) {
- return false;
- }
-
- if (ALWAYS) {
- return !isCloserException(tokenBeforeClosingParen);
- }
- return isCloserException(tokenBeforeClosingParen);
- }
-
- /**
- * Determines if a closer paren is immediately preceeded by a disallowed space
- * @param {Object} tokenBeforeClosingParen The token before the paren
- * @param {Object} closingParenToken The paren token
- * @returns {boolean} True if the closing paren has a disallowed space
- */
- function closerRejectsSpace(tokenBeforeClosingParen, closingParenToken) {
- if (!astUtils.isTokenOnSameLine(tokenBeforeClosingParen, closingParenToken)) {
- return false;
- }
-
- if (!sourceCode.isSpaceBetweenTokens(tokenBeforeClosingParen, closingParenToken)) {
- return false;
- }
-
- if (ALWAYS) {
- return isCloserException(tokenBeforeClosingParen);
- }
- return !isCloserException(tokenBeforeClosingParen);
- }
-
- //--------------------------------------------------------------------------
- // Public
- //--------------------------------------------------------------------------
-
- return {
- Program: function checkParenSpaces(node) {
- exceptions = getExceptions();
- const tokens = sourceCode.tokensAndComments;
-
- tokens.forEach((token, i) => {
- const prevToken = tokens[i - 1];
- const nextToken = tokens[i + 1];
-
- // if token is not an opening or closing paren token, do nothing
- if (!astUtils.isOpeningParenToken(token) && !astUtils.isClosingParenToken(token)) {
- return;
- }
-
- // if token is an opening paren and is not followed by a required space
- if (token.value === "(" && openerMissingSpace(token, nextToken)) {
- context.report({
- node,
- loc: token.loc,
- messageId: "missingOpeningSpace",
- fix(fixer) {
- return fixer.insertTextAfter(token, " ");
- }
- });
- }
-
- // if token is an opening paren and is followed by a disallowed space
- if (token.value === "(" && openerRejectsSpace(token, nextToken)) {
- context.report({
- node,
- loc: { start: token.loc.end, end: nextToken.loc.start },
- messageId: "rejectedOpeningSpace",
- fix(fixer) {
- return fixer.removeRange([token.range[1], nextToken.range[0]]);
- }
- });
- }
-
- // if token is a closing paren and is not preceded by a required space
- if (token.value === ")" && closerMissingSpace(prevToken, token)) {
- context.report({
- node,
- loc: token.loc,
- messageId: "missingClosingSpace",
- fix(fixer) {
- return fixer.insertTextBefore(token, " ");
- }
- });
- }
-
- // if token is a closing paren and is preceded by a disallowed space
- if (token.value === ")" && closerRejectsSpace(prevToken, token)) {
- context.report({
- node,
- loc: { start: prevToken.loc.end, end: token.loc.start },
- messageId: "rejectedClosingSpace",
- fix(fixer) {
- return fixer.removeRange([prevToken.range[1], token.range[0]]);
- }
- });
- }
- });
- }
- };
- }
-};
projects / dotfiles / .git / blobdiff