@pythonidaer/complexity-report 1.0.2

package/function-extraction/extract-name-ast.js

@@ -0,0 +1,133 @@
+/**
+ * AST-based function name extraction.
+ */
+
+import { parseAST, findAllFunctions, findAllNodesByType, findContainingNode, readFileIfExists, getNodeLine } from './ast-utils.js';
+import { identifyCallbackContext } from './extract-callback.js';
+
+export function isFirstArgOfDirectCall(funcNode, ast) {
+  const callExpressions = findAllNodesByType(ast, 'CallExpression');
+  const containingCall = findContainingNode(funcNode, callExpressions);
+  if (
+    !containingCall ||
+    !containingCall.arguments ||
+    containingCall.arguments[0] !== funcNode
+  ) {
+    return false;
+  }
+  return containingCall.callee.type === 'Identifier';
+}
+
+export function findVariableDeclaratorForFunction(funcNode, ast) {
+  const variableDeclarators = findAllNodesByType(ast, 'VariableDeclarator');
+  for (const declarator of variableDeclarators) {
+    if (declarator.init === funcNode) return declarator;
+    if (
+      funcNode.range &&
+      declarator.range &&
+      declarator.range[0] <= funcNode.range[0] &&
+      declarator.range[1] >= funcNode.range[1]
+    ) {
+      if (isFirstArgOfDirectCall(funcNode, ast)) return declarator;
+    }
+  }
+  return null;
+}
+
+export function extractNameFromVariableDeclarator(funcNode, ast) {
+  const declarator = findVariableDeclaratorForFunction(funcNode, ast);
+  if (declarator && declarator.id) return declarator.id.name;
+  return null;
+}
+
+export function extractNameFromProperty(funcNode, ast) {
+  const properties = findAllNodesByType(ast, 'Property');
+  const containingProperty = findContainingNode(funcNode, properties);
+  if (containingProperty && containingProperty.key) {
+    if (containingProperty.key.type === 'Identifier') return containingProperty.key.name;
+    if (containingProperty.key.type === 'Literal') return String(containingProperty.key.value);
+  }
+  return null;
+}
+
+export function extractNameFromMethodDefinition(funcNode, ast) {
+  const methodDefinitions = findAllNodesByType(ast, 'MethodDefinition');
+  const containingMethod = findContainingNode(funcNode, methodDefinitions);
+  if (containingMethod && containingMethod.key && containingMethod.key.type === 'Identifier') {
+    return containingMethod.key.name;
+  }
+  return null;
+}
+
+export function extractNameFromASTNode(funcNode, ast) {
+  if (funcNode.type === 'FunctionDeclaration' && funcNode.id) return funcNode.id.name;
+  const varName = extractNameFromVariableDeclarator(funcNode, ast);
+  if (varName) return varName;
+  const propName = extractNameFromProperty(funcNode, ast);
+  if (propName) return propName;
+  const methodName = extractNameFromMethodDefinition(funcNode, ast);
+  if (methodName) return methodName;
+  return null;
+}
+
+export function doNodeTypesMatch(eslintNodeType, astNodeType) {
+  return (eslintNodeType === 'FunctionDeclaration' && astNodeType === 'FunctionDeclaration') ||
+    (eslintNodeType === 'ArrowFunctionExpression' && astNodeType === 'ArrowFunctionExpression') ||
+    (eslintNodeType === 'FunctionExpression' && astNodeType === 'FunctionExpression');
+}
+
+export function findArrowFunctionLine(astFunc, sourceCode) {
+  if (!astFunc.range) return null;
+  const funcCode = sourceCode.substring(astFunc.range[0], astFunc.range[1]);
+  const arrowIndex = funcCode.indexOf('=>');
+  if (arrowIndex === -1) return null;
+  const linesBeforeArrow = sourceCode.substring(0, astFunc.range[0] + arrowIndex).split('\n');
+  return linesBeforeArrow.length;
+}
+
+export function matchesArrowFunctionLine(astFunc, lineNumber, sourceCode) {
+  const arrowLine = findArrowFunctionLine(astFunc, sourceCode);
+  return arrowLine !== null && arrowLine === lineNumber;
+}
+
+export function findMatchingASTFunction(
+  astFunctions,
+  lineNumber,
+  nodeType,
+  sourceCode
+) {
+  for (const astFunc of astFunctions) {
+    if (!doNodeTypesMatch(nodeType, astFunc.type)) continue;
+    if (astFunc.type === 'ArrowFunctionExpression') {
+      if (matchesArrowFunctionLine(astFunc, lineNumber, sourceCode)) return astFunc;
+    } else {
+      if (getNodeLine(astFunc) === lineNumber) return astFunc;
+    }
+  }
+  return null;
+}
+
+export function extractFunctionNameAST(filePath, lineNumber, nodeType, projectRoot) {
+  try {
+    const sourceCode = readFileIfExists(filePath, projectRoot);
+    if (!sourceCode) return null;
+    const ast = parseAST(sourceCode, filePath);
+    if (!ast) return null;
+    const astFunctions = findAllFunctions(ast);
+    const matchingFunc = findMatchingASTFunction(
+      astFunctions,
+      lineNumber,
+      nodeType,
+      sourceCode
+    );
+    if (!matchingFunc) return null;
+    const functionName = extractNameFromASTNode(matchingFunc, ast);
+    if (functionName) return functionName;
+    const callbackType = identifyCallbackContext(matchingFunc, ast);
+    if (callbackType) return callbackType;
+    if (matchingFunc.type === 'ArrowFunctionExpression') return 'anonymous arrow function';
+    return 'anonymous';
+  } catch {
+    return null;
+  }
+}

