@pythonidaer/complexity-report 1.0.2

package/function-boundaries/parse-utils.js

@@ -0,0 +1,456 @@
+/**
+ * Character-level parsing: comments, strings, regex, brace counting.
+ */
+
+/**
+ * Handles escape sequences in strings
+ */
+export function handleEscapeSequence(char, inString, escapeNext) {
+  if (escapeNext) return { escapeNext: false, shouldContinue: true };
+  if (char === '\\' && inString) return { escapeNext: true, shouldContinue: true };
+  return { escapeNext: false, shouldContinue: false };
+}
+
+/**
+ * Checks if a single-line comment starts
+ */
+export function isSingleLineCommentStart(
+  char,
+  nextChar,
+  inString,
+  inRegex,
+  inMultiLineComment
+) {
+  return (
+    char === '/' &&
+    nextChar === '/' &&
+    !inString &&
+    !inRegex &&
+    !inMultiLineComment
+  );
+}
+
+/**
+ * Checks if a multi-line comment starts
+ */
+export function isMultiLineCommentStart(
+  char,
+  nextChar,
+  inString,
+  inRegex,
+  inSingleLineComment
+) {
+  return (
+    char === '/' &&
+    nextChar === '*' &&
+    !inString &&
+    !inRegex &&
+    !inSingleLineComment
+  );
+}
+
+/**
+ * Checks if a multi-line comment ends
+ */
+export function isMultiLineCommentEnd(char, nextChar, inMultiLineComment) {
+  return char === '*' && nextChar === '/' && inMultiLineComment;
+}
+
+/**
+ * Handles comment detection and state updates
+ */
+export function handleComments(
+  char,
+  nextChar,
+  inString,
+  inRegex,
+  inSingleLineComment,
+  inMultiLineComment
+) {
+  if (
+    isSingleLineCommentStart(
+      char,
+      nextChar,
+      inString,
+      inRegex,
+      inMultiLineComment
+    )
+  ) {
+    return {
+      inSingleLineComment: true,
+      inMultiLineComment: false,
+      shouldBreak: true,
+      shouldContinue: false,
+      skipNext: false,
+    };
+  }
+  if (
+    isMultiLineCommentStart(
+      char,
+      nextChar,
+      inString,
+      inRegex,
+      inSingleLineComment
+    )
+  ) {
+    return {
+      inSingleLineComment: false,
+      inMultiLineComment: true,
+      shouldBreak: false,
+      shouldContinue: true,
+      skipNext: true,
+    };
+  }
+  if (isMultiLineCommentEnd(char, nextChar, inMultiLineComment)) {
+    return {
+      inSingleLineComment: false,
+      inMultiLineComment: false,
+      shouldBreak: false,
+      shouldContinue: true,
+      skipNext: true,
+    };
+  }
+  if (inSingleLineComment || inMultiLineComment) {
+    return {
+      inSingleLineComment,
+      inMultiLineComment,
+      shouldBreak: false,
+      shouldContinue: true,
+      skipNext: false,
+    };
+  }
+  return {
+    inSingleLineComment: false,
+    inMultiLineComment: false,
+    shouldBreak: false,
+    shouldContinue: false,
+    skipNext: false,
+  };
+}
+
+/**
+ * Handles string literal detection
+ */
+export function handleStringLiterals(char, inRegex, inString, stringChar) {
+  if ((char === '"' || char === "'") && !inRegex) {
+    if (!inString) return { inString: true, stringChar: char };
+    if (char === stringChar) return { inString: false, stringChar: null };
+  }
+  return { inString, stringChar };
+}
+
+/**
+ * Detects if a slash character is the start of a regex pattern
+ */
+export function isRegexStart(line, j, _prevChar) {
+  const beforeSlash = line.substring(Math.max(0, j - 2), j).trim();
+  return (
+    beforeSlash === '' ||
+    beforeSlash.endsWith('=') ||
+    beforeSlash.endsWith('(') ||
+    beforeSlash.endsWith('[') ||
+    beforeSlash.endsWith(',') ||
+    /^\s*$/.test(beforeSlash)
+  );
+}
+
+export function couldBeRegexStart(char, prevChar, inRegex, inString) {
+  return (
+    char === '/' &&
+    prevChar !== '/' &&
+    prevChar !== '*' &&
+    !inRegex &&
+    !inString
+  );
+}
+
+export function couldBeRegexEnd(char, nextChar, inRegex) {
+  return char === '/' && inRegex && nextChar !== '/' && nextChar !== '*';
+}
+
+/**
+ * Handles regex detection
+ */
+export function handleRegexDetection(
+  char,
+  prevChar,
+  nextChar,
+  line,
+  j,
+  inRegex,
+  inString
+) {
+  if (couldBeRegexStart(char, prevChar, inRegex, inString)) {
+    if (isRegexStart(line, j, prevChar)) return true;
+  }
+  if (couldBeRegexEnd(char, nextChar, inRegex)) return false;
+  return inRegex;
+}
+
+/**
+ * Creates a result object with updated state
+ */
+export function createBracesResult(
+  openBraces,
+  closeBraces,
+  state,
+  updatedState,
+  shouldBreak,
+  shouldContinue,
+  skipNext
+) {
+  return {
+    openBraces,
+    closeBraces,
+    state: { ...state, ...updatedState },
+    shouldBreak,
+    shouldContinue,
+    skipNext
+  };
+}
+
+/**
+ * Processes escape sequence
+ */
+export function processEscapeSequence(
+  char,
+  inString,
+  escapeNext,
+  state,
+  openBraces,
+  closeBraces
+) {
+  const escapeResult = handleEscapeSequence(char, inString, escapeNext);
+  if (escapeResult.shouldContinue) {
+    return {
+      result: createBracesResult(
+        openBraces,
+        closeBraces,
+        state,
+        { escapeNext: escapeResult.escapeNext },
+        false,
+        true,
+        false
+      ),
+      escapeNext: escapeResult.escapeNext
+    };
+  }
+  return { result: null, escapeNext: escapeResult.escapeNext };
+}
+
+/**
+ * Handles comment processing
+ */
+export function processCommentHandling(
+  char,
+  nextChar,
+  inString,
+  inRegex,
+  inSingleLineComment,
+  inMultiLineComment,
+  escapeNext,
+  state,
+  openBraces,
+  closeBraces
+) {
+  const commentResult = handleComments(
+    char,
+    nextChar,
+    inString,
+    inRegex,
+    inSingleLineComment,
+    inMultiLineComment
+  );
+  if (commentResult.shouldBreak) {
+    return {
+      result: createBracesResult(
+        openBraces,
+        closeBraces,
+        state,
+        {
+          inSingleLineComment: commentResult.inSingleLineComment,
+          inMultiLineComment: commentResult.inMultiLineComment,
+          escapeNext
+        },
+        true,
+        false,
+        false
+      ),
+      inSingleLineComment: commentResult.inSingleLineComment,
+      inMultiLineComment: commentResult.inMultiLineComment
+    };
+  }
+  if (commentResult.shouldContinue) {
+    return {
+      result: createBracesResult(
+        openBraces,
+        closeBraces,
+        state,
+        {
+          inSingleLineComment: commentResult.inSingleLineComment,
+          inMultiLineComment: commentResult.inMultiLineComment,
+          escapeNext
+        },
+        false,
+        true,
+        commentResult.skipNext
+      ),
+      inSingleLineComment: commentResult.inSingleLineComment,
+      inMultiLineComment: commentResult.inMultiLineComment
+    };
+  }
+  return {
+    result: null,
+    inSingleLineComment: commentResult.inSingleLineComment,
+    inMultiLineComment: commentResult.inMultiLineComment
+  };
+}
+
+/**
+ * Handles string literal processing
+ */
+export function processStringLiteralHandling(
+  char,
+  inRegex,
+  inString,
+  stringChar,
+  escapeNext,
+  state,
+  openBraces,
+  closeBraces
+) {
+  const stringResult = handleStringLiterals(char, inRegex, inString, stringChar);
+  if (
+    stringResult.inString !== inString ||
+    stringResult.stringChar !== stringChar
+  ) {
+    return {
+      result: createBracesResult(
+        openBraces,
+        closeBraces,
+        state,
+        {
+          inString: stringResult.inString,
+          stringChar: stringResult.stringChar,
+          escapeNext
+        },
+        false,
+        true,
+        false
+      ),
+      inString: stringResult.inString,
+      stringChar: stringResult.stringChar
+    };
+  }
+  return {
+    result: null,
+    inString: stringResult.inString,
+    stringChar: stringResult.stringChar,
+  };
+}
+
+/**
+ * Processes a single character in the line to count braces
+ */
+export function processCharacterForBraces(
+  char,
+  prevChar,
+  nextChar,
+  line,
+  j,
+  state,
+  openBraces,
+  closeBraces
+) {
+  let {
+    inRegex,
+    inString,
+    inSingleLineComment,
+    inMultiLineComment,
+    stringChar,
+    escapeNext,
+  } = state;
+
+  const escapeHandling = processEscapeSequence(
+    char,
+    inString,
+    escapeNext,
+    state,
+    openBraces,
+    closeBraces
+  );
+  if (escapeHandling.result) return escapeHandling.result;
+  escapeNext = escapeHandling.escapeNext;
+
+  const commentHandling = processCommentHandling(
+    char,
+    nextChar,
+    inString,
+    inRegex,
+    inSingleLineComment,
+    inMultiLineComment,
+    escapeNext,
+    state,
+    openBraces,
+    closeBraces
+  );
+  if (commentHandling.result) return commentHandling.result;
+  inSingleLineComment = commentHandling.inSingleLineComment;
+  inMultiLineComment = commentHandling.inMultiLineComment;
+
+  const stringHandling = processStringLiteralHandling(
+    char,
+    inRegex,
+    inString,
+    stringChar,
+    escapeNext,
+    state,
+    openBraces,
+    closeBraces
+  );
+  if (stringHandling.result) return stringHandling.result;
+  inString = stringHandling.inString;
+  stringChar = stringHandling.stringChar;
+
+  const newRegexState = handleRegexDetection(
+    char,
+    prevChar,
+    nextChar,
+    line,
+    j,
+    inRegex,
+    inString
+  );
+  if (newRegexState !== inRegex) {
+    return createBracesResult(
+      openBraces,
+      closeBraces,
+      state,
+      {
+        inRegex: newRegexState,
+        inString,
+        stringChar,
+        escapeNext
+      },
+      false,
+      true,
+      false
+    );
+  }
+  inRegex = newRegexState;
+
+  if (!inRegex && !inString) {
+    if (char === '{') openBraces += 1;
+    if (char === '}') closeBraces += 1;
+  }
+
+  return createBracesResult(
+    openBraces,
+    closeBraces,
+    state,
+    { inRegex, inString, stringChar, escapeNext },
+    false,
+    false,
+    false
+  );
+}

