Fix errors reported by PHPStorm (#70)

Author: theofidry

README.md

@@ -6,7 +6,7 @@ This library supports the parallelization of Symfony Console commands.
 How it works
 ------------
 
-When you launch a command with multi-processing enabled (`--processes 2`), a 
+When you launch a command with multiprocessing enabled (`--processes 2`), a
 master process fetches *items* and distributes them across the given number of
 child processes. Child processes are killed after a fixed number of items
 (a *segment*) in order to prevent them from slowing down over time.
@@ -103,7 +103,7 @@ Items
 -----
 
 The master process fetches all the items that need to be processed and passes
-them to the child processes through their Standard Input. Hence items must 
+them to the child processes through their Standard Input. Hence, items must
 fulfill two requirements:
 
 * Items must be strings
@@ -118,9 +118,9 @@ master process to the child process. Some typical examples for items:
 Segments
 --------
 
-When you run a command with multi-processing enabled, the items returned by
+When you run a command with multiprocessing enabled, the items returned by
 `fetchItems()` are split into segments of a fixed size. Each child processes
-processes a single segment and kills itself after that.
+process a single segment and kills itself after that.
 
 By default, the segment size is the same as the batch size (see below), but you 
 can try to tweak the performance of your command by choosing a different segment
@@ -173,12 +173,12 @@ Hooks
 The `Parallelization` trait supports more hooks than the one mentioned in the
 last section. In the table below you can find a complete list of them:
 
-Method                                      | Scope             | Description
-------------------------------------------- | ----------------- | ---------------------------------------------
-`runBeforeFirstCommand($input, $output)`    | Master process    | Run before any child process is spawned
-`runAfterLastCommand($input, $output)`      | Master process    | Run after all child processes have completed
-`runBeforeBatch($input, $output, $items)`   | Child process     | Run before each batch in the child process
-`runAfterBatch($input, $output, $items)`    | Child process     | Run after each batch in the child process
+| Method                                    | Scope          | Description                                  |
+|-------------------------------------------|----------------|----------------------------------------------|
+| `runBeforeFirstCommand($input, $output)`  | Master process | Run before any child process is spawned      |
+| `runAfterLastCommand($input, $output)`    | Master process | Run after all child processes have completed |
+| `runBeforeBatch($input, $output, $items)` | Child process  | Run before each batch in the child process   |
+| `runAfterBatch($input, $output, $items)`  | Child process  | Run after each batch in the child process    |
 
 Authors
 -------
@@ -206,4 +206,4 @@ All contents of this package are licensed under the [MIT license].
 [The Community Contributors]: https://github.com/webmozarts/console-parallelization/graphs/contributors
 [issue tracker]: https://github.com/webmozarts/console-parallelization/issues
 [Git repository]: https://github.com/webmozarts/console-parallelization
-[MIT license]: LICENSE
+[MIT license]: LICENSE.md_

src/ChunkedItemsIterator.php

@@ -26,9 +26,9 @@
 
 final class ChunkedItemsIterator
 {
-    private $items;
-    private $numberOfItems;
-    private $itemsChunks;
+    private array $items;
+    private int $numberOfItems;
+    private array $itemsChunks;
 
     /**
      * @param list<string> $items
@@ -48,7 +48,6 @@ public function __construct(array $items, int $batchSize)
         $this->itemsChunks = array_chunk(
             $this->items,
             $batchSize,
-            false,
         );
         $this->numberOfItems = count($this->items);
     }

src/Configuration.php

@@ -19,9 +19,9 @@
 
 final class Configuration
 {
-    private $segmentSize;
-    private $rounds;
-    private $batches;
+    private int $segmentSize;
+    private int $rounds;
+    private int $batches;
 
     public function __construct(
         bool $numberOfProcessesDefined,

src/ContainerAwareCommand.php

@@ -20,10 +20,7 @@
 
 abstract class ContainerAwareCommand extends Command implements ContainerAwareInterface
 {
-    /**
-     * @var ContainerInterface|null
-     */
-    private $container;
+    private ?ContainerInterface $container = null;
 
     public function setContainer(?ContainerInterface $container = null): void
     {

src/Parallelization.php

@@ -27,7 +27,6 @@
 use function sprintf;
 use const STDIN;
 use function stream_get_contents;
-use Symfony\Component\Console\Application;
 use Symfony\Component\Console\Command\Command;
 use Symfony\Component\Console\Helper\ProgressBar;
 use Symfony\Component\Console\Input\InputInterface;
@@ -72,7 +71,7 @@
  */
 trait Parallelization
 {
-    private $logError = true;
+    private bool $logError = true;
 
     /**
      * Provided by Symfony Command class.
@@ -311,7 +310,7 @@ function () use ($input) {
                 $this->runBeforeBatch($input, $output, $items);
 
                 foreach ($items as $item) {
-                    $this->runTolerantSingleCommand((string) $item, $input, $output);
+                    $this->runTolerantSingleCommand($item, $input, $output);
 
                     $progressBar->advance();
                 }

src/ParallelizationInput.php

@@ -27,10 +27,10 @@ final class ParallelizationInput
     private const PROCESSES_OPTION = 'processes';
     private const CHILD_OPTION = 'child';
 
-    private $numberOfProcessesDefined;
-    private $numberOfProcesses = 1;
-    private $item;
-    private $childProcess;
+    private bool $numberOfProcessesDefined;
+    private int $numberOfProcesses = 1;
+    private ?string $item;
+    private bool $childProcess;
 
     public function __construct(InputInterface $input)
     {
@@ -96,7 +96,6 @@ public static function configureParallelization(Command $command): void
                 'p',
                 InputOption::VALUE_OPTIONAL,
                 'The number of parallel processes to run',
-                null,
             )
             ->addOption(
                 self::CHILD_OPTION,

src/ProcessLauncher.php

@@ -29,24 +29,24 @@
  */
 class ProcessLauncher
 {
-    private $command;
+    private string $command;
 
-    private $workingDirectory;
+    private string $workingDirectory;
 
-    private $environmentVariables;
+    private array $environmentVariables;
 
-    private $processLimit;
+    private int $processLimit;
 
-    private $segmentSize;
+    private int $segmentSize;
 
     private $logger;
 
-    private $callback;
+    private Closure $callback;
 
     /**
      * @var Process[]
      */
-    private $runningProcesses = [];
+    private array $runningProcesses = [];
 
     public function __construct(
         string $command, // @TODO change to array for 2.0

tests/Integration/TestLogger.php

@@ -52,7 +52,7 @@ public function recordBeforeBatch(): void
         $this->write(self::formatMethodName(__METHOD__));
     }
 
-    public function recordSingleCommand(string $movieFileName, string $movieFileContent)
+    public function recordSingleCommand(string $movieFileName, string $movieFileContent): void
     {
         $this->write(
             sprintf(