Refactor ScoreCalculator to streamline metric calculations and improve score mapping

- Enhanced the `ScoreCalculator` class by introducing dedicated methods for retrieving count values and setting score values based on metric fields, improving code clarity and maintainability.
- Implemented a switch expression for `GetCountValue` to simplify the retrieval of metric counts, and added reflection-based methods for dynamic property access.
- Updated unit tests to ensure comprehensive coverage of the new score calculation logic, validating the correct mapping of known count metrics.
- Aimed to optimize the cognitive analysis process and enhance the accuracy of score calculations.

Author: floriankraemer

CognitiveCodeAnalysis.Tests/src/CognitiveAnalysis/ScoreCalculatorTests.cs

@@ -146,6 +146,46 @@ public void CalculateScoresWithValidMetric()
         }
     }
 
+    [Test]
+    public void CalculateScores_MapsAllRemainingKnownCountMetrics()
+    {
+        var metrics = new CognitiveMetrics(
+            methodName: "TestMethod",
+            className: "TestClass",
+            filePath: "TestFile.cs",
+            methodSignature: "TestMethod()",
+            methodLineNumber: 1,
+            loopCount: 5,
+            switchCount: 3,
+            tryCatchCount: 2,
+            nestingLevels: 4,
+            fieldAccessCount: 6
+        );
+
+        var configuration = new CognitiveConfiguration
+        {
+            Metrics = new Dictionary<string, MetricConfiguration>
+            {
+                { "loopCount", new MetricConfiguration { Scale = 1.0, Threshold = 2, Enabled = true } },
+                { "switchCount", new MetricConfiguration { Scale = 1.0, Threshold = 1, Enabled = true } },
+                { "tryCatchCount", new MetricConfiguration { Scale = 1.0, Threshold = 1, Enabled = true } },
+                { "nestingLevels", new MetricConfiguration { Scale = 1.0, Threshold = 2, Enabled = true } },
+                { "fieldAccessCount", new MetricConfiguration { Scale = 5.0, Threshold = 2, Enabled = true } },
+            }
+        };
+
+        new ScoreCalculator().CalculateScores(metrics, configuration);
+
+        using (Assert.EnterMultipleScope())
+        {
+            Assert.That(metrics.loopScore, Is.EqualTo(Math.Log(1 + (5.0 - 2.0) / 1.0)));
+            Assert.That(metrics.switchScore, Is.EqualTo(Math.Log(1 + (3.0 - 1.0) / 1.0)));
+            Assert.That(metrics.tryCatchScore, Is.EqualTo(Math.Log(1 + (2.0 - 1.0) / 1.0)));
+            Assert.That(metrics.nestingScore, Is.EqualTo(Math.Log(1 + (4.0 - 2.0) / 1.0)));
+            Assert.That(metrics.fieldAccessScore, Is.EqualTo(Math.Log(1 + (6.0 - 2.0) / 5.0)));
+        }
+    }
+
     private static CognitiveConfiguration GetConfiguration()
     {
         CognitiveConfiguration configuration = new()

CognitiveCodeAnalysis/src/CognitiveAnalysis/ScoreCalculator.cs

@@ -23,48 +23,87 @@ public CognitiveMetrics CalculateScores(CognitiveMetrics metrics, CognitiveConfi
     private static CognitiveMetrics CalculateMetric(
         CognitiveMetrics metrics,
         KeyValuePair<string, MetricConfiguration> keyValuePair
-    )
-    {
+    ) {
         if (!keyValuePair.Value.Enabled)
         {
             return metrics;
         }
 
         string metricField = keyValuePair.Key;
+        double count = GetCountValue(metrics, metricField);
+        double score = CalculateLogWeight(
+            value: count,
+            threshold: keyValuePair.Value.Threshold,
+            scale: keyValuePair.Value.Scale
+        );
+        SetScoreValue(metrics, metricField, score);
 
-        // Convert metric key to PascalCase property name (simple conversion)
-        string countPropertyName = ToPascalCase(metricField);
+        return metrics;
+    }
+
+    private static double GetCountValue(CognitiveMetrics metrics, string metricField) => metricField switch
+    {
+        "ifCount" => metrics.ifCount,
+        "elseCount" => metrics.elseCount,
+        "loopCount" => metrics.loopCount,
+        "switchCount" => metrics.switchCount,
+        "tryCatchCount" => metrics.tryCatchCount,
+        "returnCount" => metrics.returnCount,
+        "argumentCount" => metrics.argumentCount,
+        "nestingLevels" => metrics.nestingLevels,
+        "linesOfCode" => metrics.linesOfCode,
+        "localVariableCount" => metrics.localVariableCount,
+        "fieldAccessCount" => metrics.fieldAccessCount,
+        "propertyAccessCount" => metrics.propertyAccessCount,
+        "cyclomaticComplexity" => metrics.cyclomaticComplexity,
+        _ => GetCountViaReflection(metrics, metricField)
+    };
+
+    private static void SetScoreValue(CognitiveMetrics metrics, string metricField, double score)
+    {
+        switch (metricField)
+        {
+            case "ifCount": metrics.ifScore = score; break;
+            case "elseCount": metrics.elseScore = score; break;
+            case "loopCount": metrics.loopScore = score; break;
+            case "switchCount": metrics.switchScore = score; break;
+            case "tryCatchCount": metrics.tryCatchScore = score; break;
+            case "returnCount": metrics.returnScore = score; break;
+            case "argumentCount": metrics.argumentScore = score; break;
+            case "nestingLevels": metrics.nestingScore = score; break;
+            case "linesOfCode": metrics.linesOfCodeScore = score; break;
+            case "localVariableCount": metrics.localVariableScore = score; break;
+            case "fieldAccessCount": metrics.fieldAccessScore = score; break;
+            case "propertyAccessCount": metrics.propertyAccessScore = score; break;
+            default: SetScoreViaReflection(metrics, metricField, score); break;
+        }
+    }
 
+    private static double GetCountViaReflection(CognitiveMetrics metrics, string metricField)
+    {
+        string countPropertyName = ToPascalCase(metricField);
         Type metricsType = metrics.GetType();
 
-        // Try property first (PascalCase), otherwise try field (original key, camelCase)
         PropertyInfo? countProperty = metricsType.GetProperty(countPropertyName, BindingFlags.Public | BindingFlags.Instance);
         FieldInfo? countField = metricsType.GetField(metricField, BindingFlags.Public | BindingFlags.Instance);
 
         if (countProperty == null && countField == null)
         {
-            return metrics;
+            return 0.0;
         }
 
         object? countValue = countProperty != null
             ? countProperty.GetValue(metrics)
             : countField?.GetValue(metrics);
 
-        if (countValue == null)
-        {
-            return metrics;
-        }
-
-        double count = Convert.ToDouble(countValue);
-        double score = CalculateLogWeight(
-            value: count,
-            threshold: keyValuePair.Value.Threshold,
-            scale: keyValuePair.Value.Scale
-        );
+        return countValue == null ? 0.0 : Convert.ToDouble(countValue);
+    }
 
-        // Set score to property/field with same name but "Score" suffix (e.g., "ifCount" -> "ifScore" or "IfScore")
+    private static void SetScoreViaReflection(CognitiveMetrics metrics, string metricField, double score)
+    {
         string scoreFieldName = GetScoreFieldName(metricField);
         string scorePropertyName = ToPascalCase(scoreFieldName);
+        Type metricsType = metrics.GetType();
 
         PropertyInfo? scoreProperty = metricsType.GetProperty(scorePropertyName, BindingFlags.Public | BindingFlags.Instance);
         FieldInfo? scoreField = metricsType.GetField(scoreFieldName, BindingFlags.Public | BindingFlags.Instance);
@@ -77,15 +116,9 @@ KeyValuePair<string, MetricConfiguration> keyValuePair
         {
             scoreField.SetValue(metrics, score);
         }
-
-        return metrics;
     }
 
-    private static double CalculateLogWeight(
-        double value,
-        double threshold,
-        double scale = 1.0
-    )
+    private static double CalculateLogWeight(double value, double threshold, double scale = 1.0)
     {
         if (value <= threshold) return 0.0;
 

CognitiveCodeAnalysisConsoleApp/src/Progress/SpectreAnalysisProgressReporter.cs

@@ -229,6 +229,9 @@ private void UpdateSpectreTasks(AnalysisProgress update)
                             State.ReportDescription ?? "Writing report",
                             maxValue: State.ReportMaxValue
                         );
+                        // Expire the throttle so ShouldRefresh returns true immediately,
+                        // ensuring the progress bar appears at 0% before items process.
+                        _lastRefreshTick = 0;
                     }
 
                     if (_reportTask != null)

CognitiveCodeAnalysisConsoleApp/src/Progress/SpectreProgressSession.cs

@@ -10,12 +10,24 @@ namespace CognitiveCodeAnalysisConsoleApp.Progress;
 
 internal static class SpectreProgressSession
 {
+    /// <summary>
+    /// Synchronous IProgress adapter that invokes the reporter directly on the calling thread,
+    /// avoiding the async thread-pool dispatch of <see cref="Progress{T}"/>. This ensures the
+    /// Spectre progress state is always up-to-date before <see cref="SpectreAnalysisProgressReporter.FinalizeSession"/>
+    /// is called, and prevents progress events from being lost when work completes faster than
+    /// the thread pool can drain its queue.
+    /// </summary>
+    private sealed class SynchronousProgress(SpectreAnalysisProgressReporter reporter) : IProgress<AnalysisProgress>
+    {
+        public void Report(AnalysisProgress value) => reporter.Report(value);
+    }
+
     public static void Run(Action<SpectreAnalysisProgressReporter, IProgress<AnalysisProgress>> action)
     {
         if (!AnsiConsole.Profile.Capabilities.Interactive)
         {
             var silentReporter = new SpectreAnalysisProgressReporter();
-            var silentProgress = new Progress<AnalysisProgress>(silentReporter.Report);
+            var silentProgress = new SynchronousProgress(silentReporter);
             action(silentReporter, silentProgress);
             silentReporter.FinalizeSession();
             silentReporter.FlushPendingMessages();
@@ -37,7 +49,7 @@ public static void Run(Action<SpectreAnalysisProgressReporter, IProgress<Analysi
             {
                 reporter = new SpectreAnalysisProgressReporter();
                 reporter.Attach(ctx);
-                var progress = new Progress<AnalysisProgress>(reporter.Report);
+                var progress = new SynchronousProgress(reporter);
                 action(reporter, progress);
                 reporter.FinalizeSession();
             });