refactor: separated XML processing and file reporting

Author: NickSdot

src/Application.php

@@ -119,7 +119,7 @@ public function run(): int
         $progress = $this->createProgress($options);
 
         try {
-            $report = new RunCoordinator($progress)->run($runPlan);
+            $report = new RunCoordinator($progress, collectPerformance: $options['perf'])->runWithMetrics($runPlan);
         } catch (\Throwable $e) {
             $this->writeError('Runtime error: ' . $e->getMessage() . PHP_EOL);
 
@@ -134,7 +134,7 @@ public function run(): int
 
         $this->write($reporter->generate($report));
 
-        return (int) $report->hasViolations();
+        return (int) $report->hasFinalViolations();
     }
 
     /**

src/Fix/FixerException.php

@@ -28,11 +28,6 @@ public static function cannotFixInvalidContent(Violation $violation): self
         ));
     }
 
-    public static function cannotReadFixedContent(): self
-    {
-        return new self('Cannot read fixed content when no fix application was attempted.');
-    }
-
     public static function invalidFixedXml(string $filePath): self
     {
         return new self(

src/Report/FileReport.php

@@ -9,56 +9,215 @@
 
 final class FileReport
 {
+    public private(set) float $totalSniffingTime = 0.0;
+
+    public private(set) float $totalFixingTime = 0.0;
+
+    /** @var array<string, float> */
+    public private(set) array $sniffingTimes = [];
+
+    /** @var array<string, float> */
+    public private(set) array $fixingTimes = [];
+
+    public private(set) int $fixingPasses = 0;
+
+    public private(set) bool $changed = false;
+
+    /** @var list<Violation> */
+    public private(set) array $foundViolations;
+
     /** @var list<Violation> */
-    public private(set) array $violations = [];
+    public private(set) array $finalViolations;
 
     public function __construct(
         public readonly string $filePath,
+        private readonly bool $collectPerformance = false,
     ) {
     }
 
-    public function addViolation(Violation $violation): void
+    public function markChanged(): void
     {
-        $this->violations[] = $violation;
+        $this->changed = true;
     }
 
-    /** @param list<Violation> $violations */
-    public function addViolations(array $violations): void
+    /** @throws ReportException if found violations were already added */
+    public function addFailedViolation(Violation $violation): void
     {
-        foreach ($violations as $violation) {
-            $this->addViolation($violation);
+        if (isset($this->foundViolations)) {
+            throw ReportException::foundViolationsAlreadyAdded($this->filePath);
         }
+
+        $this->foundViolations = [$violation];
+        $this->finalViolations = [$violation];
     }
 
-    /** @return list<Violation> */
-    public function getViolations(): array
+    /**
+     * @param list<Violation> $violations
+     * @throws ReportException if found violations were already added
+     */
+    public function addFoundViolations(array $violations): void
     {
-        return $this->violations;
+        if (isset($this->foundViolations)) {
+            throw ReportException::foundViolationsAlreadyAdded($this->filePath);
+        }
+
+        $this->foundViolations = $violations;
+        $this->finalViolations = $violations;
+    }
+
+    public function getFoundViolationCount(): int
+    {
+        return isset($this->foundViolations) ? count($this->foundViolations) : 0;
     }
 
-    public function getViolationCount(): int
+    /**
+     * @param list<Violation> $violations
+     * @throws ReportException if found violations were not added
+     */
+    public function addFinalViolations(array $violations): void
     {
-        return count($this->violations);
+        if (!isset($this->foundViolations)) {
+            throw ReportException::cannotSetFinalViolationsBeforeFoundViolations($this->filePath);
+        }
+
+        $this->finalViolations = $violations;
     }
 
-    public function hasViolations(): bool
+    public function hasFinalViolations(): bool
     {
-        return $this->violations !== [];
+        return isset($this->finalViolations) && $this->finalViolations !== [];
+    }
+
+    public function getFinalViolationCount(): int
+    {
+        return isset($this->finalViolations) ? count($this->finalViolations) : 0;
+    }
+
+    public function getAppliedFixesCount(): int
+    {
+        return $this->fixingPasses > 0
+            ? max(0, $this->getFoundViolationCount() - $this->getFinalViolationCount())
+            : 0;
+    }
+
+    public function getSkippedFixesCount(): int
+    {
+        return $this->fixingPasses > 0
+            ? $this->getFinalViolationCount()
+            : 0;
+    }
+
+    public function recordFixingPass(): void
+    {
+        $this->fixingPasses++;
     }
 
     public function getErrorCount(): int
     {
-        return array_filter(
-            $this->violations,
-            static fn(Violation $v): bool => $v->severity === Severity::ERROR,
-        ) |> count(...);
+        return $this->countSeverity(Severity::ERROR);
     }
 
     public function getWarningCount(): int
     {
+        return $this->countSeverity(Severity::WARNING);
+    }
+
+    public function getInfoCount(): int
+    {
+        return $this->countSeverity(Severity::INFO);
+    }
+
+    /**
+     * @template T
+     * @param callable(): T $operation
+     * @return T
+     */
+    public function measureFixing(callable $operation): mixed
+    {
+        if (!$this->collectPerformance) {
+            return $operation();
+        }
+
+        $start = microtime(true);
+
+        try {
+            return $operation();
+        } finally {
+            $this->totalFixingTime += microtime(true) - $start;
+        }
+    }
+
+    /**
+     * @template T
+     * @param callable(): T $operation
+     * @return T
+     */
+    public function measureFixer(string $sniffCode, callable $operation): mixed
+    {
+        if (!$this->collectPerformance) {
+            return $operation();
+        }
+
+        $start = microtime(true);
+
+        try {
+            return $operation();
+        } finally {
+            $this->fixingTimes[$sniffCode] ??= 0.0;
+            $this->fixingTimes[$sniffCode] += microtime(true) - $start;
+        }
+    }
+
+    /**
+     * @template T
+     * @param callable(): T $operation
+     * @return T
+     */
+    public function measureSniffing(callable $operation): mixed
+    {
+        if (!$this->collectPerformance) {
+            return $operation();
+        }
+
+        $start = microtime(true);
+
+        try {
+            return $operation();
+        } finally {
+            $this->totalSniffingTime += microtime(true) - $start;
+        }
+    }
+
+    /**
+     * @template T
+     * @param callable(): T $operation
+     * @return T
+     */
+    public function measureSniffer(string $sniffCode, callable $operation): mixed
+    {
+        if (!$this->collectPerformance) {
+            return $operation();
+        }
+
+        $start = microtime(true);
+
+        try {
+            return $operation();
+        } finally {
+            $this->sniffingTimes[$sniffCode] ??= 0.0;
+            $this->sniffingTimes[$sniffCode] += microtime(true) - $start;
+        }
+    }
+
+    private function countSeverity(Severity $severity): int
+    {
+        if (!isset($this->finalViolations)) {
+            return 0;
+        }
+
         return array_filter(
-            $this->violations,
-            static fn(Violation $v): bool => $v->severity === Severity::WARNING,
+            $this->finalViolations,
+            static fn(Violation $violation): bool => $violation->severity === $severity,
         ) |> count(...);
     }
 }