fix: Update complexity calculations in CSharpMetricsAnalyzer (#115)

Signed-off-by: André Silva <[email protected]>

Author: askpt

package-lock.json

@@ -338,8 +338,10 @@ export class CSharpMetricsAnalyzer {
    * @param node - The current syntax node being visited
    */
   private visit(node: Parser.SyntaxNode): void {
-    const increment = this.getComplexityIncrement(node);
-    if (increment > 0) {
+    const baseIncrement = this.getComplexityIncrement(node);
+    if (baseIncrement > 0) {
+      // Add nesting level to the increment for cognitive complexity
+      const increment = baseIncrement + this.nesting;
       const reason = this.getComplexityReason(node);
       this.complexity += increment;
 

src/metricsAnalyzer/languages/csharpAnalyzer.ts

@@ -68,8 +68,8 @@ suite("CSharp Metrics Analyzer Tests", () => {
 
       assert.strictEqual(results.length, 1);
       assert.strictEqual(results[0].name, "Process");
-      // Expected complexity: if(1) + for(1) + nested if(1) + nested continue(1) = 4
-      assert.strictEqual(results[0].complexity, 4);
+      // Expected complexity: if(1) + for(2) + nested if(3) + nested continue(4) = 10
+      assert.strictEqual(results[0].complexity, 10);
       assert.strictEqual(results[0].details.length, 4);
     });
   });
@@ -88,7 +88,7 @@ suite("CSharp Metrics Analyzer Tests", () => {
 
       const results = analyzer.analyzeFunctions(sourceCode);
 
-      assert.strictEqual(results[0].complexity, 2);
+      assert.strictEqual(results[0].complexity, 3);
       assert.strictEqual(results[0].details[0].reason, "while loop");
       assert.strictEqual(
         results[0].details[1].reason,
@@ -186,7 +186,7 @@ suite("CSharp Metrics Analyzer Tests", () => {
 
       const results = analyzer.analyzeFunctions(sourceCode);
 
-      assert.strictEqual(results[0].complexity, 2);
+      assert.strictEqual(results[0].complexity, 3);
       assert.strictEqual(results[0].details.length, 2);
 
       const tryDetail = results[0].details.find(
@@ -219,7 +219,7 @@ suite("CSharp Metrics Analyzer Tests", () => {
 
       const results = analyzer.analyzeFunctions(sourceCode);
 
-      assert.strictEqual(results[0].complexity, 3); // try + 2 catches
+      assert.strictEqual(results[0].complexity, 5); // try(1) + catch1(2) + catch2(2)
       assert.strictEqual(results[0].details.length, 3);
     });
   });
@@ -316,8 +316,8 @@ suite("CSharp Metrics Analyzer Tests", () => {
 
       const results = analyzer.analyzeFunctions(sourceCode);
 
-      // Expected: if statement (1) + lambda in nested context (1) = 2
-      assert.strictEqual(results[0].complexity, 2);
+      // Expected: if statement (1) + lambda in nested context (2) = 3
+      assert.strictEqual(results[0].complexity, 3);
     });
 
     test("should not count lambda at top level", () => {
@@ -369,8 +369,8 @@ suite("CSharp Metrics Analyzer Tests", () => {
 
       const results = analyzer.analyzeFunctions(sourceCode);
 
-      // for (1) + nested if (1) + nested continue (1) = 3
-      assert.strictEqual(results[0].complexity, 3);
+      // for (1) + nested if (2) + nested continue (3) = 6
+      assert.strictEqual(results[0].complexity, 6);
     });
 
     test("should handle break in nested context", () => {
@@ -388,8 +388,8 @@ suite("CSharp Metrics Analyzer Tests", () => {
 
       const results = analyzer.analyzeFunctions(sourceCode);
 
-      // while (1) + nested if (1) + nested break (1) = 3
-      assert.strictEqual(results[0].complexity, 3);
+      // while (1) + nested if (2) + nested break (3) = 6
+      assert.strictEqual(results[0].complexity, 6);
     });
   });
 
@@ -473,7 +473,7 @@ suite("CSharp Metrics Analyzer Tests", () => {
       const results = analyzer.analyzeFunctions(sourceCode);
 
       assert.strictEqual(results.length, 1);
-      assert.strictEqual(results[0].complexity, 2); // if (+1) with logical OR (+1)
+      assert.strictEqual(results[0].complexity, 3); // if (1) + || nested in if condition (2)
     });
 
     test("should analyze local functions", () => {
@@ -590,7 +590,7 @@ suite("CSharp Metrics Analyzer Tests", () => {
       assert.ok(outerMethod);
       assert.ok(innerMethod);
       assert.strictEqual(outerMethod.complexity, 1);
-      assert.strictEqual(innerMethod.complexity, 2); // while loop + nested break
+      assert.strictEqual(innerMethod.complexity, 3); // while loop (1) + nested break (2)
     });
   });
 

src/test/metricsAnalyzer/languages/csharpAnalyzer.test.ts

@@ -107,7 +107,7 @@ suite("Metrics Analyzer Factory Tests", () => {
 
       assert.strictEqual(addFunction.complexity, 0);
       assert.strictEqual(divideFunction.complexity, 1); // if statement
-      assert.strictEqual(processFunction.complexity, 5); // if + || operator + foreach + nested if + nested continue
+      assert.strictEqual(processFunction.complexity, 9); // if(1) + ||(2) + foreach(1) + nested if(2) + nested continue(3)
     });
 
     test("should handle C# code with logical operators", () => {
@@ -152,7 +152,7 @@ suite("Metrics Analyzer Factory Tests", () => {
       const results = MetricsAnalyzerFactory.analyzeFile(sourceCode, "csharp");
 
       assert.strictEqual(results.length, 1);
-      assert.strictEqual(results[0].complexity, 3); // try + 2 catch blocks
+      assert.strictEqual(results[0].complexity, 5); // try(1) + catch(2) + catch(2)
 
       const tryDetail = results[0].details.find(
         (d) => d.reason === "try statement"
@@ -500,7 +500,7 @@ suite("Metrics Analyzer Factory Tests", () => {
 
       // ProcessData should have moderate complexity
       assert.ok(processDataFunction.complexity > 0);
-      assert.ok(processDataFunction.complexity < 10);
+      assert.ok(processDataFunction.complexity < 20);
 
       // IsComplexCondition should have high complexity due to nested conditions
       assert.ok(isComplexConditionFunction.complexity > 5);

src/test/metricsAnalyzer/metricsAnalyzerFactory.test.ts

@@ -68,7 +68,8 @@ describe("Core Logic Unit Tests (Node.js)", () => {
       const results = analyzer.analyzeFunctions(sourceCode);
 
       assert.strictEqual(results.length, 1);
-      assert.strictEqual(results[0].complexity, 4); // 2 ifs + 1 && + 1 ||
+      // 2 ifs (+1 each) + '&&' (+2 at nest 1) + '||' (+2 at nest 1) = 6
+      assert.strictEqual(results[0].complexity, 6);
     });
 
     it("should handle loops correctly", () => {