style: Apply code style fixes

Author: coisa

src/Console/Command/CodeStyleCommand.php

@@ -18,11 +18,14 @@
 
 namespace FastForward\DevTools\Console\Command;
 
+use Composer\Command\BaseCommand;
+use FastForward\DevTools\Process\ProcessBuilderInterface;
+use FastForward\DevTools\Process\ProcessQueueInterface;
+use Symfony\Component\Config\FileLocatorInterface;
 use Symfony\Component\Console\Attribute\AsCommand;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Output\OutputInterface;
-use Symfony\Component\Process\Process;
 
 /**
  * Represents the command responsible for checking and fixing code style issues.
@@ -33,13 +36,33 @@
     description: 'Checks and fixes code style issues using EasyCodingStandard and Composer Normalize.',
     help: 'This command runs EasyCodingStandard and Composer Normalize to check and fix code style issues.'
 )]
-final class CodeStyleCommand extends AbstractCommand
+final class CodeStyleCommand extends BaseCommand
 {
     /**
      * @var string the default configuration file used for EasyCodingStandard
      */
     public const string CONFIG = 'ecs.php';
 
+    /**
+     * Constructs a new command instance responsible for orchestrating code style checks.
+     *
+     * The provided collaborators SHALL be used to locate the ECS configuration,
+     * build process definitions, and execute the resulting process queue. These
+     * dependencies MUST be valid service instances capable of supporting the
+     * command lifecycle expected by this class.
+     *
+     * @param FileLocatorInterface $fileLocator locates the configuration file required by EasyCodingStandard
+     * @param ProcessBuilderInterface $processBuilder builds the process instances used to execute Composer and ECS commands
+     * @param ProcessQueueInterface $processQueue queues and executes the generated processes in the required order
+     */
+    public function __construct(
+        private readonly FileLocatorInterface $fileLocator,
+        private readonly ProcessBuilderInterface $processBuilder,
+        private readonly ProcessQueueInterface $processQueue,
+    ) {
+        parent::__construct();
+    }
+
     /**
      * Configures the current command.
      *
@@ -74,20 +97,30 @@ protected function execute(InputInterface $input, OutputInterface $output): int
     {
         $output->writeln('<info>Running code style checks and fixes...</info>');
 
-        $command = new Process(['composer', 'update', '--lock', '--quiet']);
+        $composerUpdate = $this->processBuilder
+            ->withArgument('--lock')
+            ->withArgument('--quiet')
+            ->build('composer update');
+
+        $composerNormalize = $this->processBuilder
+            ->withArgument('--ansi')
+            ->withArgument($input->getOption('fix') ? '--quiet' : '--dry-run')
+            ->build('composer normalize');
 
-        parent::runProcess($command, $output);
+        $processBuilder = $this->processBuilder
+            ->withArgument('--no-progress-bar')
+            ->withArgument('--config', $this->fileLocator->locate(self::CONFIG));
 
-        $command = new Process(['composer', 'normalize', $input->getOption('fix') ? '--quiet' : '--dry-run']);
+        if ($input->getOption('fix')) {
+            $processBuilder = $processBuilder->withArgument('--fix');
+        }
 
-        parent::runProcess($command, $output);
+        $ecs = $processBuilder->build('vendor/bin/ecs');
 
-        $command = new Process([
-            $this->getAbsolutePath('vendor/bin/ecs'),
-            '--config=' . parent::getConfigFile(self::CONFIG),
-            $input->getOption('fix') ? '--fix' : '--clear-cache',
-        ]);
+        $this->processQueue->add($composerUpdate);
+        $this->processQueue->add($composerNormalize);
+        $this->processQueue->add($ecs);
 
-        return parent::runProcess($command, $output);
+        return $this->processQueue->run($output);
     }
 }

src/Process/ProcessBuilder.php

@@ -0,0 +1,98 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * This file is part of fast-forward/dev-tools.
+ *
+ * This source file is subject to the license bundled
+ * with this source code in the file LICENSE.
+ *
+ * @copyright Copyright (c) 2026 Felipe Sayão Lobato Abreu <github@mentordosnerds.com>
+ * @license   https://opensource.org/licenses/MIT MIT License
+ *
+ * @see       https://github.com/php-fast-forward/dev-tools
+ * @see       https://github.com/php-fast-forward
+ * @see       https://datatracker.ietf.org/doc/html/rfc2119
+ */
+
+namespace FastForward\DevTools\Process;
+
+use Symfony\Component\Process\Process;
+
+/**
+ * Builds immutable process definitions from a command and a collection of arguments.
+ *
+ * This builder SHALL preserve previously supplied arguments by returning a new
+ * instance on each mutation-like operation. Implementations of this concrete
+ * builder MUST keep argument ordering stable so that the generated process
+ * reflects the exact sequence in which arguments were provided.
+ */
+final readonly class ProcessBuilder implements ProcessBuilderInterface
+{
+    /**
+     * Creates a new immutable process builder instance.
+     *
+     * The provided arguments SHALL be stored in the same order in which they are
+     * received and MUST be used when building the final process instance.
+     *
+     * @param list<string> $arguments the arguments already collected by the builder
+     */
+    public function __construct(
+        private array $arguments = [],
+    ) {}
+
+    /**
+     * Returns a new builder instance with an additional argument appended.
+     *
+     * When a value is provided, the argument SHALL be normalized to the
+     * "{argument}={value}" format before being appended. When no value is
+     * provided, the raw argument token MUST be appended as-is.
+     *
+     * This method MUST NOT mutate the current builder instance and SHALL return
+     * a new instance containing the accumulated arguments.
+     *
+     * @param string $argument the argument name or token to append
+     * @param string|null $value the optional value associated with the argument
+     *
+     * @return ProcessBuilderInterface a new builder instance containing the appended argument
+     */
+    public function withArgument(string $argument, ?string $value = null): ProcessBuilderInterface
+    {
+        if (null !== $value) {
+            $argument = \sprintf('%s=%s', $argument, $value);
+        }
+
+        return new self([...$this->arguments, $argument]);
+    }
+
+    /**
+     * Returns the arguments currently collected by the builder.
+     *
+     * The returned list SHALL preserve insertion order and MAY be used for
+     * inspection, debugging, or testing purposes.
+     *
+     * @return list<string> the collected process arguments
+     */
+    public function getArguments(): array
+    {
+        return $this->arguments;
+    }
+
+    /**
+     * Builds a process instance for the specified command.
+     *
+     * The command string SHALL be split into tokens using a space separator and
+     * combined with all previously collected builder arguments. The resulting
+     * process MUST preserve the final token order exactly as assembled by this
+     * method.
+     *
+     * @param string $command the base command used to initialize the process
+     *
+     * @return Process the configured process instance ready for execution
+     */
+    public function build(string $command): Process
+    {
+        return new Process([...explode(' ', $command), ...$this->arguments]);
+    }
+}

