no-incorrect-computed-macros.js

'use strict';

const { getImportIdentifier } = require('../utils/import');
const types = require('../utils/types');

const ERROR_MESSAGE_AND_OR = 'Computed property macro should be used with 2+ arguments';

/** @type {import('eslint').Rule.RuleModule} */
module.exports = {
  meta: {
    type: 'problem',
    docs: {
      description: 'disallow incorrect usage of computed property macros',
      category: 'Computed Properties',
      recommended: true,
      url: 'https://github.com/ember-cli/eslint-plugin-ember/tree/master/docs/rules/no-incorrect-computed-macros.md',
    },
    fixable: 'code',
    schema: [],
  },

  ERROR_MESSAGE_AND_OR,

  create(context) {
    let importNameAnd = undefined;
    let importNameOr = undefined;
    let importNameReadOnly = undefined;

    return {
      ImportDeclaration(node) {
        if (node.source.value === '@ember/object/computed') {
          // Gather the identifiers that these macros are imported under.
          importNameAnd =
            importNameAnd || getImportIdentifier(node, '@ember/object/computed', 'and');
          importNameOr = importNameOr || getImportIdentifier(node, '@ember/object/computed', 'or');
          importNameReadOnly =
            importNameReadOnly || getImportIdentifier(node, '@ember/object/computed', 'readOnly');
        }
      },

      CallExpression(node) {
        if (
          types.isIdentifier(node.callee) &&
          [importNameAnd, importNameOr].includes(node.callee.name)
        ) {
          if (
            node.arguments.length === 1 &&
            types.isStringLiteral(node.arguments[0]) &&
            !node.arguments[0].value.includes('{')
          ) {
            context.report({
              node: node.callee,
              message: ERROR_MESSAGE_AND_OR,
              fix(fixer) {
                if (importNameReadOnly) {
                  return fixer.replaceText(node.callee, importNameReadOnly);
                } else {
                  const sourceCode = context.sourceCode ?? context.getSourceCode();
                  return [
                    fixer.insertTextBefore(
                      sourceCode.ast,
                      "import { readOnly } from '@ember/object/computed';\n"
                    ),
                    fixer.replaceText(node.callee, 'readOnly'),
                  ];
                }
              },
            });
          } else if (node.arguments.length === 0) {
            context.report({ node, message: ERROR_MESSAGE_AND_OR });
          }
        }
      },
    };
  },
};