@pythonidaer/complexity-report 1.0.2

package/decision-points/function-matching.js

@@ -0,0 +1,185 @@
+/**
+ * Matching AST function nodes to ESLint function results.
+ */
+
+import { getNodeLine } from './ast-utils.js';
+
+/**
+ * Finds the line number where => appears in an arrow function
+ * @param {Object} astFunc - AST arrow function node
+ * @param {string} sourceCode - Full source code
+ * @returns {number|null} Line number where => appears, or null if not found
+ */
+export function findArrowFunctionLine(astFunc, sourceCode) {
+  if (astFunc.type !== 'ArrowFunctionExpression') return null;
+  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;
+}
+
+/**
+ * Gets the match line for an AST function (handles arrow functions)
+ * @param {Object} astFunc - AST function node
+ * @param {string} sourceCode - Full source code
+ * @returns {number} Line number to match against
+ */
+export function getMatchLineForASTFunction(astFunc, sourceCode) {
+  const astLine = getNodeLine(astFunc);
+  if (astFunc.type === 'ArrowFunctionExpression') {
+    const arrowLine = findArrowFunctionLine(astFunc, sourceCode);
+    if (arrowLine !== null) {
+      return arrowLine;
+    }
+  }
+  return astLine;
+}
+
+/**
+ * Checks if node types match between ESLint and AST
+ * @param {string} eslintNodeType - ESLint node type
+ * @param {string} astNodeType - AST node type
+ * @returns {boolean} True if types match
+ */
+export function doNodeTypesMatch(eslintNodeType, astNodeType) {
+  return (eslintNodeType === 'FunctionDeclaration' && astNodeType === 'FunctionDeclaration') ||
+         (eslintNodeType === 'ArrowFunctionExpression' && astNodeType === 'ArrowFunctionExpression') ||
+         (eslintNodeType === 'FunctionExpression' && astNodeType === 'FunctionExpression');
+}
+
+/**
+ * Matches AST function to ESLint functions by node type
+ * @param {Object} astFunc - AST function node
+ * @param {Array} matchingEslintFuncs - Array of matching ESLint functions
+ * @param {Map} astToEslintMap - Map to update
+ * @returns {boolean} True if matched
+ */
+export function matchByNodeType(astFunc, matchingEslintFuncs, astToEslintMap) {
+  for (const eslintFunc of matchingEslintFuncs) {
+    const nodeTypeMatches = doNodeTypesMatch(eslintFunc.nodeType, astFunc.type);
+    if (nodeTypeMatches || matchingEslintFuncs.length === 1) {
+      astToEslintMap.set(astFunc, eslintFunc.line);
+      return true;
+    }
+  }
+  if (matchingEslintFuncs.length > 0) {
+    astToEslintMap.set(astFunc, matchingEslintFuncs[0].line);
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Checks if ESLint line is within AST function range
+ * @param {Object} eslintFunc - ESLint function
+ * @param {Object} astFunc - AST function
+ * @param {string} sourceCode - Source code
+ * @returns {boolean} True if within range
+ */
+export function isESLintLineInASTRange(eslintFunc, astFunc, sourceCode) {
+  if (!astFunc.range) return false;
+  const lines = sourceCode.split('\n');
+  const eslintLineStart = lines.slice(0, eslintFunc.line - 1).join('\n').length;
+  const eslintLineEnd = eslintLineStart + lines[eslintFunc.line - 1].length;
+  return eslintLineStart >= astFunc.range[0] && eslintLineEnd <= astFunc.range[1];
+}
+
+/**
+ * Tries to match AST function to ESLint functions by range
+ * @param {Object} astFunc - AST function node
+ * @param {Array} eslintFunctions - All ESLint functions
+ * @param {string} sourceCode - Source code
+ * @param {Map} astToEslintMap - Map to update
+ * @returns {boolean} True if matched
+ */
+export function tryMatchByRange(astFunc, eslintFunctions, sourceCode, astToEslintMap) {
+  for (const eslintFunc of eslintFunctions) {
+    if (eslintFunc.nodeType === astFunc.type) {
+      if (isESLintLineInASTRange(eslintFunc, astFunc, sourceCode)) {
+        astToEslintMap.set(astFunc, eslintFunc.line);
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * Matches AST function nodes to ESLint function results by line number
+ * and creates a map
+ * @param {Array} astFunctions - Function nodes from AST
+ * @param {Array} eslintFunctions - Function objects from ESLint results
+ * @param {string} sourceCode - Full source code (for finding => in arrow)
+ * @returns {Map} Map of AST function node to ESLint function line
+ */
+export function matchFunctionsToAST(astFunctions, eslintFunctions, sourceCode) {
+  const astToEslintMap = new Map();
+
+  const eslintFunctionMap = new Map();
+  eslintFunctions.forEach(func => {
+    if (!eslintFunctionMap.has(func.line)) {
+      eslintFunctionMap.set(func.line, []);
+    }
+    eslintFunctionMap.get(func.line).push(func);
+  });
+
+  astFunctions.forEach(astFunc => {
+    const matchLine = getMatchLineForASTFunction(astFunc, sourceCode);
+    const matchingEslintFuncs = eslintFunctionMap.get(matchLine);
+
+    if (matchingEslintFuncs && matchingEslintFuncs.length > 0) {
+      matchByNodeType(astFunc, matchingEslintFuncs, astToEslintMap);
+    } else {
+      tryMatchByRange(astFunc, eslintFunctions, sourceCode, astToEslintMap);
+    }
+  });
+
+  return astToEslintMap;
+}
+
+/**
+ * Finds the innermost AST function that contains a decision point node
+ * @param {Object} node - Decision point node
+ * @param {Array} astFunctions - All AST function nodes
+ * @returns {Object|null} Innermost AST function node or null
+ */
+export function findInnermostASTFunction(node, astFunctions) {
+  if (!node.range) return null;
+
+  let innermost = null;
+  let innermostSize = Infinity;
+
+  for (const astFunc of astFunctions) {
+    if (astFunc.range &&
+        node.range[0] >= astFunc.range[0] &&
+        node.range[1] <= astFunc.range[1]) {
+      const size = astFunc.range[1] - astFunc.range[0];
+      if (size < innermostSize) {
+        innermost = astFunc;
+        innermostSize = size;
+      }
+    }
+  }
+
+  return innermost;
+}
+
+/**
+ * Finds the ESLint function line that contains a decision point
+ * @param {Object} node - Decision point node
+ * @param {Array} astFunctions - All AST function nodes
+ * @param {Map} astToEslintMap - Map of AST function node to ESLint function line
+ * @returns {number|null} ESLint function line number or null
+ */
+export function findFunctionForDecisionPoint(node, astFunctions, astToEslintMap) {
+  if (!node.range) return null;
+
+  const innermostASTFunc = findInnermostASTFunction(node, astFunctions);
+  if (!innermostASTFunc) return null;
+
+  return astToEslintMap.get(innermostASTFunc) || null;
+}

package/decision-points/in-params.js

@@ -0,0 +1,262 @@
+/**
+ * Checks for nodes in function parameters (default params, destructuring).
+ */
+
+/**
+ * Checks if a node type is a function type
+ * @param {string} type - Node type
+ * @returns {boolean} True if function type
+ */
+export function isFunctionType(type) {
+  return type === 'FunctionDeclaration' ||
+         type === 'FunctionExpression' ||
+         type === 'ArrowFunctionExpression';
+}
+
+/**
+ * Checks if a node is in a function's parameter list
+ * @param {Object} node - Node to check
+ * @param {Object} funcParent - Function parent node
+ * @returns {boolean} True if node is in function params
+ */
+export function isNodeInFunctionParams(node, funcParent) {
+  if (!funcParent.params || !Array.isArray(funcParent.params)) {
+    return false;
+  }
+
+  if (funcParent.params.includes(node)) {
+    return true;
+  }
+
+  for (const param of funcParent.params) {
+    if (checkNestedPattern(param, node)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Checks if a parent node is a pattern container
+ * @param {Object} parent - Parent node
+ * @returns {boolean} True if pattern container
+ */
+export function isPatternContainer(parent) {
+  return parent.type === 'ArrayPattern' ||
+         parent.type === 'ObjectPattern' ||
+         parent.type === 'Property' ||
+         parent.type === 'RestElement';
+}
+
+/**
+ * Checks if AssignmentPattern is in function parameters by traversing up
+ * @param {Object} node - AssignmentPattern node
+ * @param {Map} parentMap - Parent map
+ * @returns {boolean} True if in function parameters
+ */
+export function checkInFunctionParams(node, parentMap) {
+  let current = node;
+  let depth = 0;
+  const maxDepth = 15;
+
+  while (current && depth < maxDepth) {
+    const parent = parentMap.get(current);
+    if (!parent) break;
+
+    if (isFunctionType(parent.type)) {
+      if (isNodeInFunctionParams(node, parent)) {
+        return true;
+      }
+    }
+
+    if (isPatternContainer(parent)) {
+      current = parent;
+      depth += 1;
+      continue;
+    }
+
+    break;
+  }
+
+  return false;
+}
+
+/**
+ * Checks if VariableDeclaration is a direct child of function body
+ * @param {Object} varParent - VariableDeclaration node
+ * @param {Object} funcParent - Function parent node
+ * @returns {boolean} True if direct child of function body
+ */
+export function isVariableDeclarationInFunctionBody(varParent, funcParent) {
+  if (!funcParent.body) return false;
+
+  const bodyType = funcParent.body.type;
+  if (bodyType !== 'BlockStatement' && bodyType !== 'Program') {
+    return false;
+  }
+
+  const bodyStatements = funcParent.body.body || funcParent.body.statements || [];
+  return bodyStatements.includes(varParent);
+}
+
+/**
+ * Checks if VariableDeclarator is in a top-level destructuring in function body
+ * @param {Object} varDeclarator - VariableDeclarator node
+ * @param {Object} node - Original AssignmentPattern node
+ * @param {Map} parentMap - Parent map
+ * @returns {boolean} True if in top-level destructuring in function body
+ */
+export function checkInTopLevelDestructuring(varDeclarator, node, parentMap) {
+  let varParent = parentMap.get(varDeclarator);
+  let depth = 0;
+  const maxDepth = 15;
+
+  while (varParent && depth < maxDepth) {
+    if (varParent.type === 'VariableDeclaration') {
+      let funcParent = parentMap.get(varParent);
+      let funcDepth = 0;
+
+      while (funcParent && funcDepth < 10) {
+        if (isFunctionType(funcParent.type)) {
+          if (isVariableDeclarationInFunctionBody(varParent, funcParent)) {
+            return true;
+          }
+          break;
+        }
+        funcParent = parentMap.get(funcParent);
+        funcDepth += 1;
+      }
+    }
+    varParent = parentMap.get(varParent);
+    depth += 1;
+  }
+
+  return false;
+}
+
+/**
+ * Checks if AssignmentPattern is in a top-level destructuring
+ * assignment in function body
+ * @param {Object} node - AssignmentPattern node
+ * @param {Map} parentMap - Parent map
+ * @returns {boolean} True if in top-level destructuring
+ */
+export function checkInFunctionBodyDestructuring(node, parentMap) {
+  let current = node;
+  let depth = 0;
+  const maxDepth = 15;
+
+  while (current && depth < maxDepth) {
+    const parent = parentMap.get(current);
+    if (!parent) break;
+
+    if (parent.type === 'VariableDeclarator' && parent.id) {
+      if (checkNestedPattern(parent.id, node)) {
+        if (checkInTopLevelDestructuring(parent, node, parentMap)) {
+          return true;
+        }
+      }
+    }
+
+    if (isPatternContainer(parent)) {
+      current = parent;
+      depth += 1;
+      continue;
+    }
+
+    break;
+  }
+
+  return false;
+}
+
+/**
+ * Checks if AssignmentPattern is in function parameters or destructuring
+ * at the top level of a function body (ESLint counts these as decision)
+ * @param {Object} node - AssignmentPattern node
+ * @param {Map} parentMap - Parent map
+ * @param {Object} _ast - Root AST node (for finding containing function)
+ * @returns {boolean} True if in function params or top-level destructuring
+ */
+export function isInFunctionParameters(node, parentMap, _ast) {
+  if (checkInFunctionParams(node, parentMap)) {
+    return true;
+  }
+  return checkInFunctionBodyDestructuring(node, parentMap);
+}
+
+/**
+ * Checks if target is nested in ArrayPattern elements
+ * @param {Array} elements - Array of elements
+ * @param {Object} target - Target node to find
+ * @returns {boolean} True if target is found
+ */
+function checkArrayPatternElements(elements, target) {
+  return elements.some(el => {
+    if (el === target) return true;
+    if (el && typeof el === 'object' && el.type) {
+      return checkNestedPattern(el, target);
+    }
+    return false;
+  });
+}
+
+/**
+ * Checks if target is nested in ObjectPattern properties
+ * @param {Array} properties - Array of properties
+ * @param {Object} target - Target node to find
+ * @returns {boolean} True if target is found
+ */
+function checkObjectPatternProperties(properties, target) {
+  return properties.some(prop => {
+    if (prop.value === target) return true;
+    if (prop.value && typeof prop.value === 'object' && prop.value.type) {
+      return checkNestedPattern(prop.value, target);
+    }
+    if (prop.key && typeof prop.key === 'object' && prop.key.type) {
+      return checkNestedPattern(prop.key, target);
+    }
+    return false;
+  });
+}
+
+/**
+ * Checks if target is nested in RestElement
+ * @param {Object} restElement - RestElement node
+ * @param {Object} target - Target node to find
+ * @returns {boolean} True if target is found
+ */
+function checkRestElement(restElement, target) {
+  if (!restElement.argument) return false;
+  if (restElement.argument === target) return true;
+  if (restElement.argument && typeof restElement.argument === 'object' && restElement.argument.type) {
+    return checkNestedPattern(restElement.argument, target);
+  }
+  return false;
+}
+
+/**
+ * Checks if a node is nested in a pattern (recursively)
+ * @param {Object} pattern - Pattern node (ArrayPattern, ObjectPattern, Property, etc.)
+ * @param {Object} target - Target node to find
+ * @returns {boolean} True if target is nested in pattern
+ */
+export function checkNestedPattern(pattern, target) {
+  if (!pattern || typeof pattern !== 'object') return false;
+  if (pattern === target) return true;
+
+  if (pattern.elements && Array.isArray(pattern.elements)) {
+    return checkArrayPatternElements(pattern.elements, target);
+  }
+
+  if (pattern.properties && Array.isArray(pattern.properties)) {
+    return checkObjectPatternProperties(pattern.properties, target);
+  }
+
+  if (pattern.type === 'RestElement') {
+    return checkRestElement(pattern, target);
+  }
+
+  return false;
+}

package/decision-points/index.js

@@ -0,0 +1,6 @@
+/**
+ * Decision points module — AST-based decision point parsing.
+ * Main export: parseDecisionPointsAST.
+ */
+
+export { parseDecisionPointsAST } from './parse-main.js';

package/decision-points/node-helpers.js

@@ -0,0 +1,89 @@
+/**
+ * Node line/column helpers for decision-points.
+ */
+
+import { getNodeLine } from './ast-utils.js';
+
+/**
+ * For LogicalExpression (||, &&, ??), returns the line where the operator
+ * token lives.
+ * @param {Object} node - LogicalExpression AST node
+ * @returns {number|null} 1-based line of the operator, or null
+ */
+export function getLogicalExpressionOperatorLine(node) {
+  if (node.type !== 'LogicalExpression' || !node.left || !node.right) return null;
+  const leftEnd = node.left.loc && node.left.loc.end;
+  if (!leftEnd) return null;
+  return leftEnd.line;
+}
+
+/**
+ * For LogicalExpression, returns the column range of the operator.
+ * @param {Object} node - LogicalExpression AST node
+ * @returns {{ column: number, endColumn: number }|null} 0-based column range, or null
+ */
+export function getLogicalExpressionOperatorRange(node) {
+  if (node.type !== 'LogicalExpression' || !node.left || !node.right) return null;
+  const leftEnd = node.left.loc && node.left.loc.end;
+  const rightStart = node.right.loc && node.right.loc.start;
+  if (!leftEnd || !rightStart || leftEnd.line !== rightStart.line) return null;
+  return {
+    column: leftEnd.column,
+    endColumn: rightStart.column,
+  };
+}
+
+/**
+ * Gets the column range for an AST node (for within-line highlighting).
+ * For multi-line nodes, returns only the range on the start line.
+ * @param {Object} node - AST node
+ * @returns {{ column: number, endColumn: number }|null} 0-based column
+ */
+export function getNodeColumnRange(node) {
+  if (node.type === 'LogicalExpression') {
+    const opRange = getLogicalExpressionOperatorRange(node);
+    if (opRange) return opRange;
+  }
+  if (node.loc && node.loc.start && node.loc.end) {
+    const startLine = node.loc.start.line;
+    const endLine = node.loc.end.line;
+    
+    // For single-line nodes, use exact AST range
+    if (startLine === endLine) {
+      return {
+        column: node.loc.start.column,
+        endColumn: node.loc.end.column,
+      };
+    }
+    
+    // For multi-line nodes, return null (let multi-line logic handle it)
+    // This prevents invalid endColumn < column situations
+    return null;
+  }
+  return null;
+}
+
+/**
+ * Returns the report line for a decision point node.
+ * LogicalExpression uses operator line.
+ * @param {Object} node - AST node
+ * @returns {number} 1-based line
+ */
+export function getDecisionPointLineForNode(node) {
+  if (node.type === 'LogicalExpression') {
+    return getLogicalExpressionOperatorLine(node) ?? getNodeLine(node);
+  }
+  return getNodeLine(node);
+}
+
+/**
+ * Gets start/end line for a node's loc
+ * @param {Object} node - AST node
+ * @returns {{ startLine: number, endLine: number }|null} Line range or null
+ */
+export function getNodeLineRange(node) {
+  const startLine = node.loc && node.loc.start ? node.loc.start.line : null;
+  const endLine = node.loc && node.loc.end ? node.loc.end.line : null;
+  if (startLine == null || endLine == null) return null;
+  return { startLine, endLine };
+}

package/decision-points/parent-map.js

@@ -0,0 +1,62 @@
+/**
+ * Parent map building for AST nodes.
+ */
+
+import { shouldSkipKey } from './ast-utils.js';
+
+/**
+ * Processes an array of child nodes for parent map building
+ * @param {Array} array - Array of child nodes
+ * @param {Object} parent - Parent node
+ * @param {Map} parentMap - Parent map to update
+ * @param {Function} traverse - Traverse function to call recursively
+ */
+function processArrayChildrenForParentMap(array, parent, parentMap, traverse) {
+  array.forEach(item => {
+    if (item && typeof item === 'object' && item.type) {
+      traverse(item, parent);
+    }
+  });
+}
+
+/**
+ * Processes a single child node for parent map building
+ * @param {Object} child - Child node
+ * @param {Object} parent - Parent node
+ * @param {Function} traverse - Traverse function to call recursively
+ */
+function processChildNodeForParentMap(child, parent, traverse) {
+  if (child && typeof child === 'object' && child.type) {
+    traverse(child, parent);
+  }
+}
+
+/**
+ * Builds a parent map for AST nodes
+ * @param {Object} ast - Root AST node
+ * @returns {Map} Map of node to parent node
+ */
+export function buildParentMap(ast) {
+  const parentMap = new Map();
+
+  function traverse(node, parent = null) {
+    if (!node || typeof node !== 'object') return;
+
+    if (node.type) {
+      parentMap.set(node, parent);
+    }
+
+    for (const key in node) {
+      if (shouldSkipKey(key)) continue;
+      const child = node[key];
+      if (Array.isArray(child)) {
+        processArrayChildrenForParentMap(child, node, parentMap, traverse);
+      } else {
+        processChildNodeForParentMap(child, node, traverse);
+      }
+    }
+  }
+
+  traverse(ast);
+  return parentMap;
+}

package/decision-points/parse-main.js

@@ -0,0 +1,101 @@
+/**
+ * Core parse logic: orchestrates AST parsing and decision point extraction.
+ */
+
+import { parseAST, collectNodesByType, findAllFunctions } from './ast-utils.js';
+import { buildParentMap } from './parent-map.js';
+import { getDecisionPointType } from './decision-type.js';
+import { findFunctionForDecisionPoint } from './function-matching.js';
+import { matchFunctionsToAST } from './function-matching.js';
+import { getDecisionPointLineForNode, getNodeColumnRange } from './node-helpers.js';
+import { buildDecisionPointEntries } from './ternary-multiline.js';
+
+/**
+ * Parses decision points from source code using ESLint's AST
+ * @param {string} sourceCode - Full source code
+ * @param {Map} _functionBoundaries - Map (not used in AST approach)
+ * @param {Array} functions - Function objects with line numbers
+ * @param {string} filePath - Path to the file
+ * @param {string} _projectRoot - Root directory of the project
+ * @param {{ variant?: 'classic' | 'modified' }} [options] - Options.
+ *   variant: classic = each switch case +1; modified = whole switch +1.
+ *   Defaults to 'classic'.
+ * @returns {Promise<Array>} Array of decision point objects
+ */
+export async function parseDecisionPointsAST(
+  sourceCode,
+  _functionBoundaries,
+  functions,
+  filePath,
+  _projectRoot,
+  options = {}
+) {
+  const variant = options.variant === 'modified' ? 'modified' : 'classic';
+
+  try {
+    const ast = parseAST(sourceCode, filePath);
+    if (!ast) {
+      return [];
+    }
+
+    const astFunctions = findAllFunctions(ast);
+    const astToEslintMap = matchFunctionsToAST(astFunctions, functions, sourceCode);
+
+    if (astToEslintMap.size === 0) {
+      return [];
+    }
+
+    const parentMap = buildParentMap(ast);
+
+    const decisionPointNodeTypes = [
+      'IfStatement',
+      'ForStatement',
+      'ForInStatement',
+      'ForOfStatement',
+      'WhileStatement',
+      'DoWhileStatement',
+      ...(variant === 'modified' ? ['SwitchStatement'] : ['SwitchCase']),
+      'CatchClause',
+      'ConditionalExpression',
+      'LogicalExpression',
+      'ChainExpression',
+      'MemberExpression',
+      'BinaryExpression',
+      'AssignmentPattern',
+    ];
+
+    const allNodes = [];
+    decisionPointNodeTypes.forEach(type => {
+      collectNodesByType(ast, type, allNodes);
+    });
+
+    const decisionPoints = [];
+    const lines = sourceCode.split('\n');
+    allNodes.forEach(node => {
+      const decisionType = getDecisionPointType(node, parentMap, ast, variant);
+      if (!decisionType) return;
+      const functionLine = findFunctionForDecisionPoint(
+        node,
+        astFunctions,
+        astToEslintMap
+      );
+      if (functionLine === null) return;
+      const line = getDecisionPointLineForNode(node);
+      const columnRange = getNodeColumnRange(node);
+      const entries = buildDecisionPointEntries(
+        node,
+        decisionType,
+        functionLine,
+        line,
+        columnRange,
+        lines
+      );
+      decisionPoints.push(...entries);
+    });
+
+    return decisionPoints;
+  } catch (error) {
+    console.error(`Error parsing AST for ${filePath}:`, error.message);
+    return [];
+  }
+}