package/function-extraction/ast-utils.js

@@ -0,0 +1,112 @@
+/**
+ * AST parsing and traversal for function extraction.
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+import { parse } from '@typescript-eslint/typescript-estree';
+
+/**
+ * Parses source code into AST
+ */
+export function parseAST(sourceCode, filePath) {
+  try {
+    const isTSX = filePath.endsWith('.tsx') || filePath.endsWith('.jsx');
+    return parse(sourceCode, {
+      sourceType: 'module',
+      ecmaVersion: 2020,
+      jsx: isTSX,
+      filePath: filePath,
+      comment: true,
+      loc: true,
+      range: true,
+    });
+  } catch {
+    return null;
+  }
+}
+
+export function getNodeLine(node) {
+  if (node.loc && node.loc.start) return node.loc.start.line;
+  return 1;
+}
+
+export function shouldSkipKey(key) {
+  return key === 'parent' || key === 'range' || key === 'loc' ||
+         key === 'leadingComments' || key === 'trailingComments';
+}
+
+function processArrayChildren(array, visit) {
+  array.forEach(item => {
+    if (item && typeof item === 'object' && item.type) visit(item);
+  });
+}
+
+function processChildNode(child, visit) {
+  if (child && typeof child === 'object' && child.type) visit(child);
+}
+
+export function traverseAST(node, visit) {
+  if (!node || typeof node !== 'object') return;
+  visit(node);
+  for (const key in node) {
+    if (shouldSkipKey(key)) continue;
+    const child = node[key];
+    if (Array.isArray(child)) {
+      processArrayChildren(child, (item) => traverseAST(item, visit));
+    } else {
+      processChildNode(child, (item) => traverseAST(item, visit));
+    }
+  }
+}
+
+export function findAllFunctions(ast) {
+  const functions = [];
+  const functionTypes = new Set([
+    'FunctionDeclaration',
+    'FunctionExpression',
+    'ArrowFunctionExpression',
+    'MethodDefinition',
+  ]);
+  traverseAST(ast, (node) => {
+    if (functionTypes.has(node.type)) functions.push(node);
+  });
+  return functions;
+}
+
+export function findAllNodesByType(ast, nodeType) {
+  const results = [];
+  traverseAST(ast, (node) => {
+    if (node.type === nodeType) results.push(node);
+  });
+  return results;
+}
+
+/**
+ * Finds the containing node that wraps a function node
+ */
+export function findContainingNode(funcNode, candidateNodes) {
+  if (!funcNode.range) return null;
+  let containingNode = null;
+  let smallestSize = Infinity;
+  for (const candidate of candidateNodes) {
+    if (!candidate.range) continue;
+    if (
+      candidate.range[0] < funcNode.range[0] &&
+      candidate.range[1] > funcNode.range[1]
+    ) {
+      const size = candidate.range[1] - candidate.range[0];
+      if (size < smallestSize) {
+        containingNode = candidate;
+        smallestSize = size;
+      }
+    }
+  }
+  return containingNode;
+}
+
+export function readFileIfExists(filePath, projectRoot) {
+  const fullPath = resolve(projectRoot, filePath);
+  if (!existsSync(fullPath)) return null;
+  return readFileSync(fullPath, 'utf-8');
+}

