gravityview / GravityView

vendor/symfony/process/Pipes/PipesInterface.php

Indentation +38 added lines, -38 removed lines

@@ -20,42 +20,42 @@
  */
 interface PipesInterface
 {
-    public const CHUNK_SIZE = 16384;
-
-    /**
-     * Returns an array of descriptors for the use of proc_open.
-     */
-    public function getDescriptors(): array;
-
-    /**
-     * Returns an array of filenames indexed by their related stream in case these pipes use temporary files.
-     *
-     * @return string[]
-     */
-    public function getFiles(): array;
-
-    /**
-     * Reads data in file handles and pipes.
-     *
-     * @param bool $blocking Whether to use blocking calls or not
-     * @param bool $close    Whether to close pipes if they've reached EOF
-     *
-     * @return string[] An array of read data indexed by their fd
-     */
-    public function readAndWrite(bool $blocking, bool $close = false): array;
-
-    /**
-     * Returns if the current state has open file handles or pipes.
-     */
-    public function areOpen(): bool;
-
-    /**
-     * Returns if pipes are able to read output.
-     */
-    public function haveReadSupport(): bool;
-
-    /**
-     * Closes file handles and pipes.
-     */
-    public function close();
+	public const CHUNK_SIZE = 16384;
+
+	/**
+	 * Returns an array of descriptors for the use of proc_open.
+	 */
+	public function getDescriptors(): array;
+
+	/**
+	 * Returns an array of filenames indexed by their related stream in case these pipes use temporary files.
+	 *
+	 * @return string[]
+	 */
+	public function getFiles(): array;
+
+	/**
+	 * Reads data in file handles and pipes.
+	 *
+	 * @param bool $blocking Whether to use blocking calls or not
+	 * @param bool $close    Whether to close pipes if they've reached EOF
+	 *
+	 * @return string[] An array of read data indexed by their fd
+	 */
+	public function readAndWrite(bool $blocking, bool $close = false): array;
+
+	/**
+	 * Returns if the current state has open file handles or pipes.
+	 */
+	public function areOpen(): bool;
+
+	/**
+	 * Returns if pipes are able to read output.
+	 */
+	public function haveReadSupport(): bool;
+
+	/**
+	 * Closes file handles and pipes.
+	 */
+	public function close();
 }

Spacing +1 added lines, -1 removed lines

@@ -42,7 +42,7 @@
      *
      * @return string[] An array of read data indexed by their fd
      */
-    public function readAndWrite(bool $blocking, bool $close = false): array;
+    public function readAndWrite( bool $blocking, bool $close = false ): array;
 
     /**
      * Returns if the current state has open file handles or pipes.

Braces +1 added lines, -2 removed lines

@@ -18,8 +18,7 @@
  *
  * @internal
  */
