codtracker-js/node_modules/eslint/lib/rules/brace-style.js

/**
 * @fileoverview Rule to flag block statements that do not use the one true brace style
 * @author Ian Christian Myers
 * @deprecated in ESLint v8.53.0
 */

'use strict';

const astUtils = require('./utils/ast-utils');

//------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------

/** @type {import('../types').Rule.RuleModule} */
module.exports = {
  meta: {
    deprecated: {
      message: 'Formatting rules are being moved out of ESLint core.',
      url: 'https://eslint.org/blog/2023/10/deprecating-formatting-rules/',
      deprecatedSince: '8.53.0',
      availableUntil: '10.0.0',
      replacedBy: [
        {
          message:
            'ESLint Stylistic now maintains deprecated stylistic core rules.',
          url: 'https://eslint.style/guide/migration',
          plugin: {
            name: '@stylistic/eslint-plugin-js',
            url: 'https://eslint.style/packages/js',
          },
          rule: {
            name: 'brace-style',
            url: 'https://eslint.style/rules/js/brace-style',
          },
        },
      ],
    },
    type: 'layout',

    docs: {
      description: 'Enforce consistent brace style for blocks',
      recommended: false,
      url: 'https://eslint.org/docs/latest/rules/brace-style',
    },

    schema: [
      {
        enum: ['1tbs', 'stroustrup', 'allman'],
      },
      {
        type: 'object',
        properties: {
          allowSingleLine: {
            type: 'boolean',
            default: false,
          },
        },
        additionalProperties: false,
      },
    ],

    fixable: 'whitespace',

    messages: {
      nextLineOpen:
        'Opening curly brace does not appear on the same line as controlling statement.',
      sameLineOpen:
        'Opening curly brace appears on the same line as controlling statement.',
      blockSameLine: 'Statement inside of curly braces should be on next line.',
      nextLineClose:
        'Closing curly brace does not appear on the same line as the subsequent block.',
      singleLineClose:
        'Closing curly brace should be on the same line as opening curly brace or on the line after the previous block.',
      sameLineClose:
        'Closing curly brace appears on the same line as the subsequent block.',
    },
  },

  create(context) {
    const style = context.options[0] || '1tbs',
      params = context.options[1] || {},
      sourceCode = context.sourceCode;

    //--------------------------------------------------------------------------
    // Helpers
    //--------------------------------------------------------------------------

    /**
     * Fixes a place where a newline unexpectedly appears
     * @param {Token} firstToken The token before the unexpected newline
     * @param {Token} secondToken The token after the unexpected newline
     * @returns {Function} A fixer function to remove the newlines between the tokens
     */
    function removeNewlineBetween(firstToken, secondToken) {
      const textRange = [firstToken.range[1], secondToken.range[0]];
      const textBetween = sourceCode.text.slice(textRange[0], textRange[1]);

      // Don't do a fix if there is a comment between the tokens
      if (textBetween.trim()) {
        return null;
      }
      return (fixer) => fixer.replaceTextRange(textRange, ' ');
    }

    /**
     * Validates a pair of curly brackets based on the user's config
     * @param {Token} openingCurly The opening curly bracket
     * @param {Token} closingCurly The closing curly bracket
     * @returns {void}
     */
    function validateCurlyPair(openingCurly, closingCurly) {
      const tokenBeforeOpeningCurly = sourceCode.getTokenBefore(openingCurly);
      const tokenAfterOpeningCurly = sourceCode.getTokenAfter(openingCurly);
      const tokenBeforeClosingCurly = sourceCode.getTokenBefore(closingCurly);
      const singleLineException =
        params.allowSingleLine &&
        astUtils.isTokenOnSameLine(openingCurly, closingCurly);

      if (
        style !== 'allman' &&
        !astUtils.isTokenOnSameLine(tokenBeforeOpeningCurly, openingCurly)
      ) {
        context.report({
          node: openingCurly,
          messageId: 'nextLineOpen',
          fix: removeNewlineBetween(tokenBeforeOpeningCurly, openingCurly),
        });
      }

      if (
        style === 'allman' &&
        astUtils.isTokenOnSameLine(tokenBeforeOpeningCurly, openingCurly) &&
        !singleLineException
      ) {
        context.report({
          node: openingCurly,
          messageId: 'sameLineOpen',
          fix: (fixer) => fixer.insertTextBefore(openingCurly, '\n'),
        });
      }

      if (
        astUtils.isTokenOnSameLine(openingCurly, tokenAfterOpeningCurly) &&
        tokenAfterOpeningCurly !== closingCurly &&
        !singleLineException
      ) {
        context.report({
          node: openingCurly,
          messageId: 'blockSameLine',
          fix: (fixer) => fixer.insertTextAfter(openingCurly, '\n'),
        });
      }

      if (
        tokenBeforeClosingCurly !== openingCurly &&
        !singleLineException &&
        astUtils.isTokenOnSameLine(tokenBeforeClosingCurly, closingCurly)
      ) {
        context.report({
          node: closingCurly,
          messageId: 'singleLineClose',
          fix: (fixer) => fixer.insertTextBefore(closingCurly, '\n'),
        });
      }
    }

    /**
     * Validates the location of a token that appears before a keyword (e.g. a newline before `else`)
     * @param {Token} curlyToken The closing curly token. This is assumed to precede a keyword token (such as `else` or `finally`).
     * @returns {void}
     */
    function validateCurlyBeforeKeyword(curlyToken) {
      const keywordToken = sourceCode.getTokenAfter(curlyToken);

      if (
        style === '1tbs' &&
        !astUtils.isTokenOnSameLine(curlyToken, keywordToken)
      ) {
        context.report({
          node: curlyToken,
          messageId: 'nextLineClose',
          fix: removeNewlineBetween(curlyToken, keywordToken),
        });
      }

      if (
        style !== '1tbs' &&
        astUtils.isTokenOnSameLine(curlyToken, keywordToken)
      ) {
        context.report({
          node: curlyToken,
          messageId: 'sameLineClose',
          fix: (fixer) => fixer.insertTextAfter(curlyToken, '\n'),
        });
      }
    }

    //--------------------------------------------------------------------------
    // Public API
    //--------------------------------------------------------------------------

    return {
      BlockStatement(node) {
        if (!astUtils.STATEMENT_LIST_PARENTS.has(node.parent.type)) {
          validateCurlyPair(
            sourceCode.getFirstToken(node),
            sourceCode.getLastToken(node)
          );
        }
      },
      StaticBlock(node) {
        validateCurlyPair(
          sourceCode.getFirstToken(node, { skip: 1 }), // skip the `static` token
          sourceCode.getLastToken(node)
        );
      },
      ClassBody(node) {
        validateCurlyPair(
          sourceCode.getFirstToken(node),
          sourceCode.getLastToken(node)
        );
      },
      SwitchStatement(node) {
        const closingCurly = sourceCode.getLastToken(node);
        const openingCurly = sourceCode.getTokenBefore(
          node.cases.length ? node.cases[0] : closingCurly
        );

        validateCurlyPair(openingCurly, closingCurly);
      },
      IfStatement(node) {
        if (node.consequent.type === 'BlockStatement' && node.alternate) {
          // Handle the keyword after the `if` block (before `else`)
          validateCurlyBeforeKeyword(sourceCode.getLastToken(node.consequent));
        }
      },
      TryStatement(node) {
        // Handle the keyword after the `try` block (before `catch` or `finally`)
        validateCurlyBeforeKeyword(sourceCode.getLastToken(node.block));

        if (node.handler && node.finalizer) {
          // Handle the keyword after the `catch` block (before `finally`)
          validateCurlyBeforeKeyword(
            sourceCode.getLastToken(node.handler.body)
          );
        }
      },
    };
  },
};