package/function-extraction/extract-callback.js

@@ -0,0 +1,65 @@
+/**
+ * Callback context identification (CallExpression, JSXAttribute, ReturnStatement).
+ */
+
+import { findAllNodesByType, findAllFunctions, findContainingNode } from './ast-utils.js';
+
+export function getCalleeCallbackName(callee) {
+  if (!callee) return null;
+  if (callee.type === 'MemberExpression' && callee.property) return callee.property.name || null;
+  if (callee.type === 'Identifier') return callee.name || null;
+  return null;
+}
+
+export function checkCallExpressionCallback(funcNode, ast) {
+  const callExpressions = findAllNodesByType(ast, 'CallExpression');
+  const newExpressions = findAllNodesByType(ast, 'NewExpression');
+  const containingNode = findContainingNode(funcNode, [
+    ...callExpressions,
+    ...newExpressions,
+  ]);
+  if (containingNode && containingNode.callee) {
+    return getCalleeCallbackName(containingNode.callee);
+  }
+  return null;
+}
+
+export function checkJSXAttributeCallback(funcNode, ast) {
+  const jsxAttributes = findAllNodesByType(ast, 'JSXAttribute');
+  const containingAttr = findContainingNode(funcNode, jsxAttributes);
+  if (containingAttr && containingAttr.name) {
+    const attrName = containingAttr.name.name;
+    if (attrName.startsWith('on') || attrName === 'ref') {
+      return attrName === 'ref' ? 'ref' : `${attrName} handler`;
+    }
+  }
+  return null;
+}
+
+export function checkReturnCallback(funcNode, ast) {
+  const returnStatements = findAllNodesByType(ast, 'ReturnStatement');
+  const containingReturn = findContainingNode(funcNode, returnStatements);
+  if (containingReturn) {
+    const isDirectReturnValue = containingReturn.argument === funcNode ||
+      (containingReturn.argument &&
+        containingReturn.argument.type === 'ArrowFunctionExpression' &&
+        containingReturn.argument === funcNode);
+    if (isDirectReturnValue) {
+      const allFunctions = findAllFunctions(ast);
+      const returnParent = findContainingNode(containingReturn, allFunctions);
+      if (returnParent) return 'return';
+    }
+  }
+  return null;
+}
+
+export function identifyCallbackContext(funcNode, ast) {
+  if (!funcNode.range) return null;
+  const returnCallback = checkReturnCallback(funcNode, ast);
+  if (returnCallback) return returnCallback;
+  const jsxCallback = checkJSXAttributeCallback(funcNode, ast);
+  if (jsxCallback) return jsxCallback;
+  const callCallback = checkCallExpressionCallback(funcNode, ast);
+  if (callCallback) return callCallback;
+  return null;
+}

