Refacto ComponentMapper

Author: DeGraciaMathieu

app/Presenter/Analyze/Component/Shared/Collector.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace App\Presenter\Analyze\Component\Shared;
+
+use App\Application\Analyze\AnalyzeMetric;
+
+class Collector
+{
+    public string $name;
+    public float $totalInstability = 0;
+    public int $countAbstractions = 0;
+    public int $countClasses = 0;
+    public array $dependencies = [];
+
+    public function setName(string $name): void
+    {
+        $this->name = $name;
+    }
+
+    public function collect(AnalyzeMetric $metric): void
+    {
+        $this->totalInstability += $metric->instability();
+
+        if ($metric->abstract()) {
+            $this->countAbstractions++;
+        }
+
+        $this->countClasses++;
+    }
+
+    public function addDependency(string $dependency): void
+    {
+        $this->dependencies[] = $dependency;
+    }
+
+    public function hasDependency(string $dependency): bool
+    {
+        return in_array($dependency, $this->dependencies, true);
+    }
+}
+    

app/Presenter/Analyze/Component/Shared/Component.php

@@ -9,10 +9,9 @@ class Component implements Networkable
     public function __construct(
         public readonly string $name,   
         public readonly int $countClasses,  
-        public readonly float $countAbstractions,   
-        public readonly float $averageAbstractness, 
-        public readonly float $averageInstability,  
-        public readonly array $innerDependencies,   
+        public readonly int $countAbstractions,  
+        public readonly float $totalInstability,  
+        public readonly array $dependencies,   
     ) {}
 
     public function name(): string
@@ -32,16 +31,16 @@ public function countAbstractions(): int
 
     public function abstractness(): float
     {
-        return number_format($this->averageAbstractness, 2);
+        return number_format($this->countAbstractions / $this->countClasses, 2);
     }
 
     public function instability(): float
     {
-        return number_format($this->averageInstability, 2);
+        return number_format($this->totalInstability / $this->countClasses, 2);
     }
 
     public function dependencies(): array
     {
-        return $this->innerDependencies;
+        return $this->dependencies;
     }
 }

app/Presenter/Analyze/Component/Shared/ComponentFactory.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace App\Presenter\Analyze\Component\Shared;
+
+class ComponentFactory
+{
+    public function make(Collector $collector): Component
+    {
+        return new Component(
+            name: $collector->name,
+            countClasses: $collector->countClasses,
+            countAbstractions: $collector->countAbstractions,
+            totalInstability: $collector->totalInstability,
+            dependencies: $collector->dependencies,
+        );
+    }
+}

app/Presenter/Analyze/Component/Shared/ComponentMapper.php

@@ -6,26 +6,28 @@
 
 class ComponentMapper
 {
+    public function __construct(
+        private readonly ComponentFactory $componentFactory,
+    ) {}
+
     /**
-     * @todo : its work but it's not efficient
+     * @var array<string, array<AnalyzeMetric>> $metrics
      */
     public function from(array $metrics): array
     {
         $components = array_keys($metrics);
 
-        $tmp = [];
+        $items = [];
 
         foreach ($metrics as $component => $componentMetrics) {
 
-            $instability = 0;
-            $abstract = 0;
+            $collector = new Collector();
 
-            $innerDependencies = [];
+            $collector->setName($component);
 
             foreach ($componentMetrics as $metric) {
 
-                $instability += $metric->instability();
-                $abstract += ($metric->abstract()) ? 1 : 0;
+                $collector->collect($metric);
 
                 foreach ($metric->dependencies() as $dependency) {
 
@@ -37,24 +39,17 @@ public function from(array $metrics): array
                                 continue;
                             }
 
-                            if (! in_array($otherComponent, $innerDependencies)) {
-                                $innerDependencies[] = $otherComponent;
+                            if (! $collector->hasDependency($otherComponent)) {
+                                $collector->addDependency($otherComponent);
                             }
                         }
                     }
                 }
             }
 
-            $tmp[] = new Component(
-                $component,
-                count($componentMetrics),
-                $abstract,
-                $abstract / (count($componentMetrics) ?: 1),
-                $instability / (count($componentMetrics) ?: 1),
-                $innerDependencies,
-            );
+            $items[] = $this->componentFactory->make($collector);
         }
 
-        return $tmp;
+        return $items;
     }
 } 

tests/Unit/Presenter/ComponentMapperTest.php

@@ -2,11 +2,14 @@
 
 use App\Presenter\Analyze\Component\Shared\Component;
 use App\Presenter\Analyze\Component\Shared\ComponentMapper;
+use App\Presenter\Analyze\Component\Shared\ComponentFactory;
+
+beforeEach(function () {
+    $this->componentMapper = new ComponentMapper(new ComponentFactory());
+});
 
 it('should map metrics to components', function () {
 
-    $mapper = new ComponentMapper();
-
     $metrics = [
         'A' => [
             $this->oneAnalyzeMetric()->withName('A\Class1')->build(),
@@ -15,7 +18,7 @@
         ]
     ];
 
-    $components = $mapper->from($metrics);
+    $components = $this->componentMapper->from($metrics);
 
     expect($components)->toHaveCount(1);
     expect($components[0])->toBeInstanceOf(Component::class);
@@ -24,8 +27,6 @@
 
 it('should map metrics to components with dependencies', function () {
 
-    $mapper = new ComponentMapper();
-
     $metrics = [
         'A' => [
             $this->oneAnalyzeMetric()->withName('A\Class1')->withDependencies(['B\Class2'])->build(),
@@ -35,17 +36,14 @@
         ]
     ];
 
-    $components = $mapper->from($metrics);
+    $components = $this->componentMapper->from($metrics);
 
     expect($components)->toHaveCount(2);
     expect($components[0]->dependencies())->toBe(['B']);
-
 });
 
 it('should not keep dependencies from unwanted namespaces', function () {
 
-    $mapper = new ComponentMapper();
-
     $metrics = [
         'A' => [
             /**
@@ -58,16 +56,14 @@
         ]
     ];
 
-    $components = $mapper->from($metrics);
+    $components = $this->componentMapper->from($metrics);
 
     expect($components)->toHaveCount(2);
     expect($components[0]->dependencies())->toBe([]);
 });
 
 it('should calculate the average abstractness', function () {
 
-    $mapper = new ComponentMapper();
-
     $metrics = [
         'A' => [
             $this->oneAnalyzeMetric()->build(),
@@ -77,7 +73,7 @@
         ],
     ];
 
-    $components = $mapper->from($metrics);
+    $components = $this->componentMapper->from($metrics);
 
     expect($components[0]->countClasses())->toBe(4);
     expect($components[0]->countAbstractions())->toBe(3);
@@ -86,8 +82,6 @@
 
 it('should calculate the average instability', function () {
 
-    $mapper = new ComponentMapper();
-
     $metrics = [
         'A' => [
             $this->oneAnalyzeMetric()->withInstability(0.3)->build(),
@@ -96,7 +90,7 @@
         ],
     ];
 
-    $components = $mapper->from($metrics);
+    $components = $this->componentMapper->from($metrics);
 
     expect($components[0]->instability())->toBe(0.67);
 });