package/function-extraction/extract-name-regex.js

@@ -0,0 +1,267 @@
+/**
+ * Regex-based function name extraction (fallback when AST fails).
+ * getFunctionNameForLine is optional; when provided,
+ * findParentFunctionWithFallback uses it for recursive lookup.
+ */
+
+const FUNCTION_PATTERNS = [
+  /(?:export\s+)?function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*[<(]/,
+  /const\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*(?:\([^)]*\)\s*)?(?:=>|function)/,
+  /export\s+const\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*(?:\([^)]*\)\s*)?(?:=>|function)/,
+];
+
+export function findParentFunction(lines, lineNumber, maxLookBack = 50) {
+  let parentFunction = null;
+  let closestFunctionLine = -1;
+  for (
+    let lookBack = 1;
+    lookBack <= maxLookBack && lineNumber - lookBack >= 1;
+    lookBack += 1
+  ) {
+    const checkLine = lineNumber - lookBack;
+    const checkLineContent = lines[checkLine - 1] || '';
+    for (const funcPattern of FUNCTION_PATTERNS) {
+      const funcMatch = checkLineContent.match(funcPattern);
+      if (funcMatch && funcMatch[1]) {
+        if (closestFunctionLine === -1 || checkLine > closestFunctionLine) {
+          parentFunction = funcMatch[1];
+          closestFunctionLine = checkLine;
+        }
+      }
+    }
+  }
+  return parentFunction;
+}
+
+export function findParentFunctionWithFallback(
+  filePath,
+  lineNumber,
+  projectRoot,
+  lines,
+  getFunctionNameForLine
+) {
+  const parentFunction = findParentFunction(lines, lineNumber);
+  if (parentFunction) return parentFunction;
+  if (typeof getFunctionNameForLine === 'function') {
+    return getFunctionNameForLine(
+      filePath,
+      lineNumber - 5,
+      'FunctionDeclaration',
+      projectRoot
+    );
+  }
+  return 'anonymous';
+}
+
+export function formatCallbackName(callbackType, parentFunction) {
+  if (
+    parentFunction &&
+    parentFunction !== 'anonymous' &&
+    parentFunction !== 'unknown'
+  ) {
+    return `${parentFunction} (${callbackType})`;
+  }
+  return callbackType;
+}
+
+export function checkNamedArrowFunction(prevLine, currentLine) {
+  const combinedContext = (prevLine + ' ' + currentLine).trim();
+  const namedArrowPattern =
+    /const\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*(?:\([^)]*\)\s*)?=>/;
+  const namedMatch = combinedContext.match(namedArrowPattern);
+  return namedMatch && namedMatch[1] ? namedMatch[1] : null;
+}
+
+export function findMethodCallCallback(
+  beforeArrow,
+  filePath,
+  lineNumber,
+  projectRoot,
+  lines,
+  getFunctionNameForLine
+) {
+  const methodCallMatch = beforeArrow.match(/\.(\w+)\s*\(/);
+  if (!methodCallMatch || !methodCallMatch[1]) return null;
+  const callbackType = methodCallMatch[1];
+  const parentFunction = findParentFunctionWithFallback(
+    filePath,
+    lineNumber,
+    projectRoot,
+    lines,
+    getFunctionNameForLine
+  );
+  return formatCallbackName(callbackType, parentFunction);
+}
+
+export function findFunctionCallCallback(
+  beforeArrow,
+  filePath,
+  lineNumber,
+  projectRoot,
+  lines,
+  getFunctionNameForLine
+) {
+  const functionCallMatch = beforeArrow.match(
+    /(?!if|for|while|switch)\b(\w+)\s*\(/
+  );
+  if (!functionCallMatch || !functionCallMatch[1]) return null;
+  const callbackType = functionCallMatch[1];
+  const parentFunction = findParentFunctionWithFallback(
+    filePath,
+    lineNumber,
+    projectRoot,
+    lines,
+    getFunctionNameForLine
+  );
+  return formatCallbackName(callbackType, parentFunction);
+}
+
+export function findCallbackWithFallbackPatterns(
+  combinedContext,
+  filePath,
+  lineNumber,
+  projectRoot,
+  lines,
+  getFunctionNameForLine
+) {
+  const arrowFunctionPatterns = [
+    /\.(\w+)\s*\([^)]*\)\s*=>/,
+    /\.(\w+)\s*\([^)]*=>/,
+    /(\w+)\s*\([^)]*\)\s*=>/,
+    /(\w+)\s*\([^)]*=>/,
+  ];
+  for (const pattern of arrowFunctionPatterns) {
+    const match = combinedContext.match(pattern);
+    if (match && match[1]) {
+      const parentFunction = findParentFunctionWithFallback(
+        filePath,
+        lineNumber,
+        projectRoot,
+        lines,
+        getFunctionNameForLine
+      );
+      return formatCallbackName(match[1], parentFunction);
+    }
+  }
+  return null;
+}
+
+export function handleArrowFunctionFinalFallback(
+  filePath,
+  lineNumber,
+  projectRoot,
+  lines,
+  getFunctionNameForLine
+) {
+  const parentFunction = findParentFunctionWithFallback(
+    filePath,
+    lineNumber,
+    projectRoot,
+    lines,
+    getFunctionNameForLine
+  );
+  if (
+    parentFunction &&
+    parentFunction !== 'anonymous' &&
+    parentFunction !== 'unknown'
+  ) {
+    return `${parentFunction} (arrow function)`;
+  }
+  return 'anonymous arrow function';
+}
+
+export function tryFindCallbackFromCurrentLine(
+  currentLine,
+  filePath,
+  lineNumber,
+  projectRoot,
+  lines,
+  getFunctionNameForLine
+) {
+  const arrowIndex = currentLine.indexOf('=>');
+  if (arrowIndex === -1) return null;
+  const beforeArrow = currentLine.substring(0, arrowIndex);
+  const methodCallback = findMethodCallCallback(
+    beforeArrow,
+    filePath,
+    lineNumber,
+    projectRoot,
+    lines,
+    getFunctionNameForLine
+  );
+  if (methodCallback) return methodCallback;
+  return findFunctionCallCallback(
+    beforeArrow,
+    filePath,
+    lineNumber,
+    projectRoot,
+    lines,
+    getFunctionNameForLine
+  );
+}
+
+export function handleArrowFunctionExpression(
+  lines,
+  lineNumber,
+  filePath,
+  projectRoot,
+  getFunctionNameForLine
+) {
+  const lineIndex = lineNumber - 1;
+  const currentLine = lines[lineIndex] || '';
+  const prevLine = lines[lineIndex - 1] || '';
+  const namedArrow = checkNamedArrowFunction(prevLine, currentLine);
+  if (namedArrow) return namedArrow;
+  const callbackFromLine = tryFindCallbackFromCurrentLine(
+    currentLine,
+    filePath,
+    lineNumber,
+    projectRoot,
+    lines,
+    getFunctionNameForLine
+  );
+  if (callbackFromLine) return callbackFromLine;
+  const combinedContext = (prevLine + ' ' + currentLine).trim();
+  const fallbackCallback = findCallbackWithFallbackPatterns(
+    combinedContext,
+    filePath,
+    lineNumber,
+    projectRoot,
+    lines,
+    getFunctionNameForLine
+  );
+  if (fallbackCallback) return fallbackCallback;
+  return handleArrowFunctionFinalFallback(
+    filePath,
+    lineNumber,
+    projectRoot,
+    lines,
+    getFunctionNameForLine
+  );
+}
+
+export function handleFunctionDeclaration(lines, lineNumber) {
+  const startLine = Math.max(0, lineNumber - 50);
+  const context = lines.slice(startLine, lineNumber).join('\n');
+  const patterns = [
+    /(?:export\s+)?function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*[<(]/,
+    /const\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*(?:\([^)]*\)\s*)?(?:=>|function)/,
+    /export\s+const\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*(?:\([^)]*\)\s*)?(?:=>|function)/,
+    /export\s+default\s+function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*[<(]/,
+    /(?:export\s+default\s+|const\s+)([A-Z][a-zA-Z0-9_$]*)\s*[:=]\s*(?:\([^)]*\)\s*)?=>/,
+  ];
+  let lastMatch = null;
+  let lastIndex = -1;
+  for (const pattern of patterns) {
+    const matches = [...context.matchAll(new RegExp(pattern.source, 'g'))];
+    if (matches.length > 0) {
+      const match = matches[matches.length - 1];
+      const matchIndex = context.lastIndexOf(match[0]);
+      if (matchIndex > lastIndex) {
+        lastMatch = match[1];
+        lastIndex = matchIndex;
+      }
+    }
+  }
+  return lastMatch || 'anonymous';
+}