package/function-extraction/extract-from-eslint.js

@@ -0,0 +1,91 @@
+/**
+ * ESLint result processing and main extractFunctionName (AST + regex fallback).
+ */
+
+import { readFileIfExists } from './ast-utils.js';
+import { extractFunctionNameAST } from './extract-name-ast.js';
+import { handleArrowFunctionExpression, handleFunctionDeclaration } from './extract-name-regex.js';
+
+/**
+ * Extracts function name: AST first, then regex fallback.
+ * Uses self-reference for regex fallback.
+ */
+export function extractFunctionName(
+  filePath,
+  lineNumber,
+  nodeType,
+  projectRoot
+) {
+  const astName = extractFunctionNameAST(
+    filePath,
+    lineNumber,
+    nodeType,
+    projectRoot
+  );
+  if (astName) return astName;
+  try {
+    const fileContent = readFileIfExists(filePath, projectRoot);
+    if (!fileContent) return 'unknown';
+    const lines = fileContent.split('\n');
+    if (nodeType === 'ArrowFunctionExpression') {
+      return handleArrowFunctionExpression(
+        lines,
+        lineNumber,
+        filePath,
+        projectRoot,
+        extractFunctionName
+      );
+    }
+    return handleFunctionDeclaration(lines, lineNumber);
+  } catch {
+    return 'unknown';
+  }
+}
+
+/**
+ * Processes a single complexity message and upserts into functionMap.
+ */
+export function processComplexityMessage(message, file, projectRoot, functionMap) {
+  if (message.ruleId !== 'complexity' || message.severity !== 1) return;
+  const complexityMatch = message.message.match(/complexity of (\d+)/i);
+  if (!complexityMatch) return;
+  const filePath = file.filePath.replace(projectRoot + '/', '');
+  const nodeType = message.nodeType || 'FunctionDeclaration';
+  const functionName = extractFunctionName(
+    filePath,
+    message.line,
+    nodeType,
+    projectRoot
+  );
+  const complexity = complexityMatch[1];
+  const key = `${filePath}:${functionName}:${message.line}`;
+  const existing = functionMap.get(key);
+  if (existing && complexity <= parseInt(existing.complexity, 10)) return;
+  functionMap.set(key, {
+    file: filePath,
+    line: message.line,
+    column: message.column || 1,
+    message: message.message,
+    complexity: complexity,
+    functionName: functionName,
+    nodeType: nodeType,
+  });
+}
+
+/**
+ * Processes ESLint results and extracts function complexity data
+ */
+export function extractFunctionsFromESLintResults(eslintResults, projectRoot) {
+  const functionMap = new Map();
+  eslintResults.forEach((file) => {
+    if (!file.messages) return;
+    file.messages.forEach((message) =>
+      processComplexityMessage(message, file, projectRoot, functionMap)
+    );
+  });
+  const allFunctions = [...functionMap.values()];
+  allFunctions.sort(
+    (a, b) => parseInt(b.complexity, 10) - parseInt(a.complexity, 10)
+  );
+  return allFunctions;
+}