space-infix-ops.ts

import {
  AST_NODE_TYPES,
  TSESLint,
  TSESTree,
} from '@typescript-eslint/experimental-utils';
import baseRule from 'eslint/lib/rules/space-infix-ops';
import { TSEnumMember } from '../../../parser/node_modules/@typescript-eslint/types/dist/ts-estree';
import * as util from '../util';

export type Options = util.InferOptionsTypeFromRule<typeof baseRule>;
export type MessageIds = util.InferMessageIdsTypeFromRule<typeof baseRule>;

export default util.createRule<Options, MessageIds>({
  name: 'space-infix-ops',
  meta: {
    type: 'layout',
    docs: {
      description:
        'This rule is aimed at ensuring there are spaces around infix operators.',
      category: 'Stylistic Issues',
      recommended: false,
      extendsBaseRule: true,
    },
    fixable: baseRule.meta.fixable,
    schema: baseRule.meta.schema,
    messages: baseRule.meta.messages,
  },
  defaultOptions: [
    {
      int32Hint: false,
    },
  ],
  create(context) {
    const rules = baseRule.create(context);
    const sourceCode = context.getSourceCode();

    /**
     * Find the first non space specified char
     * @param {TSESTree.token} left The token to the left
     * @param {TSESTree.Token} right The token to the right
     * @param {string} op The token to find
     * @returns {TSESTree.Token|null}
     * @private
     */
    function getFirstNonSpacedToken(
      left: TSESTree.Token,
      right: TSESTree.Token,
      op: string,
    ): TSESTree.Token | null {
      const operator = sourceCode.getFirstTokenBetween(
        left,
        right,
        token => token.value === op,
      );
      const prev = sourceCode.getTokenBefore(operator!);
      const next = sourceCode.getTokenAfter(operator!);

      if (
        !sourceCode.isSpaceBetweenTokens(prev!, operator!) ||
        !sourceCode.isSpaceBetweenTokens(operator!, next!)
      ) {
        return operator;
      }

      return null;
    }

    /**
     * Reports an AST node as a rule violation
     * @param {TSESTree.Node} mainNode The node to report
     * @param {TSESTree.Token} culpritToken The token which has a problem
     * @returns {void}
     * @private
     */
    function report(
      mainNode: TSESTree.Node,
      culpritToken: TSESTree.Token,
    ): void {
      context.report({
        node: mainNode,
        loc: culpritToken.loc,
        messageId: 'missingSpace',
        data: {
          operator: culpritToken.value,
        },
        fix(fixer) {
          const previousToken = sourceCode.getTokenBefore(culpritToken);
          const afterToken = sourceCode.getTokenAfter(culpritToken);
          let fixString = '';

          if (culpritToken.range[0] - previousToken!.range[1] === 0) {
            fixString = ' ';
          }

          fixString += culpritToken.value;

          if (afterToken!.range[0] - culpritToken.range[1] === 0) {
            fixString += ' ';
          }

          return fixer.replaceText(culpritToken, fixString);
        },
      });
    }

    /**
     * Check if it has an assignment char and report if it's faulty
     * @param {TSESTree.Node} node The node to report
     * @returns {void}
     * @private
     */
    function checkForAssignmentSpace(node: TSEnumMember): void {
      if (!node.initializer) {
        return;
      }

      const leftNode = sourceCode.getTokenByRangeStart(
        sourceCode.getIndexFromLoc(node.id.loc.start),
      )!;
      const rightNode = sourceCode.getTokenByRangeStart(
        sourceCode.getIndexFromLoc(node.initializer.loc.start),
      )!;

      if (!rightNode) {
        return;
      }

      const operator = '=';

      const nonSpacedNode = getFirstNonSpacedToken(
        leftNode,
        rightNode,
        operator,
      );

      if (nonSpacedNode) {
        report(node as TSESTree.Node, nonSpacedNode);
      }
    }

    const nodesToCheck = [AST_NODE_TYPES.TSEnumMember].reduce<
      TSESLint.RuleListener
    >((acc, node) => {
      acc[node as string] = checkForAssignmentSpace;
      return acc;
    }, {});

    return {
      ...rules,
      ...nodesToCheck,
    };
  },
});