codtracker-js/node_modules/eslint/lib/rules/id-length.js

/**
 * @fileoverview Rule that warns when identifier names are shorter or longer
 * than the values provided in configuration.
 * @author Burak Yigit Kaya aka BYK
 */

'use strict';

//------------------------------------------------------------------------------
// Requirements
//------------------------------------------------------------------------------

const { getGraphemeCount } = require('../shared/string-utils');
const {
  getModuleExportName,
  isImportAttributeKey,
} = require('./utils/ast-utils');

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

/** @type {import('../types').Rule.RuleModule} */
module.exports = {
  meta: {
    type: 'suggestion',

    defaultOptions: [
      {
        exceptionPatterns: [],
        exceptions: [],
        min: 2,
        properties: 'always',
      },
    ],

    docs: {
      description: 'Enforce minimum and maximum identifier lengths',
      recommended: false,
      frozen: true,
      url: 'https://eslint.org/docs/latest/rules/id-length',
    },

    schema: [
      {
        type: 'object',
        properties: {
          min: {
            type: 'integer',
          },
          max: {
            type: 'integer',
          },
          exceptions: {
            type: 'array',
            uniqueItems: true,
            items: {
              type: 'string',
            },
          },
          exceptionPatterns: {
            type: 'array',
            uniqueItems: true,
            items: {
              type: 'string',
            },
          },
          properties: {
            enum: ['always', 'never'],
          },
        },
        additionalProperties: false,
      },
    ],
    messages: {
      tooShort: "Identifier name '{{name}}' is too short (< {{min}}).",
      tooShortPrivate: "Identifier name '#{{name}}' is too short (< {{min}}).",
      tooLong: "Identifier name '{{name}}' is too long (> {{max}}).",
      tooLongPrivate: "Identifier name #'{{name}}' is too long (> {{max}}).",
    },
  },

  create(context) {
    const [options] = context.options;
    const { max: maxLength = Infinity, min: minLength } = options;
    const properties = options.properties !== 'never';
    const exceptions = new Set(options.exceptions);
    const exceptionPatterns = options.exceptionPatterns.map(
      (pattern) => new RegExp(pattern, 'u')
    );
    const reportedNodes = new Set();

    /**
     * Checks if a string matches the provided exception patterns
     * @param {string} name The string to check.
     * @returns {boolean} if the string is a match
     * @private
     */
    function matchesExceptionPattern(name) {
      return exceptionPatterns.some((pattern) => pattern.test(name));
    }

    const SUPPORTED_EXPRESSIONS = {
      MemberExpression:
        properties &&
        function (parent) {
          return (
            !parent.computed &&
            // regular property assignment
            ((parent.parent.left === parent &&
              parent.parent.type === 'AssignmentExpression') ||
              // or the last identifier in an ObjectPattern destructuring
              (parent.parent.type === 'Property' &&
                parent.parent.value === parent &&
                parent.parent.parent.type === 'ObjectPattern' &&
                parent.parent.parent.parent.left === parent.parent.parent))
          );
        },
      AssignmentPattern(parent, node) {
        return parent.left === node;
      },
      VariableDeclarator(parent, node) {
        return parent.id === node;
      },
      Property(parent, node) {
        if (parent.parent.type === 'ObjectPattern') {
          const isKeyAndValueSame = parent.value.name === parent.key.name;

          return (
            (!isKeyAndValueSame && parent.value === node) ||
            (isKeyAndValueSame && parent.key === node && properties)
          );
        }
        return (
          properties &&
          !isImportAttributeKey(node) &&
          !parent.computed &&
          parent.key.name === node.name
        );
      },
      ImportSpecifier(parent, node) {
        return (
          parent.local === node &&
          getModuleExportName(parent.imported) !==
            getModuleExportName(parent.local)
        );
      },
      ImportDefaultSpecifier: true,
      ImportNamespaceSpecifier: true,
      RestElement: true,
      FunctionExpression: true,
      ArrowFunctionExpression: true,
      ClassDeclaration: true,
      FunctionDeclaration: true,
      MethodDefinition: true,
      PropertyDefinition: true,
      CatchClause: true,
      ArrayPattern: true,
    };

    return {
      [['Identifier', 'PrivateIdentifier']](node) {
        const name = node.name;
        const parent = node.parent;

        const nameLength = getGraphemeCount(name);

        const isShort = nameLength < minLength;
        const isLong = nameLength > maxLength;

        if (
          !(isShort || isLong) ||
          exceptions.has(name) ||
          matchesExceptionPattern(name)
        ) {
          return; // Nothing to report
        }

        const isValidExpression = SUPPORTED_EXPRESSIONS[parent.type];

        /*
         * We used the range instead of the node because it's possible
         * for the same identifier to be represented by two different
         * nodes, with the most clear example being shorthand properties:
         * { foo }
         * In this case, "foo" is represented by one node for the name
         * and one for the value. The only way to know they are the same
         * is to look at the range.
         */
        if (
          isValidExpression &&
          !reportedNodes.has(node.range.toString()) &&
          (isValidExpression === true || isValidExpression(parent, node))
        ) {
          reportedNodes.add(node.range.toString());

          let messageId = isShort ? 'tooShort' : 'tooLong';

          if (node.type === 'PrivateIdentifier') {
            messageId += 'Private';
          }

          context.report({
            node,
            messageId,
            data: { name, min: minLength, max: maxLength },
          });
        }
      },
    };
  },
};