@angular-modernizer/api 0.1.0

package/src/metrics/complexity-metrics.ts

@@ -0,0 +1,617 @@
+/**
+ * @angular-modernizer/api - Complexity Metrics
+ *
+ * Calculates code complexity metrics for Angular components and services.
+ * Helps identify candidates for refactoring.
+ *
+ * Analyzes:
+ * - Cyclomatic complexity for control flow complexity
+ * - Lines of code and method count for size metrics
+ * - Dependency count for coupling analysis
+ * - Additional Angular-specific metrics (template complexity, lifecycle method usage)
+ */
+
+import {
+  type SourceFile,
+  SyntaxKind,
+  type ClassDeclaration,
+  ClassDeclaration as ClassDeclarationClass,
+  type MethodDeclaration,
+} from 'ts-morph';
+
+/**
+ * Complexity metrics for a source file.
+ */
+export interface ComplexityMetrics {
+  /**
+   * Cyclomatic complexity.
+   */
+  cyclomaticComplexity: number;
+
+  /**
+   * Lines of code.
+   */
+  linesOfCode: number;
+
+  /**
+   * Number of methods/functions.
+   */
+  methodCount: number;
+
+  /**
+   * Number of dependencies.
+   */
+  dependencyCount: number;
+
+  /**
+   * Additional metrics.
+   */
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * Angular-specific metrics for components and directives.
+ */
+export interface AngularMetrics {
+  /**
+   * Number of lifecycle hooks (ngOnInit, ngOnDestroy, etc.).
+   */
+  lifecycleHooks: number;
+
+  /**
+   * Number of @Input properties.
+   */
+  inputs: number;
+
+  /**
+   * Number of @Output properties.
+   */
+  outputs: number;
+
+  /**
+   * Number of Angular decorators (@Component, @Directive, etc.).
+   */
+  decorators: number;
+
+  /**
+   * Template complexity score (structural directives, bindings, etc.).
+   */
+  templateComplexity?: number;
+}
+
+/**
+ * Complexity Metrics Calculator.
+ */
+export class ComplexityMetricsCalculator {
+  /**
+   * Calculate overall complexity score for a class (0-100 scale).
+   *
+   * Combines multiple metrics:
+   * - Cyclomatic complexity
+   * - Lines of code
+   * - Method count
+   * - Angular-specific complexity
+   *
+   * @param classDecl - The class declaration to analyze
+   * @returns Complexity score (0-100)
+   */
+  calculateOverallComplexity(classDecl: ClassDeclaration): number {
+    const cyclomatic = this.calculateCyclomaticComplexity(classDecl);
+    const loc = this.calculateLOC(classDecl.getSourceFile());
+    const methods = this.calculateMethodCount(classDecl);
+    const angularMetrics = this.calculateAngularSpecificMetrics(classDecl);
+
+    // Weighted formula for overall complexity
+    const score =
+      cyclomatic * 0.4 +
+      (loc / 10) * 0.2 +
+      methods * 2 * 0.2 +
+      (angularMetrics.lifecycleHooks +
+        angularMetrics.inputs +
+        angularMetrics.outputs) *
+        1.5 *
+        0.2;
+
+    return Math.min(100, Math.max(0, score));
+  }
+
+  /**
+   * Calculate cyclomatic complexity for a class.
+   *
+   * Measures the number of linearly independent paths through the code.
+   * Higher values indicate more complex control flow.
+   *
+   * @param classDecl - The class declaration
+   * @returns Cyclomatic complexity score
+   */
+  calculateCyclomaticComplexity(classDecl: ClassDeclaration): number;
+  calculateCyclomaticComplexity(method: MethodDeclaration): number;
+  calculateCyclomaticComplexity(
+    node: ClassDeclaration | MethodDeclaration,
+  ): number {
+    let complexity = 1; // Base complexity
+
+    if (node instanceof ClassDeclarationClass) {
+      const methods = node.getMethods();
+      for (const method of methods) {
+        complexity += this.calculateMethodComplexity(method);
+      }
+    } else {
+      complexity = this.calculateMethodComplexity(node);
+    }
+
+    return complexity;
+  }
+
+  /**
+   * Calculate cyclomatic complexity for a single method.
+   */
+  private calculateMethodComplexity(method: MethodDeclaration): number {
+    let complexity = 1; // Base complexity
+
+    // Count control flow statements
+    const statements = method.getStatements();
+    for (const statement of statements) {
+      const text = statement.getText();
+
+      // Count if statements (including else if)
+      const ifMatches = text.match(/\bif\s*\(/g);
+      if (ifMatches) {
+        complexity += ifMatches.length;
+      }
+
+      // Count loops
+      const loopMatches = text.match(/\b(for|while|do)\s*\(/g);
+      if (loopMatches) {
+        complexity += loopMatches.length;
+      }
+
+      // Count switch cases
+      const caseMatches = text.match(/\bcase\s+/g);
+      if (caseMatches) {
+        complexity += caseMatches.length;
+      }
+
+      // Count ternary operators
+      const ternaryMatches = text.match(/\?/g);
+      if (ternaryMatches) {
+        complexity += ternaryMatches.length;
+      }
+
+      // Count logical operators (&&, ||)
+      const logicalMatches = text.match(/(&&|\|\|)/g);
+      if (logicalMatches) {
+        complexity += logicalMatches.length;
+      }
+    }
+
+    return complexity;
+  }
+
+  /**
+   * Calculate lines of code for a source file.
+   *
+   * Excludes comments and whitespace for meaningful LOC count.
+   *
+   * @param sourceFile - The source file
+   * @returns Number of lines of code
+   */
+  calculateLOC(sourceFile: SourceFile): number {
+    const text = sourceFile.getText();
+    const lines = text.split('\n');
+
+    let loc = 0;
+    for (const line of lines) {
+      const trimmed = line.trim();
+      // Count non-empty, non-comment lines
+      if (
+        trimmed &&
+        !trimmed.startsWith('//') &&
+        !trimmed.startsWith('/*') &&
+        !trimmed.startsWith('*')
+      ) {
+        loc++;
+      }
+    }
+
+    return loc;
+  }
+
+  /**
+   * Calculate the number of methods in a class.
+   * Includes methods, getters, and setters.
+   *
+   * @param classDecl - The class declaration
+   * @returns Number of methods (including accessors)
+   */
+  calculateMethodCount(classDecl: ClassDeclaration): number {
+    const methods = classDecl.getMethods().length;
+    const getters = classDecl.getGetAccessors().length;
+    const setters = classDecl.getSetAccessors().length;
+    return methods + getters + setters;
+  }
+
+  /**
+   * Calculate dependency count for a source file.
+   *
+   * Counts all import declarations (including duplicates).
+   *
+   * @param sourceFile - The source file
+   * @returns Number of import declarations
+   */
+  calculateDependencyCount(sourceFile: SourceFile): number {
+    return sourceFile.getImportDeclarations().length;
+  }
+
+  /**
+   * Calculate Angular-specific metrics for a class.
+   *
+   * Analyzes Angular decorators and patterns.
+   *
+   * @param classDecl - The class declaration
+   * @returns Angular-specific metrics
+   */
+  calculateAngularSpecificMetrics(classDecl: ClassDeclaration): AngularMetrics {
+    const metrics = {
+      lifecycleHooks: 0,
+      inputs: 0,
+      outputs: 0,
+      decorators: 0,
+      templateComplexity: 0,
+    };
+
+    const lifecycleHookNames = new Set([
+      'ngOnInit',
+      'ngOnDestroy',
+      'ngOnChanges',
+      'ngDoCheck',
+      'ngAfterContentInit',
+      'ngAfterContentChecked',
+      'ngAfterViewInit',
+      'ngAfterViewChecked',
+    ]);
+
+    const angularTypes = new Set(['Component', 'Directive']);
+
+    // Count Angular decorators and analyze Component/Directive classes
+    classDecl.getDecorators().forEach((decorator) => {
+      const name = decorator.getName();
+      metrics.decorators++;
+
+      if (!angularTypes.has(name)) {
+        return;
+      }
+
+      // Count lifecycle hook methods
+      metrics.lifecycleHooks += classDecl
+        .getMethods()
+        .filter((method) => lifecycleHookNames.has(method.getName())).length;
+
+      // Count @Input decorators on properties and setters
+      const countInputOutput = (
+        nodes: { getDecorators: () => { getName: () => string }[] }[],
+      ) => {
+        nodes.forEach((node) => {
+          node.getDecorators().forEach((dec) => {
+            const decName = dec.getName();
+            if (decName === 'Input') {
+              metrics.inputs++;
+            }
+            if (decName === 'Output') {
+              metrics.outputs++;
+            }
+          });
+        });
+      };
+
+      countInputOutput(classDecl.getProperties());
+      countInputOutput(classDecl.getSetAccessors());
+
+      // Calculate template complexity for components only
+      if (name === 'Component') {
+        metrics.templateComplexity =
+          this.calculateTemplateComplexity(classDecl);
+      }
+    });
+
+    return metrics;
+  }
+
+  /**
+   * Calculate complexity metrics for a source file.
+   *
+   * @param sourceFile - The source file to analyze
+   * @returns Complexity metrics
+   *
+   * Calculates actual metrics using ts-morph AST analysis:
+   * - Cyclomatic complexity: count decision points (if, for, while, case, &&, ||, ?)
+   * - Lines of code: count non-empty, non-comment lines
+   * - Method count: count function/method declarations
+   * - Dependency count: analyze constructor parameters and property injections
+   */
+  calculate(sourceFile: SourceFile): ComplexityMetrics {
+    const cyclomaticComplexity =
+      this.calculateCyclomaticComplexitySourceFile(sourceFile);
+    const linesOfCode = this.calculateLinesOfCode(sourceFile);
+    const methodCount = this.calculateMethodCountSourceFile(sourceFile);
+    const dependencyCount = this.calculateDependencyCount(sourceFile);
+
+    // Angular-specific metrics
+    const metadata: Record<string, unknown> = {
+      ...this.calculateAngularMetrics(sourceFile),
+    };
+
+    return {
+      cyclomaticComplexity,
+      linesOfCode,
+      methodCount,
+      dependencyCount,
+      metadata,
+    };
+  }
+
+  /**
+   * Calculate cyclomatic complexity for a source file.
+   * Counts decision points: if, for, while, do-while, case, catch, &&, ||, ?
+   *
+   * @param sourceFile - The source file
+   * @returns Cyclomatic complexity value
+   */
+  private calculateCyclomaticComplexitySourceFile(
+    sourceFile: SourceFile,
+  ): number {
+    let complexity = 1; // Base complexity
+
+    // Decision point node types
+    const decisionPoints = new Set([
+      SyntaxKind.IfStatement,
+      SyntaxKind.ForStatement,
+      SyntaxKind.ForInStatement,
+      SyntaxKind.ForOfStatement,
+      SyntaxKind.WhileStatement,
+      SyntaxKind.DoStatement,
+      SyntaxKind.CaseClause,
+      SyntaxKind.CatchClause,
+      SyntaxKind.ConditionalExpression, // ternary operator
+    ]);
+
+    const logicalOperators = new Set([
+      SyntaxKind.AmpersandAmpersandToken,
+      SyntaxKind.BarBarToken,
+    ]);
+
+    // Count decision points and logical operators
+    sourceFile.forEachDescendant((node) => {
+      const kind = node.getKind();
+
+      if (decisionPoints.has(kind)) {
+        complexity++;
+        return;
+      }
+
+      // Count logical operators (&&, ||) in binary expressions
+      if (kind === SyntaxKind.BinaryExpression) {
+        const operator = node
+          .asKind(SyntaxKind.BinaryExpression)
+          ?.getOperatorToken()
+          .getKind();
+        if (operator && logicalOperators.has(operator)) {
+          complexity++;
+        }
+      }
+    });
+
+    return complexity;
+  }
+
+  /**
+   * Calculate lines of code (excluding comments and whitespace).
+   *
+   * @param sourceFile - The source file
+   * @returns Lines of code count
+   */
+  private calculateLinesOfCode(sourceFile: SourceFile): number {
+    const text = sourceFile.getFullText();
+    const lines = text.split('\n');
+
+    let inBlockComment = false;
+
+    return lines.reduce((loc, line) => {
+      const trimmed = line.trim();
+
+      // Track block comment state
+      if (trimmed.startsWith('/*')) {
+        inBlockComment = true;
+      }
+
+      // Skip lines inside block comments
+      if (inBlockComment) {
+        if (trimmed.endsWith('*/')) {
+          inBlockComment = false;
+        }
+        return loc;
+      }
+
+      // Skip empty lines and single-line comments, count everything else
+      return trimmed.length === 0 || trimmed.startsWith('//') ? loc : loc + 1;
+    }, 0);
+  }
+
+  /**
+   * Calculate method/function count.
+   *
+   * @param sourceFile - The source file
+   * @returns Method count
+   */
+  private calculateMethodCountSourceFile(sourceFile: SourceFile): number {
+    let count = 0;
+
+    sourceFile.forEachDescendant((node) => {
+      const kind = node.getKind();
+      if (
+        kind === SyntaxKind.MethodDeclaration ||
+        kind === SyntaxKind.FunctionDeclaration ||
+        kind === SyntaxKind.FunctionExpression ||
+        kind === SyntaxKind.ArrowFunction ||
+        kind === SyntaxKind.GetAccessor ||
+        kind === SyntaxKind.SetAccessor
+      ) {
+        count++;
+      }
+    });
+
+    return count;
+  }
+
+  /**
+   * Calculate Angular-specific metrics.
+   *
+   * @param sourceFile - The source file
+   * @returns Angular-specific metrics
+   */
+  private calculateAngularMetrics(
+    sourceFile: SourceFile,
+  ): Record<string, unknown> {
+    const metrics: Record<string, unknown> = {
+      lifecycleHookCount: 0,
+      inputCount: 0,
+      outputCount: 0,
+      templateComplexity: 0,
+    };
+
+    const classes = sourceFile.getClasses();
+
+    for (const classDecl of classes) {
+      // Count lifecycle hooks
+      metrics['lifecycleHookCount'] =
+        (metrics['lifecycleHookCount'] as number) +
+        this.countLifecycleHooks(classDecl);
+
+      // Count @Input and @Output decorators
+      const { inputCount, outputCount } = this.countInputsAndOutputs(classDecl);
+      metrics['inputCount'] = (metrics['inputCount'] as number) + inputCount;
+      metrics['outputCount'] = (metrics['outputCount'] as number) + outputCount;
+
+      // Calculate template complexity (if component)
+      const templateComplexity = this.calculateTemplateComplexity(classDecl);
+      metrics['templateComplexity'] =
+        (metrics['templateComplexity'] as number) + templateComplexity;
+    }
+
+    return metrics;
+  }
+
+  /**
+   * Count lifecycle hook methods in a class.
+   *
+   * @param classDecl - The class declaration
+   * @returns Count of lifecycle hooks
+   */
+  private countLifecycleHooks(classDecl: ClassDeclaration): number {
+    const lifecycleHooks = [
+      'ngOnInit',
+      'ngOnDestroy',
+      'ngOnChanges',
+      'ngDoCheck',
+      'ngAfterContentInit',
+      'ngAfterContentChecked',
+      'ngAfterViewInit',
+      'ngAfterViewChecked',
+    ];
+
+    let count = 0;
+    const methods = classDecl.getMethods();
+
+    for (const method of methods) {
+      if (lifecycleHooks.includes(method.getName())) {
+        count++;
+      }
+    }
+
+    return count;
+  }
+
+  /**
+   * Count @Input and @Output decorators in a class.
+   *
+   * @param classDecl - The class declaration
+   * @returns Input and output counts
+   */
+  private countInputsAndOutputs(classDecl: ClassDeclaration): {
+    inputCount: number;
+    outputCount: number;
+  } {
+    let inputCount = 0;
+    let outputCount = 0;
+
+    // Helper to count decorators by name
+    const countDecorators = (
+      nodes: { getDecorators: () => { getName: () => string }[] }[],
+      decoratorName: string,
+    ): number => {
+      return nodes.reduce((count, node) => {
+        return (
+          count +
+          node.getDecorators().filter((d) => d.getName() === decoratorName)
+            .length
+        );
+      }, 0);
+    };
+
+    // Count @Input on properties and setters
+    inputCount =
+      countDecorators(classDecl.getProperties(), 'Input') +
+      countDecorators(classDecl.getSetAccessors(), 'Input');
+
+    // Count @Output on properties
+    outputCount = countDecorators(classDecl.getProperties(), 'Output');
+
+    return { inputCount, outputCount };
+  }
+
+  /**
+   * Calculate template complexity for a component.
+   * Looks for inline templates in @Component decorator.
+   *
+   * @param classDecl - The class declaration
+   * @returns Template complexity score
+   */
+  private calculateTemplateComplexity(classDecl: ClassDeclaration): number {
+    const componentDecorator = classDecl
+      .getDecorators()
+      .find((d) => d.getName() === 'Component');
+
+    if (!componentDecorator) {
+      return 0;
+    }
+
+    const decoratorText = componentDecorator.getText();
+
+    // Extract inline template
+    const templateMatch = /template\s*:\s*`([^`]*)`/s.exec(decoratorText);
+    if (!templateMatch?.[1]) {
+      return 0;
+    }
+
+    const template = templateMatch[1];
+
+    // Count complexity indicators in template
+    let complexity = 0;
+
+    // Structural directives
+    complexity += (template.match(/\*ngIf/g) ?? []).length;
+    complexity += (template.match(/\*ngFor/g) ?? []).length;
+    complexity += (template.match(/\*ngSwitch/g) ?? []).length;
+
+    // Event bindings
+    complexity += (template.match(/\([a-zA-Z]+\)/g) ?? []).length;
+
+    // Property bindings
+    complexity += (template.match(/\[[a-zA-Z]+\]/g) ?? []).length;
+
+    // Pipes (complexity factor)
+    complexity += (template.match(/\|/g) ?? []).length;
+
+    return complexity;
+  }
+}