Refactor cognitive metrics and analysis to include additional metrics and improve score calculations

- Updated `cognitive-metrics-settings.json` to disable several metrics by default, including `variableCount`, `propertyCallCount`, `loopCount`, `switchCount`, and `tryCatchCount`.
- Enhanced `CognitiveCodeAnalyser` to utilize a `SemanticModel` for improved analysis, allowing for accurate counting of local variables, field accesses, and property accesses.
- Introduced new methods for counting loop statements and local variables, and updated the `AnalyseClasses` method to incorporate these metrics.
- Modified `ScoreCalculator` to resolve legacy metric aliases and ensure proper score calculations for new metrics.
- Added tests to validate the counting of loop statements, local variables, and field/property accesses, as well as the correct mapping of scores.
- Updated documentation to reflect changes in supported metric keys and their contributions to total scores.

Author: floriankraemer

CognitiveCodeAnalysis.Tests/src/CognitiveAnalysis/CognitiveAnalysisFacadeTests.cs

@@ -93,6 +93,7 @@ public void DoWork() {
         Assert.That(metrics.MethodName, Is.EqualTo("DoWork"));
         Assert.That(metrics.FilePath, Is.Not.Null.And.Not.Empty);
         Assert.That(metrics.linesOfCode, Is.GreaterThan(0));
+        Assert.That(metrics.ifCount, Is.EqualTo(1));
         Assert.That(metrics.cyclomaticComplexity, Is.GreaterThanOrEqualTo(2));
         Assert.That(metrics.Halstead, Is.Not.Null);
     }

CognitiveCodeAnalysis.Tests/src/CognitiveAnalysis/CognitiveCodeAnalyserTests.cs

@@ -0,0 +1,105 @@
+/// <copyright company="Florian Krämer">
+///     Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/// </copyright>
+
+using CognitiveCodeAnalysis.CognitiveAnalysis;
+using CognitiveCodeAnalysis.Configuration;
+
+namespace CognitiveCodeAnalysis.Tests.CognitiveAnalysis;
+
+public class CognitiveCodeAnalyserTests
+{
+    private CognitiveCodeAnalyser _analyser;
+    private CognitiveConfiguration _configuration;
+    private TempFiles _tempFiles;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _analyser = new CognitiveCodeAnalyser();
+        _configuration = new CognitiveConfiguration();
+        _tempFiles = new TempFiles();
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        _tempFiles.CleanUp();
+    }
+
+    [Test]
+    public void AnalyseFiles_CountsLoopAndSwitchStatements()
+    {
+        const string content = @"
+namespace X {
+    public class Y {
+        public void Run() {
+            for (int i = 0; i < 1; i++) { }
+            foreach (var item in new int[0]) { }
+            while (false) { }
+            do { } while (false);
+            switch (1) {
+                case 1: break;
+            }
+        }
+    }
+}";
+        string file = _tempFiles.CreateFileWithContent("Loops.cs", content);
+
+        var metrics = _analyser.AnalyseFiles([file], _configuration);
+
+        Assert.That(metrics.Count, Is.EqualTo(1));
+        using (Assert.EnterMultipleScope())
+        {
+            Assert.That(metrics.First().loopCount, Is.EqualTo(4));
+            Assert.That(metrics.First().switchCount, Is.EqualTo(1));
+        }
+    }
+
+    [Test]
+    public void AnalyseFiles_CountsLocalVariables()
+    {
+        const string content = @"
+namespace X {
+    public class Y {
+        public void Run(int arg) {
+            int a = 1;
+            var b = 2;
+            string c = ""x"";
+        }
+    }
+}";
+        string file = _tempFiles.CreateFileWithContent("Locals.cs", content);
+
+        var metrics = _analyser.AnalyseFiles([file], _configuration);
+
+        Assert.That(metrics.First().localVariableCount, Is.EqualTo(3));
+    }
+
+    [Test]
+    public void AnalyseFiles_CountsFieldAndPropertyAccesses()
+    {
+        const string content = @"
+namespace X {
+    public class Y {
+        private int _field;
+        public int Prop { get; set; }
+
+        public void Run() {
+            _field = 1;
+            Prop = 2;
+            int local = _field + Prop;
+        }
+    }
+}";
+        string file = _tempFiles.CreateFileWithContent("Members.cs", content);
+
+        var metrics = _analyser.AnalyseFiles([file], _configuration);
+
+        using (Assert.EnterMultipleScope())
+        {
+            Assert.That(metrics.First().fieldAccessCount, Is.EqualTo(2));
+            Assert.That(metrics.First().propertyAccessCount, Is.EqualTo(2));
+        }
+    }
+}

CognitiveCodeAnalysis.Tests/src/CognitiveAnalysis/ScoreCalculatorTests.cs