-interface PipesInterface
-{
+interface PipesInterface {
     public const CHUNK_SIZE = 16384;
 
     /**

vendor/symfony/process/Pipes/AbstractPipes.php

Indentation +155 added lines, -155 removed lines

@@ -20,159 +20,159 @@
  */
 abstract class AbstractPipes implements PipesInterface
 {
-    public $pipes = [];
-
-    private $inputBuffer = '';
-    private $input;
-    private $blocked = true;
-    private $lastError;
-
-    /**
-     * @param resource|string|int|float|bool|\Iterator|null $input
-     */
-    public function __construct($input)
-    {
-        if (\is_resource($input) || $input instanceof \Iterator) {
-            $this->input = $input;
-        } elseif (\is_string($input)) {
-            $this->inputBuffer = $input;
-        } else {
-            $this->inputBuffer = (string) $input;
-        }
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function close()
-    {
-        foreach ($this->pipes as $pipe) {
-            fclose($pipe);
-        }
-        $this->pipes = [];
-    }
-
-    /**
-     * Returns true if a system call has been interrupted.
-     */
-    protected function hasSystemCallBeenInterrupted(): bool
-    {
-        $lastError = $this->lastError;
-        $this->lastError = null;
-
-        // stream_select returns false when the `select` system call is interrupted by an incoming signal
-        return null !== $lastError && false !== stripos($lastError, 'interrupted system call');
-    }
-
-    /**
-     * Unblocks streams.
-     */
-    protected function unblock()
-    {
-        if (!$this->blocked) {
-            return;
-        }
-
-        foreach ($this->pipes as $pipe) {
-            stream_set_blocking($pipe, 0);
-        }
-        if (\is_resource($this->input)) {
-            stream_set_blocking($this->input, 0);
-        }
-
-        $this->blocked = false;
-    }
-
-    /**
-     * Writes input to stdin.
-     *
-     * @throws InvalidArgumentException When an input iterator yields a non supported value
-     */
-    protected function write(): ?array
-    {
-        if (!isset($this->pipes[0])) {
-            return null;
-        }
-        $input = $this->input;
-
-        if ($input instanceof \Iterator) {
-            if (!$input->valid()) {
-                $input = null;
-            } elseif (\is_resource($input = $input->current())) {
-                stream_set_blocking($input, 0);
-            } elseif (!isset($this->inputBuffer[0])) {
-                if (!\is_string($input)) {
-                    if (!is_scalar($input)) {
-                        throw new InvalidArgumentException(sprintf('"%s" yielded a value of type "%s", but only scalars and stream resources are supported.', get_debug_type($this->input), get_debug_type($input)));
-                    }
-                    $input = (string) $input;
-                }
-                $this->inputBuffer = $input;
-                $this->input->next();
-                $input = null;
-            } else {
-                $input = null;
-            }
-        }
-
-        $r = $e = [];
-        $w = [$this->pipes[0]];
-
-        // let's have a look if something changed in streams
-        if (false === @stream_select($r, $w, $e, 0, 0)) {
-            return null;
-        }
-
-        foreach ($w as $stdin) {
-            if (isset($this->inputBuffer[0])) {
-                $written = fwrite($stdin, $this->inputBuffer);
-                $this->inputBuffer = substr($this->inputBuffer, $written);
-                if (isset($this->inputBuffer[0])) {
-                    return [$this->pipes[0]];
-                }
-            }
-
-            if ($input) {
-                for (;;) {
-                    $data = fread($input, self::CHUNK_SIZE);
-                    if (!isset($data[0])) {
-                        break;
-                    }
-                    $written = fwrite($stdin, $data);
-                    $data = substr($data, $written);
-                    if (isset($data[0])) {
-                        $this->inputBuffer = $data;
-
-                        return [$this->pipes[0]];
-                    }
-                }
-                if (feof($input)) {
-                    if ($this->input instanceof \Iterator) {
-                        $this->input->next();
-                    } else {
-                        $this->input = null;
-                    }
-                }
-            }
-        }
-
-        // no input to read on resource, buffer is empty
-        if (!isset($this->inputBuffer[0]) && !($this->input instanceof \Iterator ? $this->input->valid() : $this->input)) {
-            $this->input = null;
-            fclose($this->pipes[0]);
-            unset($this->pipes[0]);
-        } elseif (!$w) {
-            return [$this->pipes[0]];
-        }
-
-        return null;
-    }
-
-    /**
-     * @internal
-     */
-    public function handleError(int $type, string $msg)
-    {
-        $this->lastError = $msg;
-    }
+	public $pipes = [];
+
+	private $inputBuffer = '';
+	private $input;
+	private $blocked = true;
+	private $lastError;
+
+	/**
+	 * @param resource|string|int|float|bool|\Iterator|null $input
+	 */
+	public function __construct($input)
+	{
+		if (\is_resource($input) || $input instanceof \Iterator) {
+			$this->input = $input;
+		} elseif (\is_string($input)) {
+			$this->inputBuffer = $input;
+		} else {
+			$this->inputBuffer = (string) $input;
+		}
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function close()
+	{
+		foreach ($this->pipes as $pipe) {
+			fclose($pipe);
+		}
+		$this->pipes = [];
+	}
+
+	/**
+	 * Returns true if a system call has been interrupted.
+	 */
+	protected function hasSystemCallBeenInterrupted(): bool
+	{
+		$lastError = $this->lastError;
+		$this->lastError = null;
+
+		// stream_select returns false when the `select` system call is interrupted by an incoming signal
+		return null !== $lastError && false !== stripos($lastError, 'interrupted system call');
+	}
+
+	/**
+	 * Unblocks streams.
+	 */
+	protected function unblock()
+	{
+		if (!$this->blocked) {
+			return;
+		}
+
+		foreach ($this->pipes as $pipe) {
+			stream_set_blocking($pipe, 0);
+		}
+		if (\is_resource($this->input)) {
+			stream_set_blocking($this->input, 0);
+		}
+
+		$this->blocked = false;
+	}
+
+	/**
+	 * Writes input to stdin.
+	 *
+	 * @throws InvalidArgumentException When an input iterator yields a non supported value
+	 */
+	protected function write(): ?array
+	{
+		if (!isset($this->pipes[0])) {
+			return null;
+		}
+		$input = $this->input;
+
+		if ($input instanceof \Iterator) {
+			if (!$input->valid()) {
+				$input = null;
+			} elseif (\is_resource($input = $input->current())) {
+				stream_set_blocking($input, 0);
+			} elseif (!isset($this->inputBuffer[0])) {
+				if (!\is_string($input)) {
+					if (!is_scalar($input)) {
+						throw new InvalidArgumentException(sprintf('"%s" yielded a value of type "%s", but only scalars and stream resources are supported.', get_debug_type($this->input), get_debug_type($input)));
+					}
+					$input = (string) $input;
+				}
+				$this->inputBuffer = $input;
+				$this->input->next();
+				$input = null;
+			} else {
+				$input = null;
+			}
+		}
+
+		$r = $e = [];
+		$w = [$this->pipes[0]];
+
+		// let's have a look if something changed in streams
+		if (false === @stream_select($r, $w, $e, 0, 0)) {
+			return null;
+		}
+
+		foreach ($w as $stdin) {
+			if (isset($this->inputBuffer[0])) {
+				$written = fwrite($stdin, $this->inputBuffer);
+				$this->inputBuffer = substr($this->inputBuffer, $written);
+				if (isset($this->inputBuffer[0])) {
+					return [$this->pipes[0]];
+				}
+			}
+
+			if ($input) {
+				for (;;) {
+					$data = fread($input, self::CHUNK_SIZE);
+					if (!isset($data[0])) {
+						break;
+					}
+					$written = fwrite($stdin, $data);
+					$data = substr($data, $written);
+					if (isset($data[0])) {
+						$this->inputBuffer = $data;
+
+						return [$this->pipes[0]];
+					}
+				}
+				if (feof($input)) {
+					if ($this->input instanceof \Iterator) {
+						$this->input->next();
+					} else {
+						$this->input = null;
+					}
+				}
+			}
+		}
+
+		// no input to read on resource, buffer is empty
+		if (!isset($this->inputBuffer[0]) && !($this->input instanceof \Iterator ? $this->input->valid() : $this->input)) {
+			$this->input = null;
+			fclose($this->pipes[0]);
+			unset($this->pipes[0]);
+		} elseif (!$w) {
+			return [$this->pipes[0]];
+		}
+
+		return null;
+	}
+
+	/**
+	 * @internal
+	 */
+	public function handleError(int $type, string $msg)
+	{
+		$this->lastError = $msg;
+	}
 }

Spacing +49 added lines, -49 removed lines

@@ -20,7 +20,7 @@ 
  */
 abstract class AbstractPipes implements PipesInterface
 {
-    public $pipes = [];
+    public $pipes = [ ];
 
     private $inputBuffer = '';
     private $input;
@@ -30,14 +30,14 @@ 
     /**
      * @param resource|string|int|float|bool|\Iterator|null $input
      */
-    public function __construct($input)
+    public function __construct( $input )
     {
-        if (\is_resource($input) || $input instanceof \Iterator) {
+        if ( \is_resource( $input ) || $input instanceof \Iterator ) {
             $this->input = $input;
-        } elseif (\is_string($input)) {
+        } elseif ( \is_string( $input ) ) {
             $this->inputBuffer = $input;
         } else {
-            $this->inputBuffer = (string) $input;
+            $this->inputBuffer = (string)$input;
         }
     }
 
@@ -46,10 +46,10 @@ 
      */
     public function close()
     {
-        foreach ($this->pipes as $pipe) {
-            fclose($pipe);
+        foreach ( $this->pipes as $pipe ) {
+            fclose( $pipe );
         }
-        $this->pipes = [];
+        $this->pipes = [ ];
     }
 
     /**
@@ -61,7 +61,7 @@ 
         $this->lastError = null;
 
         // stream_select returns false when the `select` system call is interrupted by an incoming signal
-        return null !== $lastError && false !== stripos($lastError, 'interrupted system call');
+        return null !== $lastError && false !== stripos( $lastError, 'interrupted system call' );
     }
 
     /**
@@ -69,15 +69,15 @@ 
      */
     protected function unblock()
     {
-        if (!$this->blocked) {
+        if ( ! $this->blocked ) {
             return;
         }
 
-        foreach ($this->pipes as $pipe) {
-            stream_set_blocking($pipe, 0);
+        foreach ( $this->pipes as $pipe ) {
+            stream_set_blocking( $pipe, 0 );
         }
-        if (\is_resource($this->input)) {
-            stream_set_blocking($this->input, 0);
+        if ( \is_resource( $this->input ) ) {
+            stream_set_blocking( $this->input, 0 );
         }
 
         $this->blocked = false;
@@ -90,22 +90,22 @@ 
      */
     protected function write(): ?array
     {
-        if (!isset($this->pipes[0])) {
+        if ( ! isset( $this->pipes[ 0 ] ) ) {
             return null;
         }
         $input = $this->input;
 
-        if ($input instanceof \Iterator) {
-            if (!$input->valid()) {
+        if ( $input instanceof \Iterator ) {
+            if ( ! $input->valid() ) {
                 $input = null;
-            } elseif (\is_resource($input = $input->current())) {
-                stream_set_blocking($input, 0);
-            } elseif (!isset($this->inputBuffer[0])) {
-                if (!\is_string($input)) {
-                    if (!is_scalar($input)) {
-                        throw new InvalidArgumentException(sprintf('"%s" yielded a value of type "%s", but only scalars and stream resources are supported.', get_debug_type($this->input), get_debug_type($input)));
+            } elseif ( \is_resource( $input = $input->current() ) ) {
+                stream_set_blocking( $input, 0 );
+            } elseif ( ! isset( $this->inputBuffer[ 0 ] ) ) {
+                if ( ! \is_string( $input ) ) {
+                    if ( ! is_scalar( $input ) ) {
+                        throw new InvalidArgumentException( sprintf( '"%s" yielded a value of type "%s", but only scalars and stream resources are supported.', get_debug_type( $this->input ), get_debug_type( $input ) ) );
                     }
-                    $input = (string) $input;
+                    $input = (string)$input;
                 }
                 $this->inputBuffer = $input;
                 $this->input->next();
@@ -115,39 +115,39 @@ 
             }
         }
 
-        $r = $e = [];
-        $w = [$this->pipes[0]];
+        $r = $e = [ ];
+        $w = [ $this->pipes[ 0 ] ];
 
         // let's have a look if something changed in streams
-        if (false === @stream_select($r, $w, $e, 0, 0)) {
+        if ( false === @stream_select( $r, $w, $e, 0, 0 ) ) {
             return null;
         }
 
-        foreach ($w as $stdin) {
-            if (isset($this->inputBuffer[0])) {
-                $written = fwrite($stdin, $this->inputBuffer);
-                $this->inputBuffer = substr($this->inputBuffer, $written);
-                if (isset($this->inputBuffer[0])) {
-                    return [$this->pipes[0]];
+        foreach ( $w as $stdin ) {
+            if ( isset( $this->inputBuffer[ 0 ] ) ) {
+                $written = fwrite( $stdin, $this->inputBuffer );
+                $this->inputBuffer = substr( $this->inputBuffer, $written );
+                if ( isset( $this->inputBuffer[ 0 ] ) ) {
+                    return [ $this->pipes[ 0 ] ];
                 }
             }
 
-            if ($input) {
-                for (;;) {
-                    $data = fread($input, self::CHUNK_SIZE);
-                    if (!isset($data[0])) {
+            if ( $input ) {
+                for ( ;; ) {
+                    $data = fread( $input, self::CHUNK_SIZE );
+                    if ( ! isset( $data[ 0 ] ) ) {
                         break;
                     }
-                    $written = fwrite($stdin, $data);
-                    $data = substr($data, $written);
-                    if (isset($data[0])) {
+                    $written = fwrite( $stdin, $data );
+                    $data = substr( $data, $written );
+                    if ( isset( $data[ 0 ] ) ) {
                         $this->inputBuffer = $data;
 
-                        return [$this->pipes[0]];
+                        return [ $this->pipes[ 0 ] ];
                     }
                 }
-                if (feof($input)) {
-                    if ($this->input instanceof \Iterator) {
+                if ( feof( $input ) ) {
+                    if ( $this->input instanceof \Iterator ) {
                         $this->input->next();
                     } else {
                         $this->input = null;
@@ -157,12 +157,12 @@ 
         }
 
         // no input to read on resource, buffer is empty
-        if (!isset($this->inputBuffer[0]) && !($this->input instanceof \Iterator ? $this->input->valid() : $this->input)) {
+        if ( ! isset( $this->inputBuffer[ 0 ] ) && ! ( $this->input instanceof \Iterator ? $this->input->valid() : $this->input ) ) {
             $this->input = null;
-            fclose($this->pipes[0]);
-            unset($this->pipes[0]);
-        } elseif (!$w) {
-            return [$this->pipes[0]];
+            fclose( $this->pipes[ 0 ] );
+            unset( $this->pipes[ 0 ] );
+        } elseif ( ! $w ) {
+            return [ $this->pipes[ 0 ] ];
         }
 
         return null;
@@ -171,7 +171,7 @@ 
     /**
      * @internal
      */
-    public function handleError(int $type, string $msg)
+    public function handleError( int $type, string $msg )
     {
         $this->lastError = $msg;
     }

Braces +5 added lines, -10 removed lines

@@ -18,8 +18,7 @@ 
  *
  * @internal
  */
-abstract class AbstractPipes implements PipesInterface
-{
+abstract class AbstractPipes implements PipesInterface {
     public $pipes = [];
 
     private $inputBuffer = '';
@@ -30,8 +29,7 @@ 
     /**
      * @param resource|string|int|float|bool|\Iterator|null $input
      */
-    public function __construct($input)
-    {
+    public function __construct($input) {
         if (\is_resource($input) || $input instanceof \Iterator) {
             $this->input = $input;
         } elseif (\is_string($input)) {
@@ -44,8 +42,7 @@ 
     /**
      * {@inheritdoc}
      */
-    public function close()
-    {
+    public function close() {
         foreach ($this->pipes as $pipe) {
             fclose($pipe);
         }
@@ -67,8 +64,7 @@ 
     /**
      * Unblocks streams.
      */
-    protected function unblock()
-    {
+    protected function unblock() {
         if (!$this->blocked) {
             return;
         }
@@ -171,8 +167,7 @@ 
     /**
      * @internal
      */
-    public function handleError(int $type, string $msg)
-    {
+    public function handleError(int $type, string $msg) {
         $this->lastError = $msg;
     }
 }

vendor/symfony/process/Pipes/UnixPipes.php

Indentation +141 added lines, -141 removed lines

@@ -22,145 +22,145 @@
  */
 class UnixPipes extends AbstractPipes
 {
-    private $ttyMode;
-    private $ptyMode;
-    private $haveReadSupport;
-
-    public function __construct(?bool $ttyMode, bool $ptyMode, $input, bool $haveReadSupport)
-    {
-        $this->ttyMode = $ttyMode;
-        $this->ptyMode = $ptyMode;
-        $this->haveReadSupport = $haveReadSupport;
-
-        parent::__construct($input);
-    }
-
-    /**
-     * @return array
-     */
-    public function __sleep()
-    {
-        throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
-    }
-
-    public function __wakeup()
-    {
-        throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
-    }
-
-    public function __destruct()
-    {
-        $this->close();
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function getDescriptors(): array
-    {
-        if (!$this->haveReadSupport) {
-            $nullstream = fopen('/dev/null', 'c');
-
-            return [
-                ['pipe', 'r'],
-                $nullstream,
-                $nullstream,
-            ];
-        }
-
-        if ($this->ttyMode) {
-            return [
-                ['file', '/dev/tty', 'r'],
-                ['file', '/dev/tty', 'w'],
-                ['file', '/dev/tty', 'w'],
-            ];
-        }
-
-        if ($this->ptyMode && Process::isPtySupported()) {
-            return [
-                ['pty'],
-                ['pty'],
-                ['pty'],
-            ];
-        }
-
-        return [
-            ['pipe', 'r'],
-            ['pipe', 'w'], // stdout
-            ['pipe', 'w'], // stderr
-        ];
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function getFiles(): array
-    {
-        return [];
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function readAndWrite(bool $blocking, bool $close = false): array
-    {
-        $this->unblock();
-        $w = $this->write();
-
-        $read = $e = [];
-        $r = $this->pipes;
-        unset($r[0]);
-
-        // let's have a look if something changed in streams
-        set_error_handler([$this, 'handleError']);
-        if (($r || $w) && false === stream_select($r, $w, $e, 0, $blocking ? Process::TIMEOUT_PRECISION * 1E6 : 0)) {
-            restore_error_handler();
-            // if a system call has been interrupted, forget about it, let's try again
-            // otherwise, an error occurred, let's reset pipes
-            if (!$this->hasSystemCallBeenInterrupted()) {
-                $this->pipes = [];
-            }
-
-            return $read;
-        }
-        restore_error_handler();
-
-        foreach ($r as $pipe) {
-            // prior PHP 5.4 the array passed to stream_select is modified and
-            // lose key association, we have to find back the key
-            $read[$type = array_search($pipe, $this->pipes, true)] = '';
-
-            do {
-                $data = @fread($pipe, self::CHUNK_SIZE);
-                $read[$type] .= $data;
-            } while (isset($data[0]) && ($close || isset($data[self::CHUNK_SIZE - 1])));
-
-            if (!isset($read[$type][0])) {
-                unset($read[$type]);
-            }
-
-            if ($close && feof($pipe)) {
-                fclose($pipe);
-                unset($this->pipes[$type]);
-            }
-        }
-
-        return $read;
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function haveReadSupport(): bool
-    {
-        return $this->haveReadSupport;
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function areOpen(): bool
-    {
-        return (bool) $this->pipes;
-    }
+	private $ttyMode;
+	private $ptyMode;
+	private $haveReadSupport;
+
+	public function __construct(?bool $ttyMode, bool $ptyMode, $input, bool $haveReadSupport)
+	{
+		$this->ttyMode = $ttyMode;
+		$this->ptyMode = $ptyMode;
+		$this->haveReadSupport = $haveReadSupport;
+
+		parent::__construct($input);
+	}
+
+	/**
+	 * @return array
+	 */
+	public function __sleep()
+	{
+		throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
+	}
+
+	public function __wakeup()
+	{
+		throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
+	}
+
+	public function __destruct()
+	{
+		$this->close();
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function getDescriptors(): array
+	{
+		if (!$this->haveReadSupport) {
+			$nullstream = fopen('/dev/null', 'c');
+
+			return [
+				['pipe', 'r'],
+				$nullstream,
+				$nullstream,
+			];
+		}
+
+		if ($this->ttyMode) {
+			return [
+				['file', '/dev/tty', 'r'],
+				['file', '/dev/tty', 'w'],
+				['file', '/dev/tty', 'w'],
+			];
+		}
+
+		if ($this->ptyMode && Process::isPtySupported()) {
+			return [
+				['pty'],
+				['pty'],
+				['pty'],
+			];
+		}
+
+		return [
+			['pipe', 'r'],
+			['pipe', 'w'], // stdout
+			['pipe', 'w'], // stderr
+		];
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function getFiles(): array
+	{
+		return [];
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function readAndWrite(bool $blocking, bool $close = false): array
+	{
+		$this->unblock();
+		$w = $this->write();
+
+		$read = $e = [];
+		$r = $this->pipes;
+		unset($r[0]);
+
+		// let's have a look if something changed in streams
+		set_error_handler([$this, 'handleError']);
+		if (($r || $w) && false === stream_select($r, $w, $e, 0, $blocking ? Process::TIMEOUT_PRECISION * 1E6 : 0)) {
+			restore_error_handler();
+			// if a system call has been interrupted, forget about it, let's try again
+			// otherwise, an error occurred, let's reset pipes
+			if (!$this->hasSystemCallBeenInterrupted()) {
+				$this->pipes = [];
+			}
+
+			return $read;
+		}
+		restore_error_handler();
+
+		foreach ($r as $pipe) {
+			// prior PHP 5.4 the array passed to stream_select is modified and
+			// lose key association, we have to find back the key
+			$read[$type = array_search($pipe, $this->pipes, true)] = '';
+
+			do {
+				$data = @fread($pipe, self::CHUNK_SIZE);
+				$read[$type] .= $data;
+			} while (isset($data[0]) && ($close || isset($data[self::CHUNK_SIZE - 1])));
+
+			if (!isset($read[$type][0])) {
+				unset($read[$type]);
+			}
+
+			if ($close && feof($pipe)) {
+				fclose($pipe);
+				unset($this->pipes[$type]);
+			}
+		}
+
+		return $read;
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function haveReadSupport(): bool
+	{
+		return $this->haveReadSupport;
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function areOpen(): bool
+	{
+		return (bool) $this->pipes;
+	}
 }

Spacing +37 added lines, -37 removed lines

@@ -26,13 +26,13 @@ 
     private $ptyMode;
     private $haveReadSupport;
 
-    public function __construct(?bool $ttyMode, bool $ptyMode, $input, bool $haveReadSupport)
+    public function __construct( ?bool $ttyMode, bool $ptyMode, $input, bool $haveReadSupport )
     {
         $this->ttyMode = $ttyMode;
         $this->ptyMode = $ptyMode;
         $this->haveReadSupport = $haveReadSupport;
 
-        parent::__construct($input);
+        parent::__construct( $input );
     }
 
     /**
@@ -40,12 +40,12 @@ 
      */
     public function __sleep()
     {
-        throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
+        throw new \BadMethodCallException( 'Cannot serialize ' . __CLASS__ );
     }
 
     public function __wakeup()
     {
-        throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
+        throw new \BadMethodCallException( 'Cannot unserialize ' . __CLASS__ );
     }
 
     public function __destruct()
@@ -58,36 +58,36 @@ 
      */
     public function getDescriptors(): array
     {
-        if (!$this->haveReadSupport) {
-            $nullstream = fopen('/dev/null', 'c');
+        if ( ! $this->haveReadSupport ) {
+            $nullstream = fopen( '/dev/null', 'c' );
 
             return [
-                ['pipe', 'r'],
+                [ 'pipe', 'r' ],
                 $nullstream,
                 $nullstream,
             ];
         }
 
-        if ($this->ttyMode) {
+        if ( $this->ttyMode ) {
             return [
-                ['file', '/dev/tty', 'r'],
-                ['file', '/dev/tty', 'w'],
-                ['file', '/dev/tty', 'w'],
+                [ 'file', '/dev/tty', 'r' ],
+                [ 'file', '/dev/tty', 'w' ],
+                [ 'file', '/dev/tty', 'w' ],
             ];
         }
 
-        if ($this->ptyMode && Process::isPtySupported()) {
+        if ( $this->ptyMode && Process::isPtySupported() ) {
             return [
-                ['pty'],
-                ['pty'],
-                ['pty'],
+                [ 'pty' ],
+                [ 'pty' ],
+                [ 'pty' ],
             ];
         }
 
         return [
-            ['pipe', 'r'],
-            ['pipe', 'w'], // stdout
-            ['pipe', 'w'], // stderr
+            [ 'pipe', 'r' ],
+            [ 'pipe', 'w' ], // stdout
+            [ 'pipe', 'w' ], // stderr
         ];
     }
 
@@ -96,52 +96,52 @@ 
      */
     public function getFiles(): array
     {
-        return [];
+        return [ ];
     }
 
     /**
      * {@inheritdoc}
      */
-    public function readAndWrite(bool $blocking, bool $close = false): array
+    public function readAndWrite( bool $blocking, bool $close = false ): array
     {
         $this->unblock();
         $w = $this->write();
 
-        $read = $e = [];
+        $read = $e = [ ];
         $r = $this->pipes;
-        unset($r[0]);
+        unset( $r[ 0 ] );
 
         // let's have a look if something changed in streams
-        set_error_handler([$this, 'handleError']);
-        if (($r || $w) && false === stream_select($r, $w, $e, 0, $blocking ? Process::TIMEOUT_PRECISION * 1E6 : 0)) {
+        set_error_handler( [ $this, 'handleError' ] );
+        if ( ( $r || $w ) && false === stream_select( $r, $w, $e, 0, $blocking ? Process::TIMEOUT_PRECISION * 1E6 : 0 ) ) {
             restore_error_handler();
             // if a system call has been interrupted, forget about it, let's try again
             // otherwise, an error occurred, let's reset pipes
-            if (!$this->hasSystemCallBeenInterrupted()) {
-                $this->pipes = [];
+            if ( ! $this->hasSystemCallBeenInterrupted() ) {
+                $this->pipes = [ ];
             }
 
             return $read;
         }
         restore_error_handler();
 
-        foreach ($r as $pipe) {
+        foreach ( $r as $pipe ) {
             // prior PHP 5.4 the array passed to stream_select is modified and
             // lose key association, we have to find back the key
-            $read[$type = array_search($pipe, $this->pipes, true)] = '';
+            $read[ $type = array_search( $pipe, $this->pipes, true ) ] = '';
 
             do {
-                $data = @fread($pipe, self::CHUNK_SIZE);
-                $read[$type] .= $data;
-            } while (isset($data[0]) && ($close || isset($data[self::CHUNK_SIZE - 1])));
+                $data = @fread( $pipe, self::CHUNK_SIZE );
+                $read[ $type ] .= $data;
+            } while ( isset( $data[ 0 ] ) && ( $close || isset( $data[ self::CHUNK_SIZE - 1 ] ) ) );
 
-            if (!isset($read[$type][0])) {
-                unset($read[$type]);
+            if ( ! isset( $read[ $type ][ 0 ] ) ) {
+                unset( $read[ $type ] );
             }
 
-            if ($close && feof($pipe)) {
-                fclose($pipe);
-                unset($this->pipes[$type]);
+            if ( $close && feof( $pipe ) ) {
+                fclose( $pipe );
+                unset( $this->pipes[ $type ] );
             }
         }
 
@@ -161,6 +161,6 @@ 
      */
     public function areOpen(): bool
     {
-        return (bool) $this->pipes;
+        return (bool)$this->pipes;
     }
 }

Braces +5 added lines, -10 removed lines

@@ -20,14 +20,12 @@ 
  *
  * @internal
  */
-class UnixPipes extends AbstractPipes
-{
+class UnixPipes extends AbstractPipes {
     private $ttyMode;
     private $ptyMode;
     private $haveReadSupport;
 
-    public function __construct(?bool $ttyMode, bool $ptyMode, $input, bool $haveReadSupport)
-    {
+    public function __construct(?bool $ttyMode, bool $ptyMode, $input, bool $haveReadSupport) {
         $this->ttyMode = $ttyMode;
         $this->ptyMode = $ptyMode;
         $this->haveReadSupport = $haveReadSupport;
@@ -38,18 +36,15 @@ 
     /**
      * @return array
      */
-    public function __sleep()
-    {
+    public function __sleep() {
         throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
     }
 
-    public function __wakeup()
-    {
+    public function __wakeup() {
         throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
     }
 
-    public function __destruct()
-    {
+    public function __destruct() {
         $this->close();
     }
 

vendor/symfony/process/Pipes/WindowsPipes.php

Indentation +178 added lines, -178 removed lines

@@ -26,182 +26,182 @@
  */
 class WindowsPipes extends AbstractPipes
 {
-    private $files = [];
-    private $fileHandles = [];
-    private $lockHandles = [];
-    private $readBytes = [
-        Process::STDOUT => 0,
-        Process::STDERR => 0,
-    ];
-    private $haveReadSupport;
-
-    public function __construct($input, bool $haveReadSupport)
-    {
-        $this->haveReadSupport = $haveReadSupport;
-
-        if ($this->haveReadSupport) {
-            // Fix for PHP bug #51800: reading from STDOUT pipe hangs forever on Windows if the output is too big.
-            // Workaround for this problem is to use temporary files instead of pipes on Windows platform.
-            //
-            // @see https://bugs.php.net/51800
-            $pipes = [
-                Process::STDOUT => Process::OUT,
-                Process::STDERR => Process::ERR,
-            ];
-            $tmpDir = sys_get_temp_dir();
-            $lastError = 'unknown reason';
-            set_error_handler(function ($type, $msg) use (&$lastError) { $lastError = $msg; });
-            for ($i = 0;; ++$i) {
-                foreach ($pipes as $pipe => $name) {
-                    $file = sprintf('%s\\sf_proc_%02X.%s', $tmpDir, $i, $name);
-
-                    if (!$h = fopen($file.'.lock', 'w')) {
-                        if (file_exists($file.'.lock')) {
-                            continue 2;
-                        }
-                        restore_error_handler();
-                        throw new RuntimeException('A temporary file could not be opened to write the process output: '.$lastError);
-                    }
-                    if (!flock($h, \LOCK_EX | \LOCK_NB)) {
-                        continue 2;
-                    }
-                    if (isset($this->lockHandles[$pipe])) {
-                        flock($this->lockHandles[$pipe], \LOCK_UN);
-                        fclose($this->lockHandles[$pipe]);
-                    }
-                    $this->lockHandles[$pipe] = $h;
-
-                    if (!($h = fopen($file, 'w')) || !fclose($h) || !$h = fopen($file, 'r')) {
-                        flock($this->lockHandles[$pipe], \LOCK_UN);
-                        fclose($this->lockHandles[$pipe]);
-                        unset($this->lockHandles[$pipe]);
-                        continue 2;
-                    }
-                    $this->fileHandles[$pipe] = $h;
-                    $this->files[$pipe] = $file;
-                }
-                break;
-            }
-            restore_error_handler();
-        }
-
-        parent::__construct($input);
-    }
-
-    /**
-     * @return array
-     */
-    public function __sleep()
-    {
-        throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
-    }
-
-    public function __wakeup()
-    {
-        throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
-    }
-
-    public function __destruct()
-    {
-        $this->close();
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function getDescriptors(): array
-    {
-        if (!$this->haveReadSupport) {
-            $nullstream = fopen('NUL', 'c');
-
-            return [
-                ['pipe', 'r'],
-                $nullstream,
-                $nullstream,
-            ];
-        }
-
-        // We're not using pipe on Windows platform as it hangs (https://bugs.php.net/51800)
-        // We're not using file handles as it can produce corrupted output https://bugs.php.net/65650
-        // So we redirect output within the commandline and pass the nul device to the process
-        return [
-            ['pipe', 'r'],
-            ['file', 'NUL', 'w'],
-            ['file', 'NUL', 'w'],
-        ];
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function getFiles(): array
-    {
-        return $this->files;
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function readAndWrite(bool $blocking, bool $close = false): array
-    {
-        $this->unblock();
-        $w = $this->write();
-        $read = $r = $e = [];
-
-        if ($blocking) {
-            if ($w) {
-                @stream_select($r, $w, $e, 0, Process::TIMEOUT_PRECISION * 1E6);
-            } elseif ($this->fileHandles) {
-                usleep(Process::TIMEOUT_PRECISION * 1E6);
-            }
-        }
-        foreach ($this->fileHandles as $type => $fileHandle) {
-            $data = stream_get_contents($fileHandle, -1, $this->readBytes[$type]);
-
-            if (isset($data[0])) {
-                $this->readBytes[$type] += \strlen($data);
-                $read[$type] = $data;
-            }
-            if ($close) {
-                ftruncate($fileHandle, 0);
-                fclose($fileHandle);
-                flock($this->lockHandles[$type], \LOCK_UN);
-                fclose($this->lockHandles[$type]);
-                unset($this->fileHandles[$type], $this->lockHandles[$type]);
-            }
-        }
-
-        return $read;
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function haveReadSupport(): bool
-    {
-        return $this->haveReadSupport;
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function areOpen(): bool
-    {
-        return $this->pipes && $this->fileHandles;
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function close()
-    {
-        parent::close();
-        foreach ($this->fileHandles as $type => $handle) {
-            ftruncate($handle, 0);
-            fclose($handle);
-            flock($this->lockHandles[$type], \LOCK_UN);
-            fclose($this->lockHandles[$type]);
-        }
-        $this->fileHandles = $this->lockHandles = [];
-    }
+	private $files = [];
+	private $fileHandles = [];
+	private $lockHandles = [];
+	private $readBytes = [
+		Process::STDOUT => 0,
+		Process::STDERR => 0,
+	];
+	private $haveReadSupport;
+
+	public function __construct($input, bool $haveReadSupport)
+	{
+		$this->haveReadSupport = $haveReadSupport;
+
+		if ($this->haveReadSupport) {
+			// Fix for PHP bug #51800: reading from STDOUT pipe hangs forever on Windows if the output is too big.
+			// Workaround for this problem is to use temporary files instead of pipes on Windows platform.
+			//
+			// @see https://bugs.php.net/51800
+			$pipes = [
+				Process::STDOUT => Process::OUT,
+				Process::STDERR => Process::ERR,
+			];
+			$tmpDir = sys_get_temp_dir();
+			$lastError = 'unknown reason';
+			set_error_handler(function ($type, $msg) use (&$lastError) { $lastError = $msg; });
+			for ($i = 0;; ++$i) {
+				foreach ($pipes as $pipe => $name) {
+					$file = sprintf('%s\\sf_proc_%02X.%s', $tmpDir, $i, $name);
+
+					if (!$h = fopen($file.'.lock', 'w')) {
+						if (file_exists($file.'.lock')) {
+							continue 2;
+						}
+						restore_error_handler();
+						throw new RuntimeException('A temporary file could not be opened to write the process output: '.$lastError);
+					}
+					if (!flock($h, \LOCK_EX | \LOCK_NB)) {
+						continue 2;
+					}
+					if (isset($this->lockHandles[$pipe])) {
+						flock($this->lockHandles[$pipe], \LOCK_UN);
+						fclose($this->lockHandles[$pipe]);
+					}
+					$this->lockHandles[$pipe] = $h;
+
+					if (!($h = fopen($file, 'w')) || !fclose($h) || !$h = fopen($file, 'r')) {
+						flock($this->lockHandles[$pipe], \LOCK_UN);
+						fclose($this->lockHandles[$pipe]);
+						unset($this->lockHandles[$pipe]);
+						continue 2;
+					}
+					$this->fileHandles[$pipe] = $h;
+					$this->files[$pipe] = $file;
+				}
+				break;
+			}
+			restore_error_handler();
+		}
+
+		parent::__construct($input);
+	}
+
+	/**
+	 * @return array
+	 */
+	public function __sleep()
+	{
+		throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
+	}
+
+	public function __wakeup()
+	{
+		throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
+	}
+
+	public function __destruct()
+	{
+		$this->close();
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function getDescriptors(): array
+	{
+		if (!$this->haveReadSupport) {
+			$nullstream = fopen('NUL', 'c');
+
+			return [
+				['pipe', 'r'],
+				$nullstream,
+				$nullstream,
+			];
+		}
+
+		// We're not using pipe on Windows platform as it hangs (https://bugs.php.net/51800)
+		// We're not using file handles as it can produce corrupted output https://bugs.php.net/65650
+		// So we redirect output within the commandline and pass the nul device to the process
+		return [
+			['pipe', 'r'],
+			['file', 'NUL', 'w'],
+			['file', 'NUL', 'w'],
+		];
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function getFiles(): array
+	{
+		return $this->files;
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function readAndWrite(bool $blocking, bool $close = false): array
+	{
+		$this->unblock();
+		$w = $this->write();
+		$read = $r = $e = [];
+
+		if ($blocking) {
+			if ($w) {
+				@stream_select($r, $w, $e, 0, Process::TIMEOUT_PRECISION * 1E6);
+			} elseif ($this->fileHandles) {
+				usleep(Process::TIMEOUT_PRECISION * 1E6);
+			}
+		}
+		foreach ($this->fileHandles as $type => $fileHandle) {
+			$data = stream_get_contents($fileHandle, -1, $this->readBytes[$type]);
+
+			if (isset($data[0])) {
+				$this->readBytes[$type] += \strlen($data);
+				$read[$type] = $data;
+			}
+			if ($close) {
+				ftruncate($fileHandle, 0);
+				fclose($fileHandle);
+				flock($this->lockHandles[$type], \LOCK_UN);
+				fclose($this->lockHandles[$type]);
+				unset($this->fileHandles[$type], $this->lockHandles[$type]);
+			}
+		}
+
+		return $read;
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function haveReadSupport(): bool
+	{
+		return $this->haveReadSupport;
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function areOpen(): bool
+	{
+		return $this->pipes && $this->fileHandles;
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function close()
+	{
+		parent::close();
+		foreach ($this->fileHandles as $type => $handle) {
+			ftruncate($handle, 0);
+			fclose($handle);
+			flock($this->lockHandles[$type], \LOCK_UN);
+			fclose($this->lockHandles[$type]);
+		}
+		$this->fileHandles = $this->lockHandles = [];
+	}
 }

Spacing +56 added lines, -56 removed lines

@@ -26,20 +26,20 @@ 
  */
 class WindowsPipes extends AbstractPipes
 {
-    private $files = [];
-    private $fileHandles = [];
-    private $lockHandles = [];
+    private $files = [ ];
+    private $fileHandles = [ ];
+    private $lockHandles = [ ];
     private $readBytes = [
         Process::STDOUT => 0,
         Process::STDERR => 0,
     ];
     private $haveReadSupport;
 
-    public function __construct($input, bool $haveReadSupport)
+    public function __construct( $input, bool $haveReadSupport )
     {
         $this->haveReadSupport = $haveReadSupport;
 
-        if ($this->haveReadSupport) {
+        if ( $this->haveReadSupport ) {
             // Fix for PHP bug #51800: reading from STDOUT pipe hangs forever on Windows if the output is too big.
             // Workaround for this problem is to use temporary files instead of pipes on Windows platform.
             //
@@ -50,42 +50,42 @@ 
             ];
             $tmpDir = sys_get_temp_dir();
             $lastError = 'unknown reason';
-            set_error_handler(function ($type, $msg) use (&$lastError) { $lastError = $msg; });
-            for ($i = 0;; ++$i) {
-                foreach ($pipes as $pipe => $name) {
-                    $file = sprintf('%s\\sf_proc_%02X.%s', $tmpDir, $i, $name);
+            set_error_handler( function( $type, $msg ) use ( &$lastError ) { $lastError = $msg; });
+            for ( $i = 0; ; ++$i ) {
+                foreach ( $pipes as $pipe => $name ) {
+                    $file = sprintf( '%s\\sf_proc_%02X.%s', $tmpDir, $i, $name );
 
-                    if (!$h = fopen($file.'.lock', 'w')) {
-                        if (file_exists($file.'.lock')) {
+                    if ( ! $h = fopen( $file . '.lock', 'w' ) ) {
+                        if ( file_exists( $file . '.lock' ) ) {
                             continue 2;
                         }
                         restore_error_handler();
-                        throw new RuntimeException('A temporary file could not be opened to write the process output: '.$lastError);
+                        throw new RuntimeException( 'A temporary file could not be opened to write the process output: ' . $lastError );
                     }
-                    if (!flock($h, \LOCK_EX | \LOCK_NB)) {
+                    if ( ! flock( $h, \LOCK_EX | \LOCK_NB ) ) {
                         continue 2;
                     }
-                    if (isset($this->lockHandles[$pipe])) {
-                        flock($this->lockHandles[$pipe], \LOCK_UN);
-                        fclose($this->lockHandles[$pipe]);
+                    if ( isset( $this->lockHandles[ $pipe ] ) ) {
+                        flock( $this->lockHandles[ $pipe ], \LOCK_UN );
+                        fclose( $this->lockHandles[ $pipe ] );
                     }
-                    $this->lockHandles[$pipe] = $h;
+                    $this->lockHandles[ $pipe ] = $h;
 
-                    if (!($h = fopen($file, 'w')) || !fclose($h) || !$h = fopen($file, 'r')) {
-                        flock($this->lockHandles[$pipe], \LOCK_UN);
-                        fclose($this->lockHandles[$pipe]);
-                        unset($this->lockHandles[$pipe]);
+                    if ( ! ( $h = fopen( $file, 'w' ) ) || ! fclose( $h ) || ! $h = fopen( $file, 'r' ) ) {
+                        flock( $this->lockHandles[ $pipe ], \LOCK_UN );
+                        fclose( $this->lockHandles[ $pipe ] );
+                        unset( $this->lockHandles[ $pipe ] );
                         continue 2;
                     }
-                    $this->fileHandles[$pipe] = $h;
-                    $this->files[$pipe] = $file;
+                    $this->fileHandles[ $pipe ] = $h;
+                    $this->files[ $pipe ] = $file;
                 }
                 break;
             }
             restore_error_handler();
         }
 
-        parent::__construct($input);
+        parent::__construct( $input );
     }
 
     /**
@@ -93,12 +93,12 @@ 
      */
     public function __sleep()
     {
-        throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
+        throw new \BadMethodCallException( 'Cannot serialize ' . __CLASS__ );
     }
 
     public function __wakeup()
     {
-        throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
+        throw new \BadMethodCallException( 'Cannot unserialize ' . __CLASS__ );
     }
 
     public function __destruct()
@@ -111,11 +111,11 @@ 
      */
     public function getDescriptors(): array
     {
-        if (!$this->haveReadSupport) {
-            $nullstream = fopen('NUL', 'c');
+        if ( ! $this->haveReadSupport ) {
+            $nullstream = fopen( 'NUL', 'c' );
 
             return [
-                ['pipe', 'r'],
+                [ 'pipe', 'r' ],
                 $nullstream,
                 $nullstream,
             ];
@@ -125,9 +125,9 @@ 
         // We're not using file handles as it can produce corrupted output https://bugs.php.net/65650
         // So we redirect output within the commandline and pass the nul device to the process
         return [
-            ['pipe', 'r'],
-            ['file', 'NUL', 'w'],
-            ['file', 'NUL', 'w'],
+            [ 'pipe', 'r' ],
+            [ 'file', 'NUL', 'w' ],
+            [ 'file', 'NUL', 'w' ],
         ];
     }
 
@@ -142,32 +142,32 @@ 
     /**
      * {@inheritdoc}
      */
-    public function readAndWrite(bool $blocking, bool $close = false): array
+    public function readAndWrite( bool $blocking, bool $close = false ): array
     {
         $this->unblock();
         $w = $this->write();
-        $read = $r = $e = [];
+        $read = $r = $e = [ ];
 
-        if ($blocking) {
-            if ($w) {
-                @stream_select($r, $w, $e, 0, Process::TIMEOUT_PRECISION * 1E6);
-            } elseif ($this->fileHandles) {
-                usleep(Process::TIMEOUT_PRECISION * 1E6);
+        if ( $blocking ) {
+            if ( $w ) {
+                @stream_select( $r, $w, $e, 0, Process::TIMEOUT_PRECISION * 1E6 );
+            } elseif ( $this->fileHandles ) {
+                usleep( Process::TIMEOUT_PRECISION * 1E6 );
             }
         }
-        foreach ($this->fileHandles as $type => $fileHandle) {
-            $data = stream_get_contents($fileHandle, -1, $this->readBytes[$type]);
+        foreach ( $this->fileHandles as $type => $fileHandle ) {
+            $data = stream_get_contents( $fileHandle, -1, $this->readBytes[ $type ] );
 
-            if (isset($data[0])) {
-                $this->readBytes[$type] += \strlen($data);
-                $read[$type] = $data;
+            if ( isset( $data[ 0 ] ) ) {
+                $this->readBytes[ $type ] += \strlen( $data );
+                $read[ $type ] = $data;
             }
-            if ($close) {
-                ftruncate($fileHandle, 0);
-                fclose($fileHandle);
-                flock($this->lockHandles[$type], \LOCK_UN);
-                fclose($this->lockHandles[$type]);
-                unset($this->fileHandles[$type], $this->lockHandles[$type]);
+            if ( $close ) {
+                ftruncate( $fileHandle, 0 );
+                fclose( $fileHandle );
+                flock( $this->lockHandles[ $type ], \LOCK_UN );
+                fclose( $this->lockHandles[ $type ] );
+                unset( $this->fileHandles[ $type ], $this->lockHandles[ $type ] );
             }
         }
 
@@ -196,12 +196,12 @@ 
     public function close()
     {
         parent::close();
-        foreach ($this->fileHandles as $type => $handle) {
-            ftruncate($handle, 0);
-            fclose($handle);
-            flock($this->lockHandles[$type], \LOCK_UN);
-            fclose($this->lockHandles[$type]);
+        foreach ( $this->fileHandles as $type => $handle ) {
+            ftruncate( $handle, 0 );
+            fclose( $handle );
+            flock( $this->lockHandles[ $type ], \LOCK_UN );
+            fclose( $this->lockHandles[ $type ] );
         }
-        $this->fileHandles = $this->lockHandles = [];
+        $this->fileHandles = $this->lockHandles = [ ];
     }
 }

Braces +6 added lines, -12 removed lines

@@ -24,8 +24,7 @@ 
  *
  * @internal
  */
-class WindowsPipes extends AbstractPipes
-{
+class WindowsPipes extends AbstractPipes {
     private $files = [];
     private $fileHandles = [];
     private $lockHandles = [];
@@ -35,8 +34,7 @@ 
     ];
     private $haveReadSupport;
 
-    public function __construct($input, bool $haveReadSupport)
-    {
+    public function __construct($input, bool $haveReadSupport) {
         $this->haveReadSupport = $haveReadSupport;
 
         if ($this->haveReadSupport) {
@@ -91,18 +89,15 @@ 
     /**
      * @return array
      */
-    public function __sleep()
-    {
+    public function __sleep() {
         throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
     }
 
-    public function __wakeup()
-    {
+    public function __wakeup() {
         throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
     }
 
-    public function __destruct()
-    {
+    public function __destruct() {
         $this->close();
     }
 
@@ -193,8 +188,7 @@ 
     /**
      * {@inheritdoc}
      */
-    public function close()
-    {
+    public function close() {
         parent::close();
         foreach ($this->fileHandles as $type => $handle) {
             ftruncate($handle, 0);

vendor/symfony/process/PhpProcess.php

Indentation +40 added lines, -40 removed lines

@@ -25,48 +25,48 @@
  */
 class PhpProcess extends Process
 {
-    /**
-     * @param string      $script  The PHP script to run (as a string)
-     * @param string|null $cwd     The working directory or null to use the working dir of the current PHP process
-     * @param array|null  $env     The environment variables or null to use the same environment as the current PHP process
-     * @param int         $timeout The timeout in seconds
-     * @param array|null  $php     Path to the PHP binary to use with any additional arguments
-     */
-    public function __construct(string $script, string $cwd = null, array $env = null, int $timeout = 60, array $php = null)
-    {
-        if (null === $php) {
-            $executableFinder = new PhpExecutableFinder();
-            $php = $executableFinder->find(false);
-            $php = false === $php ? null : array_merge([$php], $executableFinder->findArguments());
-        }
-        if ('phpdbg' === \PHP_SAPI) {
-            $file = tempnam(sys_get_temp_dir(), 'dbg');
-            file_put_contents($file, $script);
-            register_shutdown_function('unlink', $file);
-            $php[] = $file;
-            $script = null;
-        }
+	/**
+	 * @param string      $script  The PHP script to run (as a string)
+	 * @param string|null $cwd     The working directory or null to use the working dir of the current PHP process
+	 * @param array|null  $env     The environment variables or null to use the same environment as the current PHP process
+	 * @param int         $timeout The timeout in seconds
+	 * @param array|null  $php     Path to the PHP binary to use with any additional arguments
+	 */
+	public function __construct(string $script, string $cwd = null, array $env = null, int $timeout = 60, array $php = null)
+	{
+		if (null === $php) {
+			$executableFinder = new PhpExecutableFinder();
+			$php = $executableFinder->find(false);
+			$php = false === $php ? null : array_merge([$php], $executableFinder->findArguments());
+		}
+		if ('phpdbg' === \PHP_SAPI) {
+			$file = tempnam(sys_get_temp_dir(), 'dbg');
+			file_put_contents($file, $script);
+			register_shutdown_function('unlink', $file);
+			$php[] = $file;
+			$script = null;
+		}
 
-        parent::__construct($php, $cwd, $env, $script, $timeout);
-    }
+		parent::__construct($php, $cwd, $env, $script, $timeout);
+	}
 
-    /**
-     * {@inheritdoc}
-     */
-    public static function fromShellCommandline(string $command, string $cwd = null, array $env = null, $input = null, ?float $timeout = 60)
-    {
-        throw new LogicException(sprintf('The "%s()" method cannot be called when using "%s".', __METHOD__, self::class));
-    }
+	/**
+	 * {@inheritdoc}
+	 */
+	public static function fromShellCommandline(string $command, string $cwd = null, array $env = null, $input = null, ?float $timeout = 60)
+	{
+		throw new LogicException(sprintf('The "%s()" method cannot be called when using "%s".', __METHOD__, self::class));
+	}
 
-    /**
-     * {@inheritdoc}
-     */
-    public function start(callable $callback = null, array $env = [])
-    {
-        if (null === $this->getCommandLine()) {
-            throw new RuntimeException('Unable to find the PHP executable.');
-        }
+	/**
+	 * {@inheritdoc}
+	 */
+	public function start(callable $callback = null, array $env = [])
+	{
+		if (null === $this->getCommandLine()) {
+			throw new RuntimeException('Unable to find the PHP executable.');
+		}
 
-        parent::start($callback, $env);
-    }
+		parent::start($callback, $env);
+	}
 }

Spacing +16 added lines, -16 removed lines

@@ -32,41 +32,41 @@
      * @param int         $timeout The timeout in seconds
      * @param array|null  $php     Path to the PHP binary to use with any additional arguments
      */
-    public function __construct(string $script, string $cwd = null, array $env = null, int $timeout = 60, array $php = null)
+    public function __construct( string $script, string $cwd = null, array $env = null, int $timeout = 60, array $php = null )
     {
-        if (null === $php) {
+        if ( null === $php ) {
             $executableFinder = new PhpExecutableFinder();
-            $php = $executableFinder->find(false);
-            $php = false === $php ? null : array_merge([$php], $executableFinder->findArguments());
+            $php = $executableFinder->find( false );
+            $php = false === $php ? null : array_merge( [ $php ], $executableFinder->findArguments() );
         }
-        if ('phpdbg' === \PHP_SAPI) {
-            $file = tempnam(sys_get_temp_dir(), 'dbg');
-            file_put_contents($file, $script);
-            register_shutdown_function('unlink', $file);
-            $php[] = $file;
+        if ( 'phpdbg' === \PHP_SAPI ) {
+            $file = tempnam( sys_get_temp_dir(), 'dbg' );
+            file_put_contents( $file, $script );
+            register_shutdown_function( 'unlink', $file );
+            $php[ ] = $file;
             $script = null;
         }
 
-        parent::__construct($php, $cwd, $env, $script, $timeout);
+        parent::__construct( $php, $cwd, $env, $script, $timeout );
     }
 
     /**
      * {@inheritdoc}
      */
-    public static function fromShellCommandline(string $command, string $cwd = null, array $env = null, $input = null, ?float $timeout = 60)
+    public static function fromShellCommandline( string $command, string $cwd = null, array $env = null, $input = null, ?float $timeout = 60 )
     {
-        throw new LogicException(sprintf('The "%s()" method cannot be called when using "%s".', __METHOD__, self::class));
+        throw new LogicException( sprintf( 'The "%s()" method cannot be called when using "%s".', __METHOD__, self::class ) );
     }
 
     /**
      * {@inheritdoc}
      */
-    public function start(callable $callback = null, array $env = [])
+    public function start( callable $callback = null, array $env = [ ] )
     {
-        if (null === $this->getCommandLine()) {
-            throw new RuntimeException('Unable to find the PHP executable.');
+        if ( null === $this->getCommandLine() ) {
+            throw new RuntimeException( 'Unable to find the PHP executable.' );
         }
 
-        parent::start($callback, $env);
+        parent::start( $callback, $env );
     }
 }

Braces +4 added lines, -8 removed lines

@@ -23,8 +23,7 @@ 
  *
  * @author Fabien Potencier <fabien@symfony.com>
  */
-class PhpProcess extends Process
-{
+class PhpProcess extends Process {
     /**
      * @param string      $script  The PHP script to run (as a string)
      * @param string|null $cwd     The working directory or null to use the working dir of the current PHP process
@@ -32,8 +31,7 @@ 
      * @param int         $timeout The timeout in seconds
      * @param array|null  $php     Path to the PHP binary to use with any additional arguments
      */
-    public function __construct(string $script, string $cwd = null, array $env = null, int $timeout = 60, array $php = null)
-    {
+    public function __construct(string $script, string $cwd = null, array $env = null, int $timeout = 60, array $php = null) {
         if (null === $php) {
             $executableFinder = new PhpExecutableFinder();
             $php = $executableFinder->find(false);
@@ -53,16 +51,14 @@ 
     /**
      * {@inheritdoc}
      */
-    public static function fromShellCommandline(string $command, string $cwd = null, array $env = null, $input = null, ?float $timeout = 60)
-    {
+    public static function fromShellCommandline(string $command, string $cwd = null, array $env = null, $input = null, ?float $timeout = 60) {
         throw new LogicException(sprintf('The "%s()" method cannot be called when using "%s".', __METHOD__, self::class));
     }
 
     /**
      * {@inheritdoc}
      */
-    public function start(callable $callback = null, array $env = [])
-    {
+    public function start(callable $callback = null, array $env = []) {
         if (null === $this->getCommandLine()) {
             throw new RuntimeException('Unable to find the PHP executable.');
         }

vendor/symfony/process/InputStream.php

Indentation +64 added lines, -64 removed lines

@@ -20,75 +20,75 @@
  */
 class InputStream implements \IteratorAggregate
 {
-    /** @var callable|null */
-    private $onEmpty = null;
-    private $input = [];
-    private $open = true;
+	/** @var callable|null */
+	private $onEmpty = null;
+	private $input = [];
+	private $open = true;
 
-    /**
-     * Sets a callback that is called when the write buffer becomes empty.
-     */
-    public function onEmpty(callable $onEmpty = null)
-    {
-        $this->onEmpty = $onEmpty;
-    }
+	/**
+	 * Sets a callback that is called when the write buffer becomes empty.
+	 */
+	public function onEmpty(callable $onEmpty = null)
+	{
+		$this->onEmpty = $onEmpty;
+	}
 
-    /**
-     * Appends an input to the write buffer.
-     *
-     * @param resource|string|int|float|bool|\Traversable|null $input The input to append as scalar,
-     *                                                                stream resource or \Traversable
-     */
-    public function write($input)
-    {
-        if (null === $input) {
-            return;
-        }
-        if ($this->isClosed()) {
-            throw new RuntimeException(sprintf('"%s" is closed.', static::class));
-        }
-        $this->input[] = ProcessUtils::validateInput(__METHOD__, $input);
-    }
+	/**
+	 * Appends an input to the write buffer.
+	 *
+	 * @param resource|string|int|float|bool|\Traversable|null $input The input to append as scalar,
+	 *                                                                stream resource or \Traversable
+	 */
+	public function write($input)
+	{
+		if (null === $input) {
+			return;
+		}
+		if ($this->isClosed()) {
+			throw new RuntimeException(sprintf('"%s" is closed.', static::class));
+		}
+		$this->input[] = ProcessUtils::validateInput(__METHOD__, $input);
+	}
 
-    /**
-     * Closes the write buffer.
-     */
-    public function close()
-    {
-        $this->open = false;
-    }
+	/**
+	 * Closes the write buffer.
+	 */
+	public function close()
+	{
+		$this->open = false;
+	}
 
-    /**
-     * Tells whether the write buffer is closed or not.
-     */
-    public function isClosed()
-    {
-        return !$this->open;
-    }
+	/**
+	 * Tells whether the write buffer is closed or not.
+	 */
+	public function isClosed()
+	{
+		return !$this->open;
+	}
 
-    /**
-     * @return \Traversable
-     */
-    #[\ReturnTypeWillChange]
-    public function getIterator()
-    {
-        $this->open = true;
+	/**
+	 * @return \Traversable
+	 */
+	#[\ReturnTypeWillChange]
+	public function getIterator()
+	{
+		$this->open = true;
 
-        while ($this->open || $this->input) {
-            if (!$this->input) {
-                yield '';
-                continue;
-            }
-            $current = array_shift($this->input);
+		while ($this->open || $this->input) {
+			if (!$this->input) {
+				yield '';
+				continue;
+			}
+			$current = array_shift($this->input);
 
-            if ($current instanceof \Iterator) {
-                yield from $current;
-            } else {
-                yield $current;
-            }
-            if (!$this->input && $this->open && null !== $onEmpty = $this->onEmpty) {
-                $this->write($onEmpty($this));
-            }
-        }
-    }
+			if ($current instanceof \Iterator) {
+				yield from $current;
+			} else {
+				yield $current;
+			}
+			if (!$this->input && $this->open && null !== $onEmpty = $this->onEmpty) {
+				$this->write($onEmpty($this));
+			}
+		}
+	}
 }

Spacing +14 added lines, -14 removed lines

@@ -22,13 +22,13 @@ 
 {
     /** @var callable|null */
     private $onEmpty = null;
-    private $input = [];
+    private $input = [ ];
     private $open = true;
 
     /**
      * Sets a callback that is called when the write buffer becomes empty.
      */
-    public function onEmpty(callable $onEmpty = null)
+    public function onEmpty( callable $onEmpty = null )
     {
         $this->onEmpty = $onEmpty;
     }
@@ -39,15 +39,15 @@ 
      * @param resource|string|int|float|bool|\Traversable|null $input The input to append as scalar,
      *                                                                stream resource or \Traversable
      */
-    public function write($input)
+    public function write( $input )
     {
-        if (null === $input) {
+        if ( null === $input ) {
             return;
         }
-        if ($this->isClosed()) {
-            throw new RuntimeException(sprintf('"%s" is closed.', static::class));
+        if ( $this->isClosed() ) {
+            throw new RuntimeException( sprintf( '"%s" is closed.', static::class ) );
         }
-        $this->input[] = ProcessUtils::validateInput(__METHOD__, $input);
+        $this->input[ ] = ProcessUtils::validateInput( __METHOD__, $input );
     }
 
     /**
@@ -63,7 +63,7 @@ 
      */
     public function isClosed()
     {
-        return !$this->open;
+        return ! $this->open;
     }
 
     /**
@@ -74,20 +74,20 @@ 
     {
         $this->open = true;
 
-        while ($this->open || $this->input) {
-            if (!$this->input) {
+        while ( $this->open || $this->input ) {
+            if ( ! $this->input ) {
                 yield '';
                 continue;
             }
-            $current = array_shift($this->input);
+            $current = array_shift( $this->input );
 
-            if ($current instanceof \Iterator) {
+            if ( $current instanceof \Iterator ) {
                 yield from $current;
             } else {
                 yield $current;
             }
-            if (!$this->input && $this->open && null !== $onEmpty = $this->onEmpty) {
-                $this->write($onEmpty($this));
+            if ( ! $this->input && $this->open && null !== $onEmpty = $this->onEmpty ) {
+                $this->write( $onEmpty( $this ) );
             }
         }
     }

Braces +6 added lines, -12 removed lines

@@ -18,8 +18,7 @@ 
  *
  * @author Nicolas Grekas <p@tchwork.com>
  */
-class InputStream implements \IteratorAggregate
-{
+class InputStream implements \IteratorAggregate {
     /** @var callable|null */
     private $onEmpty = null;
     private $input = [];
@@ -28,8 +27,7 @@ 
     /**
      * Sets a callback that is called when the write buffer becomes empty.
      */
-    public function onEmpty(callable $onEmpty = null)
-    {
+    public function onEmpty(callable $onEmpty = null) {
         $this->onEmpty = $onEmpty;
     }
 
@@ -39,8 +37,7 @@ 
      * @param resource|string|int|float|bool|\Traversable|null $input The input to append as scalar,
      *                                                                stream resource or \Traversable
      */
-    public function write($input)
-    {
+    public function write($input) {
         if (null === $input) {
             return;
         }
@@ -53,16 +50,14 @@ 
     /**
      * Closes the write buffer.
      */
-    public function close()
-    {
+    public function close() {
         $this->open = false;
     }
 
     /**
      * Tells whether the write buffer is closed or not.
      */
-    public function isClosed()
-    {
+    public function isClosed() {
         return !$this->open;
     }
 
@@ -70,8 +65,7 @@ 
      * @return \Traversable
      */
     #[\ReturnTypeWillChange]
-    public function getIterator()
-    {
+    public function getIterator() {
         $this->open = true;
 
         while ($this->open || $this->input) {

vendor/symfony/process/PhpExecutableFinder.php

Indentation +77 added lines, -77 removed lines

@@ -19,81 +19,81 @@
  */
 class PhpExecutableFinder
 {
-    private $executableFinder;
-
-    public function __construct()
-    {
-        $this->executableFinder = new ExecutableFinder();
-    }
-
-    /**
-     * Finds The PHP executable.
-     *
-     * @return string|false The PHP executable path or false if it cannot be found
-     */
-    public function find(bool $includeArgs = true)
-    {
-        if ($php = getenv('PHP_BINARY')) {
-            if (!is_executable($php)) {
-                $command = '\\' === \DIRECTORY_SEPARATOR ? 'where' : 'command -v';
-                if ($php = strtok(exec($command.' '.escapeshellarg($php)), \PHP_EOL)) {
-                    if (!is_executable($php)) {
-                        return false;
-                    }
-                } else {
-                    return false;
-                }
-            }
-
-            return $php;
-        }
-
-        $args = $this->findArguments();
-        $args = $includeArgs && $args ? ' '.implode(' ', $args) : '';
-
-        // PHP_BINARY return the current sapi executable
-        if (\PHP_BINARY && \in_array(\PHP_SAPI, ['cgi-fcgi', 'cli', 'cli-server', 'phpdbg'], true)) {
-            return \PHP_BINARY.$args;
-        }
-
-        if ($php = getenv('PHP_PATH')) {
-            if (!@is_executable($php)) {
-                return false;
-            }
-
-            return $php;
-        }
-
-        if ($php = getenv('PHP_PEAR_PHP_BIN')) {
-            if (@is_executable($php)) {
-                return $php;
-            }
-        }
-
-        if (@is_executable($php = \PHP_BINDIR.('\\' === \DIRECTORY_SEPARATOR ? '\\php.exe' : '/php'))) {
-            return $php;
-        }
-
-        $dirs = [\PHP_BINDIR];
-        if ('\\' === \DIRECTORY_SEPARATOR) {
-            $dirs[] = 'C:\xampp\php\\';
-        }
-
-        return $this->executableFinder->find('php', false, $dirs);
-    }
-
-    /**
-     * Finds the PHP executable arguments.
-     *
-     * @return array The PHP executable arguments
-     */
-    public function findArguments()
-    {
-        $arguments = [];
-        if ('phpdbg' === \PHP_SAPI) {
-            $arguments[] = '-qrr';
-        }
-
-        return $arguments;
-    }
+	private $executableFinder;
+
+	public function __construct()
+	{
+		$this->executableFinder = new ExecutableFinder();
+	}
+
+	/**
+	 * Finds The PHP executable.
+	 *
+	 * @return string|false The PHP executable path or false if it cannot be found
+	 */
+	public function find(bool $includeArgs = true)
+	{
+		if ($php = getenv('PHP_BINARY')) {
+			if (!is_executable($php)) {
+				$command = '\\' === \DIRECTORY_SEPARATOR ? 'where' : 'command -v';
+				if ($php = strtok(exec($command.' '.escapeshellarg($php)), \PHP_EOL)) {
+					if (!is_executable($php)) {
+						return false;
+					}
+				} else {
+					return false;
+				}
+			}
+
+			return $php;
+		}
+
+		$args = $this->findArguments();
+		$args = $includeArgs && $args ? ' '.implode(' ', $args) : '';
+
+		// PHP_BINARY return the current sapi executable
+		if (\PHP_BINARY && \in_array(\PHP_SAPI, ['cgi-fcgi', 'cli', 'cli-server', 'phpdbg'], true)) {
+			return \PHP_BINARY.$args;
+		}
+
+		if ($php = getenv('PHP_PATH')) {
+			if (!@is_executable($php)) {
+				return false;
+			}
+
+			return $php;
+		}
+
+		if ($php = getenv('PHP_PEAR_PHP_BIN')) {
+			if (@is_executable($php)) {
+				return $php;
+			}
+		}
+
+		if (@is_executable($php = \PHP_BINDIR.('\\' === \DIRECTORY_SEPARATOR ? '\\php.exe' : '/php'))) {
+			return $php;
+		}
+
+		$dirs = [\PHP_BINDIR];
+		if ('\\' === \DIRECTORY_SEPARATOR) {
+			$dirs[] = 'C:\xampp\php\\';
+		}
+
+		return $this->executableFinder->find('php', false, $dirs);
+	}
+
+	/**
+	 * Finds the PHP executable arguments.
+	 *
+	 * @return array The PHP executable arguments
+	 */
+	public function findArguments()
+	{
+		$arguments = [];
+		if ('phpdbg' === \PHP_SAPI) {
+			$arguments[] = '-qrr';
+		}
+
+		return $arguments;
+	}
 }

Spacing +20 added lines, -20 removed lines

@@ -31,13 +31,13 @@ 
      *
      * @return string|false The PHP executable path or false if it cannot be found
      */
-    public function find(bool $includeArgs = true)
+    public function find( bool $includeArgs = true )
     {
-        if ($php = getenv('PHP_BINARY')) {
-            if (!is_executable($php)) {
+        if ( $php = getenv( 'PHP_BINARY' ) ) {
+            if ( ! is_executable( $php ) ) {
                 $command = '\\' === \DIRECTORY_SEPARATOR ? 'where' : 'command -v';
-                if ($php = strtok(exec($command.' '.escapeshellarg($php)), \PHP_EOL)) {
-                    if (!is_executable($php)) {
+                if ( $php = strtok( exec( $command . ' ' . escapeshellarg( $php ) ), \PHP_EOL ) ) {
+                    if ( ! is_executable( $php ) ) {
                         return false;
                     }
                 } else {
@@ -49,37 +49,37 @@ 
         }
 
         $args = $this->findArguments();
-        $args = $includeArgs && $args ? ' '.implode(' ', $args) : '';
+        $args = $includeArgs && $args ? ' ' . implode( ' ', $args ) : '';
 
         // PHP_BINARY return the current sapi executable
-        if (\PHP_BINARY && \in_array(\PHP_SAPI, ['cgi-fcgi', 'cli', 'cli-server', 'phpdbg'], true)) {
-            return \PHP_BINARY.$args;
+        if ( \PHP_BINARY && \in_array( \PHP_SAPI, [ 'cgi-fcgi', 'cli', 'cli-server', 'phpdbg' ], true ) ) {
+            return \PHP_BINARY . $args;
         }
 
-        if ($php = getenv('PHP_PATH')) {
-            if (!@is_executable($php)) {
+        if ( $php = getenv( 'PHP_PATH' ) ) {
+            if ( ! @is_executable( $php ) ) {
                 return false;
             }
 
             return $php;
         }
 
-        if ($php = getenv('PHP_PEAR_PHP_BIN')) {
-            if (@is_executable($php)) {
+        if ( $php = getenv( 'PHP_PEAR_PHP_BIN' ) ) {
+            if ( @is_executable( $php ) ) {
                 return $php;
             }
         }
 
-        if (@is_executable($php = \PHP_BINDIR.('\\' === \DIRECTORY_SEPARATOR ? '\\php.exe' : '/php'))) {
+        if ( @is_executable( $php = \PHP_BINDIR . ( '\\' === \DIRECTORY_SEPARATOR ? '\\php.exe' : '/php' ) ) ) {
             return $php;
         }
 
-        $dirs = [\PHP_BINDIR];
-        if ('\\' === \DIRECTORY_SEPARATOR) {
-            $dirs[] = 'C:\xampp\php\\';
+        $dirs = [ \PHP_BINDIR ];
+        if ( '\\' === \DIRECTORY_SEPARATOR ) {
+            $dirs[ ] = 'C:\xampp\php\\';
         }
 
-        return $this->executableFinder->find('php', false, $dirs);
+        return $this->executableFinder->find( 'php', false, $dirs );
     }
 
     /**
@@ -89,9 +89,9 @@ 
      */
     public function findArguments()
     {
-        $arguments = [];
-        if ('phpdbg' === \PHP_SAPI) {
-            $arguments[] = '-qrr';
+        $arguments = [ ];
+        if ( 'phpdbg' === \PHP_SAPI ) {
+            $arguments[ ] = '-qrr';
         }
 
         return $arguments;

Braces +4 added lines, -8 removed lines

@@ -17,12 +17,10 @@ 
  * @author Fabien Potencier <fabien@symfony.com>
  * @author Johannes M. Schmitt <schmittjoh@gmail.com>
  */
-class PhpExecutableFinder
-{
+class PhpExecutableFinder {
     private $executableFinder;
 
-    public function __construct()
-    {
+    public function __construct() {
         $this->executableFinder = new ExecutableFinder();
     }
 
@@ -31,8 +29,7 @@ 
      *
      * @return string|false The PHP executable path or false if it cannot be found
      */
-    public function find(bool $includeArgs = true)
-    {
+    public function find(bool $includeArgs = true) {
         if ($php = getenv('PHP_BINARY')) {
             if (!is_executable($php)) {
                 $command = '\\' === \DIRECTORY_SEPARATOR ? 'where' : 'command -v';
@@ -87,8 +84,7 @@ 
      *
      * @return array The PHP executable arguments
      */
-    public function findArguments()
-    {
+    public function findArguments() {
         $arguments = [];
         if ('phpdbg' === \PHP_SAPI) {
             $arguments[] = '-qrr';

vendor/symfony/process/ExecutableFinder.php

Indentation +59 added lines, -59 removed lines

@@ -19,68 +19,68 @@
  */
 class ExecutableFinder
 {
-    private $suffixes = ['.exe', '.bat', '.cmd', '.com'];
+	private $suffixes = ['.exe', '.bat', '.cmd', '.com'];
 
-    /**
-     * Replaces default suffixes of executable.
-     */
-    public function setSuffixes(array $suffixes)
-    {
-        $this->suffixes = $suffixes;
-    }
+	/**
+	 * Replaces default suffixes of executable.
+	 */
+	public function setSuffixes(array $suffixes)
+	{
+		$this->suffixes = $suffixes;
+	}
 
-    /**
-     * Adds new possible suffix to check for executable.
-     */
-    public function addSuffix(string $suffix)
-    {
-        $this->suffixes[] = $suffix;
-    }
+	/**
+	 * Adds new possible suffix to check for executable.
+	 */
+	public function addSuffix(string $suffix)
+	{
+		$this->suffixes[] = $suffix;
+	}
 
-    /**
-     * Finds an executable by name.
-     *
-     * @param string      $name      The executable name (without the extension)
-     * @param string|null $default   The default to return if no executable is found
-     * @param array       $extraDirs Additional dirs to check into
-     *
-     * @return string|null The executable path or default value
-     */
-    public function find(string $name, string $default = null, array $extraDirs = [])
-    {
-        if (ini_get('open_basedir')) {
-            $searchPath = array_merge(explode(\PATH_SEPARATOR, ini_get('open_basedir')), $extraDirs);
-            $dirs = [];
-            foreach ($searchPath as $path) {
-                // Silencing against https://bugs.php.net/69240
-                if (@is_dir($path)) {
-                    $dirs[] = $path;
-                } else {
-                    if (basename($path) == $name && @is_executable($path)) {
-                        return $path;
-                    }
-                }
-            }
-        } else {
-            $dirs = array_merge(
-                explode(\PATH_SEPARATOR, getenv('PATH') ?: getenv('Path')),
-                $extraDirs
-            );
-        }
+	/**
+	 * Finds an executable by name.
+	 *
+	 * @param string      $name      The executable name (without the extension)
+	 * @param string|null $default   The default to return if no executable is found
+	 * @param array       $extraDirs Additional dirs to check into
+	 *
+	 * @return string|null The executable path or default value
+	 */
+	public function find(string $name, string $default = null, array $extraDirs = [])
+	{
+		if (ini_get('open_basedir')) {
+			$searchPath = array_merge(explode(\PATH_SEPARATOR, ini_get('open_basedir')), $extraDirs);
+			$dirs = [];
+			foreach ($searchPath as $path) {
+				// Silencing against https://bugs.php.net/69240
+				if (@is_dir($path)) {
+					$dirs[] = $path;
+				} else {
+					if (basename($path) == $name && @is_executable($path)) {
+						return $path;
+					}
+				}
+			}
+		} else {
+			$dirs = array_merge(
+				explode(\PATH_SEPARATOR, getenv('PATH') ?: getenv('Path')),
+				$extraDirs
+			);
+		}
 
-        $suffixes = [''];
-        if ('\\' === \DIRECTORY_SEPARATOR) {
-            $pathExt = getenv('PATHEXT');
-            $suffixes = array_merge($pathExt ? explode(\PATH_SEPARATOR, $pathExt) : $this->suffixes, $suffixes);
-        }
-        foreach ($suffixes as $suffix) {
-            foreach ($dirs as $dir) {
-                if (@is_file($file = $dir.\DIRECTORY_SEPARATOR.$name.$suffix) && ('\\' === \DIRECTORY_SEPARATOR || @is_executable($file))) {
-                    return $file;
-                }
-            }
-        }
+		$suffixes = [''];
+		if ('\\' === \DIRECTORY_SEPARATOR) {
+			$pathExt = getenv('PATHEXT');
+			$suffixes = array_merge($pathExt ? explode(\PATH_SEPARATOR, $pathExt) : $this->suffixes, $suffixes);
+		}
+		foreach ($suffixes as $suffix) {
+			foreach ($dirs as $dir) {
+				if (@is_file($file = $dir.\DIRECTORY_SEPARATOR.$name.$suffix) && ('\\' === \DIRECTORY_SEPARATOR || @is_executable($file))) {
+					return $file;
+				}
+			}
+		}
 
-        return $default;
-    }
+		return $default;
+	}
 }

Spacing +20 added lines, -20 removed lines

@@ -19,12 +19,12 @@ 
  */
 class ExecutableFinder
 {
-    private $suffixes = ['.exe', '.bat', '.cmd', '.com'];
+    private $suffixes = [ '.exe', '.bat', '.cmd', '.com' ];
 
     /**
      * Replaces default suffixes of executable.
      */
-    public function setSuffixes(array $suffixes)
+    public function setSuffixes( array $suffixes )
     {
         $this->suffixes = $suffixes;
     }
@@ -32,9 +32,9 @@ 
     /**
      * Adds new possible suffix to check for executable.
      */
-    public function addSuffix(string $suffix)
+    public function addSuffix( string $suffix )
     {
-        $this->suffixes[] = $suffix;
+        $this->suffixes[ ] = $suffix;
     }
 
     /**
@@ -46,36 +46,36 @@ 
      *
      * @return string|null The executable path or default value
      */
-    public function find(string $name, string $default = null, array $extraDirs = [])
+    public function find( string $name, string $default = null, array $extraDirs = [ ] )
     {
-        if (ini_get('open_basedir')) {
-            $searchPath = array_merge(explode(\PATH_SEPARATOR, ini_get('open_basedir')), $extraDirs);
-            $dirs = [];
-            foreach ($searchPath as $path) {
+        if ( ini_get( 'open_basedir' ) ) {
+            $searchPath = array_merge( explode( \PATH_SEPARATOR, ini_get( 'open_basedir' ) ), $extraDirs );
+            $dirs = [ ];
+            foreach ( $searchPath as $path ) {
                 // Silencing against https://bugs.php.net/69240
-                if (@is_dir($path)) {
-                    $dirs[] = $path;
+                if ( @is_dir( $path ) ) {
+                    $dirs[ ] = $path;
                 } else {
-                    if (basename($path) == $name && @is_executable($path)) {
+                    if ( basename( $path ) == $name && @is_executable( $path ) ) {
                         return $path;
                     }
                 }
             }
         } else {
             $dirs = array_merge(
-                explode(\PATH_SEPARATOR, getenv('PATH') ?: getenv('Path')),
+                explode( \PATH_SEPARATOR, getenv( 'PATH' ) ?: getenv( 'Path' ) ),
                 $extraDirs
             );
         }
 
-        $suffixes = [''];
-        if ('\\' === \DIRECTORY_SEPARATOR) {
-            $pathExt = getenv('PATHEXT');
-            $suffixes = array_merge($pathExt ? explode(\PATH_SEPARATOR, $pathExt) : $this->suffixes, $suffixes);
+        $suffixes = [ '' ];
+        if ( '\\' === \DIRECTORY_SEPARATOR ) {
+            $pathExt = getenv( 'PATHEXT' );
+            $suffixes = array_merge( $pathExt ? explode( \PATH_SEPARATOR, $pathExt ) : $this->suffixes, $suffixes );
         }
-        foreach ($suffixes as $suffix) {
-            foreach ($dirs as $dir) {
-                if (@is_file($file = $dir.\DIRECTORY_SEPARATOR.$name.$suffix) && ('\\' === \DIRECTORY_SEPARATOR || @is_executable($file))) {
+        foreach ( $suffixes as $suffix ) {
+            foreach ( $dirs as $dir ) {
+                if ( @is_file( $file = $dir . \DIRECTORY_SEPARATOR . $name . $suffix ) && ( '\\' === \DIRECTORY_SEPARATOR || @is_executable( $file ) ) ) {
                     return $file;
                 }
             }

Braces +4 added lines, -8 removed lines

@@ -17,23 +17,20 @@ 
  * @author Fabien Potencier <fabien@symfony.com>
  * @author Johannes M. Schmitt <schmittjoh@gmail.com>
  */
-class ExecutableFinder
-{
+class ExecutableFinder {
     private $suffixes = ['.exe', '.bat', '.cmd', '.com'];
 
     /**
      * Replaces default suffixes of executable.
      */
-    public function setSuffixes(array $suffixes)
-    {
+    public function setSuffixes(array $suffixes) {
         $this->suffixes = $suffixes;
     }
 
     /**
      * Adds new possible suffix to check for executable.
      */
-    public function addSuffix(string $suffix)
-    {
+    public function addSuffix(string $suffix) {
         $this->suffixes[] = $suffix;
     }
 
@@ -46,8 +43,7 @@ 
      *
      * @return string|null The executable path or default value
      */
-    public function find(string $name, string $default = null, array $extraDirs = [])
-    {
+    public function find(string $name, string $default = null, array $extraDirs = []) {
         if (ini_get('open_basedir')) {
             $searchPath = array_merge(explode(\PATH_SEPARATOR, ini_get('open_basedir')), $extraDirs);
             $dirs = [];

vendor/symfony/process/Process.php

Indentation +1639 added lines, -1639 removed lines

@@ -30,1649 +30,1649 @@
  */
 class Process implements \IteratorAggregate
 {
-    public const ERR = 'err';
-    public const OUT = 'out';
-
-    public const STATUS_READY = 'ready';
-    public const STATUS_STARTED = 'started';
-    public const STATUS_TERMINATED = 'terminated';
-
-    public const STDIN = 0;
-    public const STDOUT = 1;
-    public const STDERR = 2;
-
-    // Timeout Precision in seconds.
-    public const TIMEOUT_PRECISION = 0.2;
-
-    public const ITER_NON_BLOCKING = 1; // By default, iterating over outputs is a blocking call, use this flag to make it non-blocking
-    public const ITER_KEEP_OUTPUT = 2;  // By default, outputs are cleared while iterating, use this flag to keep them in memory
-    public const ITER_SKIP_OUT = 4;     // Use this flag to skip STDOUT while iterating
-    public const ITER_SKIP_ERR = 8;     // Use this flag to skip STDERR while iterating
-
-    private $callback;
-    private $hasCallback = false;
-    private $commandline;
-    private $cwd;
-    private $env;
-    private $input;
-    private $starttime;
-    private $lastOutputTime;
-    private $timeout;
-    private $idleTimeout;
-    private $exitcode;
-    private $fallbackStatus = [];
-    private $processInformation;
-    private $outputDisabled = false;
-    private $stdout;
-    private $stderr;
-    private $process;
-    private $status = self::STATUS_READY;
-    private $incrementalOutputOffset = 0;
-    private $incrementalErrorOutputOffset = 0;
-    private $tty = false;
-    private $pty;
-    private $options = ['suppress_errors' => true, 'bypass_shell' => true];
-
-    private $useFileHandles = false;
-    /** @var PipesInterface */
-    private $processPipes;
-
-    private $latestSignal;
-
-    private static $sigchild;
-
-    /**
-     * Exit codes translation table.
-     *
-     * User-defined errors must use exit codes in the 64-113 range.
-     */
-    public static $exitCodes = [
-        0 => 'OK',
-        1 => 'General error',
-        2 => 'Misuse of shell builtins',
-
-        126 => 'Invoked command cannot execute',
-        127 => 'Command not found',
-        128 => 'Invalid exit argument',
-
-        // signals
-        129 => 'Hangup',
-        130 => 'Interrupt',
-        131 => 'Quit and dump core',
-        132 => 'Illegal instruction',
-        133 => 'Trace/breakpoint trap',
-        134 => 'Process aborted',
-        135 => 'Bus error: "access to undefined portion of memory object"',
-        136 => 'Floating point exception: "erroneous arithmetic operation"',
-        137 => 'Kill (terminate immediately)',
-        138 => 'User-defined 1',
-        139 => 'Segmentation violation',
-        140 => 'User-defined 2',
-        141 => 'Write to pipe with no one reading',
-        142 => 'Signal raised by alarm',
-        143 => 'Termination (request to terminate)',
-        // 144 - not defined
-        145 => 'Child process terminated, stopped (or continued*)',
-        146 => 'Continue if stopped',
-        147 => 'Stop executing temporarily',
-        148 => 'Terminal stop signal',
-        149 => 'Background process attempting to read from tty ("in")',
-        150 => 'Background process attempting to write to tty ("out")',
-        151 => 'Urgent data available on socket',
-        152 => 'CPU time limit exceeded',
-        153 => 'File size limit exceeded',
-        154 => 'Signal raised by timer counting virtual time: "virtual timer expired"',
-        155 => 'Profiling timer expired',
-        // 156 - not defined
-        157 => 'Pollable event',
-        // 158 - not defined
-        159 => 'Bad syscall',
-    ];
-
-    /**
-     * @param array          $command The command to run and its arguments listed as separate entries
-     * @param string|null    $cwd     The working directory or null to use the working dir of the current PHP process
-     * @param array|null     $env     The environment variables or null to use the same environment as the current PHP process
-     * @param mixed          $input   The input as stream resource, scalar or \Traversable, or null for no input
-     * @param int|float|null $timeout The timeout in seconds or null to disable
-     *
-     * @throws LogicException When proc_open is not installed
-     */
-    public function __construct(array $command, string $cwd = null, array $env = null, $input = null, ?float $timeout = 60)
-    {
-        if (!\function_exists('proc_open')) {
-            throw new LogicException('The Process class relies on proc_open, which is not available on your PHP installation.');
-        }
-
-        $this->commandline = $command;
-        $this->cwd = $cwd;
-
-        // on Windows, if the cwd changed via chdir(), proc_open defaults to the dir where PHP was started
-        // on Gnu/Linux, PHP builds with --enable-maintainer-zts are also affected
-        // @see : https://bugs.php.net/51800
-        // @see : https://bugs.php.net/50524
-        if (null === $this->cwd && (\defined('ZEND_THREAD_SAFE') || '\\' === \DIRECTORY_SEPARATOR)) {
-            $this->cwd = getcwd();
-        }
-        if (null !== $env) {
-            $this->setEnv($env);
-        }
-
-        $this->setInput($input);
-        $this->setTimeout($timeout);
-        $this->useFileHandles = '\\' === \DIRECTORY_SEPARATOR;
-        $this->pty = false;
-    }
-
-    /**
-     * Creates a Process instance as a command-line to be run in a shell wrapper.
-     *
-     * Command-lines are parsed by the shell of your OS (/bin/sh on Unix-like, cmd.exe on Windows.)
-     * This allows using e.g. pipes or conditional execution. In this mode, signals are sent to the
-     * shell wrapper and not to your commands.
-     *
-     * In order to inject dynamic values into command-lines, we strongly recommend using placeholders.
-     * This will save escaping values, which is not portable nor secure anyway:
-     *
-     *   $process = Process::fromShellCommandline('my_command "$MY_VAR"');
-     *   $process->run(null, ['MY_VAR' => $theValue]);
-     *
-     * @param string         $command The command line to pass to the shell of the OS
-     * @param string|null    $cwd     The working directory or null to use the working dir of the current PHP process
-     * @param array|null     $env     The environment variables or null to use the same environment as the current PHP process
-     * @param mixed          $input   The input as stream resource, scalar or \Traversable, or null for no input
-     * @param int|float|null $timeout The timeout in seconds or null to disable
-     *
-     * @return static
-     *
-     * @throws LogicException When proc_open is not installed
-     */
-    public static function fromShellCommandline(string $command, string $cwd = null, array $env = null, $input = null, ?float $timeout = 60)
-    {
-        $process = new static([], $cwd, $env, $input, $timeout);
-        $process->commandline = $command;
-
-        return $process;
-    }
-
-    /**
-     * @return array
-     */
-    public function __sleep()
-    {
-        throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
-    }
-
-    public function __wakeup()
-    {
-        throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
-    }
-
-    public function __destruct()
-    {
-        if ($this->options['create_new_console'] ?? false) {
-            $this->processPipes->close();
-        } else {
-            $this->stop(0);
-        }
-    }
-
-    public function __clone()
-    {
-        $this->resetProcessData();
-    }
-
-    /**
-     * Runs the process.
-     *
-     * The callback receives the type of output (out or err) and
-     * some bytes from the output in real-time. It allows to have feedback
-     * from the independent process during execution.
-     *
-     * The STDOUT and STDERR are also available after the process is finished
-     * via the getOutput() and getErrorOutput() methods.
-     *
-     * @param callable|null $callback A PHP callback to run whenever there is some
-     *                                output available on STDOUT or STDERR
-     *
-     * @return int The exit status code
-     *
-     * @throws RuntimeException         When process can't be launched
-     * @throws RuntimeException         When process is already running
-     * @throws ProcessTimedOutException When process timed out
-     * @throws ProcessSignaledException When process stopped after receiving signal
-     * @throws LogicException           In case a callback is provided and output has been disabled
-     *
-     * @final
-     */
-    public function run(callable $callback = null, array $env = []): int
-    {
-        $this->start($callback, $env);
-
-        return $this->wait();
-    }
-
-    /**
-     * Runs the process.
-     *
-     * This is identical to run() except that an exception is thrown if the process
-     * exits with a non-zero exit code.
-     *
-     * @return $this
-     *
-     * @throws ProcessFailedException if the process didn't terminate successfully
-     *
-     * @final
-     */
-    public function mustRun(callable $callback = null, array $env = []): self
-    {
-        if (0 !== $this->run($callback, $env)) {
-            throw new ProcessFailedException($this);
-        }
-
-        return $this;
-    }
-
-    /**
-     * Starts the process and returns after writing the input to STDIN.
-     *
-     * This method blocks until all STDIN data is sent to the process then it
-     * returns while the process runs in the background.
-     *
-     * The termination of the process can be awaited with wait().
-     *
-     * The callback receives the type of output (out or err) and some bytes from
-     * the output in real-time while writing the standard input to the process.
-     * It allows to have feedback from the independent process during execution.
-     *
-     * @param callable|null $callback A PHP callback to run whenever there is some
-     *                                output available on STDOUT or STDERR
-     *
-     * @throws RuntimeException When process can't be launched
-     * @throws RuntimeException When process is already running
-     * @throws LogicException   In case a callback is provided and output has been disabled
-     */
-    public function start(callable $callback = null, array $env = [])
-    {
-        if ($this->isRunning()) {
-            throw new RuntimeException('Process is already running.');
-        }
-
-        $this->resetProcessData();
-        $this->starttime = $this->lastOutputTime = microtime(true);
-        $this->callback = $this->buildCallback($callback);
-        $this->hasCallback = null !== $callback;
-        $descriptors = $this->getDescriptors();
-
-        if ($this->env) {
-            $env += $this->env;
-        }
-
-        $env += $this->getDefaultEnv();
-
-        if (\is_array($commandline = $this->commandline)) {
-            $commandline = implode(' ', array_map([$this, 'escapeArgument'], $commandline));
-
-            if ('\\' !== \DIRECTORY_SEPARATOR) {
-                // exec is mandatory to deal with sending a signal to the process
-                $commandline = 'exec '.$commandline;
-            }
-        } else {
-            $commandline = $this->replacePlaceholders($commandline, $env);
-        }
-
-        if ('\\' === \DIRECTORY_SEPARATOR) {
-            $commandline = $this->prepareWindowsCommandLine($commandline, $env);
-        } elseif (!$this->useFileHandles && $this->isSigchildEnabled()) {
-            // last exit code is output on the fourth pipe and caught to work around --enable-sigchild
-            $descriptors[3] = ['pipe', 'w'];
-
-            // See https://unix.stackexchange.com/questions/71205/background-process-pipe-input
-            $commandline = '{ ('.$commandline.') <&3 3<&- 3>/dev/null & } 3<&0;';
-            $commandline .= 'pid=$!; echo $pid >&3; wait $pid; code=$?; echo $code >&3; exit $code';
-
-            // Workaround for the bug, when PTS functionality is enabled.
-            // @see : https://bugs.php.net/69442
-            $ptsWorkaround = fopen(__FILE__, 'r');
-        }
-
-        $envPairs = [];
-        foreach ($env as $k => $v) {
-            if (false !== $v) {
-                $envPairs[] = $k.'='.$v;
-            }
-        }
-
-        if (!is_dir($this->cwd)) {
-            throw new RuntimeException(sprintf('The provided cwd "%s" does not exist.', $this->cwd));
-        }
-
-        $this->process = @proc_open($commandline, $descriptors, $this->processPipes->pipes, $this->cwd, $envPairs, $this->options);
-
-        if (!\is_resource($this->process)) {
-            throw new RuntimeException('Unable to launch a new process.');
-        }
-        $this->status = self::STATUS_STARTED;
-
-        if (isset($descriptors[3])) {
-            $this->fallbackStatus['pid'] = (int) fgets($this->processPipes->pipes[3]);
-        }
-
-        if ($this->tty) {
-            return;
-        }
-
-        $this->updateStatus(false);
-        $this->checkTimeout();
-    }
-
-    /**
-     * Restarts the process.
-     *
-     * Be warned that the process is cloned before being started.
-     *
-     * @param callable|null $callback A PHP callback to run whenever there is some
-     *                                output available on STDOUT or STDERR
-     *
-     * @return static
-     *
-     * @throws RuntimeException When process can't be launched
-     * @throws RuntimeException When process is already running
-     *
-     * @see start()
-     *
-     * @final
-     */
-    public function restart(callable $callback = null, array $env = []): self
-    {
-        if ($this->isRunning()) {
-            throw new RuntimeException('Process is already running.');
-        }
-
-        $process = clone $this;
-        $process->start($callback, $env);
-
-        return $process;
-    }
-
-    /**
-     * Waits for the process to terminate.
-     *
-     * The callback receives the type of output (out or err) and some bytes
-     * from the output in real-time while writing the standard input to the process.
-     * It allows to have feedback from the independent process during execution.
-     *
-     * @param callable|null $callback A valid PHP callback
-     *
-     * @return int The exitcode of the process
-     *
-     * @throws ProcessTimedOutException When process timed out
-     * @throws ProcessSignaledException When process stopped after receiving signal
-     * @throws LogicException           When process is not yet started
-     */
-    public function wait(callable $callback = null)
-    {
-        $this->requireProcessIsStarted(__FUNCTION__);
-
-        $this->updateStatus(false);
-
-        if (null !== $callback) {
-            if (!$this->processPipes->haveReadSupport()) {
-                $this->stop(0);
-                throw new LogicException('Pass the callback to the "Process::start" method or call enableOutput to use a callback with "Process::wait".');
-            }
-            $this->callback = $this->buildCallback($callback);
-        }
-
-        do {
-            $this->checkTimeout();
-            $running = '\\' === \DIRECTORY_SEPARATOR ? $this->isRunning() : $this->processPipes->areOpen();
-            $this->readPipes($running, '\\' !== \DIRECTORY_SEPARATOR || !$running);
-        } while ($running);
-
-        while ($this->isRunning()) {
-            $this->checkTimeout();
-            usleep(1000);
-        }
-
-        if ($this->processInformation['signaled'] && $this->processInformation['termsig'] !== $this->latestSignal) {
-            throw new ProcessSignaledException($this);
-        }
-
-        return $this->exitcode;
-    }
-
-    /**
-     * Waits until the callback returns true.
-     *
-     * The callback receives the type of output (out or err) and some bytes
-     * from the output in real-time while writing the standard input to the process.
-     * It allows to have feedback from the independent process during execution.
-     *
-     * @throws RuntimeException         When process timed out
-     * @throws LogicException           When process is not yet started
-     * @throws ProcessTimedOutException In case the timeout was reached
-     */
-    public function waitUntil(callable $callback): bool
-    {
-        $this->requireProcessIsStarted(__FUNCTION__);
-        $this->updateStatus(false);
-
-        if (!$this->processPipes->haveReadSupport()) {
-            $this->stop(0);
-            throw new LogicException('Pass the callback to the "Process::start" method or call enableOutput to use a callback with "Process::waitUntil".');
-        }
-        $callback = $this->buildCallback($callback);
-
-        $ready = false;
-        while (true) {
-            $this->checkTimeout();
-            $running = '\\' === \DIRECTORY_SEPARATOR ? $this->isRunning() : $this->processPipes->areOpen();
-            $output = $this->processPipes->readAndWrite($running, '\\' !== \DIRECTORY_SEPARATOR || !$running);
-
-            foreach ($output as $type => $data) {
-                if (3 !== $type) {
-                    $ready = $callback(self::STDOUT === $type ? self::OUT : self::ERR, $data) || $ready;
-                } elseif (!isset($this->fallbackStatus['signaled'])) {
-                    $this->fallbackStatus['exitcode'] = (int) $data;
-                }
-            }
-            if ($ready) {
-                return true;
-            }
-            if (!$running) {
-                return false;
-            }
-
-            usleep(1000);
-        }
-    }
-
-    /**
-     * Returns the Pid (process identifier), if applicable.
-     *
-     * @return int|null The process id if running, null otherwise
-     */
-    public function getPid()
-    {
-        return $this->isRunning() ? $this->processInformation['pid'] : null;
-    }
-
-    /**
-     * Sends a POSIX signal to the process.
-     *
-     * @param int $signal A valid POSIX signal (see https://php.net/pcntl.constants)
-     *
-     * @return $this
-     *
-     * @throws LogicException   In case the process is not running
-     * @throws RuntimeException In case --enable-sigchild is activated and the process can't be killed
-     * @throws RuntimeException In case of failure
-     */
-    public function signal(int $signal)
-    {
-        $this->doSignal($signal, true);
-
-        return $this;
-    }
-
-    /**
-     * Disables fetching output and error output from the underlying process.
-     *
-     * @return $this
-     *
-     * @throws RuntimeException In case the process is already running
-     * @throws LogicException   if an idle timeout is set
-     */
-    public function disableOutput()
-    {
-        if ($this->isRunning()) {
-            throw new RuntimeException('Disabling output while the process is running is not possible.');
-        }
-        if (null !== $this->idleTimeout) {
-            throw new LogicException('Output can not be disabled while an idle timeout is set.');
-        }
-
-        $this->outputDisabled = true;
-
-        return $this;
-    }
-
-    /**
-     * Enables fetching output and error output from the underlying process.
-     *
-     * @return $this
-     *
-     * @throws RuntimeException In case the process is already running
-     */
-    public function enableOutput()
-    {
-        if ($this->isRunning()) {
-            throw new RuntimeException('Enabling output while the process is running is not possible.');
-        }
-
-        $this->outputDisabled = false;
-
-        return $this;
-    }
-
-    /**
-     * Returns true in case the output is disabled, false otherwise.
-     *
-     * @return bool
-     */
-    public function isOutputDisabled()
-    {
-        return $this->outputDisabled;
-    }
-
-    /**
-     * Returns the current output of the process (STDOUT).
-     *
-     * @return string The process output
-     *
-     * @throws LogicException in case the output has been disabled
-     * @throws LogicException In case the process is not started
-     */
-    public function getOutput()
-    {
-        $this->readPipesForOutput(__FUNCTION__);
-
-        if (false === $ret = stream_get_contents($this->stdout, -1, 0)) {
-            return '';
-        }
-
-        return $ret;
-    }
-
-    /**
-     * Returns the output incrementally.
-     *
-     * In comparison with the getOutput method which always return the whole
-     * output, this one returns the new output since the last call.
-     *
-     * @return string The process output since the last call
-     *
-     * @throws LogicException in case the output has been disabled
-     * @throws LogicException In case the process is not started
-     */
-    public function getIncrementalOutput()
-    {
-        $this->readPipesForOutput(__FUNCTION__);
-
-        $latest = stream_get_contents($this->stdout, -1, $this->incrementalOutputOffset);
-        $this->incrementalOutputOffset = ftell($this->stdout);
-
-        if (false === $latest) {
-            return '';
-        }
-
-        return $latest;
-    }
-
-    /**
-     * Returns an iterator to the output of the process, with the output type as keys (Process::OUT/ERR).
-     *
-     * @param int $flags A bit field of Process::ITER_* flags
-     *
-     * @throws LogicException in case the output has been disabled
-     * @throws LogicException In case the process is not started
-     *
-     * @return \Generator
-     */
-    #[\ReturnTypeWillChange]
-    public function getIterator(int $flags = 0)
-    {
-        $this->readPipesForOutput(__FUNCTION__, false);
-
-        $clearOutput = !(self::ITER_KEEP_OUTPUT & $flags);
-        $blocking = !(self::ITER_NON_BLOCKING & $flags);
-        $yieldOut = !(self::ITER_SKIP_OUT & $flags);
-        $yieldErr = !(self::ITER_SKIP_ERR & $flags);
-
-        while (null !== $this->callback || ($yieldOut && !feof($this->stdout)) || ($yieldErr && !feof($this->stderr))) {
-            if ($yieldOut) {
-                $out = stream_get_contents($this->stdout, -1, $this->incrementalOutputOffset);
-
-                if (isset($out[0])) {
-                    if ($clearOutput) {
-                        $this->clearOutput();
-                    } else {
-                        $this->incrementalOutputOffset = ftell($this->stdout);
-                    }
-
-                    yield self::OUT => $out;
-                }
-            }
-
-            if ($yieldErr) {
-                $err = stream_get_contents($this->stderr, -1, $this->incrementalErrorOutputOffset);
-
-                if (isset($err[0])) {
-                    if ($clearOutput) {
-                        $this->clearErrorOutput();
-                    } else {
-                        $this->incrementalErrorOutputOffset = ftell($this->stderr);
-                    }
-
-                    yield self::ERR => $err;
-                }
-            }
-
-            if (!$blocking && !isset($out[0]) && !isset($err[0])) {
-                yield self::OUT => '';
-            }
-
-            $this->checkTimeout();
-            $this->readPipesForOutput(__FUNCTION__, $blocking);
-        }
-    }
-
-    /**
-     * Clears the process output.
-     *
-     * @return $this
-     */
-    public function clearOutput()
-    {
-        ftruncate($this->stdout, 0);
-        fseek($this->stdout, 0);
-        $this->incrementalOutputOffset = 0;
-
-        return $this;
-    }
-
-    /**
-     * Returns the current error output of the process (STDERR).
-     *
-     * @return string The process error output
-     *
-     * @throws LogicException in case the output has been disabled
-     * @throws LogicException In case the process is not started
-     */
-    public function getErrorOutput()
-    {
-        $this->readPipesForOutput(__FUNCTION__);
-
-        if (false === $ret = stream_get_contents($this->stderr, -1, 0)) {
-            return '';
-        }
-
-        return $ret;
-    }
-
-    /**
-     * Returns the errorOutput incrementally.
-     *
-     * In comparison with the getErrorOutput method which always return the
-     * whole error output, this one returns the new error output since the last
-     * call.
-     *
-     * @return string The process error output since the last call
-     *
-     * @throws LogicException in case the output has been disabled
-     * @throws LogicException In case the process is not started
-     */
-    public function getIncrementalErrorOutput()
-    {
-        $this->readPipesForOutput(__FUNCTION__);
-
-        $latest = stream_get_contents($this->stderr, -1, $this->incrementalErrorOutputOffset);
-        $this->incrementalErrorOutputOffset = ftell($this->stderr);
-
-        if (false === $latest) {
-            return '';
-        }
-
-        return $latest;
-    }
-
-    /**
-     * Clears the process output.
-     *
-     * @return $this
-     */
-    public function clearErrorOutput()
-    {
-        ftruncate($this->stderr, 0);
-        fseek($this->stderr, 0);
-        $this->incrementalErrorOutputOffset = 0;
-
-        return $this;
-    }
-
-    /**
-     * Returns the exit code returned by the process.
-     *
-     * @return int|null The exit status code, null if the Process is not terminated
-     */
-    public function getExitCode()
-    {
-        $this->updateStatus(false);
-
-        return $this->exitcode;
-    }
-
-    /**
-     * Returns a string representation for the exit code returned by the process.
-     *
-     * This method relies on the Unix exit code status standardization
-     * and might not be relevant for other operating systems.
-     *
-     * @return string|null A string representation for the exit status code, null if the Process is not terminated
-     *
-     * @see http://tldp.org/LDP/abs/html/exitcodes.html
-     * @see http://en.wikipedia.org/wiki/Unix_signal
-     */
-    public function getExitCodeText()
-    {
-        if (null === $exitcode = $this->getExitCode()) {
-            return null;
-        }
-
-        return self::$exitCodes[$exitcode] ?? 'Unknown error';
-    }
-
-    /**
-     * Checks if the process ended successfully.
-     *
-     * @return bool true if the process ended successfully, false otherwise
-     */
-    public function isSuccessful()
-    {
-        return 0 === $this->getExitCode();
-    }
-
-    /**
-     * Returns true if the child process has been terminated by an uncaught signal.
-     *
-     * It always returns false on Windows.
-     *
-     * @return bool
-     *
-     * @throws LogicException In case the process is not terminated
-     */
-    public function hasBeenSignaled()
-    {
-        $this->requireProcessIsTerminated(__FUNCTION__);
-
-        return $this->processInformation['signaled'];
-    }
-
-    /**
-     * Returns the number of the signal that caused the child process to terminate its execution.
-     *
-     * It is only meaningful if hasBeenSignaled() returns true.
-     *
-     * @return int
-     *
-     * @throws RuntimeException In case --enable-sigchild is activated
-     * @throws LogicException   In case the process is not terminated
-     */
-    public function getTermSignal()
-    {
-        $this->requireProcessIsTerminated(__FUNCTION__);
-
-        if ($this->isSigchildEnabled() && -1 === $this->processInformation['termsig']) {
-            throw new RuntimeException('This PHP has been compiled with --enable-sigchild. Term signal can not be retrieved.');
-        }
-
-        return $this->processInformation['termsig'];
-    }
-
-    /**
-     * Returns true if the child process has been stopped by a signal.
-     *
-     * It always returns false on Windows.
-     *
-     * @return bool
-     *
-     * @throws LogicException In case the process is not terminated
-     */
-    public function hasBeenStopped()
-    {
-        $this->requireProcessIsTerminated(__FUNCTION__);
-
-        return $this->processInformation['stopped'];
-    }
-
-    /**
-     * Returns the number of the signal that caused the child process to stop its execution.
-     *
-     * It is only meaningful if hasBeenStopped() returns true.
-     *
-     * @return int
-     *
-     * @throws LogicException In case the process is not terminated
-     */
-    public function getStopSignal()
-    {
-        $this->requireProcessIsTerminated(__FUNCTION__);
-
-        return $this->processInformation['stopsig'];
-    }
-
-    /**
-     * Checks if the process is currently running.
-     *
-     * @return bool true if the process is currently running, false otherwise
-     */
-    public function isRunning()
-    {
-        if (self::STATUS_STARTED !== $this->status) {
-            return false;
-        }
-
-        $this->updateStatus(false);
-
-        return $this->processInformation['running'];
-    }
-
-    /**
-     * Checks if the process has been started with no regard to the current state.
-     *
-     * @return bool true if status is ready, false otherwise
-     */
-    public function isStarted()
-    {
-        return self::STATUS_READY != $this->status;
-    }
-
-    /**
-     * Checks if the process is terminated.
-     *
-     * @return bool true if process is terminated, false otherwise
-     */
-    public function isTerminated()
-    {
-        $this->updateStatus(false);
-
-        return self::STATUS_TERMINATED == $this->status;
-    }
-
-    /**
-     * Gets the process status.
-     *
-     * The status is one of: ready, started, terminated.
-     *
-     * @return string The current process status
-     */
-    public function getStatus()
-    {
-        $this->updateStatus(false);
-
-        return $this->status;
-    }
-
-    /**
-     * Stops the process.
-     *
-     * @param int|float $timeout The timeout in seconds
-     * @param int       $signal  A POSIX signal to send in case the process has not stop at timeout, default is SIGKILL (9)
-     *
-     * @return int|null The exit-code of the process or null if it's not running
-     */
-    public function stop(float $timeout = 10, int $signal = null)
-    {
-        $timeoutMicro = microtime(true) + $timeout;
-        if ($this->isRunning()) {
-            // given SIGTERM may not be defined and that "proc_terminate" uses the constant value and not the constant itself, we use the same here
-            $this->doSignal(15, false);
-            do {
-                usleep(1000);
-            } while ($this->isRunning() && microtime(true) < $timeoutMicro);
-
-            if ($this->isRunning()) {
-                // Avoid exception here: process is supposed to be running, but it might have stopped just
-                // after this line. In any case, let's silently discard the error, we cannot do anything.
-                $this->doSignal($signal ?: 9, false);
-            }
-        }
-
-        if ($this->isRunning()) {
-            if (isset($this->fallbackStatus['pid'])) {
-                unset($this->fallbackStatus['pid']);
-
-                return $this->stop(0, $signal);
-            }
-            $this->close();
-        }
-
-        return $this->exitcode;
-    }
-
-    /**
-     * Adds a line to the STDOUT stream.
-     *
-     * @internal
-     */
-    public function addOutput(string $line)
-    {
-        $this->lastOutputTime = microtime(true);
-
-        fseek($this->stdout, 0, \SEEK_END);
-        fwrite($this->stdout, $line);
-        fseek($this->stdout, $this->incrementalOutputOffset);
-    }
-
-    /**
-     * Adds a line to the STDERR stream.
-     *
-     * @internal
-     */
-    public function addErrorOutput(string $line)
-    {
-        $this->lastOutputTime = microtime(true);
-
-        fseek($this->stderr, 0, \SEEK_END);
-        fwrite($this->stderr, $line);
-        fseek($this->stderr, $this->incrementalErrorOutputOffset);
-    }
-
-    /**
-     * Gets the last output time in seconds.
-     *
-     * @return float|null The last output time in seconds or null if it isn't started
-     */
-    public function getLastOutputTime(): ?float
-    {
-        return $this->lastOutputTime;
-    }
-
-    /**
-     * Gets the command line to be executed.
-     *
-     * @return string The command to execute
-     */
-    public function getCommandLine()
-    {
-        return \is_array($this->commandline) ? implode(' ', array_map([$this, 'escapeArgument'], $this->commandline)) : $this->commandline;
-    }
-
-    /**
-     * Gets the process timeout (max. runtime).
-     *
-     * @return float|null The timeout in seconds or null if it's disabled
-     */
-    public function getTimeout()
-    {
-        return $this->timeout;
-    }
-
-    /**
-     * Gets the process idle timeout (max. time since last output).
-     *
-     * @return float|null The timeout in seconds or null if it's disabled
-     */
-    public function getIdleTimeout()
-    {
-        return $this->idleTimeout;
-    }
-
-    /**
-     * Sets the process timeout (max. runtime) in seconds.
-     *
-     * To disable the timeout, set this value to null.
-     *
-     * @return $this
-     *
-     * @throws InvalidArgumentException if the timeout is negative
-     */
-    public function setTimeout(?float $timeout)
-    {
-        $this->timeout = $this->validateTimeout($timeout);
-
-        return $this;
-    }
-
-    /**
-     * Sets the process idle timeout (max. time since last output) in seconds.
-     *
-     * To disable the timeout, set this value to null.
-     *
-     * @return $this
-     *
-     * @throws LogicException           if the output is disabled
-     * @throws InvalidArgumentException if the timeout is negative
-     */
-    public function setIdleTimeout(?float $timeout)
-    {
-        if (null !== $timeout && $this->outputDisabled) {
-            throw new LogicException('Idle timeout can not be set while the output is disabled.');
-        }
-
-        $this->idleTimeout = $this->validateTimeout($timeout);
-
-        return $this;
-    }
-
-    /**
-     * Enables or disables the TTY mode.
-     *
-     * @return $this
-     *
-     * @throws RuntimeException In case the TTY mode is not supported
-     */
-    public function setTty(bool $tty)
-    {
-        if ('\\' === \DIRECTORY_SEPARATOR && $tty) {
-            throw new RuntimeException('TTY mode is not supported on Windows platform.');
-        }
-
-        if ($tty && !self::isTtySupported()) {
-            throw new RuntimeException('TTY mode requires /dev/tty to be read/writable.');
-        }
-
-        $this->tty = $tty;
-
-        return $this;
-    }
-
-    /**
-     * Checks if the TTY mode is enabled.
-     *
-     * @return bool true if the TTY mode is enabled, false otherwise
-     */
-    public function isTty()
-    {
-        return $this->tty;
-    }
-
-    /**
-     * Sets PTY mode.
-     *
-     * @return $this
-     */
-    public function setPty(bool $bool)
-    {
-        $this->pty = $bool;
-
-        return $this;
-    }
-
-    /**
-     * Returns PTY state.
-     *
-     * @return bool
-     */
-    public function isPty()
-    {
-        return $this->pty;
-    }
-
-    /**
-     * Gets the working directory.
-     *
-     * @return string|null The current working directory or null on failure
-     */
-    public function getWorkingDirectory()
-    {
-        if (null === $this->cwd) {
-            // getcwd() will return false if any one of the parent directories does not have
-            // the readable or search mode set, even if the current directory does
-            return getcwd() ?: null;
-        }
-
-        return $this->cwd;
-    }
-
-    /**
-     * Sets the current working directory.
-     *
-     * @return $this
-     */
-    public function setWorkingDirectory(string $cwd)
-    {
-        $this->cwd = $cwd;
-
-        return $this;
-    }
-
-    /**
-     * Gets the environment variables.
-     *
-     * @return array The current environment variables
-     */
-    public function getEnv()
-    {
-        return $this->env;
-    }
-
-    /**
-     * Sets the environment variables.
-     *
-     * Each environment variable value should be a string.
-     * If it is an array, the variable is ignored.
-     * If it is false or null, it will be removed when
-     * env vars are otherwise inherited.
-     *
-     * That happens in PHP when 'argv' is registered into
-     * the $_ENV array for instance.
-     *
-     * @param array $env The new environment variables
-     *
-     * @return $this
-     */
-    public function setEnv(array $env)
-    {
-        // Process can not handle env values that are arrays
-        $env = array_filter($env, function ($value) {
-            return !\is_array($value);
-        });
-
-        $this->env = $env;
-
-        return $this;
-    }
-
-    /**
-     * Gets the Process input.
-     *
-     * @return resource|string|\Iterator|null The Process input
-     */
-    public function getInput()
-    {
-        return $this->input;
-    }
-
-    /**
-     * Sets the input.
-     *
-     * This content will be passed to the underlying process standard input.
-     *
-     * @param string|int|float|bool|resource|\Traversable|null $input The content
-     *
-     * @return $this
-     *
-     * @throws LogicException In case the process is running
-     */
-    public function setInput($input)
-    {
-        if ($this->isRunning()) {
-            throw new LogicException('Input can not be set while the process is running.');
-        }
-
-        $this->input = ProcessUtils::validateInput(__METHOD__, $input);
-
-        return $this;
-    }
-
-    /**
-     * Performs a check between the timeout definition and the time the process started.
-     *
-     * In case you run a background process (with the start method), you should
-     * trigger this method regularly to ensure the process timeout
-     *
-     * @throws ProcessTimedOutException In case the timeout was reached
-     */
-    public function checkTimeout()
-    {
-        if (self::STATUS_STARTED !== $this->status) {
-            return;
-        }
-
-        if (null !== $this->timeout && $this->timeout < microtime(true) - $this->starttime) {
-            $this->stop(0);
-
-            throw new ProcessTimedOutException($this, ProcessTimedOutException::TYPE_GENERAL);
-        }
-
-        if (null !== $this->idleTimeout && $this->idleTimeout < microtime(true) - $this->lastOutputTime) {
-            $this->stop(0);
-
-            throw new ProcessTimedOutException($this, ProcessTimedOutException::TYPE_IDLE);
-        }
-    }
-
-    /**
-     * @throws LogicException in case process is not started
-     */
-    public function getStartTime(): float
-    {
-        if (!$this->isStarted()) {
-            throw new LogicException('Start time is only available after process start.');
-        }
-
-        return $this->starttime;
-    }
-
-    /**
-     * Defines options to pass to the underlying proc_open().
-     *
-     * @see https://php.net/proc_open for the options supported by PHP.
-     *
-     * Enabling the "create_new_console" option allows a subprocess to continue
-     * to run after the main process exited, on both Windows and *nix
-     */
-    public function setOptions(array $options)
-    {
-        if ($this->isRunning()) {
-            throw new RuntimeException('Setting options while the process is running is not possible.');
-        }
-
-        $defaultOptions = $this->options;
-        $existingOptions = ['blocking_pipes', 'create_process_group', 'create_new_console'];
-
-        foreach ($options as $key => $value) {
-            if (!\in_array($key, $existingOptions)) {
-                $this->options = $defaultOptions;
-                throw new LogicException(sprintf('Invalid option "%s" passed to "%s()". Supported options are "%s".', $key, __METHOD__, implode('", "', $existingOptions)));
-            }
-            $this->options[$key] = $value;
-        }
-    }
-
-    /**
-     * Returns whether TTY is supported on the current operating system.
-     */
-    public static function isTtySupported(): bool
-    {
-        static $isTtySupported;
-
-        if (null === $isTtySupported) {
-            $isTtySupported = (bool) @proc_open('echo 1 >/dev/null', [['file', '/dev/tty', 'r'], ['file', '/dev/tty', 'w'], ['file', '/dev/tty', 'w']], $pipes);
-        }
-
-        return $isTtySupported;
-    }
-
-    /**
-     * Returns whether PTY is supported on the current operating system.
-     *
-     * @return bool
-     */
-    public static function isPtySupported()
-    {
-        static $result;
-
-        if (null !== $result) {
-            return $result;
-        }
-
-        if ('\\' === \DIRECTORY_SEPARATOR) {
-            return $result = false;
-        }
-
-        return $result = (bool) @proc_open('echo 1 >/dev/null', [['pty'], ['pty'], ['pty']], $pipes);
-    }
-
-    /**
-     * Creates the descriptors needed by the proc_open.
-     */
-    private function getDescriptors(): array
-    {
-        if ($this->input instanceof \Iterator) {
-            $this->input->rewind();
-        }
-        if ('\\' === \DIRECTORY_SEPARATOR) {
-            $this->processPipes = new WindowsPipes($this->input, !$this->outputDisabled || $this->hasCallback);
-        } else {
-            $this->processPipes = new UnixPipes($this->isTty(), $this->isPty(), $this->input, !$this->outputDisabled || $this->hasCallback);
-        }
-
-        return $this->processPipes->getDescriptors();
-    }
-
-    /**
-     * Builds up the callback used by wait().
-     *
-     * The callbacks adds all occurred output to the specific buffer and calls
-     * the user callback (if present) with the received output.
-     *
-     * @param callable|null $callback The user defined PHP callback
-     *
-     * @return \Closure A PHP closure
-     */
-    protected function buildCallback(callable $callback = null)
-    {
-        if ($this->outputDisabled) {
-            return function ($type, $data) use ($callback): bool {
-                return null !== $callback && $callback($type, $data);
-            };
-        }
-
-        $out = self::OUT;
-
-        return function ($type, $data) use ($callback, $out): bool {
-            if ($out == $type) {
-                $this->addOutput($data);
-            } else {
-                $this->addErrorOutput($data);
-            }
-
-            return null !== $callback && $callback($type, $data);
-        };
-    }
-
-    /**
-     * Updates the status of the process, reads pipes.
-     *
-     * @param bool $blocking Whether to use a blocking read call
-     */
-    protected function updateStatus(bool $blocking)
-    {
-        if (self::STATUS_STARTED !== $this->status) {
-            return;
-        }
-
-        $this->processInformation = proc_get_status($this->process);
-        $running = $this->processInformation['running'];
-
-        $this->readPipes($running && $blocking, '\\' !== \DIRECTORY_SEPARATOR || !$running);
-
-        if ($this->fallbackStatus && $this->isSigchildEnabled()) {
-            $this->processInformation = $this->fallbackStatus + $this->processInformation;
-        }
-
-        if (!$running) {
-            $this->close();
-        }
-    }
-
-    /**
-     * Returns whether PHP has been compiled with the '--enable-sigchild' option or not.
-     *
-     * @return bool
-     */
-    protected function isSigchildEnabled()
-    {
-        if (null !== self::$sigchild) {
-            return self::$sigchild;
-        }
-
-        if (!\function_exists('phpinfo')) {
-            return self::$sigchild = false;
-        }
-
-        ob_start();
-        phpinfo(\INFO_GENERAL);
-
-        return self::$sigchild = str_contains(ob_get_clean(), '--enable-sigchild');
-    }
-
-    /**
-     * Reads pipes for the freshest output.
-     *
-     * @param string $caller   The name of the method that needs fresh outputs
-     * @param bool   $blocking Whether to use blocking calls or not
-     *
-     * @throws LogicException in case output has been disabled or process is not started
-     */
-    private function readPipesForOutput(string $caller, bool $blocking = false)
-    {
-        if ($this->outputDisabled) {
-            throw new LogicException('Output has been disabled.');
-        }
-
-        $this->requireProcessIsStarted($caller);
-
-        $this->updateStatus($blocking);
-    }
-
-    /**
-     * Validates and returns the filtered timeout.
-     *
-     * @throws InvalidArgumentException if the given timeout is a negative number
-     */
-    private function validateTimeout(?float $timeout): ?float
-    {
-        $timeout = (float) $timeout;
-
-        if (0.0 === $timeout) {
-            $timeout = null;
-        } elseif ($timeout < 0) {
-            throw new InvalidArgumentException('The timeout value must be a valid positive integer or float number.');
-        }
-
-        return $timeout;
-    }
-
-    /**
-     * Reads pipes, executes callback.
-     *
-     * @param bool $blocking Whether to use blocking calls or not
-     * @param bool $close    Whether to close file handles or not
-     */
-    private function readPipes(bool $blocking, bool $close)
-    {
-        $result = $this->processPipes->readAndWrite($blocking, $close);
-
-        $callback = $this->callback;
-        foreach ($result as $type => $data) {
-            if (3 !== $type) {
-                $callback(self::STDOUT === $type ? self::OUT : self::ERR, $data);
-            } elseif (!isset($this->fallbackStatus['signaled'])) {
-                $this->fallbackStatus['exitcode'] = (int) $data;
-            }
-        }
-    }
-
-    /**
-     * Closes process resource, closes file handles, sets the exitcode.
-     *
-     * @return int The exitcode
-     */
-    private function close(): int
-    {
-        $this->processPipes->close();
-        if (\is_resource($this->process)) {
-            proc_close($this->process);
-        }
-        $this->exitcode = $this->processInformation['exitcode'];
-        $this->status = self::STATUS_TERMINATED;
-
-        if (-1 === $this->exitcode) {
-            if ($this->processInformation['signaled'] && 0 < $this->processInformation['termsig']) {
-                // if process has been signaled, no exitcode but a valid termsig, apply Unix convention
-                $this->exitcode = 128 + $this->processInformation['termsig'];
-            } elseif ($this->isSigchildEnabled()) {
-                $this->processInformation['signaled'] = true;
-                $this->processInformation['termsig'] = -1;
-            }
-        }
-
-        // Free memory from self-reference callback created by buildCallback
-        // Doing so in other contexts like __destruct or by garbage collector is ineffective
-        // Now pipes are closed, so the callback is no longer necessary
-        $this->callback = null;
-
-        return $this->exitcode;
-    }
-
-    /**
-     * Resets data related to the latest run of the process.
-     */
-    private function resetProcessData()
-    {
-        $this->starttime = null;
-        $this->callback = null;
-        $this->exitcode = null;
-        $this->fallbackStatus = [];
-        $this->processInformation = null;
-        $this->stdout = fopen('php://temp/maxmemory:'.(1024 * 1024), 'w+');
-        $this->stderr = fopen('php://temp/maxmemory:'.(1024 * 1024), 'w+');
-        $this->process = null;
-        $this->latestSignal = null;
-        $this->status = self::STATUS_READY;
-        $this->incrementalOutputOffset = 0;
-        $this->incrementalErrorOutputOffset = 0;
-    }
-
-    /**
-     * Sends a POSIX signal to the process.
-     *
-     * @param int  $signal         A valid POSIX signal (see https://php.net/pcntl.constants)
-     * @param bool $throwException Whether to throw exception in case signal failed
-     *
-     * @return bool True if the signal was sent successfully, false otherwise
-     *
-     * @throws LogicException   In case the process is not running
-     * @throws RuntimeException In case --enable-sigchild is activated and the process can't be killed
-     * @throws RuntimeException In case of failure
-     */
-    private function doSignal(int $signal, bool $throwException): bool
-    {
-        if (null === $pid = $this->getPid()) {
-            if ($throwException) {
-                throw new LogicException('Can not send signal on a non running process.');
-            }
-
-            return false;
-        }
-
-        if ('\\' === \DIRECTORY_SEPARATOR) {
-            exec(sprintf('taskkill /F /T /PID %d 2>&1', $pid), $output, $exitCode);
-            if ($exitCode && $this->isRunning()) {
-                if ($throwException) {
-                    throw new RuntimeException(sprintf('Unable to kill the process (%s).', implode(' ', $output)));
-                }
-
-                return false;
-            }
-        } else {
-            if (!$this->isSigchildEnabled()) {
-                $ok = @proc_terminate($this->process, $signal);
-            } elseif (\function_exists('posix_kill')) {
-                $ok = @posix_kill($pid, $signal);
-            } elseif ($ok = proc_open(sprintf('kill -%d %d', $signal, $pid), [2 => ['pipe', 'w']], $pipes)) {
-                $ok = false === fgets($pipes[2]);
-            }
-            if (!$ok) {
-                if ($throwException) {
-                    throw new RuntimeException(sprintf('Error while sending signal "%s".', $signal));
-                }
-
-                return false;
-            }
-        }
-
-        $this->latestSignal = $signal;
-        $this->fallbackStatus['signaled'] = true;
-        $this->fallbackStatus['exitcode'] = -1;
-        $this->fallbackStatus['termsig'] = $this->latestSignal;
-
-        return true;
-    }
-
-    private function prepareWindowsCommandLine(string $cmd, array &$env): string
-    {
-        $uid = uniqid('', true);
-        $varCount = 0;
-        $varCache = [];
-        $cmd = preg_replace_callback(
-            '/"(?:(
+	public const ERR = 'err';
+	public const OUT = 'out';
+
+	public const STATUS_READY = 'ready';
+	public const STATUS_STARTED = 'started';
+	public const STATUS_TERMINATED = 'terminated';
+
+	public const STDIN = 0;
+	public const STDOUT = 1;
+	public const STDERR = 2;
+
+	// Timeout Precision in seconds.
+	public const TIMEOUT_PRECISION = 0.2;
+
+	public const ITER_NON_BLOCKING = 1; // By default, iterating over outputs is a blocking call, use this flag to make it non-blocking
+	public const ITER_KEEP_OUTPUT = 2;  // By default, outputs are cleared while iterating, use this flag to keep them in memory
+	public const ITER_SKIP_OUT = 4;     // Use this flag to skip STDOUT while iterating
+	public const ITER_SKIP_ERR = 8;     // Use this flag to skip STDERR while iterating
+
+	private $callback;
+	private $hasCallback = false;
+	private $commandline;
+	private $cwd;
+	private $env;
+	private $input;
+	private $starttime;
+	private $lastOutputTime;
+	private $timeout;
+	private $idleTimeout;
+	private $exitcode;
+	private $fallbackStatus = [];
+	private $processInformation;
+	private $outputDisabled = false;
+	private $stdout;
+	private $stderr;
+	private $process;
+	private $status = self::STATUS_READY;
+	private $incrementalOutputOffset = 0;
+	private $incrementalErrorOutputOffset = 0;
+	private $tty = false;
+	private $pty;
+	private $options = ['suppress_errors' => true, 'bypass_shell' => true];
+
+	private $useFileHandles = false;
+	/** @var PipesInterface */
+	private $processPipes;
+
+	private $latestSignal;
+
+	private static $sigchild;
+
+	/**
+	 * Exit codes translation table.
+	 *
+	 * User-defined errors must use exit codes in the 64-113 range.
+	 */
+	public static $exitCodes = [
+		0 => 'OK',
+		1 => 'General error',
+		2 => 'Misuse of shell builtins',
+
+		126 => 'Invoked command cannot execute',
+		127 => 'Command not found',
+		128 => 'Invalid exit argument',
+
+		// signals
+		129 => 'Hangup',
+		130 => 'Interrupt',
+		131 => 'Quit and dump core',
+		132 => 'Illegal instruction',
+		133 => 'Trace/breakpoint trap',
+		134 => 'Process aborted',
+		135 => 'Bus error: "access to undefined portion of memory object"',
+		136 => 'Floating point exception: "erroneous arithmetic operation"',
+		137 => 'Kill (terminate immediately)',
+		138 => 'User-defined 1',
+		139 => 'Segmentation violation',
+		140 => 'User-defined 2',
+		141 => 'Write to pipe with no one reading',
+		142 => 'Signal raised by alarm',
+		143 => 'Termination (request to terminate)',
+		// 144 - not defined
+		145 => 'Child process terminated, stopped (or continued*)',
+		146 => 'Continue if stopped',
+		147 => 'Stop executing temporarily',
+		148 => 'Terminal stop signal',
+		149 => 'Background process attempting to read from tty ("in")',
+		150 => 'Background process attempting to write to tty ("out")',
+		151 => 'Urgent data available on socket',
+		152 => 'CPU time limit exceeded',
+		153 => 'File size limit exceeded',
+		154 => 'Signal raised by timer counting virtual time: "virtual timer expired"',
+		155 => 'Profiling timer expired',
+		// 156 - not defined
+		157 => 'Pollable event',
+		// 158 - not defined
+		159 => 'Bad syscall',
+	];
+
+	/**
+	 * @param array          $command The command to run and its arguments listed as separate entries
+	 * @param string|null    $cwd     The working directory or null to use the working dir of the current PHP process
+	 * @param array|null     $env     The environment variables or null to use the same environment as the current PHP process
+	 * @param mixed          $input   The input as stream resource, scalar or \Traversable, or null for no input
+	 * @param int|float|null $timeout The timeout in seconds or null to disable
+	 *
+	 * @throws LogicException When proc_open is not installed
+	 */
+	public function __construct(array $command, string $cwd = null, array $env = null, $input = null, ?float $timeout = 60)
+	{
+		if (!\function_exists('proc_open')) {
+			throw new LogicException('The Process class relies on proc_open, which is not available on your PHP installation.');
+		}
+
+		$this->commandline = $command;
+		$this->cwd = $cwd;
+
+		// on Windows, if the cwd changed via chdir(), proc_open defaults to the dir where PHP was started
+		// on Gnu/Linux, PHP builds with --enable-maintainer-zts are also affected
+		// @see : https://bugs.php.net/51800
+		// @see : https://bugs.php.net/50524
+		if (null === $this->cwd && (\defined('ZEND_THREAD_SAFE') || '\\' === \DIRECTORY_SEPARATOR)) {
+			$this->cwd = getcwd();
+		}
+		if (null !== $env) {
+			$this->setEnv($env);
+		}
+
+		$this->setInput($input);
+		$this->setTimeout($timeout);
+		$this->useFileHandles = '\\' === \DIRECTORY_SEPARATOR;
+		$this->pty = false;
+	}
+
+	/**
+	 * Creates a Process instance as a command-line to be run in a shell wrapper.
+	 *
+	 * Command-lines are parsed by the shell of your OS (/bin/sh on Unix-like, cmd.exe on Windows.)
+	 * This allows using e.g. pipes or conditional execution. In this mode, signals are sent to the
+	 * shell wrapper and not to your commands.
+	 *
+	 * In order to inject dynamic values into command-lines, we strongly recommend using placeholders.
+	 * This will save escaping values, which is not portable nor secure anyway:
+	 *
+	 *   $process = Process::fromShellCommandline('my_command "$MY_VAR"');
+	 *   $process->run(null, ['MY_VAR' => $theValue]);
+	 *
+	 * @param string         $command The command line to pass to the shell of the OS
+	 * @param string|null    $cwd     The working directory or null to use the working dir of the current PHP process
+	 * @param array|null     $env     The environment variables or null to use the same environment as the current PHP process
+	 * @param mixed          $input   The input as stream resource, scalar or \Traversable, or null for no input
+	 * @param int|float|null $timeout The timeout in seconds or null to disable
+	 *
+	 * @return static
+	 *
+	 * @throws LogicException When proc_open is not installed
+	 */
+	public static function fromShellCommandline(string $command, string $cwd = null, array $env = null, $input = null, ?float $timeout = 60)
+	{
+		$process = new static([], $cwd, $env, $input, $timeout);
+		$process->commandline = $command;
+
+		return $process;
+	}
+
+	/**
+	 * @return array
+	 */
+	public function __sleep()
+	{
+		throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
+	}
+
+	public function __wakeup()
+	{
+		throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
+	}
+
+	public function __destruct()
+	{
+		if ($this->options['create_new_console'] ?? false) {
+			$this->processPipes->close();
+		} else {
+			$this->stop(0);
+		}
+	}
+
+	public function __clone()
+	{
+		$this->resetProcessData();
+	}
+
+	/**
+	 * Runs the process.
+	 *
+	 * The callback receives the type of output (out or err) and
+	 * some bytes from the output in real-time. It allows to have feedback
+	 * from the independent process during execution.
+	 *
+	 * The STDOUT and STDERR are also available after the process is finished
+	 * via the getOutput() and getErrorOutput() methods.
+	 *
+	 * @param callable|null $callback A PHP callback to run whenever there is some
+	 *                                output available on STDOUT or STDERR
+	 *
+	 * @return int The exit status code
+	 *
+	 * @throws RuntimeException         When process can't be launched
+	 * @throws RuntimeException         When process is already running
+	 * @throws ProcessTimedOutException When process timed out
+	 * @throws ProcessSignaledException When process stopped after receiving signal
+	 * @throws LogicException           In case a callback is provided and output has been disabled
+	 *
+	 * @final
+	 */
+	public function run(callable $callback = null, array $env = []): int
+	{
+		$this->start($callback, $env);
+
+		return $this->wait();
+	}
+
+	/**
+	 * Runs the process.
+	 *
+	 * This is identical to run() except that an exception is thrown if the process
+	 * exits with a non-zero exit code.
+	 *
+	 * @return $this
+	 *
+	 * @throws ProcessFailedException if the process didn't terminate successfully
+	 *
+	 * @final
+	 */
+	public function mustRun(callable $callback = null, array $env = []): self
+	{
+		if (0 !== $this->run($callback, $env)) {
+			throw new ProcessFailedException($this);
+		}
+
+		return $this;
+	}
+
+	/**
+	 * Starts the process and returns after writing the input to STDIN.
+	 *
+	 * This method blocks until all STDIN data is sent to the process then it
+	 * returns while the process runs in the background.
+	 *
+	 * The termination of the process can be awaited with wait().
+	 *
+	 * The callback receives the type of output (out or err) and some bytes from
+	 * the output in real-time while writing the standard input to the process.
+	 * It allows to have feedback from the independent process during execution.
+	 *
+	 * @param callable|null $callback A PHP callback to run whenever there is some
+	 *                                output available on STDOUT or STDERR
+	 *
+	 * @throws RuntimeException When process can't be launched
+	 * @throws RuntimeException When process is already running
+	 * @throws LogicException   In case a callback is provided and output has been disabled
+	 */
+	public function start(callable $callback = null, array $env = [])
+	{
+		if ($this->isRunning()) {
+			throw new RuntimeException('Process is already running.');
+		}
+
+		$this->resetProcessData();
+		$this->starttime = $this->lastOutputTime = microtime(true);
+		$this->callback = $this->buildCallback($callback);
+		$this->hasCallback = null !== $callback;
+		$descriptors = $this->getDescriptors();
+
+		if ($this->env) {
+			$env += $this->env;
+		}
+
+		$env += $this->getDefaultEnv();
+
+		if (\is_array($commandline = $this->commandline)) {
+			$commandline = implode(' ', array_map([$this, 'escapeArgument'], $commandline));
+
+			if ('\\' !== \DIRECTORY_SEPARATOR) {
+				// exec is mandatory to deal with sending a signal to the process
+				$commandline = 'exec '.$commandline;
+			}
+		} else {
+			$commandline = $this->replacePlaceholders($commandline, $env);
+		}
+
+		if ('\\' === \DIRECTORY_SEPARATOR) {
+			$commandline = $this->prepareWindowsCommandLine($commandline, $env);
+		} elseif (!$this->useFileHandles && $this->isSigchildEnabled()) {
+			// last exit code is output on the fourth pipe and caught to work around --enable-sigchild
+			$descriptors[3] = ['pipe', 'w'];
+
+			// See https://unix.stackexchange.com/questions/71205/background-process-pipe-input
+			$commandline = '{ ('.$commandline.') <&3 3<&- 3>/dev/null & } 3<&0;';
+			$commandline .= 'pid=$!; echo $pid >&3; wait $pid; code=$?; echo $code >&3; exit $code';
+
+			// Workaround for the bug, when PTS functionality is enabled.
+			// @see : https://bugs.php.net/69442
+			$ptsWorkaround = fopen(__FILE__, 'r');
+		}
+
+		$envPairs = [];
+		foreach ($env as $k => $v) {
+			if (false !== $v) {
+				$envPairs[] = $k.'='.$v;
+			}
+		}
+
+		if (!is_dir($this->cwd)) {
+			throw new RuntimeException(sprintf('The provided cwd "%s" does not exist.', $this->cwd));
+		}
+
+		$this->process = @proc_open($commandline, $descriptors, $this->processPipes->pipes, $this->cwd, $envPairs, $this->options);
+
+		if (!\is_resource($this->process)) {
+			throw new RuntimeException('Unable to launch a new process.');
+		}
+		$this->status = self::STATUS_STARTED;
+
+		if (isset($descriptors[3])) {
+			$this->fallbackStatus['pid'] = (int) fgets($this->processPipes->pipes[3]);
+		}
+
+		if ($this->tty) {
+			return;
+		}
+
+		$this->updateStatus(false);
+		$this->checkTimeout();
+	}
+
+	/**
+	 * Restarts the process.
+	 *
+	 * Be warned that the process is cloned before being started.
+	 *
+	 * @param callable|null $callback A PHP callback to run whenever there is some
+	 *                                output available on STDOUT or STDERR
+	 *
+	 * @return static
+	 *
+	 * @throws RuntimeException When process can't be launched
+	 * @throws RuntimeException When process is already running
+	 *
+	 * @see start()
+	 *
+	 * @final
+	 */
+	public function restart(callable $callback = null, array $env = []): self
+	{
+		if ($this->isRunning()) {
+			throw new RuntimeException('Process is already running.');
+		}
+
+		$process = clone $this;
+		$process->start($callback, $env);
+
+		return $process;
+	}
+
+	/**
+	 * Waits for the process to terminate.
+	 *
+	 * The callback receives the type of output (out or err) and some bytes
+	 * from the output in real-time while writing the standard input to the process.
+	 * It allows to have feedback from the independent process during execution.
+	 *
+	 * @param callable|null $callback A valid PHP callback
+	 *
+	 * @return int The exitcode of the process
+	 *
+	 * @throws ProcessTimedOutException When process timed out
+	 * @throws ProcessSignaledException When process stopped after receiving signal
+	 * @throws LogicException           When process is not yet started
+	 */
+	public function wait(callable $callback = null)
+	{
+		$this->requireProcessIsStarted(__FUNCTION__);
+
+		$this->updateStatus(false);
+
+		if (null !== $callback) {
+			if (!$this->processPipes->haveReadSupport()) {
+				$this->stop(0);
+				throw new LogicException('Pass the callback to the "Process::start" method or call enableOutput to use a callback with "Process::wait".');
+			}
+			$this->callback = $this->buildCallback($callback);
+		}
+
+		do {
+			$this->checkTimeout();
+			$running = '\\' === \DIRECTORY_SEPARATOR ? $this->isRunning() : $this->processPipes->areOpen();
+			$this->readPipes($running, '\\' !== \DIRECTORY_SEPARATOR || !$running);
+		} while ($running);
+
+		while ($this->isRunning()) {
+			$this->checkTimeout();
+			usleep(1000);
+		}
+
+		if ($this->processInformation['signaled'] && $this->processInformation['termsig'] !== $this->latestSignal) {
+			throw new ProcessSignaledException($this);
+		}
+
+		return $this->exitcode;
+	}
+
+	/**
+	 * Waits until the callback returns true.
+	 *
+	 * The callback receives the type of output (out or err) and some bytes
+	 * from the output in real-time while writing the standard input to the process.
+	 * It allows to have feedback from the independent process during execution.
+	 *
+	 * @throws RuntimeException         When process timed out
+	 * @throws LogicException           When process is not yet started
+	 * @throws ProcessTimedOutException In case the timeout was reached
+	 */
+	public function waitUntil(callable $callback): bool
+	{
+		$this->requireProcessIsStarted(__FUNCTION__);
+		$this->updateStatus(false);
+
+		if (!$this->processPipes->haveReadSupport()) {
+			$this->stop(0);
+			throw new LogicException('Pass the callback to the "Process::start" method or call enableOutput to use a callback with "Process::waitUntil".');
+		}
+		$callback = $this->buildCallback($callback);
+
+		$ready = false;
+		while (true) {
+			$this->checkTimeout();
+			$running = '\\' === \DIRECTORY_SEPARATOR ? $this->isRunning() : $this->processPipes->areOpen();
+			$output = $this->processPipes->readAndWrite($running, '\\' !== \DIRECTORY_SEPARATOR || !$running);
+
+			foreach ($output as $type => $data) {
+				if (3 !== $type) {
+					$ready = $callback(self::STDOUT === $type ? self::OUT : self::ERR, $data) || $ready;
+				} elseif (!isset($this->fallbackStatus['signaled'])) {
+					$this->fallbackStatus['exitcode'] = (int) $data;
+				}
+			}
+			if ($ready) {
+				return true;
+			}
+			if (!$running) {
+				return false;
+			}
+
+			usleep(1000);
+		}
+	}
+
+	/**
+	 * Returns the Pid (process identifier), if applicable.
+	 *
+	 * @return int|null The process id if running, null otherwise
+	 */
+	public function getPid()
+	{
+		return $this->isRunning() ? $this->processInformation['pid'] : null;
+	}
+
+	/**
+	 * Sends a POSIX signal to the process.
+	 *
+	 * @param int $signal A valid POSIX signal (see https://php.net/pcntl.constants)
+	 *
+	 * @return $this
+	 *
+	 * @throws LogicException   In case the process is not running
+	 * @throws RuntimeException In case --enable-sigchild is activated and the process can't be killed
+	 * @throws RuntimeException In case of failure
+	 */
+	public function signal(int $signal)
+	{
+		$this->doSignal($signal, true);
+
+		return $this;
+	}
+
+	/**
+	 * Disables fetching output and error output from the underlying process.
+	 *
+	 * @return $this
+	 *
+	 * @throws RuntimeException In case the process is already running
+	 * @throws LogicException   if an idle timeout is set
+	 */
+	public function disableOutput()
+	{
+		if ($this->isRunning()) {
+			throw new RuntimeException('Disabling output while the process is running is not possible.');
+		}
+		if (null !== $this->idleTimeout) {
+			throw new LogicException('Output can not be disabled while an idle timeout is set.');
+		}
+
+		$this->outputDisabled = true;
+
+		return $this;
+	}
+
+	/**
+	 * Enables fetching output and error output from the underlying process.
+	 *
+	 * @return $this
+	 *
+	 * @throws RuntimeException In case the process is already running
+	 */
+	public function enableOutput()
+	{
+		if ($this->isRunning()) {
+			throw new RuntimeException('Enabling output while the process is running is not possible.');
+		}
+
+		$this->outputDisabled = false;
+
+		return $this;
+	}
+
+	/**
+	 * Returns true in case the output is disabled, false otherwise.
+	 *
+	 * @return bool
+	 */
+	public function isOutputDisabled()
+	{
+		return $this->outputDisabled;
+	}
+
+	/**
+	 * Returns the current output of the process (STDOUT).
+	 *
+	 * @return string The process output
+	 *
+	 * @throws LogicException in case the output has been disabled
+	 * @throws LogicException In case the process is not started
+	 */
+	public function getOutput()
+	{
+		$this->readPipesForOutput(__FUNCTION__);
+
+		if (false === $ret = stream_get_contents($this->stdout, -1, 0)) {
+			return '';
+		}
+
+		return $ret;
+	}
+
+	/**
+	 * Returns the output incrementally.
+	 *
+	 * In comparison with the getOutput method which always return the whole
+	 * output, this one returns the new output since the last call.
+	 *
+	 * @return string The process output since the last call
+	 *
+	 * @throws LogicException in case the output has been disabled
+	 * @throws LogicException In case the process is not started
+	 */
+	public function getIncrementalOutput()
+	{
+		$this->readPipesForOutput(__FUNCTION__);
+
+		$latest = stream_get_contents($this->stdout, -1, $this->incrementalOutputOffset);
+		$this->incrementalOutputOffset = ftell($this->stdout);
+
+		if (false === $latest) {
+			return '';
+		}
+
+		return $latest;
+	}
+
+	/**
+	 * Returns an iterator to the output of the process, with the output type as keys (Process::OUT/ERR).
+	 *
+	 * @param int $flags A bit field of Process::ITER_* flags
+	 *
+	 * @throws LogicException in case the output has been disabled
+	 * @throws LogicException In case the process is not started
+	 *
+	 * @return \Generator
+	 */
+	#[\ReturnTypeWillChange]
+	public function getIterator(int $flags = 0)
+	{
+		$this->readPipesForOutput(__FUNCTION__, false);
+
+		$clearOutput = !(self::ITER_KEEP_OUTPUT & $flags);
+		$blocking = !(self::ITER_NON_BLOCKING & $flags);
+		$yieldOut = !(self::ITER_SKIP_OUT & $flags);
+		$yieldErr = !(self::ITER_SKIP_ERR & $flags);
+
+		while (null !== $this->callback || ($yieldOut && !feof($this->stdout)) || ($yieldErr && !feof($this->stderr))) {
+			if ($yieldOut) {
+				$out = stream_get_contents($this->stdout, -1, $this->incrementalOutputOffset);
+
+				if (isset($out[0])) {
+					if ($clearOutput) {
+						$this->clearOutput();
+					} else {
+						$this->incrementalOutputOffset = ftell($this->stdout);
+					}
+
+					yield self::OUT => $out;
+				}
+			}
+
+			if ($yieldErr) {
+				$err = stream_get_contents($this->stderr, -1, $this->incrementalErrorOutputOffset);
+
+				if (isset($err[0])) {
+					if ($clearOutput) {
+						$this->clearErrorOutput();
+					} else {
+						$this->incrementalErrorOutputOffset = ftell($this->stderr);
+					}
+
+					yield self::ERR => $err;
+				}
+			}
+
+			if (!$blocking && !isset($out[0]) && !isset($err[0])) {
+				yield self::OUT => '';
+			}
+
+			$this->checkTimeout();
+			$this->readPipesForOutput(__FUNCTION__, $blocking);
+		}
+	}
+
+	/**
+	 * Clears the process output.
+	 *
+	 * @return $this
+	 */
+	public function clearOutput()
+	{
+		ftruncate($this->stdout, 0);
+		fseek($this->stdout, 0);
+		$this->incrementalOutputOffset = 0;
+
+		return $this;
+	}
+
+	/**
+	 * Returns the current error output of the process (STDERR).
+	 *
+	 * @return string The process error output
+	 *
+	 * @throws LogicException in case the output has been disabled
+	 * @throws LogicException In case the process is not started
+	 */
+	public function getErrorOutput()
+	{
+		$this->readPipesForOutput(__FUNCTION__);
+
+		if (false === $ret = stream_get_contents($this->stderr, -1, 0)) {
+			return '';
+		}
+
+		return $ret;
+	}
+
+	/**
+	 * Returns the errorOutput incrementally.
+	 *
+	 * In comparison with the getErrorOutput method which always return the
+	 * whole error output, this one returns the new error output since the last
+	 * call.
+	 *
+	 * @return string The process error output since the last call
+	 *
+	 * @throws LogicException in case the output has been disabled
+	 * @throws LogicException In case the process is not started
+	 */
+	public function getIncrementalErrorOutput()
+	{
+		$this->readPipesForOutput(__FUNCTION__);
+
+		$latest = stream_get_contents($this->stderr, -1, $this->incrementalErrorOutputOffset);
+		$this->incrementalErrorOutputOffset = ftell($this->stderr);
+
+		if (false === $latest) {
+			return '';
+		}
+
+		return $latest;
+	}
+
+	/**
+	 * Clears the process output.
+	 *
+	 * @return $this
+	 */
+	public function clearErrorOutput()
+	{
+		ftruncate($this->stderr, 0);
+		fseek($this->stderr, 0);
+		$this->incrementalErrorOutputOffset = 0;
+
+		return $this;
+	}
+
+	/**
+	 * Returns the exit code returned by the process.
+	 *
+	 * @return int|null The exit status code, null if the Process is not terminated
+	 */
+	public function getExitCode()
+	{
+		$this->updateStatus(false);
+
+		return $this->exitcode;
+	}
+
+	/**
+	 * Returns a string representation for the exit code returned by the process.
+	 *
+	 * This method relies on the Unix exit code status standardization
+	 * and might not be relevant for other operating systems.
+	 *
+	 * @return string|null A string representation for the exit status code, null if the Process is not terminated
+	 *
+	 * @see http://tldp.org/LDP/abs/html/exitcodes.html
+	 * @see http://en.wikipedia.org/wiki/Unix_signal
+	 */
+	public function getExitCodeText()
+	{
+		if (null === $exitcode = $this->getExitCode()) {
+			return null;
+		}
+
+		return self::$exitCodes[$exitcode] ?? 'Unknown error';
+	}
+
+	/**
+	 * Checks if the process ended successfully.
+	 *
+	 * @return bool true if the process ended successfully, false otherwise
+	 */
+	public function isSuccessful()
+	{
+		return 0 === $this->getExitCode();
+	}
+
+	/**
+	 * Returns true if the child process has been terminated by an uncaught signal.
+	 *
+	 * It always returns false on Windows.
+	 *
+	 * @return bool
+	 *
+	 * @throws LogicException In case the process is not terminated
+	 */
+	public function hasBeenSignaled()
+	{
+		$this->requireProcessIsTerminated(__FUNCTION__);
+
+		return $this->processInformation['signaled'];
+	}
+
+	/**
+	 * Returns the number of the signal that caused the child process to terminate its execution.
+	 *
+	 * It is only meaningful if hasBeenSignaled() returns true.
+	 *
+	 * @return int
+	 *
+	 * @throws RuntimeException In case --enable-sigchild is activated
+	 * @throws LogicException   In case the process is not terminated
+	 */
+	public function getTermSignal()
+	{
+		$this->requireProcessIsTerminated(__FUNCTION__);
+
+		if ($this->isSigchildEnabled() && -1 === $this->processInformation['termsig']) {
+			throw new RuntimeException('This PHP has been compiled with --enable-sigchild. Term signal can not be retrieved.');
+		}
+
+		return $this->processInformation['termsig'];
+	}
+
+	/**
+	 * Returns true if the child process has been stopped by a signal.
+	 *
+	 * It always returns false on Windows.
+	 *
+	 * @return bool
+	 *
+	 * @throws LogicException In case the process is not terminated
+	 */
+	public function hasBeenStopped()
+	{
+		$this->requireProcessIsTerminated(__FUNCTION__);
+
+		return $this->processInformation['stopped'];
+	}
+
+	/**
+	 * Returns the number of the signal that caused the child process to stop its execution.
+	 *
+	 * It is only meaningful if hasBeenStopped() returns true.
+	 *
+	 * @return int
+	 *
+	 * @throws LogicException In case the process is not terminated
+	 */
+	public function getStopSignal()
+	{
+		$this->requireProcessIsTerminated(__FUNCTION__);
+
+		return $this->processInformation['stopsig'];
+	}
+
+	/**
+	 * Checks if the process is currently running.
+	 *
+	 * @return bool true if the process is currently running, false otherwise
+	 */
+	public function isRunning()
+	{
+		if (self::STATUS_STARTED !== $this->status) {
+			return false;
+		}
+
+		$this->updateStatus(false);
+
+		return $this->processInformation['running'];
+	}
+
+	/**
+	 * Checks if the process has been started with no regard to the current state.
+	 *
+	 * @return bool true if status is ready, false otherwise
+	 */
+	public function isStarted()
+	{
+		return self::STATUS_READY != $this->status;
+	}
+
+	/**
+	 * Checks if the process is terminated.
+	 *
+	 * @return bool true if process is terminated, false otherwise
+	 */
+	public function isTerminated()
+	{
+		$this->updateStatus(false);
+
+		return self::STATUS_TERMINATED == $this->status;
+	}
+
+	/**
+	 * Gets the process status.
+	 *
+	 * The status is one of: ready, started, terminated.
+	 *
+	 * @return string The current process status
+	 */
+	public function getStatus()
+	{
+		$this->updateStatus(false);
+
+		return $this->status;
+	}
+
+	/**
+	 * Stops the process.
+	 *
+	 * @param int|float $timeout The timeout in seconds
+	 * @param int       $signal  A POSIX signal to send in case the process has not stop at timeout, default is SIGKILL (9)
+	 *
+	 * @return int|null The exit-code of the process or null if it's not running
+	 */
+	public function stop(float $timeout = 10, int $signal = null)
+	{
+		$timeoutMicro = microtime(true) + $timeout;
+		if ($this->isRunning()) {
+			// given SIGTERM may not be defined and that "proc_terminate" uses the constant value and not the constant itself, we use the same here
+			$this->doSignal(15, false);
+			do {
+				usleep(1000);
+			} while ($this->isRunning() && microtime(true) < $timeoutMicro);
+
+			if ($this->isRunning()) {
+				// Avoid exception here: process is supposed to be running, but it might have stopped just
+				// after this line. In any case, let's silently discard the error, we cannot do anything.
+				$this->doSignal($signal ?: 9, false);
+			}
+		}
+
+		if ($this->isRunning()) {
+			if (isset($this->fallbackStatus['pid'])) {
+				unset($this->fallbackStatus['pid']);
+
+				return $this->stop(0, $signal);
+			}
+			$this->close();
+		}
+
+		return $this->exitcode;
+	}
+
+	/**
+	 * Adds a line to the STDOUT stream.
+	 *
+	 * @internal
+	 */
+	public function addOutput(string $line)
+	{
+		$this->lastOutputTime = microtime(true);
+
+		fseek($this->stdout, 0, \SEEK_END);
+		fwrite($this->stdout, $line);
+		fseek($this->stdout, $this->incrementalOutputOffset);
+	}
+
+	/**
+	 * Adds a line to the STDERR stream.
+	 *
+	 * @internal
+	 */
+	public function addErrorOutput(string $line)
+	{
+		$this->lastOutputTime = microtime(true);
+
+		fseek($this->stderr, 0, \SEEK_END);
+		fwrite($this->stderr, $line);
+		fseek($this->stderr, $this->incrementalErrorOutputOffset);
+	}
+
+	/**
+	 * Gets the last output time in seconds.
+	 *
+	 * @return float|null The last output time in seconds or null if it isn't started
+	 */
+	public function getLastOutputTime(): ?float
+	{
+		return $this->lastOutputTime;
+	}
+
+	/**
+	 * Gets the command line to be executed.
+	 *
+	 * @return string The command to execute
+	 */
+	public function getCommandLine()
+	{
+		return \is_array($this->commandline) ? implode(' ', array_map([$this, 'escapeArgument'], $this->commandline)) : $this->commandline;
+	}
+
+	/**
+	 * Gets the process timeout (max. runtime).
+	 *
+	 * @return float|null The timeout in seconds or null if it's disabled
+	 */
+	public function getTimeout()
+	{
+		return $this->timeout;
+	}
+
+	/**
+	 * Gets the process idle timeout (max. time since last output).
+	 *
+	 * @return float|null The timeout in seconds or null if it's disabled
+	 */
+	public function getIdleTimeout()
+	{
+		return $this->idleTimeout;
+	}
+
+	/**
+	 * Sets the process timeout (max. runtime) in seconds.
+	 *
+	 * To disable the timeout, set this value to null.
+	 *
+	 * @return $this
+	 *
+	 * @throws InvalidArgumentException if the timeout is negative
+	 */
+	public function setTimeout(?float $timeout)
+	{
+		$this->timeout = $this->validateTimeout($timeout);
+
+		return $this;
+	}
+
+	/**
+	 * Sets the process idle timeout (max. time since last output) in seconds.
+	 *
+	 * To disable the timeout, set this value to null.
+	 *
+	 * @return $this
+	 *
+	 * @throws LogicException           if the output is disabled
+	 * @throws InvalidArgumentException if the timeout is negative
+	 */
+	public function setIdleTimeout(?float $timeout)
+	{
+		if (null !== $timeout && $this->outputDisabled) {
+			throw new LogicException('Idle timeout can not be set while the output is disabled.');
+		}
+
+		$this->idleTimeout = $this->validateTimeout($timeout);
+
+		return $this;
+	}
+
+	/**
+	 * Enables or disables the TTY mode.
+	 *
+	 * @return $this
+	 *
+	 * @throws RuntimeException In case the TTY mode is not supported
+	 */
+	public function setTty(bool $tty)
+	{
+		if ('\\' === \DIRECTORY_SEPARATOR && $tty) {
+			throw new RuntimeException('TTY mode is not supported on Windows platform.');
+		}
+
+		if ($tty && !self::isTtySupported()) {
+			throw new RuntimeException('TTY mode requires /dev/tty to be read/writable.');
+		}
+
+		$this->tty = $tty;
+
+		return $this;
+	}
+
+	/**
+	 * Checks if the TTY mode is enabled.
+	 *
+	 * @return bool true if the TTY mode is enabled, false otherwise
+	 */
+	public function isTty()
+	{
+		return $this->tty;
+	}
+
+	/**
+	 * Sets PTY mode.
+	 *
+	 * @return $this
+	 */
+	public function setPty(bool $bool)
+	{
+		$this->pty = $bool;
+
+		return $this;
+	}
+
+	/**
+	 * Returns PTY state.
+	 *
+	 * @return bool
+	 */
+	public function isPty()
+	{
+		return $this->pty;
+	}
+
+	/**
+	 * Gets the working directory.
+	 *
+	 * @return string|null The current working directory or null on failure
+	 */
+	public function getWorkingDirectory()
+	{
+		if (null === $this->cwd) {
+			// getcwd() will return false if any one of the parent directories does not have
+			// the readable or search mode set, even if the current directory does
+			return getcwd() ?: null;
+		}
+
+		return $this->cwd;
+	}
+
+	/**
+	 * Sets the current working directory.
+	 *
+	 * @return $this
+	 */
+	public function setWorkingDirectory(string $cwd)
+	{
+		$this->cwd = $cwd;
+
+		return $this;
+	}
+
+	/**
+	 * Gets the environment variables.
+	 *
+	 * @return array The current environment variables
+	 */
+	public function getEnv()
+	{
+		return $this->env;
+	}
+
+	/**
+	 * Sets the environment variables.
+	 *
+	 * Each environment variable value should be a string.
+	 * If it is an array, the variable is ignored.
+	 * If it is false or null, it will be removed when
+	 * env vars are otherwise inherited.
+	 *
+	 * That happens in PHP when 'argv' is registered into
+	 * the $_ENV array for instance.
+	 *
+	 * @param array $env The new environment variables
+	 *
+	 * @return $this
+	 */
+	public function setEnv(array $env)
+	{
+		// Process can not handle env values that are arrays
+		$env = array_filter($env, function ($value) {
+			return !\is_array($value);
+		});
+
+		$this->env = $env;
+
+		return $this;
+	}
+
+	/**
+	 * Gets the Process input.
+	 *
+	 * @return resource|string|\Iterator|null The Process input
+	 */
+	public function getInput()
+	{
+		return $this->input;
+	}
+
+	/**
+	 * Sets the input.
+	 *
+	 * This content will be passed to the underlying process standard input.
+	 *
+	 * @param string|int|float|bool|resource|\Traversable|null $input The content
+	 *
+	 * @return $this
+	 *
+	 * @throws LogicException In case the process is running
+	 */
+	public function setInput($input)
+	{
+		if ($this->isRunning()) {
+			throw new LogicException('Input can not be set while the process is running.');
+		}
+
+		$this->input = ProcessUtils::validateInput(__METHOD__, $input);
+
+		return $this;
+	}
+
+	/**
+	 * Performs a check between the timeout definition and the time the process started.
+	 *
+	 * In case you run a background process (with the start method), you should
+	 * trigger this method regularly to ensure the process timeout
+	 *
+	 * @throws ProcessTimedOutException In case the timeout was reached
+	 */
+	public function checkTimeout()
+	{
+		if (self::STATUS_STARTED !== $this->status) {
+			return;
+		}
+
+		if (null !== $this->timeout && $this->timeout < microtime(true) - $this->starttime) {
+			$this->stop(0);
+
+			throw new ProcessTimedOutException($this, ProcessTimedOutException::TYPE_GENERAL);
+		}
+
+		if (null !== $this->idleTimeout && $this->idleTimeout < microtime(true) - $this->lastOutputTime) {
+			$this->stop(0);
+
+			throw new ProcessTimedOutException($this, ProcessTimedOutException::TYPE_IDLE);
+		}
+	}
+
+	/**
+	 * @throws LogicException in case process is not started
+	 */
+	public function getStartTime(): float
+	{
+		if (!$this->isStarted()) {
+			throw new LogicException('Start time is only available after process start.');
+		}
+
+		return $this->starttime;
+	}
+
+	/**
+	 * Defines options to pass to the underlying proc_open().
+	 *
+	 * @see https://php.net/proc_open for the options supported by PHP.
+	 *
+	 * Enabling the "create_new_console" option allows a subprocess to continue
+	 * to run after the main process exited, on both Windows and *nix
+	 */
+	public function setOptions(array $options)
+	{
+		if ($this->isRunning()) {
+			throw new RuntimeException('Setting options while the process is running is not possible.');
+		}
+
+		$defaultOptions = $this->options;
+		$existingOptions = ['blocking_pipes', 'create_process_group', 'create_new_console'];
+
+		foreach ($options as $key => $value) {
+			if (!\in_array($key, $existingOptions)) {
+				$this->options = $defaultOptions;
+				throw new LogicException(sprintf('Invalid option "%s" passed to "%s()". Supported options are "%s".', $key, __METHOD__, implode('", "', $existingOptions)));
+			}
+			$this->options[$key] = $value;
+		}
+	}
+
+	/**
+	 * Returns whether TTY is supported on the current operating system.
+	 */
+	public static function isTtySupported(): bool
+	{
+		static $isTtySupported;
+
+		if (null === $isTtySupported) {
+			$isTtySupported = (bool) @proc_open('echo 1 >/dev/null', [['file', '/dev/tty', 'r'], ['file', '/dev/tty', 'w'], ['file', '/dev/tty', 'w']], $pipes);
+		}
+
+		return $isTtySupported;
+	}
+
+	/**
+	 * Returns whether PTY is supported on the current operating system.
+	 *
+	 * @return bool
+	 */
+	public static function isPtySupported()
+	{
+		static $result;
+
+		if (null !== $result) {
+			return $result;
+		}
+
+		if ('\\' === \DIRECTORY_SEPARATOR) {
+			return $result = false;
+		}
+
+		return $result = (bool) @proc_open('echo 1 >/dev/null', [['pty'], ['pty'], ['pty']], $pipes);
+	}
+
+	/**
+	 * Creates the descriptors needed by the proc_open.
+	 */
+	private function getDescriptors(): array
+	{
+		if ($this->input instanceof \Iterator) {
+			$this->input->rewind();
+		}
+		if ('\\' === \DIRECTORY_SEPARATOR) {
+			$this->processPipes = new WindowsPipes($this->input, !$this->outputDisabled || $this->hasCallback);
+		} else {
+			$this->processPipes = new UnixPipes($this->isTty(), $this->isPty(), $this->input, !$this->outputDisabled || $this->hasCallback);
+		}
+
+		return $this->processPipes->getDescriptors();
+	}
+
+	/**
+	 * Builds up the callback used by wait().
+	 *
+	 * The callbacks adds all occurred output to the specific buffer and calls
+	 * the user callback (if present) with the received output.
+	 *
+	 * @param callable|null $callback The user defined PHP callback
+	 *
+	 * @return \Closure A PHP closure
+	 */
+	protected function buildCallback(callable $callback = null)
+	{
+		if ($this->outputDisabled) {
+			return function ($type, $data) use ($callback): bool {
+				return null !== $callback && $callback($type, $data);
+			};
+		}
+
+		$out = self::OUT;
+
+		return function ($type, $data) use ($callback, $out): bool {
+			if ($out == $type) {
+				$this->addOutput($data);
+			} else {
+				$this->addErrorOutput($data);
+			}
+
+			return null !== $callback && $callback($type, $data);
+		};
+	}
+
+	/**
+	 * Updates the status of the process, reads pipes.
+	 *
+	 * @param bool $blocking Whether to use a blocking read call
+	 */
+	protected function updateStatus(bool $blocking)
+	{
+		if (self::STATUS_STARTED !== $this->status) {
+			return;
+		}
+
+		$this->processInformation = proc_get_status($this->process);
+		$running = $this->processInformation['running'];
+
+		$this->readPipes($running && $blocking, '\\' !== \DIRECTORY_SEPARATOR || !$running);
+
+		if ($this->fallbackStatus && $this->isSigchildEnabled()) {
+			$this->processInformation = $this->fallbackStatus + $this->processInformation;
+		}
+
+		if (!$running) {
+			$this->close();
+		}
+	}
+
+	/**
+	 * Returns whether PHP has been compiled with the '--enable-sigchild' option or not.
+	 *
+	 * @return bool
+	 */
+	protected function isSigchildEnabled()
+	{
+		if (null !== self::$sigchild) {
+			return self::$sigchild;
+		}
+
+		if (!\function_exists('phpinfo')) {
+			return self::$sigchild = false;
+		}
+
+		ob_start();
+		phpinfo(\INFO_GENERAL);
+
+		return self::$sigchild = str_contains(ob_get_clean(), '--enable-sigchild');
+	}
+
+	/**
+	 * Reads pipes for the freshest output.
+	 *
+	 * @param string $caller   The name of the method that needs fresh outputs
+	 * @param bool   $blocking Whether to use blocking calls or not
+	 *
+	 * @throws LogicException in case output has been disabled or process is not started
+	 */
+	private function readPipesForOutput(string $caller, bool $blocking = false)
+	{
+		if ($this->outputDisabled) {
+			throw new LogicException('Output has been disabled.');
+		}
+
+		$this->requireProcessIsStarted($caller);
+
+		$this->updateStatus($blocking);
+	}
+
+	/**
+	 * Validates and returns the filtered timeout.
+	 *
+	 * @throws InvalidArgumentException if the given timeout is a negative number
+	 */
+	private function validateTimeout(?float $timeout): ?float
+	{
+		$timeout = (float) $timeout;
+
+		if (0.0 === $timeout) {
+			$timeout = null;
+		} elseif ($timeout < 0) {
+			throw new InvalidArgumentException('The timeout value must be a valid positive integer or float number.');
+		}
+
+		return $timeout;
+	}
+
+	/**
+	 * Reads pipes, executes callback.
+	 *
+	 * @param bool $blocking Whether to use blocking calls or not
+	 * @param bool $close    Whether to close file handles or not
+	 */
+	private function readPipes(bool $blocking, bool $close)
+	{
+		$result = $this->processPipes->readAndWrite($blocking, $close);
+
+		$callback = $this->callback;
+		foreach ($result as $type => $data) {
+			if (3 !== $type) {
+				$callback(self::STDOUT === $type ? self::OUT : self::ERR, $data);
+			} elseif (!isset($this->fallbackStatus['signaled'])) {
+				$this->fallbackStatus['exitcode'] = (int) $data;
+			}
+		}
+	}
+
+	/**
+	 * Closes process resource, closes file handles, sets the exitcode.
+	 *
+	 * @return int The exitcode
+	 */
+	private function close(): int
+	{
+		$this->processPipes->close();
+		if (\is_resource($this->process)) {
+			proc_close($this->process);
+		}
+		$this->exitcode = $this->processInformation['exitcode'];
+		$this->status = self::STATUS_TERMINATED;
+
+		if (-1 === $this->exitcode) {
+			if ($this->processInformation['signaled'] && 0 < $this->processInformation['termsig']) {
+				// if process has been signaled, no exitcode but a valid termsig, apply Unix convention
+				$this->exitcode = 128 + $this->processInformation['termsig'];
+			} elseif ($this->isSigchildEnabled()) {
+				$this->processInformation['signaled'] = true;
+				$this->processInformation['termsig'] = -1;
+			}
+		}
+
+		// Free memory from self-reference callback created by buildCallback
+		// Doing so in other contexts like __destruct or by garbage collector is ineffective
+		// Now pipes are closed, so the callback is no longer necessary
+		$this->callback = null;
+
+		return $this->exitcode;
+	}
+
+	/**
+	 * Resets data related to the latest run of the process.
+	 */
+	private function resetProcessData()
+	{
+		$this->starttime = null;
+		$this->callback = null;
+		$this->exitcode = null;
+		$this->fallbackStatus = [];
+		$this->processInformation = null;
+		$this->stdout = fopen('php://temp/maxmemory:'.(1024 * 1024), 'w+');
+		$this->stderr = fopen('php://temp/maxmemory:'.(1024 * 1024), 'w+');
+		$this->process = null;
+		$this->latestSignal = null;
+		$this->status = self::STATUS_READY;
+		$this->incrementalOutputOffset = 0;
+		$this->incrementalErrorOutputOffset = 0;
+	}
+
+	/**
+	 * Sends a POSIX signal to the process.
+	 *
+	 * @param int  $signal         A valid POSIX signal (see https://php.net/pcntl.constants)
+	 * @param bool $throwException Whether to throw exception in case signal failed
+	 *
+	 * @return bool True if the signal was sent successfully, false otherwise
+	 *
+	 * @throws LogicException   In case the process is not running
+	 * @throws RuntimeException In case --enable-sigchild is activated and the process can't be killed
+	 * @throws RuntimeException In case of failure
+	 */
+	private function doSignal(int $signal, bool $throwException): bool
+	{
+		if (null === $pid = $this->getPid()) {
+			if ($throwException) {
+				throw new LogicException('Can not send signal on a non running process.');
+			}
+
+			return false;
+		}
+
+		if ('\\' === \DIRECTORY_SEPARATOR) {
+			exec(sprintf('taskkill /F /T /PID %d 2>&1', $pid), $output, $exitCode);
+			if ($exitCode && $this->isRunning()) {
+				if ($throwException) {
+					throw new RuntimeException(sprintf('Unable to kill the process (%s).', implode(' ', $output)));
+				}
+
+				return false;
+			}
+		} else {
+			if (!$this->isSigchildEnabled()) {
+				$ok = @proc_terminate($this->process, $signal);
+			} elseif (\function_exists('posix_kill')) {
+				$ok = @posix_kill($pid, $signal);
+			} elseif ($ok = proc_open(sprintf('kill -%d %d', $signal, $pid), [2 => ['pipe', 'w']], $pipes)) {
+				$ok = false === fgets($pipes[2]);
+			}
+			if (!$ok) {
+				if ($throwException) {
+					throw new RuntimeException(sprintf('Error while sending signal "%s".', $signal));
+				}
+
+				return false;
+			}
+		}
+
+		$this->latestSignal = $signal;
+		$this->fallbackStatus['signaled'] = true;
+		$this->fallbackStatus['exitcode'] = -1;
+		$this->fallbackStatus['termsig'] = $this->latestSignal;
+
+		return true;
+	}
+
+	private function prepareWindowsCommandLine(string $cmd, array &$env): string
+	{
+		$uid = uniqid('', true);
+		$varCount = 0;
+		$varCache = [];
+		$cmd = preg_replace_callback(
+			'/"(?:(
                 [^"%!^]*+
                 (?:
                     (?: !LF! | "(?:\^[%!^])?+" )
                     [^"%!^]*+
                 )++
             ) | [^"]*+ )"/x',
-            function ($m) use (&$env, &$varCache, &$varCount, $uid) {
-                if (!isset($m[1])) {
-                    return $m[0];
-                }
-                if (isset($varCache[$m[0]])) {
-                    return $varCache[$m[0]];
-                }
-                if (str_contains($value = $m[1], "\0")) {
-                    $value = str_replace("\0", '?', $value);
-                }
-                if (false === strpbrk($value, "\"%!\n")) {
-                    return '"'.$value.'"';
-                }
-
-                $value = str_replace(['!LF!', '"^!"', '"^%"', '"^^"', '""'], ["\n", '!', '%', '^', '"'], $value);
-                $value = '"'.preg_replace('/(\\\\*)"/', '$1$1\\"', $value).'"';
-                $var = $uid.++$varCount;
-
-                $env[$var] = $value;
-
-                return $varCache[$m[0]] = '!'.$var.'!';
-            },
-            $cmd
-        );
-
-        $cmd = 'cmd /V:ON /E:ON /D /C ('.str_replace("\n", ' ', $cmd).')';
-        foreach ($this->processPipes->getFiles() as $offset => $filename) {
-            $cmd .= ' '.$offset.'>"'.$filename.'"';
-        }
-
-        return $cmd;
-    }
-
-    /**
-     * Ensures the process is running or terminated, throws a LogicException if the process has a not started.
-     *
-     * @throws LogicException if the process has not run
-     */
-    private function requireProcessIsStarted(string $functionName)
-    {
-        if (!$this->isStarted()) {
-            throw new LogicException(sprintf('Process must be started before calling "%s()".', $functionName));
-        }
-    }
-
-    /**
-     * Ensures the process is terminated, throws a LogicException if the process has a status different than "terminated".
-     *
-     * @throws LogicException if the process is not yet terminated
-     */
-    private function requireProcessIsTerminated(string $functionName)
-    {
-        if (!$this->isTerminated()) {
-            throw new LogicException(sprintf('Process must be terminated before calling "%s()".', $functionName));
-        }
-    }
-
-    /**
-     * Escapes a string to be used as a shell argument.
-     */
-    private function escapeArgument(?string $argument): string
-    {
-        if ('' === $argument || null === $argument) {
-            return '""';
-        }
-        if ('\\' !== \DIRECTORY_SEPARATOR) {
-            return "'".str_replace("'", "'\\''", $argument)."'";
-        }
-        if (str_contains($argument, "\0")) {
-            $argument = str_replace("\0", '?', $argument);
-        }
-        if (!preg_match('/[\/()%!^"<>&|\s]/', $argument)) {
-            return $argument;
-        }
-        $argument = preg_replace('/(\\\\+)$/', '$1$1', $argument);
-
-        return '"'.str_replace(['"', '^', '%', '!', "\n"], ['""', '"^^"', '"^%"', '"^!"', '!LF!'], $argument).'"';
-    }
-
-    private function replacePlaceholders(string $commandline, array $env)
-    {
-        return preg_replace_callback('/"\$\{:([_a-zA-Z]++[_a-zA-Z0-9]*+)\}"/', function ($matches) use ($commandline, $env) {
-            if (!isset($env[$matches[1]]) || false === $env[$matches[1]]) {
-                throw new InvalidArgumentException(sprintf('Command line is missing a value for parameter "%s": ', $matches[1]).$commandline);
-            }
-
-            return $this->escapeArgument($env[$matches[1]]);
-        }, $commandline);
-    }
-
-    private function getDefaultEnv(): array
-    {
-        $env = [];
-
-        foreach ($_SERVER as $k => $v) {
-            if (\is_string($v) && false !== $v = getenv($k)) {
-                $env[$k] = $v;
-            }
-        }
-
-        foreach ($_ENV as $k => $v) {
-            if (\is_string($v)) {
-                $env[$k] = $v;
-            }
-        }
-
-        return $env;
-    }
+			function ($m) use (&$env, &$varCache, &$varCount, $uid) {
+				if (!isset($m[1])) {
+					return $m[0];
+				}
+				if (isset($varCache[$m[0]])) {
+					return $varCache[$m[0]];
+				}
+				if (str_contains($value = $m[1], "\0")) {
+					$value = str_replace("\0", '?', $value);
+				}
+				if (false === strpbrk($value, "\"%!\n")) {
+					return '"'.$value.'"';
+				}
+
+				$value = str_replace(['!LF!', '"^!"', '"^%"', '"^^"', '""'], ["\n", '!', '%', '^', '"'], $value);
+				$value = '"'.preg_replace('/(\\\\*)"/', '$1$1\\"', $value).'"';
+				$var = $uid.++$varCount;
+
+				$env[$var] = $value;
+
+				return $varCache[$m[0]] = '!'.$var.'!';
+			},
+			$cmd
+		);
+
+		$cmd = 'cmd /V:ON /E:ON /D /C ('.str_replace("\n", ' ', $cmd).')';
+		foreach ($this->processPipes->getFiles() as $offset => $filename) {
+			$cmd .= ' '.$offset.'>"'.$filename.'"';
+		}
+
+		return $cmd;
+	}
+
+	/**
+	 * Ensures the process is running or terminated, throws a LogicException if the process has a not started.
+	 *
+	 * @throws LogicException if the process has not run
+	 */
+	private function requireProcessIsStarted(string $functionName)
+	{
+		if (!$this->isStarted()) {
+			throw new LogicException(sprintf('Process must be started before calling "%s()".', $functionName));
+		}
+	}
+
+	/**
+	 * Ensures the process is terminated, throws a LogicException if the process has a status different than "terminated".
+	 *
+	 * @throws LogicException if the process is not yet terminated
+	 */
+	private function requireProcessIsTerminated(string $functionName)
+	{
+		if (!$this->isTerminated()) {
+			throw new LogicException(sprintf('Process must be terminated before calling "%s()".', $functionName));
+		}
+	}
+
+	/**
+	 * Escapes a string to be used as a shell argument.
+	 */
+	private function escapeArgument(?string $argument): string
+	{
+		if ('' === $argument || null === $argument) {
+			return '""';
+		}
+		if ('\\' !== \DIRECTORY_SEPARATOR) {
+			return "'".str_replace("'", "'\\''", $argument)."'";
+		}
+		if (str_contains($argument, "\0")) {
+			$argument = str_replace("\0", '?', $argument);
+		}
+		if (!preg_match('/[\/()%!^"<>&|\s]/', $argument)) {
+			return $argument;
+		}
+		$argument = preg_replace('/(\\\\+)$/', '$1$1', $argument);
+
+		return '"'.str_replace(['"', '^', '%', '!', "\n"], ['""', '"^^"', '"^%"', '"^!"', '!LF!'], $argument).'"';
+	}
+
+	private function replacePlaceholders(string $commandline, array $env)
+	{
+		return preg_replace_callback('/"\$\{:([_a-zA-Z]++[_a-zA-Z0-9]*+)\}"/', function ($matches) use ($commandline, $env) {
+			if (!isset($env[$matches[1]]) || false === $env[$matches[1]]) {
+				throw new InvalidArgumentException(sprintf('Command line is missing a value for parameter "%s": ', $matches[1]).$commandline);
+			}
+
+			return $this->escapeArgument($env[$matches[1]]);
+		}, $commandline);
+	}
+
+	private function getDefaultEnv(): array
+	{
+		$env = [];
+
+		foreach ($_SERVER as $k => $v) {
+			if (\is_string($v) && false !== $v = getenv($k)) {
+				$env[$k] = $v;
+			}
+		}
+
+		foreach ($_ENV as $k => $v) {
+			if (\is_string($v)) {
+				$env[$k] = $v;
+			}
+		}
+
+		return $env;
+	}
 }

Spacing +338 added lines, -338 removed lines

@@ -45,9 +45,9 @@ 
     public const TIMEOUT_PRECISION = 0.2;
 
     public const ITER_NON_BLOCKING = 1; // By default, iterating over outputs is a blocking call, use this flag to make it non-blocking
-    public const ITER_KEEP_OUTPUT = 2;  // By default, outputs are cleared while iterating, use this flag to keep them in memory
-    public const ITER_SKIP_OUT = 4;     // Use this flag to skip STDOUT while iterating
-    public const ITER_SKIP_ERR = 8;     // Use this flag to skip STDERR while iterating
+    public const ITER_KEEP_OUTPUT = 2; // By default, outputs are cleared while iterating, use this flag to keep them in memory
+    public const ITER_SKIP_OUT = 4; // Use this flag to skip STDOUT while iterating
+    public const ITER_SKIP_ERR = 8; // Use this flag to skip STDERR while iterating
 
     private $callback;
     private $hasCallback = false;
@@ -60,7 +60,7 @@ 
     private $timeout;
     private $idleTimeout;
     private $exitcode;
-    private $fallbackStatus = [];
+    private $fallbackStatus = [ ];
     private $processInformation;
     private $outputDisabled = false;
     private $stdout;
@@ -71,7 +71,7 @@ 
     private $incrementalErrorOutputOffset = 0;
     private $tty = false;
     private $pty;
-    private $options = ['suppress_errors' => true, 'bypass_shell' => true];
+    private $options = [ 'suppress_errors' => true, 'bypass_shell' => true ];
 
     private $useFileHandles = false;
     /** @var PipesInterface */
@@ -138,10 +138,10 @@ 
      *
      * @throws LogicException When proc_open is not installed
      */
-    public function __construct(array $command, string $cwd = null, array $env = null, $input = null, ?float $timeout = 60)
+    public function __construct( array $command, string $cwd = null, array $env = null, $input = null, ?float $timeout = 60 )
     {
-        if (!\function_exists('proc_open')) {
-            throw new LogicException('The Process class relies on proc_open, which is not available on your PHP installation.');
+        if ( ! \function_exists( 'proc_open' ) ) {
+            throw new LogicException( 'The Process class relies on proc_open, which is not available on your PHP installation.' );
         }
 
         $this->commandline = $command;
@@ -151,15 +151,15 @@ 
         // on Gnu/Linux, PHP builds with --enable-maintainer-zts are also affected
         // @see : https://bugs.php.net/51800
         // @see : https://bugs.php.net/50524
-        if (null === $this->cwd && (\defined('ZEND_THREAD_SAFE') || '\\' === \DIRECTORY_SEPARATOR)) {
+        if ( null === $this->cwd && ( \defined( 'ZEND_THREAD_SAFE' ) || '\\' === \DIRECTORY_SEPARATOR ) ) {
             $this->cwd = getcwd();
         }
-        if (null !== $env) {
-            $this->setEnv($env);
+        if ( null !== $env ) {
+            $this->setEnv( $env );
         }
 
-        $this->setInput($input);
-        $this->setTimeout($timeout);
+        $this->setInput( $input );
+        $this->setTimeout( $timeout );
         $this->useFileHandles = '\\' === \DIRECTORY_SEPARATOR;
         $this->pty = false;
     }
@@ -187,9 +187,9 @@ 
      *
      * @throws LogicException When proc_open is not installed
      */
-    public static function fromShellCommandline(string $command, string $cwd = null, array $env = null, $input = null, ?float $timeout = 60)
+    public static function fromShellCommandline( string $command, string $cwd = null, array $env = null, $input = null, ?float $timeout = 60 )
     {
-        $process = new static([], $cwd, $env, $input, $timeout);
+        $process = new static( [ ], $cwd, $env, $input, $timeout );
         $process->commandline = $command;
 
         return $process;
@@ -200,20 +200,20 @@ 
      */
     public function __sleep()
     {
-        throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
+        throw new \BadMethodCallException( 'Cannot serialize ' . __CLASS__ );
     }
 
     public function __wakeup()
     {
-        throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
+        throw new \BadMethodCallException( 'Cannot unserialize ' . __CLASS__ );
     }
 
     public function __destruct()
     {
-        if ($this->options['create_new_console'] ?? false) {
+        if ( $this->options[ 'create_new_console' ] ?? false ) {
             $this->processPipes->close();
         } else {
-            $this->stop(0);
+            $this->stop( 0 );
         }
     }
 
@@ -245,9 +245,9 @@ 
      *
      * @final
      */
-    public function run(callable $callback = null, array $env = []): int
+    public function run( callable $callback = null, array $env = [ ] ): int
     {
-        $this->start($callback, $env);
+        $this->start( $callback, $env );
 
         return $this->wait();
     }
@@ -264,10 +264,10 @@ 
      *
      * @final
      */
-    public function mustRun(callable $callback = null, array $env = []): self
+    public function mustRun( callable $callback = null, array $env = [ ] ): self
     {
-        if (0 !== $this->run($callback, $env)) {
-            throw new ProcessFailedException($this);
+        if ( 0 !== $this->run( $callback, $env ) ) {
+            throw new ProcessFailedException( $this );
         }
 
         return $this;
@@ -292,77 +292,77 @@ 
      * @throws RuntimeException When process is already running
      * @throws LogicException   In case a callback is provided and output has been disabled
      */
-    public function start(callable $callback = null, array $env = [])
+    public function start( callable $callback = null, array $env = [ ] )
     {
-        if ($this->isRunning()) {
-            throw new RuntimeException('Process is already running.');
+        if ( $this->isRunning() ) {
+            throw new RuntimeException( 'Process is already running.' );
         }
 
         $this->resetProcessData();
-        $this->starttime = $this->lastOutputTime = microtime(true);
-        $this->callback = $this->buildCallback($callback);
+        $this->starttime = $this->lastOutputTime = microtime( true );
+        $this->callback = $this->buildCallback( $callback );
         $this->hasCallback = null !== $callback;
         $descriptors = $this->getDescriptors();
 
-        if ($this->env) {
+        if ( $this->env ) {
             $env += $this->env;
         }
 
         $env += $this->getDefaultEnv();
 
-        if (\is_array($commandline = $this->commandline)) {
-            $commandline = implode(' ', array_map([$this, 'escapeArgument'], $commandline));
+        if ( \is_array( $commandline = $this->commandline ) ) {
+            $commandline = implode( ' ', array_map( [ $this, 'escapeArgument' ], $commandline ) );
 
-            if ('\\' !== \DIRECTORY_SEPARATOR) {
+            if ( '\\' !== \DIRECTORY_SEPARATOR ) {
                 // exec is mandatory to deal with sending a signal to the process
-                $commandline = 'exec '.$commandline;
+                $commandline = 'exec ' . $commandline;
             }
         } else {
-            $commandline = $this->replacePlaceholders($commandline, $env);
+            $commandline = $this->replacePlaceholders( $commandline, $env );
         }
 
-        if ('\\' === \DIRECTORY_SEPARATOR) {
-            $commandline = $this->prepareWindowsCommandLine($commandline, $env);
-        } elseif (!$this->useFileHandles && $this->isSigchildEnabled()) {
+        if ( '\\' === \DIRECTORY_SEPARATOR ) {
+            $commandline = $this->prepareWindowsCommandLine( $commandline, $env );
+        } elseif ( ! $this->useFileHandles && $this->isSigchildEnabled() ) {
             // last exit code is output on the fourth pipe and caught to work around --enable-sigchild
-            $descriptors[3] = ['pipe', 'w'];
+            $descriptors[ 3 ] = [ 'pipe', 'w' ];
 
             // See https://unix.stackexchange.com/questions/71205/background-process-pipe-input
-            $commandline = '{ ('.$commandline.') <&3 3<&- 3>/dev/null & } 3<&0;';
+            $commandline = '{ (' . $commandline . ') <&3 3<&- 3>/dev/null & } 3<&0;';
             $commandline .= 'pid=$!; echo $pid >&3; wait $pid; code=$?; echo $code >&3; exit $code';
 
             // Workaround for the bug, when PTS functionality is enabled.
             // @see : https://bugs.php.net/69442
-            $ptsWorkaround = fopen(__FILE__, 'r');
+            $ptsWorkaround = fopen( __FILE__, 'r' );
         }
 
-        $envPairs = [];
-        foreach ($env as $k => $v) {
-            if (false !== $v) {
-                $envPairs[] = $k.'='.$v;
+        $envPairs = [ ];
+        foreach ( $env as $k => $v ) {
+            if ( false !== $v ) {
+                $envPairs[ ] = $k . '=' . $v;
             }
         }
 
-        if (!is_dir($this->cwd)) {
-            throw new RuntimeException(sprintf('The provided cwd "%s" does not exist.', $this->cwd));
+        if ( ! is_dir( $this->cwd ) ) {
+            throw new RuntimeException( sprintf( 'The provided cwd "%s" does not exist.', $this->cwd ) );
         }
 
-        $this->process = @proc_open($commandline, $descriptors, $this->processPipes->pipes, $this->cwd, $envPairs, $this->options);
+        $this->process = @proc_open( $commandline, $descriptors, $this->processPipes->pipes, $this->cwd, $envPairs, $this->options );
 
-        if (!\is_resource($this->process)) {
-            throw new RuntimeException('Unable to launch a new process.');
+        if ( ! \is_resource( $this->process ) ) {
+            throw new RuntimeException( 'Unable to launch a new process.' );
         }
         $this->status = self::STATUS_STARTED;
 
-        if (isset($descriptors[3])) {
-            $this->fallbackStatus['pid'] = (int) fgets($this->processPipes->pipes[3]);
+        if ( isset( $descriptors[ 3 ] ) ) {
+            $this->fallbackStatus[ 'pid' ] = (int)fgets( $this->processPipes->pipes[ 3 ] );
         }
 
-        if ($this->tty) {
+        if ( $this->tty ) {
             return;
         }
 
-        $this->updateStatus(false);
+        $this->updateStatus( false );
         $this->checkTimeout();
     }
 
@@ -383,14 +383,14 @@ 
      *
      * @final
      */
-    public function restart(callable $callback = null, array $env = []): self
+    public function restart( callable $callback = null, array $env = [ ] ): self
     {
-        if ($this->isRunning()) {
-            throw new RuntimeException('Process is already running.');
+        if ( $this->isRunning() ) {
+            throw new RuntimeException( 'Process is already running.' );
         }
 
         $process = clone $this;
-        $process->start($callback, $env);
+        $process->start( $callback, $env );
 
         return $process;
     }
@@ -410,33 +410,33 @@ 
      * @throws ProcessSignaledException When process stopped after receiving signal
      * @throws LogicException           When process is not yet started
      */
-    public function wait(callable $callback = null)
+    public function wait( callable $callback = null )
     {
-        $this->requireProcessIsStarted(__FUNCTION__);
+        $this->requireProcessIsStarted( __FUNCTION__ );
 
-        $this->updateStatus(false);
+        $this->updateStatus( false );
 
-        if (null !== $callback) {
-            if (!$this->processPipes->haveReadSupport()) {
-                $this->stop(0);
-                throw new LogicException('Pass the callback to the "Process::start" method or call enableOutput to use a callback with "Process::wait".');
+        if ( null !== $callback ) {
+            if ( ! $this->processPipes->haveReadSupport() ) {
+                $this->stop( 0 );
+                throw new LogicException( 'Pass the callback to the "Process::start" method or call enableOutput to use a callback with "Process::wait".' );
             }
-            $this->callback = $this->buildCallback($callback);
+            $this->callback = $this->buildCallback( $callback );
         }
 
         do {
             $this->checkTimeout();
             $running = '\\' === \DIRECTORY_SEPARATOR ? $this->isRunning() : $this->processPipes->areOpen();
-            $this->readPipes($running, '\\' !== \DIRECTORY_SEPARATOR || !$running);
-        } while ($running);
+            $this->readPipes( $running, '\\' !== \DIRECTORY_SEPARATOR || ! $running );
+        } while ( $running );
 
-        while ($this->isRunning()) {
+        while ( $this->isRunning() ) {
             $this->checkTimeout();
-            usleep(1000);
+            usleep( 1000 );
         }
 
-        if ($this->processInformation['signaled'] && $this->processInformation['termsig'] !== $this->latestSignal) {
-            throw new ProcessSignaledException($this);
+        if ( $this->processInformation[ 'signaled' ] && $this->processInformation[ 'termsig' ] !== $this->latestSignal ) {
+            throw new ProcessSignaledException( $this );
         }
 
         return $this->exitcode;
@@ -453,38 +453,38 @@ 
      * @throws LogicException           When process is not yet started
      * @throws ProcessTimedOutException In case the timeout was reached
      */
-    public function waitUntil(callable $callback): bool
+    public function waitUntil( callable $callback ): bool
     {
-        $this->requireProcessIsStarted(__FUNCTION__);
-        $this->updateStatus(false);
+        $this->requireProcessIsStarted( __FUNCTION__ );
+        $this->updateStatus( false );
 
-        if (!$this->processPipes->haveReadSupport()) {
-            $this->stop(0);
-            throw new LogicException('Pass the callback to the "Process::start" method or call enableOutput to use a callback with "Process::waitUntil".');
+        if ( ! $this->processPipes->haveReadSupport() ) {
+            $this->stop( 0 );
+            throw new LogicException( 'Pass the callback to the "Process::start" method or call enableOutput to use a callback with "Process::waitUntil".' );
         }
-        $callback = $this->buildCallback($callback);
+        $callback = $this->buildCallback( $callback );
 
         $ready = false;
-        while (true) {
+        while ( true ) {
             $this->checkTimeout();
             $running = '\\' === \DIRECTORY_SEPARATOR ? $this->isRunning() : $this->processPipes->areOpen();
-            $output = $this->processPipes->readAndWrite($running, '\\' !== \DIRECTORY_SEPARATOR || !$running);
+            $output = $this->processPipes->readAndWrite( $running, '\\' !== \DIRECTORY_SEPARATOR || ! $running );
 
-            foreach ($output as $type => $data) {
-                if (3 !== $type) {
-                    $ready = $callback(self::STDOUT === $type ? self::OUT : self::ERR, $data) || $ready;
-                } elseif (!isset($this->fallbackStatus['signaled'])) {
-                    $this->fallbackStatus['exitcode'] = (int) $data;
+            foreach ( $output as $type => $data ) {
+                if ( 3 !== $type ) {
+                    $ready = $callback( self::STDOUT === $type ? self::OUT : self::ERR, $data ) || $ready;
+                } elseif ( ! isset( $this->fallbackStatus[ 'signaled' ] ) ) {
+                    $this->fallbackStatus[ 'exitcode' ] = (int)$data;
                 }
             }
-            if ($ready) {
+            if ( $ready ) {
                 return true;
             }
-            if (!$running) {
+            if ( ! $running ) {
                 return false;
             }
 
-            usleep(1000);
+            usleep( 1000 );
         }
     }
 
@@ -495,7 +495,7 @@ 
      */
     public function getPid()
     {
-        return $this->isRunning() ? $this->processInformation['pid'] : null;
+        return $this->isRunning() ? $this->processInformation[ 'pid' ] : null;
     }
 
     /**
@@ -509,9 +509,9 @@ 
      * @throws RuntimeException In case --enable-sigchild is activated and the process can't be killed
      * @throws RuntimeException In case of failure
      */
-    public function signal(int $signal)
+    public function signal( int $signal )
     {
-        $this->doSignal($signal, true);
+        $this->doSignal( $signal, true );
 
         return $this;
     }
@@ -526,11 +526,11 @@ 
      */
     public function disableOutput()
     {
-        if ($this->isRunning()) {
-            throw new RuntimeException('Disabling output while the process is running is not possible.');
+        if ( $this->isRunning() ) {
+            throw new RuntimeException( 'Disabling output while the process is running is not possible.' );
         }
-        if (null !== $this->idleTimeout) {
-            throw new LogicException('Output can not be disabled while an idle timeout is set.');
+        if ( null !== $this->idleTimeout ) {
+            throw new LogicException( 'Output can not be disabled while an idle timeout is set.' );
         }
 
         $this->outputDisabled = true;
@@ -547,8 +547,8 @@ 
      */
     public function enableOutput()
     {
-        if ($this->isRunning()) {
-            throw new RuntimeException('Enabling output while the process is running is not possible.');
+        if ( $this->isRunning() ) {
+            throw new RuntimeException( 'Enabling output while the process is running is not possible.' );
         }
 
         $this->outputDisabled = false;
@@ -576,9 +576,9 @@ 
      */
     public function getOutput()
     {
-        $this->readPipesForOutput(__FUNCTION__);
+        $this->readPipesForOutput( __FUNCTION__ );
 
-        if (false === $ret = stream_get_contents($this->stdout, -1, 0)) {
+        if ( false === $ret = stream_get_contents( $this->stdout, -1, 0 ) ) {
             return '';
         }
 
@@ -598,12 +598,12 @@ 
      */
     public function getIncrementalOutput()
     {
-        $this->readPipesForOutput(__FUNCTION__);
+        $this->readPipesForOutput( __FUNCTION__ );
 
-        $latest = stream_get_contents($this->stdout, -1, $this->incrementalOutputOffset);
-        $this->incrementalOutputOffset = ftell($this->stdout);
+        $latest = stream_get_contents( $this->stdout, -1, $this->incrementalOutputOffset );
+        $this->incrementalOutputOffset = ftell( $this->stdout );
 
-        if (false === $latest) {
+        if ( false === $latest ) {
             return '';
         }
 
@@ -621,50 +621,50 @@ 
      * @return \Generator
      */
     #[\ReturnTypeWillChange]
-    public function getIterator(int $flags = 0)
+    public function getIterator( int $flags = 0 )
     {
-        $this->readPipesForOutput(__FUNCTION__, false);
+        $this->readPipesForOutput( __FUNCTION__, false );
 
-        $clearOutput = !(self::ITER_KEEP_OUTPUT & $flags);
-        $blocking = !(self::ITER_NON_BLOCKING & $flags);
-        $yieldOut = !(self::ITER_SKIP_OUT & $flags);
-        $yieldErr = !(self::ITER_SKIP_ERR & $flags);
+        $clearOutput = ! ( self::ITER_KEEP_OUTPUT & $flags );
+        $blocking = ! ( self::ITER_NON_BLOCKING & $flags );
+        $yieldOut = ! ( self::ITER_SKIP_OUT & $flags );
+        $yieldErr = ! ( self::ITER_SKIP_ERR & $flags );
 
-        while (null !== $this->callback || ($yieldOut && !feof($this->stdout)) || ($yieldErr && !feof($this->stderr))) {
-            if ($yieldOut) {
-                $out = stream_get_contents($this->stdout, -1, $this->incrementalOutputOffset);
+        while ( null !== $this->callback || ( $yieldOut && ! feof( $this->stdout ) ) || ( $yieldErr && ! feof( $this->stderr ) ) ) {
+            if ( $yieldOut ) {
+                $out = stream_get_contents( $this->stdout, -1, $this->incrementalOutputOffset );
 
-                if (isset($out[0])) {
-                    if ($clearOutput) {
+                if ( isset( $out[ 0 ] ) ) {
+                    if ( $clearOutput ) {
                         $this->clearOutput();
                     } else {
-                        $this->incrementalOutputOffset = ftell($this->stdout);
+                        $this->incrementalOutputOffset = ftell( $this->stdout );
                     }
 
                     yield self::OUT => $out;
                 }
             }
 
-            if ($yieldErr) {
-                $err = stream_get_contents($this->stderr, -1, $this->incrementalErrorOutputOffset);
+            if ( $yieldErr ) {
+                $err = stream_get_contents( $this->stderr, -1, $this->incrementalErrorOutputOffset );
 
-                if (isset($err[0])) {
-                    if ($clearOutput) {
+                if ( isset( $err[ 0 ] ) ) {
+                    if ( $clearOutput ) {
                         $this->clearErrorOutput();
                     } else {
-                        $this->incrementalErrorOutputOffset = ftell($this->stderr);
+                        $this->incrementalErrorOutputOffset = ftell( $this->stderr );
                     }
 
                     yield self::ERR => $err;
                 }
             }
 
-            if (!$blocking && !isset($out[0]) && !isset($err[0])) {
+            if ( ! $blocking && ! isset( $out[ 0 ] ) && ! isset( $err[ 0 ] ) ) {
                 yield self::OUT => '';
             }
 
             $this->checkTimeout();
-            $this->readPipesForOutput(__FUNCTION__, $blocking);
+            $this->readPipesForOutput( __FUNCTION__, $blocking );
         }
     }
 
@@ -675,8 +675,8 @@ 
      */
     public function clearOutput()
     {
-        ftruncate($this->stdout, 0);
-        fseek($this->stdout, 0);
+        ftruncate( $this->stdout, 0 );
+        fseek( $this->stdout, 0 );
         $this->incrementalOutputOffset = 0;
 
         return $this;
@@ -692,9 +692,9 @@ 
      */
     public function getErrorOutput()
     {
-        $this->readPipesForOutput(__FUNCTION__);
+        $this->readPipesForOutput( __FUNCTION__ );
 
-        if (false === $ret = stream_get_contents($this->stderr, -1, 0)) {
+        if ( false === $ret = stream_get_contents( $this->stderr, -1, 0 ) ) {
             return '';
         }
 
@@ -715,12 +715,12 @@ 
      */
     public function getIncrementalErrorOutput()
     {
-        $this->readPipesForOutput(__FUNCTION__);
+        $this->readPipesForOutput( __FUNCTION__ );
 
-        $latest = stream_get_contents($this->stderr, -1, $this->incrementalErrorOutputOffset);
-        $this->incrementalErrorOutputOffset = ftell($this->stderr);
+        $latest = stream_get_contents( $this->stderr, -1, $this->incrementalErrorOutputOffset );
+        $this->incrementalErrorOutputOffset = ftell( $this->stderr );
 
-        if (false === $latest) {
+        if ( false === $latest ) {
             return '';
         }
 
@@ -734,8 +734,8 @@ 
      */
     public function clearErrorOutput()
     {
-        ftruncate($this->stderr, 0);
-        fseek($this->stderr, 0);
+        ftruncate( $this->stderr, 0 );
+        fseek( $this->stderr, 0 );
         $this->incrementalErrorOutputOffset = 0;
 
         return $this;
@@ -748,7 +748,7 @@ 
      */
     public function getExitCode()
     {
-        $this->updateStatus(false);
+        $this->updateStatus( false );
 
         return $this->exitcode;
     }
@@ -766,11 +766,11 @@ 
      */
     public function getExitCodeText()
     {
-        if (null === $exitcode = $this->getExitCode()) {
+        if ( null === $exitcode = $this->getExitCode() ) {
             return null;
         }
 
-        return self::$exitCodes[$exitcode] ?? 'Unknown error';
+        return self::$exitCodes[ $exitcode ] ?? 'Unknown error';
     }
 
     /**
@@ -794,9 +794,9 @@ 
      */
     public function hasBeenSignaled()
     {
-        $this->requireProcessIsTerminated(__FUNCTION__);
+        $this->requireProcessIsTerminated( __FUNCTION__ );
 
-        return $this->processInformation['signaled'];
+        return $this->processInformation[ 'signaled' ];
     }
 
     /**
@@ -811,13 +811,13 @@ 
      */
     public function getTermSignal()
     {
-        $this->requireProcessIsTerminated(__FUNCTION__);
+        $this->requireProcessIsTerminated( __FUNCTION__ );
 
-        if ($this->isSigchildEnabled() && -1 === $this->processInformation['termsig']) {
-            throw new RuntimeException('This PHP has been compiled with --enable-sigchild. Term signal can not be retrieved.');
+        if ( $this->isSigchildEnabled() && -1 === $this->processInformation[ 'termsig' ] ) {
+            throw new RuntimeException( 'This PHP has been compiled with --enable-sigchild. Term signal can not be retrieved.' );
         }
 
-        return $this->processInformation['termsig'];
+        return $this->processInformation[ 'termsig' ];
     }
 
     /**
@@ -831,9 +831,9 @@ 
      */
     public function hasBeenStopped()
     {
-        $this->requireProcessIsTerminated(__FUNCTION__);
+        $this->requireProcessIsTerminated( __FUNCTION__ );
 
-        return $this->processInformation['stopped'];
+        return $this->processInformation[ 'stopped' ];
     }
 
     /**
@@ -847,9 +847,9 @@ 
      */
     public function getStopSignal()
     {
-        $this->requireProcessIsTerminated(__FUNCTION__);
+        $this->requireProcessIsTerminated( __FUNCTION__ );
 
-        return $this->processInformation['stopsig'];
+        return $this->processInformation[ 'stopsig' ];
     }
 
     /**
@@ -859,13 +859,13 @@ 
      */
     public function isRunning()
     {
-        if (self::STATUS_STARTED !== $this->status) {
+        if ( self::STATUS_STARTED !== $this->status ) {
             return false;
         }
 
-        $this->updateStatus(false);
+        $this->updateStatus( false );
 
-        return $this->processInformation['running'];
+        return $this->processInformation[ 'running' ];
     }
 
     /**
@@ -885,7 +885,7 @@ 
      */
     public function isTerminated()
     {
-        $this->updateStatus(false);
+        $this->updateStatus( false );
 
         return self::STATUS_TERMINATED == $this->status;
     }
@@ -899,7 +899,7 @@ 
      */
     public function getStatus()
     {
-        $this->updateStatus(false);
+        $this->updateStatus( false );
 
         return $this->status;
     }
@@ -912,28 +912,28 @@ 
      *
      * @return int|null The exit-code of the process or null if it's not running
      */
-    public function stop(float $timeout = 10, int $signal = null)
+    public function stop( float $timeout = 10, int $signal = null )
     {
-        $timeoutMicro = microtime(true) + $timeout;
-        if ($this->isRunning()) {
+        $timeoutMicro = microtime( true ) + $timeout;
+        if ( $this->isRunning() ) {
             // given SIGTERM may not be defined and that "proc_terminate" uses the constant value and not the constant itself, we use the same here
-            $this->doSignal(15, false);
+            $this->doSignal( 15, false );
             do {
-                usleep(1000);
-            } while ($this->isRunning() && microtime(true) < $timeoutMicro);
+                usleep( 1000 );
+            } while ( $this->isRunning() && microtime( true ) < $timeoutMicro );
 
-            if ($this->isRunning()) {
+            if ( $this->isRunning() ) {
                 // Avoid exception here: process is supposed to be running, but it might have stopped just
                 // after this line. In any case, let's silently discard the error, we cannot do anything.
-                $this->doSignal($signal ?: 9, false);
+                $this->doSignal( $signal ?: 9, false );
             }
         }
 
-        if ($this->isRunning()) {
-            if (isset($this->fallbackStatus['pid'])) {
-                unset($this->fallbackStatus['pid']);
+        if ( $this->isRunning() ) {
+            if ( isset( $this->fallbackStatus[ 'pid' ] ) ) {
+                unset( $this->fallbackStatus[ 'pid' ] );
 
-                return $this->stop(0, $signal);
+                return $this->stop( 0, $signal );
             }
             $this->close();
         }
@@ -946,13 +946,13 @@ 
      *
      * @internal
      */
-    public function addOutput(string $line)
+    public function addOutput( string $line )
     {
-        $this->lastOutputTime = microtime(true);
+        $this->lastOutputTime = microtime( true );
 
-        fseek($this->stdout, 0, \SEEK_END);
-        fwrite($this->stdout, $line);
-        fseek($this->stdout, $this->incrementalOutputOffset);
+        fseek( $this->stdout, 0, \SEEK_END );
+        fwrite( $this->stdout, $line );
+        fseek( $this->stdout, $this->incrementalOutputOffset );
     }
 
     /**
@@ -960,13 +960,13 @@ 
      *
      * @internal
      */
-    public function addErrorOutput(string $line)
+    public function addErrorOutput( string $line )
     {
-        $this->lastOutputTime = microtime(true);
+        $this->lastOutputTime = microtime( true );
 
-        fseek($this->stderr, 0, \SEEK_END);
-        fwrite($this->stderr, $line);
-        fseek($this->stderr, $this->incrementalErrorOutputOffset);
+        fseek( $this->stderr, 0, \SEEK_END );
+        fwrite( $this->stderr, $line );
+        fseek( $this->stderr, $this->incrementalErrorOutputOffset );
     }
 
     /**
@@ -986,7 +986,7 @@ 
      */
     public function getCommandLine()
     {
-        return \is_array($this->commandline) ? implode(' ', array_map([$this, 'escapeArgument'], $this->commandline)) : $this->commandline;
+        return \is_array( $this->commandline ) ? implode( ' ', array_map( [ $this, 'escapeArgument' ], $this->commandline ) ) : $this->commandline;
     }
 
     /**
@@ -1018,9 +1018,9 @@ 
      *
      * @throws InvalidArgumentException if the timeout is negative
      */
-    public function setTimeout(?float $timeout)
+    public function setTimeout( ?float $timeout )
     {
-        $this->timeout = $this->validateTimeout($timeout);
+        $this->timeout = $this->validateTimeout( $timeout );
 
         return $this;
     }
@@ -1035,13 +1035,13 @@ 
      * @throws LogicException           if the output is disabled
      * @throws InvalidArgumentException if the timeout is negative
      */
-    public function setIdleTimeout(?float $timeout)
+    public function setIdleTimeout( ?float $timeout )
     {
-        if (null !== $timeout && $this->outputDisabled) {
-            throw new LogicException('Idle timeout can not be set while the output is disabled.');
+        if ( null !== $timeout && $this->outputDisabled ) {
+            throw new LogicException( 'Idle timeout can not be set while the output is disabled.' );
         }
 
-        $this->idleTimeout = $this->validateTimeout($timeout);
+        $this->idleTimeout = $this->validateTimeout( $timeout );
 
         return $this;
     }
@@ -1053,14 +1053,14 @@ 
      *
      * @throws RuntimeException In case the TTY mode is not supported
      */
-    public function setTty(bool $tty)
+    public function setTty( bool $tty )
     {
-        if ('\\' === \DIRECTORY_SEPARATOR && $tty) {
-            throw new RuntimeException('TTY mode is not supported on Windows platform.');
+        if ( '\\' === \DIRECTORY_SEPARATOR && $tty ) {
+            throw new RuntimeException( 'TTY mode is not supported on Windows platform.' );
         }
 
-        if ($tty && !self::isTtySupported()) {
-            throw new RuntimeException('TTY mode requires /dev/tty to be read/writable.');
+        if ( $tty && ! self::isTtySupported() ) {
+            throw new RuntimeException( 'TTY mode requires /dev/tty to be read/writable.' );
         }
 
         $this->tty = $tty;
@@ -1083,7 +1083,7 @@ 
      *
      * @return $this
      */
-    public function setPty(bool $bool)
+    public function setPty( bool $bool )
     {
         $this->pty = $bool;
 
@@ -1107,7 +1107,7 @@ 
      */
     public function getWorkingDirectory()
     {
-        if (null === $this->cwd) {
+        if ( null === $this->cwd ) {
             // getcwd() will return false if any one of the parent directories does not have
             // the readable or search mode set, even if the current directory does
             return getcwd() ?: null;
@@ -1121,7 +1121,7 @@ 
      *
      * @return $this
      */
-    public function setWorkingDirectory(string $cwd)
+    public function setWorkingDirectory( string $cwd )
     {
         $this->cwd = $cwd;
 
@@ -1153,11 +1153,11 @@ 
      *
      * @return $this
      */
-    public function setEnv(array $env)
+    public function setEnv( array $env )
     {
         // Process can not handle env values that are arrays
-        $env = array_filter($env, function ($value) {
-            return !\is_array($value);
+        $env = array_filter( $env, function( $value ) {
+            return ! \is_array( $value );
         });
 
         $this->env = $env;
@@ -1186,13 +1186,13 @@ 
      *
      * @throws LogicException In case the process is running
      */
-    public function setInput($input)
+    public function setInput( $input )
     {
-        if ($this->isRunning()) {
-            throw new LogicException('Input can not be set while the process is running.');
+        if ( $this->isRunning() ) {
+            throw new LogicException( 'Input can not be set while the process is running.' );
         }
 
-        $this->input = ProcessUtils::validateInput(__METHOD__, $input);
+        $this->input = ProcessUtils::validateInput( __METHOD__, $input );
 
         return $this;
     }
@@ -1207,20 +1207,20 @@ 
      */
     public function checkTimeout()
     {
-        if (self::STATUS_STARTED !== $this->status) {
+        if ( self::STATUS_STARTED !== $this->status ) {
             return;
         }
 
-        if (null !== $this->timeout && $this->timeout < microtime(true) - $this->starttime) {
-            $this->stop(0);
+        if ( null !== $this->timeout && $this->timeout < microtime( true ) - $this->starttime ) {
+            $this->stop( 0 );
 
-            throw new ProcessTimedOutException($this, ProcessTimedOutException::TYPE_GENERAL);
+            throw new ProcessTimedOutException( $this, ProcessTimedOutException::TYPE_GENERAL );
         }
 
-        if (null !== $this->idleTimeout && $this->idleTimeout < microtime(true) - $this->lastOutputTime) {
-            $this->stop(0);
+        if ( null !== $this->idleTimeout && $this->idleTimeout < microtime( true ) - $this->lastOutputTime ) {
+            $this->stop( 0 );
 
-            throw new ProcessTimedOutException($this, ProcessTimedOutException::TYPE_IDLE);
+            throw new ProcessTimedOutException( $this, ProcessTimedOutException::TYPE_IDLE );
         }
     }
 
@@ -1229,8 +1229,8 @@ 
      */
     public function getStartTime(): float
     {
-        if (!$this->isStarted()) {
-            throw new LogicException('Start time is only available after process start.');
+        if ( ! $this->isStarted() ) {
+            throw new LogicException( 'Start time is only available after process start.' );
         }
 
         return $this->starttime;
@@ -1244,21 +1244,21 @@ 
      * Enabling the "create_new_console" option allows a subprocess to continue
      * to run after the main process exited, on both Windows and *nix
      */
-    public function setOptions(array $options)
+    public function setOptions( array $options )
     {
-        if ($this->isRunning()) {
-            throw new RuntimeException('Setting options while the process is running is not possible.');
+        if ( $this->isRunning() ) {
+            throw new RuntimeException( 'Setting options while the process is running is not possible.' );
         }
 
         $defaultOptions = $this->options;
-        $existingOptions = ['blocking_pipes', 'create_process_group', 'create_new_console'];
+        $existingOptions = [ 'blocking_pipes', 'create_process_group', 'create_new_console' ];
 
-        foreach ($options as $key => $value) {
-            if (!\in_array($key, $existingOptions)) {
+        foreach ( $options as $key => $value ) {
+            if ( ! \in_array( $key, $existingOptions ) ) {
                 $this->options = $defaultOptions;
-                throw new LogicException(sprintf('Invalid option "%s" passed to "%s()". Supported options are "%s".', $key, __METHOD__, implode('", "', $existingOptions)));
+                throw new LogicException( sprintf( 'Invalid option "%s" passed to "%s()". Supported options are "%s".', $key, __METHOD__, implode( '", "', $existingOptions ) ) );
             }
-            $this->options[$key] = $value;
+            $this->options[ $key ] = $value;
         }
     }
 
@@ -1269,8 +1269,8 @@ 
     {
         static $isTtySupported;
 
-        if (null === $isTtySupported) {
-            $isTtySupported = (bool) @proc_open('echo 1 >/dev/null', [['file', '/dev/tty', 'r'], ['file', '/dev/tty', 'w'], ['file', '/dev/tty', 'w']], $pipes);
+        if ( null === $isTtySupported ) {
+            $isTtySupported = (bool)@proc_open( 'echo 1 >/dev/null', [ [ 'file', '/dev/tty', 'r' ], [ 'file', '/dev/tty', 'w' ], [ 'file', '/dev/tty', 'w' ] ], $pipes );
         }
 
         return $isTtySupported;
@@ -1285,15 +1285,15 @@ 
     {
         static $result;
 
-        if (null !== $result) {
+        if ( null !== $result ) {
             return $result;
         }
 
-        if ('\\' === \DIRECTORY_SEPARATOR) {
+        if ( '\\' === \DIRECTORY_SEPARATOR ) {
             return $result = false;
         }
 
-        return $result = (bool) @proc_open('echo 1 >/dev/null', [['pty'], ['pty'], ['pty']], $pipes);
+        return $result = (bool)@proc_open( 'echo 1 >/dev/null', [ [ 'pty' ], [ 'pty' ], [ 'pty' ] ], $pipes );
     }
 
     /**
@@ -1301,13 +1301,13 @@ 
      */
     private function getDescriptors(): array
     {
-        if ($this->input instanceof \Iterator) {
+        if ( $this->input instanceof \Iterator ) {
             $this->input->rewind();
         }
-        if ('\\' === \DIRECTORY_SEPARATOR) {
-            $this->processPipes = new WindowsPipes($this->input, !$this->outputDisabled || $this->hasCallback);
+        if ( '\\' === \DIRECTORY_SEPARATOR ) {
+            $this->processPipes = new WindowsPipes( $this->input, ! $this->outputDisabled || $this->hasCallback );
         } else {
-            $this->processPipes = new UnixPipes($this->isTty(), $this->isPty(), $this->input, !$this->outputDisabled || $this->hasCallback);
+            $this->processPipes = new UnixPipes( $this->isTty(), $this->isPty(), $this->input, ! $this->outputDisabled || $this->hasCallback );
         }
 
         return $this->processPipes->getDescriptors();
@@ -1323,24 +1323,24 @@ 
      *
      * @return \Closure A PHP closure
      */
-    protected function buildCallback(callable $callback = null)
+    protected function buildCallback( callable $callback = null )
     {
-        if ($this->outputDisabled) {
-            return function ($type, $data) use ($callback): bool {
-                return null !== $callback && $callback($type, $data);
+        if ( $this->outputDisabled ) {
+            return function( $type, $data ) use ( $callback ): bool {
+                return null !== $callback && $callback( $type, $data );
             };
         }
 
         $out = self::OUT;
 
-        return function ($type, $data) use ($callback, $out): bool {
-            if ($out == $type) {
-                $this->addOutput($data);
+        return function( $type, $data ) use ( $callback, $out ): bool {
+            if ( $out == $type ) {
+                $this->addOutput( $data );
             } else {
-                $this->addErrorOutput($data);
+                $this->addErrorOutput( $data );
             }
 
-            return null !== $callback && $callback($type, $data);
+            return null !== $callback && $callback( $type, $data );
         };
     }
 
@@ -1349,22 +1349,22 @@ 
      *
      * @param bool $blocking Whether to use a blocking read call
      */
-    protected function updateStatus(bool $blocking)
+    protected function updateStatus( bool $blocking )
     {
-        if (self::STATUS_STARTED !== $this->status) {
+        if ( self::STATUS_STARTED !== $this->status ) {
             return;
         }
 
-        $this->processInformation = proc_get_status($this->process);
-        $running = $this->processInformation['running'];
+        $this->processInformation = proc_get_status( $this->process );
+        $running = $this->processInformation[ 'running' ];
 
-        $this->readPipes($running && $blocking, '\\' !== \DIRECTORY_SEPARATOR || !$running);
+        $this->readPipes( $running && $blocking, '\\' !== \DIRECTORY_SEPARATOR || ! $running );
 
-        if ($this->fallbackStatus && $this->isSigchildEnabled()) {
+        if ( $this->fallbackStatus && $this->isSigchildEnabled() ) {
             $this->processInformation = $this->fallbackStatus + $this->processInformation;
         }
 
-        if (!$running) {
+        if ( ! $running ) {
             $this->close();
         }
     }
@@ -1376,18 +1376,18 @@ 
      */
     protected function isSigchildEnabled()
     {
-        if (null !== self::$sigchild) {
+        if ( null !== self::$sigchild ) {
             return self::$sigchild;
         }
 
-        if (!\function_exists('phpinfo')) {
+        if ( ! \function_exists( 'phpinfo' ) ) {
             return self::$sigchild = false;
         }
 
         ob_start();
-        phpinfo(\INFO_GENERAL);
+        phpinfo( \INFO_GENERAL );
 
-        return self::$sigchild = str_contains(ob_get_clean(), '--enable-sigchild');
+        return self::$sigchild = str_contains( ob_get_clean(), '--enable-sigchild' );
     }
 
     /**
@@ -1398,15 +1398,15 @@ 
      *
      * @throws LogicException in case output has been disabled or process is not started
      */
-    private function readPipesForOutput(string $caller, bool $blocking = false)
+    private function readPipesForOutput( string $caller, bool $blocking = false )
     {
-        if ($this->outputDisabled) {
-            throw new LogicException('Output has been disabled.');
+        if ( $this->outputDisabled ) {
+            throw new LogicException( 'Output has been disabled.' );
         }
 
-        $this->requireProcessIsStarted($caller);
+        $this->requireProcessIsStarted( $caller );
 
-        $this->updateStatus($blocking);
+        $this->updateStatus( $blocking );
     }
 
     /**
@@ -1414,14 +1414,14 @@ 
      *
      * @throws InvalidArgumentException if the given timeout is a negative number
      */
-    private function validateTimeout(?float $timeout): ?float
+    private function validateTimeout( ?float $timeout ): ?float
     {
-        $timeout = (float) $timeout;
+        $timeout = (float)$timeout;
 
-        if (0.0 === $timeout) {
+        if ( 0.0 === $timeout ) {
             $timeout = null;
-        } elseif ($timeout < 0) {
-            throw new InvalidArgumentException('The timeout value must be a valid positive integer or float number.');
+        } elseif ( $timeout < 0 ) {
+            throw new InvalidArgumentException( 'The timeout value must be a valid positive integer or float number.' );
         }
 
         return $timeout;
@@ -1433,16 +1433,16 @@ 
      * @param bool $blocking Whether to use blocking calls or not
      * @param bool $close    Whether to close file handles or not
      */
-    private function readPipes(bool $blocking, bool $close)
+    private function readPipes( bool $blocking, bool $close )
     {
-        $result = $this->processPipes->readAndWrite($blocking, $close);
+        $result = $this->processPipes->readAndWrite( $blocking, $close );
 
         $callback = $this->callback;
-        foreach ($result as $type => $data) {
-            if (3 !== $type) {
-                $callback(self::STDOUT === $type ? self::OUT : self::ERR, $data);
-            } elseif (!isset($this->fallbackStatus['signaled'])) {
-                $this->fallbackStatus['exitcode'] = (int) $data;
+        foreach ( $result as $type => $data ) {
+            if ( 3 !== $type ) {
+                $callback( self::STDOUT === $type ? self::OUT : self::ERR, $data );
+            } elseif ( ! isset( $this->fallbackStatus[ 'signaled' ] ) ) {
+                $this->fallbackStatus[ 'exitcode' ] = (int)$data;
             }
         }
     }
@@ -1455,19 +1455,19 @@ 
     private function close(): int
     {
         $this->processPipes->close();
-        if (\is_resource($this->process)) {
-            proc_close($this->process);
+        if ( \is_resource( $this->process ) ) {
+            proc_close( $this->process );
         }
-        $this->exitcode = $this->processInformation['exitcode'];
+        $this->exitcode = $this->processInformation[ 'exitcode' ];
         $this->status = self::STATUS_TERMINATED;
 
         if (-1 === $this->exitcode) {
-            if ($this->processInformation['signaled'] && 0 < $this->processInformation['termsig']) {
+            if ( $this->processInformation[ 'signaled' ] && 0 < $this->processInformation[ 'termsig' ] ) {
                 // if process has been signaled, no exitcode but a valid termsig, apply Unix convention
-                $this->exitcode = 128 + $this->processInformation['termsig'];
-            } elseif ($this->isSigchildEnabled()) {
-                $this->processInformation['signaled'] = true;
-                $this->processInformation['termsig'] = -1;
+                $this->exitcode = 128 + $this->processInformation[ 'termsig' ];
+            } elseif ( $this->isSigchildEnabled() ) {
+                $this->processInformation[ 'signaled' ] = true;
+                $this->processInformation[ 'termsig' ] = -1;
             }
         }
 
@@ -1487,10 +1487,10 @@ 
         $this->starttime = null;
         $this->callback = null;
         $this->exitcode = null;
-        $this->fallbackStatus = [];
+        $this->fallbackStatus = [ ];
         $this->processInformation = null;
-        $this->stdout = fopen('php://temp/maxmemory:'.(1024 * 1024), 'w+');
-        $this->stderr = fopen('php://temp/maxmemory:'.(1024 * 1024), 'w+');
+        $this->stdout = fopen( 'php://temp/maxmemory:' . ( 1024 * 1024 ), 'w+' );
+        $this->stderr = fopen( 'php://temp/maxmemory:' . ( 1024 * 1024 ), 'w+' );
         $this->process = null;
         $this->latestSignal = null;
         $this->status = self::STATUS_READY;
@@ -1510,36 +1510,36 @@ 
      * @throws RuntimeException In case --enable-sigchild is activated and the process can't be killed
      * @throws RuntimeException In case of failure
      */
-    private function doSignal(int $signal, bool $throwException): bool
+    private function doSignal( int $signal, bool $throwException ): bool
     {
-        if (null === $pid = $this->getPid()) {
-            if ($throwException) {
-                throw new LogicException('Can not send signal on a non running process.');
+        if ( null === $pid = $this->getPid() ) {
+            if ( $throwException ) {
+                throw new LogicException( 'Can not send signal on a non running process.' );
             }
 
             return false;
         }
 
-        if ('\\' === \DIRECTORY_SEPARATOR) {
-            exec(sprintf('taskkill /F /T /PID %d 2>&1', $pid), $output, $exitCode);
-            if ($exitCode && $this->isRunning()) {
-                if ($throwException) {
-                    throw new RuntimeException(sprintf('Unable to kill the process (%s).', implode(' ', $output)));
+        if ( '\\' === \DIRECTORY_SEPARATOR ) {
+            exec( sprintf( 'taskkill /F /T /PID %d 2>&1', $pid ), $output, $exitCode );
+            if ( $exitCode && $this->isRunning() ) {
+                if ( $throwException ) {
+                    throw new RuntimeException( sprintf( 'Unable to kill the process (%s).', implode( ' ', $output ) ) );
                 }
 
                 return false;
             }
         } else {
-            if (!$this->isSigchildEnabled()) {
-                $ok = @proc_terminate($this->process, $signal);
-            } elseif (\function_exists('posix_kill')) {
-                $ok = @posix_kill($pid, $signal);
-            } elseif ($ok = proc_open(sprintf('kill -%d %d', $signal, $pid), [2 => ['pipe', 'w']], $pipes)) {
-                $ok = false === fgets($pipes[2]);
+            if ( ! $this->isSigchildEnabled() ) {
+                $ok = @proc_terminate( $this->process, $signal );
+            } elseif ( \function_exists( 'posix_kill' ) ) {
+                $ok = @posix_kill( $pid, $signal );
+            } elseif ( $ok = proc_open( sprintf( 'kill -%d %d', $signal, $pid ), [ 2 => [ 'pipe', 'w' ] ], $pipes ) ) {
+                $ok = false === fgets( $pipes[ 2 ] );
             }
-            if (!$ok) {
-                if ($throwException) {
-                    throw new RuntimeException(sprintf('Error while sending signal "%s".', $signal));
+            if ( ! $ok ) {
+                if ( $throwException ) {
+                    throw new RuntimeException( sprintf( 'Error while sending signal "%s".', $signal ) );
                 }
 
                 return false;
@@ -1547,18 +1547,18 @@ 
         }
 
         $this->latestSignal = $signal;
-        $this->fallbackStatus['signaled'] = true;
-        $this->fallbackStatus['exitcode'] = -1;
-        $this->fallbackStatus['termsig'] = $this->latestSignal;
+        $this->fallbackStatus[ 'signaled' ] = true;
+        $this->fallbackStatus[ 'exitcode' ] = -1;
+        $this->fallbackStatus[ 'termsig' ] = $this->latestSignal;
 
         return true;
     }
 
-    private function prepareWindowsCommandLine(string $cmd, array &$env): string
+    private function prepareWindowsCommandLine( string $cmd, array &$env ): string
     {
-        $uid = uniqid('', true);
+        $uid = uniqid( '', true );
         $varCount = 0;
-        $varCache = [];
+        $varCache = [ ];
         $cmd = preg_replace_callback(
             '/"(?:(
                 [^"%!^]*+
@@ -1567,34 +1567,34 @@ 
                     [^"%!^]*+
                 )++
             ) | [^"]*+ )"/x',
-            function ($m) use (&$env, &$varCache, &$varCount, $uid) {
-                if (!isset($m[1])) {
-                    return $m[0];
+            function( $m ) use ( &$env, &$varCache, &$varCount, $uid ) {
+                if ( ! isset( $m[ 1 ] ) ) {
+                    return $m[ 0 ];
                 }
-                if (isset($varCache[$m[0]])) {
-                    return $varCache[$m[0]];
+                if ( isset( $varCache[ $m[ 0 ] ] ) ) {
+                    return $varCache[ $m[ 0 ] ];
                 }
-                if (str_contains($value = $m[1], "\0")) {
-                    $value = str_replace("\0", '?', $value);
+                if ( str_contains( $value = $m[ 1 ], "\0" ) ) {
+                    $value = str_replace( "\0", '?', $value );
                 }
-                if (false === strpbrk($value, "\"%!\n")) {
-                    return '"'.$value.'"';
+                if ( false === strpbrk( $value, "\"%!\n" ) ) {
+                    return '"' . $value . '"';
                 }
 
-                $value = str_replace(['!LF!', '"^!"', '"^%"', '"^^"', '""'], ["\n", '!', '%', '^', '"'], $value);
-                $value = '"'.preg_replace('/(\\\\*)"/', '$1$1\\"', $value).'"';
-                $var = $uid.++$varCount;
+                $value = str_replace( [ '!LF!', '"^!"', '"^%"', '"^^"', '""' ], [ "\n", '!', '%', '^', '"' ], $value );
+                $value = '"' . preg_replace( '/(\\\\*)"/', '$1$1\\"', $value ) . '"';
+                $var = $uid . ++$varCount;
 
-                $env[$var] = $value;
+                $env[ $var ] = $value;
 
-                return $varCache[$m[0]] = '!'.$var.'!';
+                return $varCache[ $m[ 0 ] ] = '!' . $var . '!';
             },
             $cmd
         );
 
-        $cmd = 'cmd /V:ON /E:ON /D /C ('.str_replace("\n", ' ', $cmd).')';
-        foreach ($this->processPipes->getFiles() as $offset => $filename) {
-            $cmd .= ' '.$offset.'>"'.$filename.'"';
+        $cmd = 'cmd /V:ON /E:ON /D /C (' . str_replace( "\n", ' ', $cmd ) . ')';
+        foreach ( $this->processPipes->getFiles() as $offset => $filename ) {
+            $cmd .= ' ' . $offset . '>"' . $filename . '"';
         }
 
         return $cmd;
@@ -1605,10 +1605,10 @@ 
      *
      * @throws LogicException if the process has not run
      */
-    private function requireProcessIsStarted(string $functionName)
+    private function requireProcessIsStarted( string $functionName )
     {
-        if (!$this->isStarted()) {
-            throw new LogicException(sprintf('Process must be started before calling "%s()".', $functionName));
+        if ( ! $this->isStarted() ) {
+            throw new LogicException( sprintf( 'Process must be started before calling "%s()".', $functionName ) );
         }
     }
 
@@ -1617,59 +1617,59 @@ 
      *
      * @throws LogicException if the process is not yet terminated
      */
-    private function requireProcessIsTerminated(string $functionName)
+    private function requireProcessIsTerminated( string $functionName )
     {
-        if (!$this->isTerminated()) {
-            throw new LogicException(sprintf('Process must be terminated before calling "%s()".', $functionName));
+        if ( ! $this->isTerminated() ) {
+            throw new LogicException( sprintf( 'Process must be terminated before calling "%s()".', $functionName ) );
         }
     }
 
     /**
      * Escapes a string to be used as a shell argument.
      */
-    private function escapeArgument(?string $argument): string
+    private function escapeArgument( ?string $argument ): string
     {
-        if ('' === $argument || null === $argument) {
+        if ( '' === $argument || null === $argument ) {
             return '""';
         }
-        if ('\\' !== \DIRECTORY_SEPARATOR) {
-            return "'".str_replace("'", "'\\''", $argument)."'";
+        if ( '\\' !== \DIRECTORY_SEPARATOR ) {
+            return "'" . str_replace( "'", "'\\''", $argument ) . "'";
         }
-        if (str_contains($argument, "\0")) {
-            $argument = str_replace("\0", '?', $argument);
+        if ( str_contains( $argument, "\0" ) ) {
+            $argument = str_replace( "\0", '?', $argument );
         }
-        if (!preg_match('/[\/()%!^"<>&|\s]/', $argument)) {
+        if ( ! preg_match( '/[\/()%!^"<>&|\s]/', $argument ) ) {
             return $argument;
         }
-        $argument = preg_replace('/(\\\\+)$/', '$1$1', $argument);
+        $argument = preg_replace( '/(\\\\+)$/', '$1$1', $argument );
 
-        return '"'.str_replace(['"', '^', '%', '!', "\n"], ['""', '"^^"', '"^%"', '"^!"', '!LF!'], $argument).'"';
+        return '"' . str_replace( [ '"', '^', '%', '!', "\n" ], [ '""', '"^^"', '"^%"', '"^!"', '!LF!' ], $argument ) . '"';
     }
 
-    private function replacePlaceholders(string $commandline, array $env)
+    private function replacePlaceholders( string $commandline, array $env )
     {
-        return preg_replace_callback('/"\$\{:([_a-zA-Z]++[_a-zA-Z0-9]*+)\}"/', function ($matches) use ($commandline, $env) {
-            if (!isset($env[$matches[1]]) || false === $env[$matches[1]]) {
-                throw new InvalidArgumentException(sprintf('Command line is missing a value for parameter "%s": ', $matches[1]).$commandline);
+        return preg_replace_callback( '/"\$\{:([_a-zA-Z]++[_a-zA-Z0-9]*+)\}"/', function( $matches ) use ( $commandline, $env ) {
+            if ( ! isset( $env[ $matches[ 1 ] ] ) || false === $env[ $matches[ 1 ] ] ) {
+                throw new InvalidArgumentException( sprintf( 'Command line is missing a value for parameter "%s": ', $matches[ 1 ] ) . $commandline );
             }
 
-            return $this->escapeArgument($env[$matches[1]]);
-        }, $commandline);
+            return $this->escapeArgument( $env[ $matches[ 1 ] ] );
+        }, $commandline );
     }
 
     private function getDefaultEnv(): array
     {
-        $env = [];
+        $env = [ ];
 
-        foreach ($_SERVER as $k => $v) {
-            if (\is_string($v) && false !== $v = getenv($k)) {
-                $env[$k] = $v;
+        foreach ( $_SERVER as $k => $v ) {
+            if ( \is_string( $v ) && false !== $v = getenv( $k ) ) {
+                $env[ $k ] = $v;
             }
         }
 
-        foreach ($_ENV as $k => $v) {
-            if (\is_string($v)) {
-                $env[$k] = $v;
+        foreach ( $_ENV as $k => $v ) {
+            if ( \is_string( $v ) ) {
+                $env[ $k ] = $v;
             }
         }
 

Braces +62 added lines, -124 removed lines

@@ -28,8 +28,7 @@ 
  * @author Fabien Potencier <fabien@symfony.com>
  * @author Romain Neutron <imprec@gmail.com>
  */
-class Process implements \IteratorAggregate
-{
+class Process implements \IteratorAggregate {
     public const ERR = 'err';
     public const OUT = 'out';
 
@@ -138,8 +137,7 @@ 
      *
      * @throws LogicException When proc_open is not installed
      */
-    public function __construct(array $command, string $cwd = null, array $env = null, $input = null, ?float $timeout = 60)
-    {
+    public function __construct(array $command, string $cwd = null, array $env = null, $input = null, ?float $timeout = 60) {
         if (!\function_exists('proc_open')) {
             throw new LogicException('The Process class relies on proc_open, which is not available on your PHP installation.');
         }
@@ -187,8 +185,7 @@ 
      *
      * @throws LogicException When proc_open is not installed
      */
-    public static function fromShellCommandline(string $command, string $cwd = null, array $env = null, $input = null, ?float $timeout = 60)
-    {
+    public static function fromShellCommandline(string $command, string $cwd = null, array $env = null, $input = null, ?float $timeout = 60) {
         $process = new static([], $cwd, $env, $input, $timeout);
         $process->commandline = $command;
 
@@ -198,18 +195,15 @@ 
     /**
      * @return array
      */
-    public function __sleep()
-    {
+    public function __sleep() {
         throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
     }
 
-    public function __wakeup()
-    {
+    public function __wakeup() {
         throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
     }
 
-    public function __destruct()
-    {
+    public function __destruct() {
         if ($this->options['create_new_console'] ?? false) {
             $this->processPipes->close();
         } else {
@@ -217,8 +211,7 @@ 
         }
     }
 
-    public function __clone()
-    {
+    public function __clone() {
         $this->resetProcessData();
     }
 
@@ -292,8 +285,7 @@ 
      * @throws RuntimeException When process is already running
      * @throws LogicException   In case a callback is provided and output has been disabled
      */
-    public function start(callable $callback = null, array $env = [])
-    {
+    public function start(callable $callback = null, array $env = []) {
         if ($this->isRunning()) {
             throw new RuntimeException('Process is already running.');
         }
@@ -410,8 +402,7 @@ 
      * @throws ProcessSignaledException When process stopped after receiving signal
      * @throws LogicException           When process is not yet started
      */
-    public function wait(callable $callback = null)
-    {
+    public function wait(callable $callback = null) {
         $this->requireProcessIsStarted(__FUNCTION__);
 
         $this->updateStatus(false);
@@ -493,8 +484,7 @@ 
      *
      * @return int|null The process id if running, null otherwise
      */
-    public function getPid()
-    {
+    public function getPid() {
         return $this->isRunning() ? $this->processInformation['pid'] : null;
     }
 
@@ -509,8 +499,7 @@ 
      * @throws RuntimeException In case --enable-sigchild is activated and the process can't be killed
      * @throws RuntimeException In case of failure
      */
-    public function signal(int $signal)
-    {
+    public function signal(int $signal) {
         $this->doSignal($signal, true);
 
         return $this;
@@ -524,8 +513,7 @@ 
      * @throws RuntimeException In case the process is already running
      * @throws LogicException   if an idle timeout is set
      */
-    public function disableOutput()
-    {
+    public function disableOutput() {
         if ($this->isRunning()) {
             throw new RuntimeException('Disabling output while the process is running is not possible.');
         }
@@ -545,8 +533,7 @@ 
      *
      * @throws RuntimeException In case the process is already running
      */
-    public function enableOutput()
-    {
+    public function enableOutput() {
         if ($this->isRunning()) {
             throw new RuntimeException('Enabling output while the process is running is not possible.');
         }
@@ -561,8 +548,7 @@ 
      *
      * @return bool
      */
-    public function isOutputDisabled()
-    {
+    public function isOutputDisabled() {
         return $this->outputDisabled;
     }
 
@@ -574,8 +560,7 @@ 
      * @throws LogicException in case the output has been disabled
      * @throws LogicException In case the process is not started
      */
-    public function getOutput()
-    {
+    public function getOutput() {
         $this->readPipesForOutput(__FUNCTION__);
 
         if (false === $ret = stream_get_contents($this->stdout, -1, 0)) {
@@ -596,8 +581,7 @@ 
      * @throws LogicException in case the output has been disabled
      * @throws LogicException In case the process is not started
      */
-    public function getIncrementalOutput()
-    {
+    public function getIncrementalOutput() {
         $this->readPipesForOutput(__FUNCTION__);
 
         $latest = stream_get_contents($this->stdout, -1, $this->incrementalOutputOffset);
@@ -621,8 +605,7 @@ 
      * @return \Generator
      */
     #[\ReturnTypeWillChange]
-    public function getIterator(int $flags = 0)
-    {
+    public function getIterator(int $flags = 0) {
         $this->readPipesForOutput(__FUNCTION__, false);
 
         $clearOutput = !(self::ITER_KEEP_OUTPUT & $flags);
@@ -673,8 +656,7 @@ 
      *
      * @return $this
      */
-    public function clearOutput()
-    {
+    public function clearOutput() {
         ftruncate($this->stdout, 0);
         fseek($this->stdout, 0);
         $this->incrementalOutputOffset = 0;
@@ -690,8 +672,7 @@ 
      * @throws LogicException in case the output has been disabled
      * @throws LogicException In case the process is not started
      */
-    public function getErrorOutput()
-    {
+    public function getErrorOutput() {
         $this->readPipesForOutput(__FUNCTION__);
 
         if (false === $ret = stream_get_contents($this->stderr, -1, 0)) {
@@ -713,8 +694,7 @@ 
      * @throws LogicException in case the output has been disabled
      * @throws LogicException In case the process is not started
      */
-    public function getIncrementalErrorOutput()
-    {
+    public function getIncrementalErrorOutput() {
         $this->readPipesForOutput(__FUNCTION__);
 
         $latest = stream_get_contents($this->stderr, -1, $this->incrementalErrorOutputOffset);
@@ -732,8 +712,7 @@ 
      *
      * @return $this
      */
-    public function clearErrorOutput()
-    {
+    public function clearErrorOutput() {
         ftruncate($this->stderr, 0);
         fseek($this->stderr, 0);
         $this->incrementalErrorOutputOffset = 0;
@@ -746,8 +725,7 @@ 
      *
      * @return int|null The exit status code, null if the Process is not terminated
      */
-    public function getExitCode()
-    {
+    public function getExitCode() {
         $this->updateStatus(false);
 
         return $this->exitcode;
@@ -764,8 +742,7 @@ 
      * @see http://tldp.org/LDP/abs/html/exitcodes.html
      * @see http://en.wikipedia.org/wiki/Unix_signal
      */
-    public function getExitCodeText()
-    {
+    public function getExitCodeText() {
         if (null === $exitcode = $this->getExitCode()) {
             return null;
         }
@@ -778,8 +755,7 @@ 
      *
      * @return bool true if the process ended successfully, false otherwise
      */
-    public function isSuccessful()
-    {
+    public function isSuccessful() {
         return 0 === $this->getExitCode();
     }
 
@@ -792,8 +768,7 @@ 
      *
      * @throws LogicException In case the process is not terminated
      */
-    public function hasBeenSignaled()
-    {
+    public function hasBeenSignaled() {
         $this->requireProcessIsTerminated(__FUNCTION__);
 
         return $this->processInformation['signaled'];
@@ -809,8 +784,7 @@ 
      * @throws RuntimeException In case --enable-sigchild is activated
      * @throws LogicException   In case the process is not terminated
      */
-    public function getTermSignal()
-    {
+    public function getTermSignal() {
         $this->requireProcessIsTerminated(__FUNCTION__);
 
         if ($this->isSigchildEnabled() && -1 === $this->processInformation['termsig']) {
@@ -829,8 +803,7 @@ 
      *
      * @throws LogicException In case the process is not terminated
      */
-    public function hasBeenStopped()
-    {
+    public function hasBeenStopped() {
         $this->requireProcessIsTerminated(__FUNCTION__);
 
         return $this->processInformation['stopped'];
@@ -845,8 +818,7 @@ 
      *
      * @throws LogicException In case the process is not terminated
      */
-    public function getStopSignal()
-    {
+    public function getStopSignal() {
         $this->requireProcessIsTerminated(__FUNCTION__);
 
         return $this->processInformation['stopsig'];
@@ -857,8 +829,7 @@ 
      *
      * @return bool true if the process is currently running, false otherwise
      */
-    public function isRunning()
-    {
+    public function isRunning() {
         if (self::STATUS_STARTED !== $this->status) {
             return false;
         }
@@ -873,8 +844,7 @@ 
      *
      * @return bool true if status is ready, false otherwise
      */
-    public function isStarted()
-    {
+    public function isStarted() {
         return self::STATUS_READY != $this->status;
     }
 
@@ -883,8 +853,7 @@ 
      *
      * @return bool true if process is terminated, false otherwise
      */
-    public function isTerminated()
-    {
+    public function isTerminated() {
         $this->updateStatus(false);
 
         return self::STATUS_TERMINATED == $this->status;
@@ -897,8 +866,7 @@ 
      *
      * @return string The current process status
      */
-    public function getStatus()
-    {
+    public function getStatus() {
         $this->updateStatus(false);
 
         return $this->status;
@@ -912,8 +880,7 @@ 
      *
      * @return int|null The exit-code of the process or null if it's not running
      */
-    public function stop(float $timeout = 10, int $signal = null)
-    {
+    public function stop(float $timeout = 10, int $signal = null) {
         $timeoutMicro = microtime(true) + $timeout;
         if ($this->isRunning()) {
             // given SIGTERM may not be defined and that "proc_terminate" uses the constant value and not the constant itself, we use the same here
@@ -946,8 +913,7 @@ 
      *
      * @internal
      */
-    public function addOutput(string $line)
-    {
+    public function addOutput(string $line) {
         $this->lastOutputTime = microtime(true);
 
         fseek($this->stdout, 0, \SEEK_END);
@@ -960,8 +926,7 @@ 
      *
      * @internal
      */
-    public function addErrorOutput(string $line)
-    {
+    public function addErrorOutput(string $line) {
         $this->lastOutputTime = microtime(true);
 
         fseek($this->stderr, 0, \SEEK_END);
@@ -984,8 +949,7 @@ 
      *
      * @return string The command to execute
      */
-    public function getCommandLine()
-    {
+    public function getCommandLine() {
         return \is_array($this->commandline) ? implode(' ', array_map([$this, 'escapeArgument'], $this->commandline)) : $this->commandline;
     }
 
@@ -994,8 +958,7 @@ 
      *
      * @return float|null The timeout in seconds or null if it's disabled
      */
-    public function getTimeout()
-    {
+    public function getTimeout() {
         return $this->timeout;
     }
 
@@ -1004,8 +967,7 @@ 
      *
      * @return float|null The timeout in seconds or null if it's disabled
      */
-    public function getIdleTimeout()
-    {
+    public function getIdleTimeout() {
         return $this->idleTimeout;
     }
 
@@ -1018,8 +980,7 @@ 
      *
      * @throws InvalidArgumentException if the timeout is negative
      */
-    public function setTimeout(?float $timeout)
-    {
+    public function setTimeout(?float $timeout) {
         $this->timeout = $this->validateTimeout($timeout);
 
         return $this;
@@ -1035,8 +996,7 @@ 
      * @throws LogicException           if the output is disabled
      * @throws InvalidArgumentException if the timeout is negative
      */
-    public function setIdleTimeout(?float $timeout)
-    {
+    public function setIdleTimeout(?float $timeout) {
         if (null !== $timeout && $this->outputDisabled) {
             throw new LogicException('Idle timeout can not be set while the output is disabled.');
         }
@@ -1053,8 +1013,7 @@ 
      *
      * @throws RuntimeException In case the TTY mode is not supported
      */
-    public function setTty(bool $tty)
-    {
+    public function setTty(bool $tty) {
         if ('\\' === \DIRECTORY_SEPARATOR && $tty) {
             throw new RuntimeException('TTY mode is not supported on Windows platform.');
         }
@@ -1073,8 +1032,7 @@ 
      *
      * @return bool true if the TTY mode is enabled, false otherwise
      */
-    public function isTty()
-    {
+    public function isTty() {
         return $this->tty;
     }
 
@@ -1083,8 +1041,7 @@ 
      *
      * @return $this
      */
-    public function setPty(bool $bool)
-    {
+    public function setPty(bool $bool) {
         $this->pty = $bool;
 
         return $this;
@@ -1095,8 +1052,7 @@ 
      *
      * @return bool
      */
-    public function isPty()
-    {
+    public function isPty() {
         return $this->pty;
     }
 
@@ -1105,8 +1061,7 @@ 
      *
      * @return string|null The current working directory or null on failure
      */
-    public function getWorkingDirectory()
-    {
+    public function getWorkingDirectory() {
         if (null === $this->cwd) {
             // getcwd() will return false if any one of the parent directories does not have
             // the readable or search mode set, even if the current directory does
@@ -1121,8 +1076,7 @@ 
      *
      * @return $this
      */
-    public function setWorkingDirectory(string $cwd)
-    {
+    public function setWorkingDirectory(string $cwd) {
         $this->cwd = $cwd;
 
         return $this;
@@ -1133,8 +1087,7 @@ 
      *
      * @return array The current environment variables
      */
-    public function getEnv()
-    {
+    public function getEnv() {
         return $this->env;
     }
 
@@ -1153,8 +1106,7 @@ 
      *
      * @return $this
      */
-    public function setEnv(array $env)
-    {
+    public function setEnv(array $env) {
         // Process can not handle env values that are arrays
         $env = array_filter($env, function ($value) {
             return !\is_array($value);
@@ -1170,8 +1122,7 @@ 
      *
      * @return resource|string|\Iterator|null The Process input
      */
-    public function getInput()
-    {
+    public function getInput() {
         return $this->input;
     }
 
@@ -1186,8 +1137,7 @@ 
      *
      * @throws LogicException In case the process is running
      */
-    public function setInput($input)
-    {
+    public function setInput($input) {
         if ($this->isRunning()) {
             throw new LogicException('Input can not be set while the process is running.');
         }
@@ -1205,8 +1155,7 @@ 
      *
      * @throws ProcessTimedOutException In case the timeout was reached
      */
-    public function checkTimeout()
-    {
+    public function checkTimeout() {
         if (self::STATUS_STARTED !== $this->status) {
             return;
         }
@@ -1244,8 +1193,7 @@ 
      * Enabling the "create_new_console" option allows a subprocess to continue
      * to run after the main process exited, on both Windows and *nix
      */
-    public function setOptions(array $options)
-    {
+    public function setOptions(array $options) {
         if ($this->isRunning()) {
             throw new RuntimeException('Setting options while the process is running is not possible.');
         }
@@ -1281,8 +1229,7 @@ 
      *
      * @return bool
      */
-    public static function isPtySupported()
-    {
+    public static function isPtySupported() {
         static $result;
 
         if (null !== $result) {
@@ -1323,8 +1270,7 @@ 
      *
      * @return \Closure A PHP closure
      */
-    protected function buildCallback(callable $callback = null)
-    {
+    protected function buildCallback(callable $callback = null) {
         if ($this->outputDisabled) {
             return function ($type, $data) use ($callback): bool {
                 return null !== $callback && $callback($type, $data);
@@ -1349,8 +1295,7 @@ 
      *
      * @param bool $blocking Whether to use a blocking read call
      */
-    protected function updateStatus(bool $blocking)
-    {
+    protected function updateStatus(bool $blocking) {
         if (self::STATUS_STARTED !== $this->status) {
             return;
         }
@@ -1374,8 +1319,7 @@ 
      *
      * @return bool
      */
-    protected function isSigchildEnabled()
-    {
+    protected function isSigchildEnabled() {
         if (null !== self::$sigchild) {
             return self::$sigchild;
         }
@@ -1398,8 +1342,7 @@ 
      *
      * @throws LogicException in case output has been disabled or process is not started
      */
-    private function readPipesForOutput(string $caller, bool $blocking = false)
-    {
+    private function readPipesForOutput(string $caller, bool $blocking = false) {
         if ($this->outputDisabled) {
             throw new LogicException('Output has been disabled.');
         }
@@ -1433,8 +1376,7 @@ 
      * @param bool $blocking Whether to use blocking calls or not
      * @param bool $close    Whether to close file handles or not
      */
-    private function readPipes(bool $blocking, bool $close)
-    {
+    private function readPipes(bool $blocking, bool $close) {
         $result = $this->processPipes->readAndWrite($blocking, $close);
 
         $callback = $this->callback;
@@ -1482,8 +1424,7 @@ 
     /**
      * Resets data related to the latest run of the process.
      */
-    private function resetProcessData()
-    {
+    private function resetProcessData() {
         $this->starttime = null;
         $this->callback = null;
         $this->exitcode = null;
@@ -1605,8 +1546,7 @@ 
      *
      * @throws LogicException if the process has not run
      */
-    private function requireProcessIsStarted(string $functionName)
-    {
+    private function requireProcessIsStarted(string $functionName) {
         if (!$this->isStarted()) {
             throw new LogicException(sprintf('Process must be started before calling "%s()".', $functionName));
         }
@@ -1617,8 +1557,7 @@ 
      *
      * @throws LogicException if the process is not yet terminated
      */
-    private function requireProcessIsTerminated(string $functionName)
-    {
+    private function requireProcessIsTerminated(string $functionName) {
         if (!$this->isTerminated()) {
             throw new LogicException(sprintf('Process must be terminated before calling "%s()".', $functionName));
         }
@@ -1646,8 +1585,7 @@ 
         return '"'.str_replace(['"', '^', '%', '!', "\n"], ['""', '"^^"', '"^%"', '"^!"', '!LF!'], $argument).'"';
     }
 
-    private function replacePlaceholders(string $commandline, array $env)
-    {
+    private function replacePlaceholders(string $commandline, array $env) {
         return preg_replace_callback('/"\$\{:([_a-zA-Z]++[_a-zA-Z0-9]*+)\}"/', function ($matches) use ($commandline, $env) {
             if (!isset($env[$matches[1]]) || false === $env[$matches[1]]) {
                 throw new InvalidArgumentException(sprintf('Command line is missing a value for parameter "%s": ', $matches[1]).$commandline);