src/Process/ProcessBuilderInterface.php

@@ -0,0 +1,59 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * This file is part of fast-forward/dev-tools.
+ *
+ * This source file is subject to the license bundled
+ * with this source code in the file LICENSE.
+ *
+ * @copyright Copyright (c) 2026 Felipe Sayão Lobato Abreu <github@mentordosnerds.com>
+ * @license   https://opensource.org/licenses/MIT MIT License
+ *
+ * @see       https://github.com/php-fast-forward/dev-tools
+ * @see       https://github.com/php-fast-forward
+ * @see       https://datatracker.ietf.org/doc/html/rfc2119
+ */
+
+namespace FastForward\DevTools\Process;
+
+use Symfony\Component\Process\Process;
+
+/**
+ * Defines a fluent builder responsible for constructing process instances.
+ *
+ * Implementations MUST preserve the builder state consistently across chained
+ * calls and SHALL return a process configured according to all previously
+ * supplied arguments when build() is invoked.
+ */
+interface ProcessBuilderInterface
+{
+    /**
+     * Adds an argument to the process being built.
+     *
+     * Implementations MUST append or register the provided argument for later
+     * use when build() is called. When a non-empty value is provided, the
+     * implementation SHALL associate that value with the argument according to
+     * its command-building strategy.
+     *
+     * @param string $argument the argument name or token that SHALL be added to the process definition
+     * @param ?string $value an optional value associated with the argument
+     *
+     * @return self the current builder instance for fluent chaining
+     */
+    public function withArgument(string $argument, ?string $value = null): self;
+
+    /**
+     * Builds a process instance for the specified command.
+     *
+     * Implementations MUST return a Process configured with the provided
+     * command and all arguments previously collected by the builder. The
+     * returned process SHOULD be ready for execution by the caller.
+     *
+     * @param string $command the base command that SHALL be used to create the process
+     *
+     * @return Process the configured process instance
+     */
+    public function build(string $command): Process;
+}