@@ -14,6 +14,99 @@ public void Setup()
     {
     }
 
+    [Test]
+    public void CalculateScores_MapsLinesOfCodeToScoreAndTotalScore()
+    {
+        var metrics = new CognitiveMetrics(
+            methodName: "TestMethod",
+            className: "TestClass",
+            filePath: "TestFile.cs",
+            methodSignature: "TestMethod()",
+            methodLineNumber: 10,
+            linesOfCode: 85
+        );
+
+        var configuration = new CognitiveConfiguration
+        {
+            Metrics = new Dictionary<string, MetricConfiguration>
+            {
+                { "linesOfCode", new MetricConfiguration { Scale = 25.0, Threshold = 60, Enabled = true } },
+            }
+        };
+
+        new ScoreCalculator().CalculateScores(metrics, configuration);
+
+        using (Assert.EnterMultipleScope())
+        {
+            Assert.That(metrics.linesOfCodeScore, Is.EqualTo(Math.Log(2)));
+            Assert.That(metrics.totalScore, Is.EqualTo(metrics.linesOfCodeScore));
+        }
+    }
+
+    [Test]
+    public void CalculateScores_ResolvesLegacyMetricAliases()
+    {
+        var metrics = new CognitiveMetrics(
+            methodName: "TestMethod",
+            className: "TestClass",
+            filePath: "TestFile.cs",
+            methodSignature: "TestMethod()",
+            methodLineNumber: 10,
+            localVariableCount: 5,
+            propertyAccessCount: 6
+        );
+
+        var configuration = new CognitiveConfiguration
+        {
+            Metrics = new Dictionary<string, MetricConfiguration>
+            {
+                { "variableCount", new MetricConfiguration { Scale = 5.0, Threshold = 4, Enabled = true } },
+                { "propertyCallCount", new MetricConfiguration { Scale = 15.0, Threshold = 4, Enabled = true } },
+            }
+        };
+
+        new ScoreCalculator().CalculateScores(metrics, configuration);
+
+        using (Assert.EnterMultipleScope())
+        {
+            Assert.That(metrics.localVariableScore, Is.EqualTo(Math.Log(1.2)));
+            Assert.That(metrics.propertyAccessScore, Is.EqualTo(Math.Log(1 + 2.0 / 15.0)));
+            Assert.That(metrics.totalScore, Is.EqualTo(metrics.localVariableScore + metrics.propertyAccessScore));
+        }
+    }
+
+    [Test]
+    public void CalculateScores_DisabledMetricsDoNotContribute()
+    {
+        var metrics = new CognitiveMetrics(
+            methodName: "TestMethod",
+            className: "TestClass",
+            filePath: "TestFile.cs",
+            methodSignature: "TestMethod()",
+            methodLineNumber: 10,
+            localVariableCount: 10,
+            fieldAccessCount: 10
+        );
+
+        var configuration = new CognitiveConfiguration
+        {
+            Metrics = new Dictionary<string, MetricConfiguration>
+            {
+                { "variableCount", new MetricConfiguration { Scale = 5.0, Threshold = 4, Enabled = false } },
+                { "fieldAccessCount", new MetricConfiguration { Scale = 15.0, Threshold = 4, Enabled = false } },
+            }
+        };
+
+        new ScoreCalculator().CalculateScores(metrics, configuration);
+
+        using (Assert.EnterMultipleScope())
+        {
+            Assert.That(metrics.localVariableScore, Is.EqualTo(0));
+            Assert.That(metrics.fieldAccessScore, Is.EqualTo(0));
+            Assert.That(metrics.totalScore, Is.EqualTo(0));
+        }
+    }
+
     [Test]
     public void CalculateScoresWithValidMetric()
     {

CognitiveCodeAnalysis/cognitive-metrics-settings.json

@@ -30,12 +30,17 @@
             "variableCount": {
                 "threshold": 4,
                 "scale": 5.0,
-                "enabled": true
+                "enabled": false
             },
             "propertyCallCount": {
                 "threshold": 4,
                 "scale": 15.0,
-                "enabled": true
+                "enabled": false
+            },
+            "fieldAccessCount": {
+                "threshold": 4,
+                "scale": 15.0,
+                "enabled": false
             },
             "ifCount": {
                 "threshold": 3,
@@ -51,6 +56,21 @@
                 "threshold": 1,
                 "scale": 1.0,
                 "enabled": true
+            },
+            "loopCount": {
+                "threshold": 2,
+                "scale": 1.0,
+                "enabled": false
+            },
+            "switchCount": {
+                "threshold": 1,
+                "scale": 1.0,
+                "enabled": false
+            },
+            "tryCatchCount": {
+                "threshold": 1,
+                "scale": 1.0,
+                "enabled": false
             }
         }
     }