Refactoring the baseline handling.

src/Business/Cognitive/BaselineService.php

@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phauthentic\CodeQualityMetrics\Business\Cognitive;
+
+use RuntimeException;
+
+/**
+ *
+ */
+class BaselineService
+{
+    /**
+     * @param CognitiveMetricsCollection $metricsCollection
+     * @param array<string, array<string, mixed>> $baseline
+     */
+    public function calculateDeltas(CognitiveMetricsCollection $metricsCollection, array $baseline): void
+    {
+        foreach ($baseline as $class => $data) {
+            foreach ($data['methods'] as $methodName => $methodData) {
+                $metrics = $metricsCollection->getClassWithMethod($class, $methodName);
+                if (!$metrics) {
+                    continue;
+                }
+
+                $previousMetrics = CognitiveMetrics::fromArray($methodData);
+                $metrics->calculateDeltas($previousMetrics);
+            }
+        }
+    }
+
+
+    /**
+     * Loads the baseline file and returns the data as an array.
+     *
+     * @param string $baselineFile
+     * @return array<string, array<string, mixed>> $baseline
+     * @throws \JsonException
+     */
+    public function loadBaseline(string $baselineFile): array
+    {
+        if (!file_exists($baselineFile)) {
+            throw new RuntimeException('Baseline file does not exist.');
+        }
+
+        $baseline = file_get_contents($baselineFile);
+        if ($baseline === false) {
+            throw new RuntimeException('Failed to read baseline file.');
+        }
+
+        return json_decode($baseline, true, 512, JSON_THROW_ON_ERROR);
+    }
+}

src/Business/Cognitive/CognitiveMetrics.php

