eslint-plugin-code-quality-rules/func-lines.js

code-quality-rules

/**
 * @fileoverview A rule to set the maximum number of line of code in a function.
 * @author Pete Ward <peteward44@gmail.com>
 */

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

const astUtils = require('eslint/lib/rules/utils/ast-utils');

const lodash = require('lodash');

//------------------------------------------------------------------------------
// Constants
//------------------------------------------------------------------------------

const OPTIONS_SCHEMA = {
  type: 'object',
  properties: {
    max: {
      type: 'integer',
      minimum: 0,
    },
    skipComments: {
      type: 'boolean',
    },
    skipBlankLines: {
      type: 'boolean',
    },
    IIFEs: {
      type: 'boolean',
    },
  },
  additionalProperties: false,
};

const OPTIONS_OR_INTEGER_SCHEMA = {
  oneOf: [
    OPTIONS_SCHEMA,
    {
      type: 'integer',
      minimum: 1,
    },
  ],
};

/**
 * Given a list of comment nodes, return a map with numeric keys (source code line numbers) and comment token values.
 * @param {Array} comments An array of comment nodes.
 * @returns {Map.<string,Node>} A map with numeric keys (source code line numbers) and comment token values.
 */
function getCommentLineNumbers(comments) {
  const map = new Map();

  if (!comments) {
    return map;
  }
  comments.forEach((comment) => {
    for (let i = comment.loc.start.line; i <= comment.loc.end.line; i++) {
      map.set(i, comment);
    }
  });
  return map;
}

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

module.exports = {
  meta: {
    type: 'suggestion',

    docs: {
      description: 'enforce a maximum number of line of code in a function',
      category: 'Stylistic Issues',
      recommended: false,
      url: 'https://eslint.org/docs/rules/max-lines-per-function',
    },

    schema: [
      OPTIONS_OR_INTEGER_SCHEMA,
    ],
    messages: {
      exceed: '<%={{name}}=%> has too many lines (<%={{lineCount}}=%>). Maximum allowed is <%={{maxLines}}=%>.Detail is <%={{detail}}=%>',
    },
  },

  create(context) {
    const sourceCode = context.getSourceCode();
    const { lines } = sourceCode;

    const option = context.options[0];
    let maxLines = 50;
    let skipComments = false;
    let skipBlankLines = false;
    let IIFEs = false;

    if (typeof option === 'object') {
      maxLines = typeof option.max === 'number' ? option.max : 50;
      skipComments = !!option.skipComments;
      skipBlankLines = !!option.skipBlankLines;
      IIFEs = !!option.IIFEs;
    } else if (typeof option === 'number') {
      maxLines = option;
    }

    const commentLineNumbers = getCommentLineNumbers(sourceCode.getAllComments());

    const fns = [];

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

    /**
         * Tells if a comment encompasses the entire line.
         * @param {string} line The source line with a trailing comment
         * @param {number} lineNumber The one-indexed line number this is on
         * @param {ASTNode} comment The comment to remove
         * @returns {boolean} If the comment covers the entire line
         */
    function isFullLineComment(line, lineNumber, comment) {
      const { start } = comment.loc;
      const { end } = comment.loc;
      const isFirstTokenOnLine = start.line === lineNumber && !line.slice(0, start.column).trim();
      const isLastTokenOnLine = end.line === lineNumber && !line.slice(end.column).trim();

      return comment
                && (start.line < lineNumber || isFirstTokenOnLine)
                && (end.line > lineNumber || isLastTokenOnLine);
    }

    /**
         * Identifies is a node is a FunctionExpression which is part of an IIFE
         * @param {ASTNode} node Node to test
         * @returns {boolean} True if it's an IIFE
         */
    function isIIFE(node) {
      return node.type === 'FunctionExpression' && node.parent && node.parent.type === 'CallExpression' && node.parent.callee === node;
    }

    /**
         * Identifies is a node is a FunctionExpression which is embedded within a MethodDefinition or Property
         * @param {ASTNode} node Node to test
         * @returns {boolean} True if it's a FunctionExpression embedded within a MethodDefinition or Property
         */
    function isEmbedded(node) {
      if (!node.parent) {
        return false;
      }
      if (node !== node.parent.value) {
        return false;
      }
      if (node.parent.type === 'MethodDefinition') {
        return true;
      }
      if (node.parent.type === 'Property') {
        return node.parent.method === true || node.parent.kind === 'get' || node.parent.kind === 'set';
      }
      return false;
    }

    /**
         * Count the lines in the function
         * @param {ASTNode} funcNode Function AST node
         * @returns {void}
         * @private
         */
    function processFunction(funcNode) {
      const node = isEmbedded(funcNode) ? funcNode.parent : funcNode;

      if (!IIFEs && isIIFE(node)) {
        return 0;
      }
      let lineCount = 0;

      for (let i = node.loc.start.line - 1; i < node.loc.end.line; ++i) {
        const line = lines[i];

        if (skipComments) {
          if (commentLineNumbers.has(i + 1) && isFullLineComment(line, i + 1, commentLineNumbers.get(i + 1))) {
            continue;
          }
        }

        if (skipBlankLines) {
          if (line.match(/^\s*$/u)) {
            continue;
          }
        }

        lineCount++;
      }
      return lineCount;
    }

    function endFunction(node) {
      const detail = fns.pop();
      const { lineCount } = detail;
      if (lineCount > maxLines) {
        const name = lodash.upperFirst(astUtils.getFunctionNameWithKind(node));
        context.report({
          node,
          messageId: 'exceed',
          data: {
            name, lineCount, maxLines, detail: JSON.stringify(lodash.omit(detail, ['lineCount'])),
          },
        });
      }
    }

    function startFunction(node) {
      const lineCount = processFunction(node);
      fns.push({ lineCount });
    }

    function increaseCountByType(type) {
      if (fns.length) {
        const detail = fns[fns.length - 1];
        const typeCount = detail[type];
        if (!typeCount) {
          detail[type] = 1;
        } else {
          detail[type] = typeCount + 1;
        }
      }
    }

    //--------------------------------------------------------------------------
    // Public API
    //--------------------------------------------------------------------------
    // todo 可以在processFunction函数计算行数结束之后，遍历该节点下面是由哪些节点组成
    // 如逻辑表达式，变量声明，统计这些信息来知道如何解决过长函数问题
    return {
      FunctionDeclaration: (node) => startFunction(node),
      FunctionExpression: (node) => startFunction(node),
      ArrowFunctionExpression: (node) => startFunction(node),
      'FunctionDeclaration:exit': endFunction,
      'FunctionExpression:exit': endFunction,
      'ArrowFunctionExpression:exit': endFunction,

      ConditionalExpression: () => increaseCountByType('ConditionalExpression'),
      LogicalExpression: () => increaseCountByType('LogicalExpression'),
      IfStatement: () => increaseCountByType('IfStatement'),
      VariableDeclaration: () => increaseCountByType('VariableDeclaration'),
      CatchClause: () => increaseCountByType('CatchClause'),
      ForStatement: () => increaseCountByType('ForStatement'),
      ForInStatement: () => increaseCountByType('ForInStatement'),
      ForOfStatement: () => increaseCountByType('ForOfStatement'),
      SwitchCase: () => increaseCountByType('SwitchCase'),
      WhileStatement: () => increaseCountByType('WhileStatement'),
      DoWhileStatement: () => increaseCountByType('DoWhileStatement'),
    };
  },
};