package/function-extraction/index.js

@@ -0,0 +1,6 @@
+/**
+ * Function extraction module — public API.
+ */
+
+export { extractFunctionName, extractFunctionsFromESLintResults, processComplexityMessage } from './extract-from-eslint.js';
+export { getComplexityLevel, getDirectory, getBaseFunctionName } from './utils.js';

package/function-extraction/utils.js

@@ -0,0 +1,29 @@
+/**
+ * Complexity and path utilities.
+ */
+
+export function getComplexityLevel(complexity) {
+  const num = parseInt(complexity, 10);
+  if (num >= 20) return 'low';
+  if (num >= 15) return 'medium';
+  if (num > 10) return 'high';
+  if (num > 6) return 'acceptable';
+  return 'good';
+}
+
+export function getDirectory(filePath) {
+  const parts = filePath.split('/');
+  if (parts.length <= 1) return filePath;
+  return parts.slice(0, -1).join('/');
+}
+
+export function getBaseFunctionName(name) {
+  if (!name) return 'unknown';
+  let baseName = String(name).trim();
+  let prev = '';
+  while (prev !== baseName) {
+    prev = baseName;
+    baseName = baseName.replace(/\s*\([^)]+\)\s*$/g, '').replace(/\s*→\s*[^→]*$/g, '').trim();
+  }
+  return baseName || 'unknown';
+}