@@ -12,8 +12,23 @@
  */
 class CognitiveMetrics implements JsonSerializable
 {
-    private string $class = '';
-    private string $method = '';
+    /**
+     * @var array<int, string>
+     */
+    private array $metrics = [
+        'lineCount',
+        'argCount',
+        'returnCount',
+        'variableCount',
+        'propertyCallCount',
+        'ifCount',
+        'ifNestingLevel',
+        'elseCount'
+    ];
+
+    private string $class;
+    private string $method;
+
     private int $lineCount = 0;
     private int $argCount = 0;
     private int $returnCount = 0;
@@ -49,25 +64,37 @@ public function __construct(array $metrics)
     {
         $this->assertArrayKeyIsPresent($metrics, 'class');
         $this->assertArrayKeyIsPresent($metrics, 'method');
-        $this->assertArrayKeyIsPresent($metrics, 'lineCount');
-        $this->assertArrayKeyIsPresent($metrics, 'argCount');
-        $this->assertArrayKeyIsPresent($metrics, 'returnCount');
-        $this->assertArrayKeyIsPresent($metrics, 'variableCount');
-        $this->assertArrayKeyIsPresent($metrics, 'propertyCallCount');
-        $this->assertArrayKeyIsPresent($metrics, 'ifCount');
-        $this->assertArrayKeyIsPresent($metrics, 'ifNestingLevel');
-        $this->assertArrayKeyIsPresent($metrics, 'elseCount');
-
-        $this->class = $metrics['class'];
         $this->method = $metrics['method'];
-        $this->lineCount = $metrics['lineCount'];
-        $this->argCount = $metrics['argCount'];
-        $this->returnCount = $metrics['returnCount'];
-        $this->variableCount = $metrics['variableCount'];
-        $this->propertyCallCount = $metrics['propertyCallCount'];
-        $this->ifCount = $metrics['ifCount'];
-        $this->ifNestingLevel = $metrics['ifNestingLevel'];
-        $this->elseCount = $metrics['elseCount'];
+        $this->class = $metrics['class'];
+
+        $this->setRequiredMetricProperties($metrics);
+        $this->setOptionalMetricProperties($metrics);
+    }
+
+    /**
+     * @param array<string, mixed> $metrics
+     * @return void
+     */
+    private function setRequiredMetricProperties(array $metrics): void
+    {
+        foreach ($this->metrics as $metricName) {
+            $this->assertArrayKeyIsPresent($metrics, $metricName);
+            $this->$metricName = $metrics[$metricName];
+        }
+    }
+
+    /**
+     * @param array<string, mixed> $metrics
+     * @return void
+     */
+    private function setOptionalMetricProperties(array $metrics): void
+    {
+        foreach ($this->metrics as $metricName) {
+            $property = $metricName . 'Weight';
+            if (array_key_exists($property, $metrics)) {
+                $this->$property = $metrics[$property];
+            }
+        }
     }
 
     private function assertSame(self $other): void
@@ -93,17 +120,16 @@ public function calculateDeltas(self $other): void
     {
         $this->assertSame($other);
 
-        $this->lineCountWeightDelta = new Delta($this->lineCountWeight, $other->getLineCountWeight());
-        $this->argCountWeightDelta = new Delta($this->argCountWeight, $other->getArgCountWeight());
-        $this->returnCountWeightDelta = new Delta($this->returnCountWeight, $other->getReturnCountWeight());
-        $this->variableCountWeightDelta = new Delta($this->variableCountWeight, $other->getVariableCountWeight());
-        $this->propertyCallCountWeightDelta = new Delta($this->propertyCallCountWeight, $other->getPropertyCallCountWeight());
-        $this->ifCountWeightDelta = new Delta($this->ifCountWeight, $other->getIfCountWeight());
-        $this->ifNestingLevelWeightDelta = new Delta($this->ifNestingLevelWeight, $other->getIfNestingLevelWeight());
-        $this->elseCountWeightDelta = new Delta($this->elseCountWeight, $other->getElseCountWeight());
+        $this->lineCountWeightDelta = new Delta($other->getLineCountWeight(), $this->lineCountWeight);
+        $this->argCountWeightDelta = new Delta($other->getArgCountWeight(), $this->argCountWeight);
+        $this->returnCountWeightDelta = new Delta($other->getReturnCountWeight(), $this->returnCountWeight);
+        $this->variableCountWeightDelta = new Delta($other->getVariableCountWeight(), $this->variableCountWeight);
+        $this->propertyCallCountWeightDelta = new Delta($other->getPropertyCallCountWeight(), $this->propertyCallCountWeight);
+        $this->ifCountWeightDelta = new Delta($other->getIfCountWeight(), $this->ifCountWeight);
+        $this->ifNestingLevelWeightDelta = new Delta($other->getIfNestingLevelWeight(), $this->ifNestingLevelWeight);
+        $this->elseCountWeightDelta = new Delta($other->getElseCountWeight(), $this->elseCountWeight);
     }
 
-
     /**
      * @param array<string, mixed> $metrics
      * @return self

src/Business/Cognitive/Delta.php

@@ -16,12 +16,12 @@ public function __construct(float $before, float $after)
     {
         if ($before < $after) {
             $this->hasIncreased = true;
-            $this->difference = $after - $before; // Positive difference for increase
+            $this->difference = $after - $before;
             return;
         }
 
         $this->hasIncreased = false;
-        $this->difference = $after - $before; // Negative difference for decrease or zero
+        $this->difference = $after - $before;
     }
 
     public function getValue(): float
@@ -38,4 +38,9 @@ public function __toString(): string
     {
         return (string)$this->difference;
     }
+
+    public function hasNotChanged(): bool
+    {
+        return $this->difference === 0.0;
+    }
 }

src/Business/Cognitive/Exporter/JsonExporter.php

@@ -5,12 +5,16 @@
 namespace Phauthentic\CodeQualityMetrics\Business\Cognitive\Exporter;
 
 use Phauthentic\CodeQualityMetrics\Business\Cognitive\CognitiveMetricsCollection;
+use RuntimeException;
 
 /**
  *
  */
 class JsonExporter implements DataExporterInterface
 {
+    /**
+     * @throws \JsonException
+     */
     public function export(CognitiveMetricsCollection $metricsCollection, string $filename): void
     {
         $jsonData = [];
@@ -19,38 +23,34 @@ public function export(CognitiveMetricsCollection $metricsCollection, string $fi
 
         foreach ($groupedByClass as $class => $methods) {
             foreach ($methods as $metrics) {
-                $jsonData[] = [
+                $jsonData[$class]['methods'][$metrics->getMethod()] = [
                     'class' => $metrics->getClass(),
-                    'methods' => [
-                        $metrics->getMethod() => [
-                            'name' => $metrics->getMethod(),
-                            'lineCount' => $metrics->getLineCount(),
-                            'lineCountWeight' => $metrics->getLineCountWeight(),
-                            'argCount' => $metrics->getArgCount(),
-                            'argCountWeight' => $metrics->getArgCountWeight(),
-                            'returnCount' => $metrics->getReturnCount(),
-                            'returnCountWeight' => $metrics->getReturnCountWeight(),
-                            'variableCount' => $metrics->getVariableCount(),
-                            'variableCountWeight' => $metrics->getVariableCountWeight(),
-                            'propertyCallCount' => $metrics->getPropertyCallCount(),
-                            'propertyCallCountWeight' => $metrics->getPropertyCallCountWeight(),
-                            'ifCount' => $metrics->getIfCount(),
-                            'ifCountWeight' => $metrics->getIfCountWeight(),
-                            'ifNestingLevel' => $metrics->getIfNestingLevel(),
-                            'ifNestingLevelWeight' => $metrics->getIfNestingLevelWeight(),
-                            'elseCount' => $metrics->getElseCount(),
-                            'elseCountWeight' => $metrics->getElseCountWeight(),
-                            'score' => $metrics->getScore()
-                        ]
-                    ]
+                    'method' => $metrics->getMethod(),
+                    'lineCount' => $metrics->getLineCount(),
+                    'lineCountWeight' => $metrics->getLineCountWeight(),
+                    'argCount' => $metrics->getArgCount(),
+                    'argCountWeight' => $metrics->getArgCountWeight(),
+                    'returnCount' => $metrics->getReturnCount(),
+                    'returnCountWeight' => $metrics->getReturnCountWeight(),
+                    'variableCount' => $metrics->getVariableCount(),
+                    'variableCountWeight' => $metrics->getVariableCountWeight(),
+                    'propertyCallCount' => $metrics->getPropertyCallCount(),
+                    'propertyCallCountWeight' => $metrics->getPropertyCallCountWeight(),
+                    'ifCount' => $metrics->getIfCount(),
+                    'ifCountWeight' => $metrics->getIfCountWeight(),
+                    'ifNestingLevel' => $metrics->getIfNestingLevel(),
+                    'ifNestingLevelWeight' => $metrics->getIfNestingLevelWeight(),
+                    'elseCount' => $metrics->getElseCount(),
+                    'elseCountWeight' => $metrics->getElseCountWeight(),
+                    'score' => $metrics->getScore()
                 ];
             }
         }
 
         $jsonData = json_encode($jsonData, JSON_PRETTY_PRINT | JSON_THROW_ON_ERROR);
 
         if (file_put_contents($filename, $jsonData) === false) {
-            throw new \RuntimeException("Unable to write to file: $filename");
+            throw new RuntimeException("Unable to write to file: $filename");
         }
     }
 }

src/Command/CognitiveMetricsCommand.php

@@ -5,6 +5,7 @@
 namespace Phauthentic\CodeQualityMetrics\Command;
 
 use Exception;
+use Phauthentic\CodeQualityMetrics\Business\Cognitive\BaselineService;
 use Phauthentic\CodeQualityMetrics\Business\Cognitive\CognitiveMetricsCollection;
 use Phauthentic\CodeQualityMetrics\Business\MetricsFacade;
 use Phauthentic\CodeQualityMetrics\Command\Presentation\CognitiveMetricTextRenderer;
@@ -34,6 +35,7 @@ class CognitiveMetricsCommand extends Command
 
     private MetricsFacade $metricsFacade;
     private CognitiveMetricTextRenderer $metricTextRenderer;
+    private BaselineService $baselineService;
 
     /**
      * Constructor to initialize dependencies.
@@ -43,6 +45,7 @@ public function __construct()
         parent::__construct();
         $this->metricsFacade = new MetricsFacade();
         $this->metricTextRenderer = new CognitiveMetricTextRenderer();
+        $this->baselineService = new BaselineService();
     }
 
     /**
@@ -76,19 +79,19 @@ protected function execute(InputInterface $input, OutputInterface $output): int
             return Command::FAILURE;
         }
 
-        // Load baseline if the option is provided.
-        $baseline = $this->handleBaseLine($input);
-
         // Generate metrics for the provided path.
         $metricsCollection = $this->metricsFacade->getCognitiveMetrics($path);
 
+        // Load baseline if the option is provided.
+        $this->handleBaseLine($input, $metricsCollection);
+
         // Handle different export options.
         if (!$this->handleExportOptions($input, $output, $metricsCollection)) {
             return Command::FAILURE;
         }
 
         // Render the metrics to the console.
-        $this->metricTextRenderer->render($metricsCollection, $baseline, $output);
+        $this->metricTextRenderer->render($metricsCollection, [], $output);
 
         return Command::SUCCESS;
     }
@@ -97,39 +100,16 @@ protected function execute(InputInterface $input, OutputInterface $output): int
      * Handles the baseline option and loads the baseline file if provided.
      *
      * @param InputInterface $input
-     * @return array<int, array<string, mixed>>
+     * @param CognitiveMetricsCollection $metricsCollection
      * @throws Exception
      */
-    private function handleBaseLine(InputInterface $input): array
+    private function handleBaseLine(InputInterface $input, CognitiveMetricsCollection $metricsCollection): void
     {
-        $baseline = [];
         $baselineFile = $input->getOption(self::OPTION_BASELINE);
         if ($baselineFile) {
-            $baseline = $this->loadBaseline($baselineFile);
-        }
-
-        return $baseline;
-    }
-
-    /**
-     * Loads the baseline file and returns the data as an array.
-     *
-     * @param string $baselineFile
-     * @return array<int, array<string, mixed>> $baseline
-     * @throws \JsonException
-     */
-    private function loadBaseline(string $baselineFile): array
-    {
-        if (!file_exists($baselineFile)) {
-            throw new Exception('Baseline file does not exist.');
-        }
-
-        $baseline = file_get_contents($baselineFile);
-        if ($baseline === false) {
-            throw new Exception('Failed to read baseline file.');
+            $baseline = $this->baselineService->loadBaseline($baselineFile);
+            $this->baselineService->calculateDeltas($metricsCollection, $baseline);
         }
-
-        return json_decode($baseline, true, 512, JSON_THROW_ON_ERROR);
     }
 
     /**