require-meta-fixable.js

/**
 * @fileoverview require rules to implement a meta.fixable property
 * @author Teddy Katz
 */

'use strict';

const { getStaticValue } = require('eslint-utils');
const utils = require('../utils');

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

module.exports = {
  meta: {
    type: 'problem',
    docs: {
      description: 'require rules to implement a meta.fixable property',
      category: 'Rules',
      recommended: true,
    },
    schema: [],
    messages: {
      invalid: '`meta.fixable` must be either `code`, `whitespace` or `null`.',
      missing: 'Fixable rules must export a `meta.fixable` property.',
    },
  },

  create (context) {
    const sourceCode = context.getSourceCode();
    const ruleInfo = utils.getRuleInfo(sourceCode);
    let contextIdentifiers;
    let usesFixFunctions;

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

    // ----------------------------------------------------------------------
    // Public
    // ----------------------------------------------------------------------

    return {
      Program (node) {
        contextIdentifiers = utils.getContextIdentifiers(context, node);
      },
      CallExpression (node) {
        if (
          node.callee.type === 'MemberExpression' &&
          contextIdentifiers.has(node.callee.object) &&
          node.callee.property.type === 'Identifier' &&
          node.callee.property.name === 'report' &&
          (node.arguments.length > 4 || (
            node.arguments.length === 1 &&
            node.arguments[0].type === 'ObjectExpression' &&
            node.arguments[0].properties.some(prop => utils.getKeyName(prop) === 'fix')
          ))
        ) {
          usesFixFunctions = true;
        }
      },
      'Program:exit' () {
        const metaFixableProp = ruleInfo &&
          ruleInfo.meta &&
          ruleInfo.meta.type === 'ObjectExpression' &&
          ruleInfo.meta.properties.find(prop => utils.getKeyName(prop) === 'fixable');

        if (metaFixableProp) {
          const staticValue = getStaticValue(metaFixableProp.value, context.getScope());
          if (!staticValue) {
            // Ignore non-static values since we can't determine what they look like.
            return;
          }

          if (!['code', 'whitespace', null, undefined].includes(staticValue.value)) {
            // `fixable` property has an invalid value.
            context.report({ node: metaFixableProp.value, messageId: 'invalid' });
            return;
          }

          if (usesFixFunctions && !['code', 'whitespace'].includes(staticValue.value)) {
            // Rule is fixable but `fixable` property does not have a fixable value.
            context.report({ node: metaFixableProp.value, messageId: 'missing' });
          }
        } else if (!metaFixableProp && usesFixFunctions) {
          // Rule is fixable but is missing the `fixable` property.
          context.report({ node: ruleInfo.meta || ruleInfo.create, messageId: 'missing' });
        }
      },
    };
  },
};