gravityview / GravityView

vendor/symfony/console/Input/ArgvInput.php

Indentation +328 added lines, -328 removed lines

@@ -40,332 +40,332 @@
  */
 class ArgvInput extends Input
 {
-    private $tokens;
-    private $parsed;
-
-    public function __construct(array $argv = null, InputDefinition $definition = null)
-    {
-        $argv = $argv ?? $_SERVER['argv'] ?? [];
-
-        // strip the application name
-        array_shift($argv);
-
-        $this->tokens = $argv;
-
-        parent::__construct($definition);
-    }
-
-    protected function setTokens(array $tokens)
-    {
-        $this->tokens = $tokens;
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    protected function parse()
-    {
-        $parseOptions = true;
-        $this->parsed = $this->tokens;
-        while (null !== $token = array_shift($this->parsed)) {
-            if ($parseOptions && '' == $token) {
-                $this->parseArgument($token);
-            } elseif ($parseOptions && '--' == $token) {
-                $parseOptions = false;
-            } elseif ($parseOptions && str_starts_with($token, '--')) {
-                $this->parseLongOption($token);
-            } elseif ($parseOptions && '-' === $token[0] && '-' !== $token) {
-                $this->parseShortOption($token);
-            } else {
-                $this->parseArgument($token);
-            }
-        }
-    }
-
-    /**
-     * Parses a short option.
-     */
-    private function parseShortOption(string $token)
-    {
-        $name = substr($token, 1);
-
-        if (\strlen($name) > 1) {
-            if ($this->definition->hasShortcut($name[0]) && $this->definition->getOptionForShortcut($name[0])->acceptValue()) {
-                // an option with a value (with no space)
-                $this->addShortOption($name[0], substr($name, 1));
-            } else {
-                $this->parseShortOptionSet($name);
-            }
-        } else {
-            $this->addShortOption($name, null);
-        }
-    }
-
-    /**
-     * Parses a short option set.
-     *
-     * @throws RuntimeException When option given doesn't exist
-     */
-    private function parseShortOptionSet(string $name)
-    {
-        $len = \strlen($name);
-        for ($i = 0; $i < $len; ++$i) {
-            if (!$this->definition->hasShortcut($name[$i])) {
-                $encoding = mb_detect_encoding($name, null, true);
-                throw new RuntimeException(sprintf('The "-%s" option does not exist.', false === $encoding ? $name[$i] : mb_substr($name, $i, 1, $encoding)));
-            }
-
-            $option = $this->definition->getOptionForShortcut($name[$i]);
-            if ($option->acceptValue()) {
-                $this->addLongOption($option->getName(), $i === $len - 1 ? null : substr($name, $i + 1));
-
-                break;
-            } else {
-                $this->addLongOption($option->getName(), null);
-            }
-        }
-    }
-
-    /**
-     * Parses a long option.
-     */
-    private function parseLongOption(string $token)
-    {
-        $name = substr($token, 2);
-
-        if (false !== $pos = strpos($name, '=')) {
-            if (0 === \strlen($value = substr($name, $pos + 1))) {
-                array_unshift($this->parsed, $value);
-            }
-            $this->addLongOption(substr($name, 0, $pos), $value);
-        } else {
-            $this->addLongOption($name, null);
-        }
-    }
-
-    /**
-     * Parses an argument.
-     *
-     * @throws RuntimeException When too many arguments are given
-     */
-    private function parseArgument(string $token)
-    {
-        $c = \count($this->arguments);
-
-        // if input is expecting another argument, add it
-        if ($this->definition->hasArgument($c)) {
-            $arg = $this->definition->getArgument($c);
-            $this->arguments[$arg->getName()] = $arg->isArray() ? [$token] : $token;
-
-        // if last argument isArray(), append token to last argument
-        } elseif ($this->definition->hasArgument($c - 1) && $this->definition->getArgument($c - 1)->isArray()) {
-            $arg = $this->definition->getArgument($c - 1);
-            $this->arguments[$arg->getName()][] = $token;
-
-        // unexpected argument
-        } else {
-            $all = $this->definition->getArguments();
-            $symfonyCommandName = null;
-            if (($inputArgument = $all[$key = array_key_first($all)] ?? null) && 'command' === $inputArgument->getName()) {
-                $symfonyCommandName = $this->arguments['command'] ?? null;
-                unset($all[$key]);
-            }
-
-            if (\count($all)) {
-                if ($symfonyCommandName) {
-                    $message = sprintf('Too many arguments to "%s" command, expected arguments "%s".', $symfonyCommandName, implode('" "', array_keys($all)));
-                } else {
-                    $message = sprintf('Too many arguments, expected arguments "%s".', implode('" "', array_keys($all)));
-                }
-            } elseif ($symfonyCommandName) {
-                $message = sprintf('No arguments expected for "%s" command, got "%s".', $symfonyCommandName, $token);
-            } else {
-                $message = sprintf('No arguments expected, got "%s".', $token);
-            }
-
-            throw new RuntimeException($message);
-        }
-    }
-
-    /**
-     * Adds a short option value.
-     *
-     * @throws RuntimeException When option given doesn't exist
-     */
-    private function addShortOption(string $shortcut, $value)
-    {
-        if (!$this->definition->hasShortcut($shortcut)) {
-            throw new RuntimeException(sprintf('The "-%s" option does not exist.', $shortcut));
-        }
-
-        $this->addLongOption($this->definition->getOptionForShortcut($shortcut)->getName(), $value);
-    }
-
-    /**
-     * Adds a long option value.
-     *
-     * @throws RuntimeException When option given doesn't exist
-     */
-    private function addLongOption(string $name, $value)
-    {
-        if (!$this->definition->hasOption($name)) {
-            if (!$this->definition->hasNegation($name)) {
-                throw new RuntimeException(sprintf('The "--%s" option does not exist.', $name));
-            }
-
-            $optionName = $this->definition->negationToName($name);
-            if (null !== $value) {
-                throw new RuntimeException(sprintf('The "--%s" option does not accept a value.', $name));
-            }
-            $this->options[$optionName] = false;
-
-            return;
-        }
-
-        $option = $this->definition->getOption($name);
-
-        if (null !== $value && !$option->acceptValue()) {
-            throw new RuntimeException(sprintf('The "--%s" option does not accept a value.', $name));
-        }
-
-        if (\in_array($value, ['', null], true) && $option->acceptValue() && \count($this->parsed)) {
-            // if option accepts an optional or mandatory argument
-            // let's see if there is one provided
-            $next = array_shift($this->parsed);
-            if ((isset($next[0]) && '-' !== $next[0]) || \in_array($next, ['', null], true)) {
-                $value = $next;
-            } else {
-                array_unshift($this->parsed, $next);
-            }
-        }
-
-        if (null === $value) {
-            if ($option->isValueRequired()) {
-                throw new RuntimeException(sprintf('The "--%s" option requires a value.', $name));
-            }
-
-            if (!$option->isArray() && !$option->isValueOptional()) {
-                $value = true;
-            }
-        }
-
-        if ($option->isArray()) {
-            $this->options[$name][] = $value;
-        } else {
-            $this->options[$name] = $value;
-        }
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function getFirstArgument()
-    {
-        $isOption = false;
-        foreach ($this->tokens as $i => $token) {
-            if ($token && '-' === $token[0]) {
-                if (str_contains($token, '=') || !isset($this->tokens[$i + 1])) {
-                    continue;
-                }
-
-                // If it's a long option, consider that everything after "--" is the option name.
-                // Otherwise, use the last char (if it's a short option set, only the last one can take a value with space separator)
-                $name = '-' === $token[1] ? substr($token, 2) : substr($token, -1);
-                if (!isset($this->options[$name]) && !$this->definition->hasShortcut($name)) {
-                    // noop
-                } elseif ((isset($this->options[$name]) || isset($this->options[$name = $this->definition->shortcutToName($name)])) && $this->tokens[$i + 1] === $this->options[$name]) {
-                    $isOption = true;
-                }
-
-                continue;
-            }
-
-            if ($isOption) {
-                $isOption = false;
-                continue;
-            }
-
-            return $token;
-        }
-
-        return null;
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function hasParameterOption($values, bool $onlyParams = false)
-    {
-        $values = (array) $values;
-
-        foreach ($this->tokens as $token) {
-            if ($onlyParams && '--' === $token) {
-                return false;
-            }
-            foreach ($values as $value) {
-                // Options with values:
-                //   For long options, test for '--option=' at beginning
-                //   For short options, test for '-o' at beginning
-                $leading = str_starts_with($value, '--') ? $value.'=' : $value;
-                if ($token === $value || '' !== $leading && str_starts_with($token, $leading)) {
-                    return true;
-                }
-            }
-        }
-
-        return false;
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function getParameterOption($values, $default = false, bool $onlyParams = false)
-    {
-        $values = (array) $values;
-        $tokens = $this->tokens;
-
-        while (0 < \count($tokens)) {
-            $token = array_shift($tokens);
-            if ($onlyParams && '--' === $token) {
-                return $default;
-            }
-
-            foreach ($values as $value) {
-                if ($token === $value) {
-                    return array_shift($tokens);
-                }
-                // Options with values:
-                //   For long options, test for '--option=' at beginning
-                //   For short options, test for '-o' at beginning
-                $leading = str_starts_with($value, '--') ? $value.'=' : $value;
-                if ('' !== $leading && str_starts_with($token, $leading)) {
-                    return substr($token, \strlen($leading));
-                }
-            }
-        }
-
-        return $default;
-    }
-
-    /**
-     * Returns a stringified representation of the args passed to the command.
-     *
-     * @return string
-     */
-    public function __toString()
-    {
-        $tokens = array_map(function ($token) {
-            if (preg_match('{^(-[^=]+=)(.+)}', $token, $match)) {
-                return $match[1].$this->escapeToken($match[2]);
-            }
-
-            if ($token && '-' !== $token[0]) {
-                return $this->escapeToken($token);
-            }
-
-            return $token;
-        }, $this->tokens);
-
-        return implode(' ', $tokens);
-    }
+	private $tokens;
+	private $parsed;
+
+	public function __construct(array $argv = null, InputDefinition $definition = null)
+	{
+		$argv = $argv ?? $_SERVER['argv'] ?? [];
+
+		// strip the application name
+		array_shift($argv);
+
+		$this->tokens = $argv;
+
+		parent::__construct($definition);
+	}
+
+	protected function setTokens(array $tokens)
+	{
+		$this->tokens = $tokens;
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	protected function parse()
+	{
+		$parseOptions = true;
+		$this->parsed = $this->tokens;
+		while (null !== $token = array_shift($this->parsed)) {
+			if ($parseOptions && '' == $token) {
+				$this->parseArgument($token);
+			} elseif ($parseOptions && '--' == $token) {
+				$parseOptions = false;
+			} elseif ($parseOptions && str_starts_with($token, '--')) {
+				$this->parseLongOption($token);
+			} elseif ($parseOptions && '-' === $token[0] && '-' !== $token) {
+				$this->parseShortOption($token);
+			} else {
+				$this->parseArgument($token);
+			}
+		}
+	}
+
+	/**
+	 * Parses a short option.
+	 */
+	private function parseShortOption(string $token)
+	{
+		$name = substr($token, 1);
+
+		if (\strlen($name) > 1) {
+			if ($this->definition->hasShortcut($name[0]) && $this->definition->getOptionForShortcut($name[0])->acceptValue()) {
+				// an option with a value (with no space)
+				$this->addShortOption($name[0], substr($name, 1));
+			} else {
+				$this->parseShortOptionSet($name);
+			}
+		} else {
+			$this->addShortOption($name, null);
+		}
+	}
+
+	/**
+	 * Parses a short option set.
+	 *
+	 * @throws RuntimeException When option given doesn't exist
+	 */
+	private function parseShortOptionSet(string $name)
+	{
+		$len = \strlen($name);
+		for ($i = 0; $i < $len; ++$i) {
+			if (!$this->definition->hasShortcut($name[$i])) {
+				$encoding = mb_detect_encoding($name, null, true);
+				throw new RuntimeException(sprintf('The "-%s" option does not exist.', false === $encoding ? $name[$i] : mb_substr($name, $i, 1, $encoding)));
+			}
+
+			$option = $this->definition->getOptionForShortcut($name[$i]);
+			if ($option->acceptValue()) {
+				$this->addLongOption($option->getName(), $i === $len - 1 ? null : substr($name, $i + 1));
+
+				break;
+			} else {
+				$this->addLongOption($option->getName(), null);
+			}
+		}
+	}
+
+	/**
+	 * Parses a long option.
+	 */
+	private function parseLongOption(string $token)
+	{
+		$name = substr($token, 2);
+
+		if (false !== $pos = strpos($name, '=')) {
+			if (0 === \strlen($value = substr($name, $pos + 1))) {
+				array_unshift($this->parsed, $value);
+			}
+			$this->addLongOption(substr($name, 0, $pos), $value);
+		} else {
+			$this->addLongOption($name, null);
+		}
+	}
+
+	/**
+	 * Parses an argument.
+	 *
+	 * @throws RuntimeException When too many arguments are given
+	 */
+	private function parseArgument(string $token)
+	{
+		$c = \count($this->arguments);
+
+		// if input is expecting another argument, add it
+		if ($this->definition->hasArgument($c)) {
+			$arg = $this->definition->getArgument($c);
+			$this->arguments[$arg->getName()] = $arg->isArray() ? [$token] : $token;
+
+		// if last argument isArray(), append token to last argument
+		} elseif ($this->definition->hasArgument($c - 1) && $this->definition->getArgument($c - 1)->isArray()) {
+			$arg = $this->definition->getArgument($c - 1);
+			$this->arguments[$arg->getName()][] = $token;
+
+		// unexpected argument
+		} else {
+			$all = $this->definition->getArguments();
+			$symfonyCommandName = null;
+			if (($inputArgument = $all[$key = array_key_first($all)] ?? null) && 'command' === $inputArgument->getName()) {
+				$symfonyCommandName = $this->arguments['command'] ?? null;
+				unset($all[$key]);
+			}
+
+			if (\count($all)) {
+				if ($symfonyCommandName) {
+					$message = sprintf('Too many arguments to "%s" command, expected arguments "%s".', $symfonyCommandName, implode('" "', array_keys($all)));
+				} else {
+					$message = sprintf('Too many arguments, expected arguments "%s".', implode('" "', array_keys($all)));
+				}
+			} elseif ($symfonyCommandName) {
+				$message = sprintf('No arguments expected for "%s" command, got "%s".', $symfonyCommandName, $token);
+			} else {
+				$message = sprintf('No arguments expected, got "%s".', $token);
+			}
+
+			throw new RuntimeException($message);
+		}
+	}
+
+	/**
+	 * Adds a short option value.
+	 *
+	 * @throws RuntimeException When option given doesn't exist
+	 */
+	private function addShortOption(string $shortcut, $value)
+	{
+		if (!$this->definition->hasShortcut($shortcut)) {
+			throw new RuntimeException(sprintf('The "-%s" option does not exist.', $shortcut));
+		}
+
+		$this->addLongOption($this->definition->getOptionForShortcut($shortcut)->getName(), $value);
+	}
+
+	/**
+	 * Adds a long option value.
+	 *
+	 * @throws RuntimeException When option given doesn't exist
+	 */
+	private function addLongOption(string $name, $value)
+	{
+		if (!$this->definition->hasOption($name)) {
+			if (!$this->definition->hasNegation($name)) {
+				throw new RuntimeException(sprintf('The "--%s" option does not exist.', $name));
+			}
+
+			$optionName = $this->definition->negationToName($name);
+			if (null !== $value) {
+				throw new RuntimeException(sprintf('The "--%s" option does not accept a value.', $name));
+			}
+			$this->options[$optionName] = false;
+
+			return;
+		}
+
+		$option = $this->definition->getOption($name);
+
+		if (null !== $value && !$option->acceptValue()) {
+			throw new RuntimeException(sprintf('The "--%s" option does not accept a value.', $name));
+		}
+
+		if (\in_array($value, ['', null], true) && $option->acceptValue() && \count($this->parsed)) {
+			// if option accepts an optional or mandatory argument
+			// let's see if there is one provided
+			$next = array_shift($this->parsed);
+			if ((isset($next[0]) && '-' !== $next[0]) || \in_array($next, ['', null], true)) {
+				$value = $next;
+			} else {
+				array_unshift($this->parsed, $next);
+			}
+		}
+
+		if (null === $value) {
+			if ($option->isValueRequired()) {
+				throw new RuntimeException(sprintf('The "--%s" option requires a value.', $name));
+			}
+
+			if (!$option->isArray() && !$option->isValueOptional()) {
+				$value = true;
+			}
+		}
+
+		if ($option->isArray()) {
+			$this->options[$name][] = $value;
+		} else {
+			$this->options[$name] = $value;
+		}
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function getFirstArgument()
+	{
+		$isOption = false;
+		foreach ($this->tokens as $i => $token) {
+			if ($token && '-' === $token[0]) {
+				if (str_contains($token, '=') || !isset($this->tokens[$i + 1])) {
+					continue;
+				}
+
+				// If it's a long option, consider that everything after "--" is the option name.
+				// Otherwise, use the last char (if it's a short option set, only the last one can take a value with space separator)
+				$name = '-' === $token[1] ? substr($token, 2) : substr($token, -1);
+				if (!isset($this->options[$name]) && !$this->definition->hasShortcut($name)) {
+					// noop
+				} elseif ((isset($this->options[$name]) || isset($this->options[$name = $this->definition->shortcutToName($name)])) && $this->tokens[$i + 1] === $this->options[$name]) {
+					$isOption = true;
+				}
+
+				continue;
+			}
+
+			if ($isOption) {
+				$isOption = false;
+				continue;
+			}
+
+			return $token;
+		}
+
+		return null;
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function hasParameterOption($values, bool $onlyParams = false)
+	{
+		$values = (array) $values;
+
+		foreach ($this->tokens as $token) {
+			if ($onlyParams && '--' === $token) {
+				return false;
+			}
+			foreach ($values as $value) {
+				// Options with values:
+				//   For long options, test for '--option=' at beginning
+				//   For short options, test for '-o' at beginning
+				$leading = str_starts_with($value, '--') ? $value.'=' : $value;
+				if ($token === $value || '' !== $leading && str_starts_with($token, $leading)) {
+					return true;
+				}
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function getParameterOption($values, $default = false, bool $onlyParams = false)
+	{
+		$values = (array) $values;
+		$tokens = $this->tokens;
+
+		while (0 < \count($tokens)) {
+			$token = array_shift($tokens);
+			if ($onlyParams && '--' === $token) {
+				return $default;
+			}
+
+			foreach ($values as $value) {
+				if ($token === $value) {
+					return array_shift($tokens);
+				}
+				// Options with values:
+				//   For long options, test for '--option=' at beginning
+				//   For short options, test for '-o' at beginning
+				$leading = str_starts_with($value, '--') ? $value.'=' : $value;
+				if ('' !== $leading && str_starts_with($token, $leading)) {
+					return substr($token, \strlen($leading));
+				}
+			}
+		}
+
+		return $default;
+	}
+
+	/**
+	 * Returns a stringified representation of the args passed to the command.
+	 *
+	 * @return string
+	 */
+	public function __toString()
+	{
+		$tokens = array_map(function ($token) {
+			if (preg_match('{^(-[^=]+=)(.+)}', $token, $match)) {
+				return $match[1].$this->escapeToken($match[2]);
+			}
+
+			if ($token && '-' !== $token[0]) {
+				return $this->escapeToken($token);
+			}
+
+			return $token;
+		}, $this->tokens);
+
+		return implode(' ', $tokens);
+	}
 }

vendor/symfony/console/Input/StreamableInputInterface.php

Indentation +14 added lines, -14 removed lines

@@ -19,19 +19,19 @@
  */
 interface StreamableInputInterface extends InputInterface
 {
-    /**
-     * Sets the input stream to read from when interacting with the user.
-     *
-     * This is mainly useful for testing purpose.
-     *
-     * @param resource $stream The input stream
-     */
-    public function setStream($stream);
+	/**
+	 * Sets the input stream to read from when interacting with the user.
+	 *
+	 * This is mainly useful for testing purpose.
+	 *
+	 * @param resource $stream The input stream
+	 */
+	public function setStream($stream);
 
-    /**
-     * Returns the input stream.
-     *
-     * @return resource|null
-     */
-    public function getStream();
+	/**
+	 * Returns the input stream.
+	 *
+	 * @return resource|null
+	 */
+	public function getStream();
 }

vendor/symfony/console/Input/InputInterface.php

Indentation +127 added lines, -127 removed lines

@@ -21,131 +21,131 @@
  */
 interface InputInterface
 {
-    /**
-     * Returns the first argument from the raw parameters (not parsed).
-     *
-     * @return string|null The value of the first argument or null otherwise
-     */
-    public function getFirstArgument();
-
-    /**
-     * Returns true if the raw parameters (not parsed) contain a value.
-     *
-     * This method is to be used to introspect the input parameters
-     * before they have been validated. It must be used carefully.
-     * Does not necessarily return the correct result for short options
-     * when multiple flags are combined in the same option.
-     *
-     * @param string|array $values     The values to look for in the raw parameters (can be an array)
-     * @param bool         $onlyParams Only check real parameters, skip those following an end of options (--) signal
-     *
-     * @return bool true if the value is contained in the raw parameters
-     */
-    public function hasParameterOption($values, bool $onlyParams = false);
-
-    /**
-     * Returns the value of a raw option (not parsed).
-     *
-     * This method is to be used to introspect the input parameters
-     * before they have been validated. It must be used carefully.
-     * Does not necessarily return the correct result for short options
-     * when multiple flags are combined in the same option.
-     *
-     * @param string|array                     $values     The value(s) to look for in the raw parameters (can be an array)
-     * @param string|bool|int|float|array|null $default    The default value to return if no result is found
-     * @param bool                             $onlyParams Only check real parameters, skip those following an end of options (--) signal
-     *
-     * @return mixed The option value
-     */
-    public function getParameterOption($values, $default = false, bool $onlyParams = false);
-
-    /**
-     * Binds the current Input instance with the given arguments and options.
-     *
-     * @throws RuntimeException
-     */
-    public function bind(InputDefinition $definition);
-
-    /**
-     * Validates the input.
-     *
-     * @throws RuntimeException When not enough arguments are given
-     */
-    public function validate();
-
-    /**
-     * Returns all the given arguments merged with the default values.
-     *
-     * @return array<string|bool|int|float|array|null>
-     */
-    public function getArguments();
-
-    /**
-     * Returns the argument value for a given argument name.
-     *
-     * @return mixed
-     *
-     * @throws InvalidArgumentException When argument given doesn't exist
-     */
-    public function getArgument(string $name);
-
-    /**
-     * Sets an argument value by name.
-     *
-     * @param mixed $value The argument value
-     *
-     * @throws InvalidArgumentException When argument given doesn't exist
-     */
-    public function setArgument(string $name, $value);
-
-    /**
-     * Returns true if an InputArgument object exists by name or position.
-     *
-     * @return bool true if the InputArgument object exists, false otherwise
-     */
-    public function hasArgument(string $name);
-
-    /**
-     * Returns all the given options merged with the default values.
-     *
-     * @return array<string|bool|int|float|array|null>
-     */
-    public function getOptions();
-
-    /**
-     * Returns the option value for a given option name.
-     *
-     * @return mixed
-     *
-     * @throws InvalidArgumentException When option given doesn't exist
-     */
-    public function getOption(string $name);
-
-    /**
-     * Sets an option value by name.
-     *
-     * @param mixed $value The option value
-     *
-     * @throws InvalidArgumentException When option given doesn't exist
-     */
-    public function setOption(string $name, $value);
-
-    /**
-     * Returns true if an InputOption object exists by name.
-     *
-     * @return bool true if the InputOption object exists, false otherwise
-     */
-    public function hasOption(string $name);
-
-    /**
-     * Is this input means interactive?
-     *
-     * @return bool
-     */
-    public function isInteractive();
-
-    /**
-     * Sets the input interactivity.
-     */
-    public function setInteractive(bool $interactive);
+	/**
+	 * Returns the first argument from the raw parameters (not parsed).
+	 *
+	 * @return string|null The value of the first argument or null otherwise
+	 */
+	public function getFirstArgument();
+
+	/**
+	 * Returns true if the raw parameters (not parsed) contain a value.
+	 *
+	 * This method is to be used to introspect the input parameters
+	 * before they have been validated. It must be used carefully.
+	 * Does not necessarily return the correct result for short options
+	 * when multiple flags are combined in the same option.
+	 *
+	 * @param string|array $values     The values to look for in the raw parameters (can be an array)
+	 * @param bool         $onlyParams Only check real parameters, skip those following an end of options (--) signal
+	 *
+	 * @return bool true if the value is contained in the raw parameters
+	 */
+	public function hasParameterOption($values, bool $onlyParams = false);
+
+	/**
+	 * Returns the value of a raw option (not parsed).
+	 *
+	 * This method is to be used to introspect the input parameters
+	 * before they have been validated. It must be used carefully.
+	 * Does not necessarily return the correct result for short options
+	 * when multiple flags are combined in the same option.
+	 *
+	 * @param string|array                     $values     The value(s) to look for in the raw parameters (can be an array)
+	 * @param string|bool|int|float|array|null $default    The default value to return if no result is found
+	 * @param bool                             $onlyParams Only check real parameters, skip those following an end of options (--) signal
+	 *
+	 * @return mixed The option value
+	 */
+	public function getParameterOption($values, $default = false, bool $onlyParams = false);
+
+	/**
+	 * Binds the current Input instance with the given arguments and options.
+	 *
+	 * @throws RuntimeException
+	 */
+	public function bind(InputDefinition $definition);
+
+	/**
+	 * Validates the input.
+	 *
+	 * @throws RuntimeException When not enough arguments are given
+	 */
+	public function validate();
+
+	/**
+	 * Returns all the given arguments merged with the default values.
+	 *
+	 * @return array<string|bool|int|float|array|null>
+	 */
+	public function getArguments();
+
+	/**
+	 * Returns the argument value for a given argument name.
+	 *
+	 * @return mixed
+	 *
+	 * @throws InvalidArgumentException When argument given doesn't exist
+	 */
+	public function getArgument(string $name);
+
+	/**
+	 * Sets an argument value by name.
+	 *
+	 * @param mixed $value The argument value
+	 *
+	 * @throws InvalidArgumentException When argument given doesn't exist
+	 */
+	public function setArgument(string $name, $value);
+
+	/**
+	 * Returns true if an InputArgument object exists by name or position.
+	 *
+	 * @return bool true if the InputArgument object exists, false otherwise
+	 */
+	public function hasArgument(string $name);
+
+	/**
+	 * Returns all the given options merged with the default values.
+	 *
+	 * @return array<string|bool|int|float|array|null>
+	 */
+	public function getOptions();
+
+	/**
+	 * Returns the option value for a given option name.
+	 *
+	 * @return mixed
+	 *
+	 * @throws InvalidArgumentException When option given doesn't exist
+	 */
+	public function getOption(string $name);
+
+	/**
+	 * Sets an option value by name.
+	 *
+	 * @param mixed $value The option value
+	 *
+	 * @throws InvalidArgumentException When option given doesn't exist
+	 */
+	public function setOption(string $name, $value);
+
+	/**
+	 * Returns true if an InputOption object exists by name.
+	 *
+	 * @return bool true if the InputOption object exists, false otherwise
+	 */
+	public function hasOption(string $name);
+
+	/**
+	 * Is this input means interactive?
+	 *
+	 * @return bool
+	 */
+	public function isInteractive();
+
+	/**
+	 * Sets the input interactivity.
+	 */
+	public function setInteractive(bool $interactive);
 }

vendor/symfony/console/Input/InputDefinition.php

Indentation +393 added lines, -393 removed lines

@@ -28,397 +28,397 @@
  */
 class InputDefinition
 {
-    private $arguments;
-    private $requiredCount;
-    private $lastArrayArgument;
-    private $lastOptionalArgument;
-    private $options;
-    private $negations;
-    private $shortcuts;
-
-    /**
-     * @param array $definition An array of InputArgument and InputOption instance
-     */
-    public function __construct(array $definition = [])
-    {
-        $this->setDefinition($definition);
-    }
-
-    /**
-     * Sets the definition of the input.
-     */
-    public function setDefinition(array $definition)
-    {
-        $arguments = [];
-        $options = [];
-        foreach ($definition as $item) {
-            if ($item instanceof InputOption) {
-                $options[] = $item;
-            } else {
-                $arguments[] = $item;
-            }
-        }
-
-        $this->setArguments($arguments);
-        $this->setOptions($options);
-    }
-
-    /**
-     * Sets the InputArgument objects.
-     *
-     * @param InputArgument[] $arguments An array of InputArgument objects
-     */
-    public function setArguments(array $arguments = [])
-    {
-        $this->arguments = [];
-        $this->requiredCount = 0;
-        $this->lastOptionalArgument = null;
-        $this->lastArrayArgument = null;
-        $this->addArguments($arguments);
-    }
-
-    /**
-     * Adds an array of InputArgument objects.
-     *
-     * @param InputArgument[] $arguments An array of InputArgument objects
-     */
-    public function addArguments(?array $arguments = [])
-    {
-        if (null !== $arguments) {
-            foreach ($arguments as $argument) {
-                $this->addArgument($argument);
-            }
-        }
-    }
-
-    /**
-     * @throws LogicException When incorrect argument is given
-     */
-    public function addArgument(InputArgument $argument)
-    {
-        if (isset($this->arguments[$argument->getName()])) {
-            throw new LogicException(sprintf('An argument with name "%s" already exists.', $argument->getName()));
-        }
-
-        if (null !== $this->lastArrayArgument) {
-            throw new LogicException(sprintf('Cannot add a required argument "%s" after an array argument "%s".', $argument->getName(), $this->lastArrayArgument->getName()));
-        }
-
-        if ($argument->isRequired() && null !== $this->lastOptionalArgument) {
-            throw new LogicException(sprintf('Cannot add a required argument "%s" after an optional one "%s".', $argument->getName(), $this->lastOptionalArgument->getName()));
-        }
-
-        if ($argument->isArray()) {
-            $this->lastArrayArgument = $argument;
-        }
-
-        if ($argument->isRequired()) {
-            ++$this->requiredCount;
-        } else {
-            $this->lastOptionalArgument = $argument;
-        }
-
-        $this->arguments[$argument->getName()] = $argument;
-    }
-
-    /**
-     * Returns an InputArgument by name or by position.
-     *
-     * @param string|int $name The InputArgument name or position
-     *
-     * @return InputArgument An InputArgument object
-     *
-     * @throws InvalidArgumentException When argument given doesn't exist
-     */
-    public function getArgument($name)
-    {
-        if (!$this->hasArgument($name)) {
-            throw new InvalidArgumentException(sprintf('The "%s" argument does not exist.', $name));
-        }
-
-        $arguments = \is_int($name) ? array_values($this->arguments) : $this->arguments;
-
-        return $arguments[$name];
-    }
-
-    /**
-     * Returns true if an InputArgument object exists by name or position.
-     *
-     * @param string|int $name The InputArgument name or position
-     *
-     * @return bool true if the InputArgument object exists, false otherwise
-     */
-    public function hasArgument($name)
-    {
-        $arguments = \is_int($name) ? array_values($this->arguments) : $this->arguments;
-
-        return isset($arguments[$name]);
-    }
-
-    /**
-     * Gets the array of InputArgument objects.
-     *
-     * @return InputArgument[] An array of InputArgument objects
-     */
-    public function getArguments()
-    {
-        return $this->arguments;
-    }
-
-    /**
-     * Returns the number of InputArguments.
-     *
-     * @return int The number of InputArguments
-     */
-    public function getArgumentCount()
-    {
-        return null !== $this->lastArrayArgument ? \PHP_INT_MAX : \count($this->arguments);
-    }
-
-    /**
-     * Returns the number of required InputArguments.
-     *
-     * @return int The number of required InputArguments
-     */
-    public function getArgumentRequiredCount()
-    {
-        return $this->requiredCount;
-    }
-
-    /**
-     * @return array<string|bool|int|float|array|null>
-     */
-    public function getArgumentDefaults()
-    {
-        $values = [];
-        foreach ($this->arguments as $argument) {
-            $values[$argument->getName()] = $argument->getDefault();
-        }
-
-        return $values;
-    }
-
-    /**
-     * Sets the InputOption objects.
-     *
-     * @param InputOption[] $options An array of InputOption objects
-     */
-    public function setOptions(array $options = [])
-    {
-        $this->options = [];
-        $this->shortcuts = [];
-        $this->negations = [];
-        $this->addOptions($options);
-    }
-
-    /**
-     * Adds an array of InputOption objects.
-     *
-     * @param InputOption[] $options An array of InputOption objects
-     */
-    public function addOptions(array $options = [])
-    {
-        foreach ($options as $option) {
-            $this->addOption($option);
-        }
-    }
-
-    /**
-     * @throws LogicException When option given already exist
-     */
-    public function addOption(InputOption $option)
-    {
-        if (isset($this->options[$option->getName()]) && !$option->equals($this->options[$option->getName()])) {
-            throw new LogicException(sprintf('An option named "%s" already exists.', $option->getName()));
-        }
-        if (isset($this->negations[$option->getName()])) {
-            throw new LogicException(sprintf('An option named "%s" already exists.', $option->getName()));
-        }
-
-        if ($option->getShortcut()) {
-            foreach (explode('|', $option->getShortcut()) as $shortcut) {
-                if (isset($this->shortcuts[$shortcut]) && !$option->equals($this->options[$this->shortcuts[$shortcut]])) {
-                    throw new LogicException(sprintf('An option with shortcut "%s" already exists.', $shortcut));
-                }
-            }
-        }
-
-        $this->options[$option->getName()] = $option;
-        if ($option->getShortcut()) {
-            foreach (explode('|', $option->getShortcut()) as $shortcut) {
-                $this->shortcuts[$shortcut] = $option->getName();
-            }
-        }
-
-        if ($option->isNegatable()) {
-            $negatedName = 'no-'.$option->getName();
-            if (isset($this->options[$negatedName])) {
-                throw new LogicException(sprintf('An option named "%s" already exists.', $negatedName));
-            }
-            $this->negations[$negatedName] = $option->getName();
-        }
-    }
-
-    /**
-     * Returns an InputOption by name.
-     *
-     * @return InputOption A InputOption object
-     *
-     * @throws InvalidArgumentException When option given doesn't exist
-     */
-    public function getOption(string $name)
-    {
-        if (!$this->hasOption($name)) {
-            throw new InvalidArgumentException(sprintf('The "--%s" option does not exist.', $name));
-        }
-
-        return $this->options[$name];
-    }
-
-    /**
-     * Returns true if an InputOption object exists by name.
-     *
-     * This method can't be used to check if the user included the option when
-     * executing the command (use getOption() instead).
-     *
-     * @return bool true if the InputOption object exists, false otherwise
-     */
-    public function hasOption(string $name)
-    {
-        return isset($this->options[$name]);
-    }
-
-    /**
-     * Gets the array of InputOption objects.
-     *
-     * @return InputOption[] An array of InputOption objects
-     */
-    public function getOptions()
-    {
-        return $this->options;
-    }
-
-    /**
-     * Returns true if an InputOption object exists by shortcut.
-     *
-     * @return bool true if the InputOption object exists, false otherwise
-     */
-    public function hasShortcut(string $name)
-    {
-        return isset($this->shortcuts[$name]);
-    }
-
-    /**
-     * Returns true if an InputOption object exists by negated name.
-     */
-    public function hasNegation(string $name): bool
-    {
-        return isset($this->negations[$name]);
-    }
-
-    /**
-     * Gets an InputOption by shortcut.
-     *
-     * @return InputOption An InputOption object
-     */
-    public function getOptionForShortcut(string $shortcut)
-    {
-        return $this->getOption($this->shortcutToName($shortcut));
-    }
-
-    /**
-     * @return array<string|bool|int|float|array|null>
-     */
-    public function getOptionDefaults()
-    {
-        $values = [];
-        foreach ($this->options as $option) {
-            $values[$option->getName()] = $option->getDefault();
-        }
-
-        return $values;
-    }
-
-    /**
-     * Returns the InputOption name given a shortcut.
-     *
-     * @throws InvalidArgumentException When option given does not exist
-     *
-     * @internal
-     */
-    public function shortcutToName(string $shortcut): string
-    {
-        if (!isset($this->shortcuts[$shortcut])) {
-            throw new InvalidArgumentException(sprintf('The "-%s" option does not exist.', $shortcut));
-        }
-
-        return $this->shortcuts[$shortcut];
-    }
-
-    /**
-     * Returns the InputOption name given a negation.
-     *
-     * @throws InvalidArgumentException When option given does not exist
-     *
-     * @internal
-     */
-    public function negationToName(string $negation): string
-    {
-        if (!isset($this->negations[$negation])) {
-            throw new InvalidArgumentException(sprintf('The "--%s" option does not exist.', $negation));
-        }
-
-        return $this->negations[$negation];
-    }
-
-    /**
-     * Gets the synopsis.
-     *
-     * @return string The synopsis
-     */
-    public function getSynopsis(bool $short = false)
-    {
-        $elements = [];
-
-        if ($short && $this->getOptions()) {
-            $elements[] = '[options]';
-        } elseif (!$short) {
-            foreach ($this->getOptions() as $option) {
-                $value = '';
-                if ($option->acceptValue()) {
-                    $value = sprintf(
-                        ' %s%s%s',
-                        $option->isValueOptional() ? '[' : '',
-                        strtoupper($option->getName()),
-                        $option->isValueOptional() ? ']' : ''
-                    );
-                }
-
-                $shortcut = $option->getShortcut() ? sprintf('-%s|', $option->getShortcut()) : '';
-                $negation = $option->isNegatable() ? sprintf('|--no-%s', $option->getName()) : '';
-                $elements[] = sprintf('[%s--%s%s%s]', $shortcut, $option->getName(), $value, $negation);
-            }
-        }
-
-        if (\count($elements) && $this->getArguments()) {
-            $elements[] = '[--]';
-        }
-
-        $tail = '';
-        foreach ($this->getArguments() as $argument) {
-            $element = '<'.$argument->getName().'>';
-            if ($argument->isArray()) {
-                $element .= '...';
-            }
-
-            if (!$argument->isRequired()) {
-                $element = '['.$element;
-                $tail .= ']';
-            }
-
-            $elements[] = $element;
-        }
-
-        return implode(' ', $elements).$tail;
-    }
+	private $arguments;
+	private $requiredCount;
+	private $lastArrayArgument;
+	private $lastOptionalArgument;
+	private $options;
+	private $negations;
+	private $shortcuts;
+
+	/**
+	 * @param array $definition An array of InputArgument and InputOption instance
+	 */
+	public function __construct(array $definition = [])
+	{
+		$this->setDefinition($definition);
+	}
+
+	/**
+	 * Sets the definition of the input.
+	 */
+	public function setDefinition(array $definition)
+	{
+		$arguments = [];
+		$options = [];
+		foreach ($definition as $item) {
+			if ($item instanceof InputOption) {
+				$options[] = $item;
+			} else {
+				$arguments[] = $item;
+			}
+		}
+
+		$this->setArguments($arguments);
+		$this->setOptions($options);
+	}
+
+	/**
+	 * Sets the InputArgument objects.
+	 *
+	 * @param InputArgument[] $arguments An array of InputArgument objects
+	 */
+	public function setArguments(array $arguments = [])
+	{
+		$this->arguments = [];
+		$this->requiredCount = 0;
+		$this->lastOptionalArgument = null;
+		$this->lastArrayArgument = null;
+		$this->addArguments($arguments);
+	}
+
+	/**
+	 * Adds an array of InputArgument objects.
+	 *
+	 * @param InputArgument[] $arguments An array of InputArgument objects
+	 */
+	public function addArguments(?array $arguments = [])
+	{
+		if (null !== $arguments) {
+			foreach ($arguments as $argument) {
+				$this->addArgument($argument);
+			}
+		}
+	}
+
+	/**
+	 * @throws LogicException When incorrect argument is given
+	 */
+	public function addArgument(InputArgument $argument)
+	{
+		if (isset($this->arguments[$argument->getName()])) {
+			throw new LogicException(sprintf('An argument with name "%s" already exists.', $argument->getName()));
+		}
+
+		if (null !== $this->lastArrayArgument) {
+			throw new LogicException(sprintf('Cannot add a required argument "%s" after an array argument "%s".', $argument->getName(), $this->lastArrayArgument->getName()));
+		}
+
+		if ($argument->isRequired() && null !== $this->lastOptionalArgument) {
+			throw new LogicException(sprintf('Cannot add a required argument "%s" after an optional one "%s".', $argument->getName(), $this->lastOptionalArgument->getName()));
+		}
+
+		if ($argument->isArray()) {
+			$this->lastArrayArgument = $argument;
+		}
+
+		if ($argument->isRequired()) {
+			++$this->requiredCount;
+		} else {
+			$this->lastOptionalArgument = $argument;
+		}
+
+		$this->arguments[$argument->getName()] = $argument;
+	}
+
+	/**
+	 * Returns an InputArgument by name or by position.
+	 *
+	 * @param string|int $name The InputArgument name or position
+	 *
+	 * @return InputArgument An InputArgument object
+	 *
+	 * @throws InvalidArgumentException When argument given doesn't exist
+	 */
+	public function getArgument($name)
+	{
+		if (!$this->hasArgument($name)) {
+			throw new InvalidArgumentException(sprintf('The "%s" argument does not exist.', $name));
+		}
+
+		$arguments = \is_int($name) ? array_values($this->arguments) : $this->arguments;
+
+		return $arguments[$name];
+	}
+
+	/**
+	 * Returns true if an InputArgument object exists by name or position.
+	 *
+	 * @param string|int $name The InputArgument name or position
+	 *
+	 * @return bool true if the InputArgument object exists, false otherwise
+	 */
+	public function hasArgument($name)
+	{
+		$arguments = \is_int($name) ? array_values($this->arguments) : $this->arguments;
+
+		return isset($arguments[$name]);
+	}
+
+	/**
+	 * Gets the array of InputArgument objects.
+	 *
+	 * @return InputArgument[] An array of InputArgument objects
+	 */
+	public function getArguments()
+	{
+		return $this->arguments;
+	}
+
+	/**
+	 * Returns the number of InputArguments.
+	 *
+	 * @return int The number of InputArguments
+	 */
+	public function getArgumentCount()
+	{
+		return null !== $this->lastArrayArgument ? \PHP_INT_MAX : \count($this->arguments);
+	}
+
+	/**
+	 * Returns the number of required InputArguments.
+	 *
+	 * @return int The number of required InputArguments
+	 */
+	public function getArgumentRequiredCount()
+	{
+		return $this->requiredCount;
+	}
+
+	/**
+	 * @return array<string|bool|int|float|array|null>
+	 */
+	public function getArgumentDefaults()
+	{
+		$values = [];
+		foreach ($this->arguments as $argument) {
+			$values[$argument->getName()] = $argument->getDefault();
+		}
+
+		return $values;
+	}
+
+	/**
+	 * Sets the InputOption objects.
+	 *
+	 * @param InputOption[] $options An array of InputOption objects
+	 */
+	public function setOptions(array $options = [])
+	{
+		$this->options = [];
+		$this->shortcuts = [];
+		$this->negations = [];
+		$this->addOptions($options);
+	}
+
+	/**
+	 * Adds an array of InputOption objects.
+	 *
+	 * @param InputOption[] $options An array of InputOption objects
+	 */
+	public function addOptions(array $options = [])
+	{
+		foreach ($options as $option) {
+			$this->addOption($option);
+		}
+	}
+
+	/**
+	 * @throws LogicException When option given already exist
+	 */
+	public function addOption(InputOption $option)
+	{
+		if (isset($this->options[$option->getName()]) && !$option->equals($this->options[$option->getName()])) {
+			throw new LogicException(sprintf('An option named "%s" already exists.', $option->getName()));
+		}
+		if (isset($this->negations[$option->getName()])) {
+			throw new LogicException(sprintf('An option named "%s" already exists.', $option->getName()));
+		}
+
+		if ($option->getShortcut()) {
+			foreach (explode('|', $option->getShortcut()) as $shortcut) {
+				if (isset($this->shortcuts[$shortcut]) && !$option->equals($this->options[$this->shortcuts[$shortcut]])) {
+					throw new LogicException(sprintf('An option with shortcut "%s" already exists.', $shortcut));
+				}
+			}
+		}
+
+		$this->options[$option->getName()] = $option;
+		if ($option->getShortcut()) {
+			foreach (explode('|', $option->getShortcut()) as $shortcut) {
+				$this->shortcuts[$shortcut] = $option->getName();
+			}
+		}
+
+		if ($option->isNegatable()) {
+			$negatedName = 'no-'.$option->getName();
+			if (isset($this->options[$negatedName])) {
+				throw new LogicException(sprintf('An option named "%s" already exists.', $negatedName));
+			}
+			$this->negations[$negatedName] = $option->getName();
+		}
+	}
+
+	/**
+	 * Returns an InputOption by name.
+	 *
+	 * @return InputOption A InputOption object
+	 *
+	 * @throws InvalidArgumentException When option given doesn't exist
+	 */
+	public function getOption(string $name)
+	{
+		if (!$this->hasOption($name)) {
+			throw new InvalidArgumentException(sprintf('The "--%s" option does not exist.', $name));
+		}
+
+		return $this->options[$name];
+	}
+
+	/**
+	 * Returns true if an InputOption object exists by name.
+	 *
+	 * This method can't be used to check if the user included the option when
+	 * executing the command (use getOption() instead).
+	 *
+	 * @return bool true if the InputOption object exists, false otherwise
+	 */
+	public function hasOption(string $name)
+	{
+		return isset($this->options[$name]);
+	}
+
+	/**
+	 * Gets the array of InputOption objects.
+	 *
+	 * @return InputOption[] An array of InputOption objects
+	 */
+	public function getOptions()
+	{
+		return $this->options;
+	}
+
+	/**
+	 * Returns true if an InputOption object exists by shortcut.
+	 *
+	 * @return bool true if the InputOption object exists, false otherwise
+	 */
+	public function hasShortcut(string $name)
+	{
+		return isset($this->shortcuts[$name]);
+	}
+
+	/**
+	 * Returns true if an InputOption object exists by negated name.
+	 */
+	public function hasNegation(string $name): bool
+	{
+		return isset($this->negations[$name]);
+	}
+
+	/**
+	 * Gets an InputOption by shortcut.
+	 *
+	 * @return InputOption An InputOption object
+	 */
+	public function getOptionForShortcut(string $shortcut)
+	{
+		return $this->getOption($this->shortcutToName($shortcut));
+	}
+
+	/**
+	 * @return array<string|bool|int|float|array|null>
+	 */
+	public function getOptionDefaults()
+	{
+		$values = [];
+		foreach ($this->options as $option) {
+			$values[$option->getName()] = $option->getDefault();
+		}
+
+		return $values;
+	}
+
+	/**
+	 * Returns the InputOption name given a shortcut.
+	 *
+	 * @throws InvalidArgumentException When option given does not exist
+	 *
+	 * @internal
+	 */
+	public function shortcutToName(string $shortcut): string
+	{
+		if (!isset($this->shortcuts[$shortcut])) {
+			throw new InvalidArgumentException(sprintf('The "-%s" option does not exist.', $shortcut));
+		}
+
+		return $this->shortcuts[$shortcut];
+	}
+
+	/**
+	 * Returns the InputOption name given a negation.
+	 *
+	 * @throws InvalidArgumentException When option given does not exist
+	 *
+	 * @internal
+	 */
+	public function negationToName(string $negation): string
+	{
+		if (!isset($this->negations[$negation])) {
+			throw new InvalidArgumentException(sprintf('The "--%s" option does not exist.', $negation));
+		}
+
+		return $this->negations[$negation];
+	}
+
+	/**
+	 * Gets the synopsis.
+	 *
+	 * @return string The synopsis
+	 */
+	public function getSynopsis(bool $short = false)
+	{
+		$elements = [];
+
+		if ($short && $this->getOptions()) {
+			$elements[] = '[options]';
+		} elseif (!$short) {
+			foreach ($this->getOptions() as $option) {
+				$value = '';
+				if ($option->acceptValue()) {
+					$value = sprintf(
+						' %s%s%s',
+						$option->isValueOptional() ? '[' : '',
+						strtoupper($option->getName()),
+						$option->isValueOptional() ? ']' : ''
+					);
+				}
+
+				$shortcut = $option->getShortcut() ? sprintf('-%s|', $option->getShortcut()) : '';
+				$negation = $option->isNegatable() ? sprintf('|--no-%s', $option->getName()) : '';
+				$elements[] = sprintf('[%s--%s%s%s]', $shortcut, $option->getName(), $value, $negation);
+			}
+		}
+
+		if (\count($elements) && $this->getArguments()) {
+			$elements[] = '[--]';
+		}
+
+		$tail = '';
+		foreach ($this->getArguments() as $argument) {
+			$element = '<'.$argument->getName().'>';
+			if ($argument->isArray()) {
+				$element .= '...';
+			}
+
+			if (!$argument->isRequired()) {
+				$element = '['.$element;
+				$tail .= ']';
+			}
+
+			$elements[] = $element;
+		}
+
+		return implode(' ', $elements).$tail;
+	}
 }

vendor/symfony/console/Input/InputAwareInterface.php

Indentation +4 added lines, -4 removed lines

@@ -19,8 +19,8 @@
  */
 interface InputAwareInterface
 {
-    /**
-     * Sets the Console Input.
-     */
-    public function setInput(InputInterface $input);
+	/**
+	 * Sets the Console Input.
+	 */
+	public function setInput(InputInterface $input);
 }

vendor/symfony/console/Input/Input.php

Indentation +183 added lines, -183 removed lines

@@ -27,187 +27,187 @@
  */
 abstract class Input implements InputInterface, StreamableInputInterface
 {
-    protected $definition;
-    protected $stream;
-    protected $options = [];
-    protected $arguments = [];
-    protected $interactive = true;
-
-    public function __construct(InputDefinition $definition = null)
-    {
-        if (null === $definition) {
-            $this->definition = new InputDefinition();
-        } else {
-            $this->bind($definition);
-            $this->validate();
-        }
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function bind(InputDefinition $definition)
-    {
-        $this->arguments = [];
-        $this->options = [];
-        $this->definition = $definition;
-
-        $this->parse();
-    }
-
-    /**
-     * Processes command line arguments.
-     */
-    abstract protected function parse();
-
-    /**
-     * {@inheritdoc}
-     */
-    public function validate()
-    {
-        $definition = $this->definition;
-        $givenArguments = $this->arguments;
-
-        $missingArguments = array_filter(array_keys($definition->getArguments()), function ($argument) use ($definition, $givenArguments) {
-            return !\array_key_exists($argument, $givenArguments) && $definition->getArgument($argument)->isRequired();
-        });
-
-        if (\count($missingArguments) > 0) {
-            throw new RuntimeException(sprintf('Not enough arguments (missing: "%s").', implode(', ', $missingArguments)));
-        }
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function isInteractive()
-    {
-        return $this->interactive;
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function setInteractive(bool $interactive)
-    {
-        $this->interactive = $interactive;
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function getArguments()
-    {
-        return array_merge($this->definition->getArgumentDefaults(), $this->arguments);
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function getArgument(string $name)
-    {
-        if (!$this->definition->hasArgument($name)) {
-            throw new InvalidArgumentException(sprintf('The "%s" argument does not exist.', $name));
-        }
-
-        return $this->arguments[$name] ?? $this->definition->getArgument($name)->getDefault();
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function setArgument(string $name, $value)
-    {
-        if (!$this->definition->hasArgument($name)) {
-            throw new InvalidArgumentException(sprintf('The "%s" argument does not exist.', $name));
-        }
-
-        $this->arguments[$name] = $value;
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function hasArgument(string $name)
-    {
-        return $this->definition->hasArgument($name);
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function getOptions()
-    {
-        return array_merge($this->definition->getOptionDefaults(), $this->options);
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function getOption(string $name)
-    {
-        if ($this->definition->hasNegation($name)) {
-            if (null === $value = $this->getOption($this->definition->negationToName($name))) {
-                return $value;
-            }
-
-            return !$value;
-        }
-
-        if (!$this->definition->hasOption($name)) {
-            throw new InvalidArgumentException(sprintf('The "%s" option does not exist.', $name));
-        }
-
-        return \array_key_exists($name, $this->options) ? $this->options[$name] : $this->definition->getOption($name)->getDefault();
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function setOption(string $name, $value)
-    {
-        if ($this->definition->hasNegation($name)) {
-            $this->options[$this->definition->negationToName($name)] = !$value;
-
-            return;
-        } elseif (!$this->definition->hasOption($name)) {
-            throw new InvalidArgumentException(sprintf('The "%s" option does not exist.', $name));
-        }
-
-        $this->options[$name] = $value;
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function hasOption(string $name)
-    {
-        return $this->definition->hasOption($name) || $this->definition->hasNegation($name);
-    }
-
-    /**
-     * Escapes a token through escapeshellarg if it contains unsafe chars.
-     *
-     * @return string
-     */
-    public function escapeToken(string $token)
-    {
-        return preg_match('{^[\w-]+$}', $token) ? $token : escapeshellarg($token);
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function setStream($stream)
-    {
-        $this->stream = $stream;
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function getStream()
-    {
-        return $this->stream;
-    }
+	protected $definition;
+	protected $stream;
+	protected $options = [];
+	protected $arguments = [];
+	protected $interactive = true;
+
+	public function __construct(InputDefinition $definition = null)
+	{
+		if (null === $definition) {
+			$this->definition = new InputDefinition();
+		} else {
+			$this->bind($definition);
+			$this->validate();
+		}
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function bind(InputDefinition $definition)
+	{
+		$this->arguments = [];
+		$this->options = [];
+		$this->definition = $definition;
+
+		$this->parse();
+	}
+
+	/**
+	 * Processes command line arguments.
+	 */
+	abstract protected function parse();
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function validate()
+	{
+		$definition = $this->definition;
+		$givenArguments = $this->arguments;
+
+		$missingArguments = array_filter(array_keys($definition->getArguments()), function ($argument) use ($definition, $givenArguments) {
+			return !\array_key_exists($argument, $givenArguments) && $definition->getArgument($argument)->isRequired();
+		});
+
+		if (\count($missingArguments) > 0) {
+			throw new RuntimeException(sprintf('Not enough arguments (missing: "%s").', implode(', ', $missingArguments)));
+		}
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function isInteractive()
+	{
+		return $this->interactive;
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function setInteractive(bool $interactive)
+	{
+		$this->interactive = $interactive;
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function getArguments()
+	{
+		return array_merge($this->definition->getArgumentDefaults(), $this->arguments);
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function getArgument(string $name)
+	{
+		if (!$this->definition->hasArgument($name)) {
+			throw new InvalidArgumentException(sprintf('The "%s" argument does not exist.', $name));
+		}
+
+		return $this->arguments[$name] ?? $this->definition->getArgument($name)->getDefault();
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function setArgument(string $name, $value)
+	{
+		if (!$this->definition->hasArgument($name)) {
+			throw new InvalidArgumentException(sprintf('The "%s" argument does not exist.', $name));
+		}
+
+		$this->arguments[$name] = $value;
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function hasArgument(string $name)
+	{
+		return $this->definition->hasArgument($name);
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function getOptions()
+	{
+		return array_merge($this->definition->getOptionDefaults(), $this->options);
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function getOption(string $name)
+	{
+		if ($this->definition->hasNegation($name)) {
+			if (null === $value = $this->getOption($this->definition->negationToName($name))) {
+				return $value;
+			}
+
+			return !$value;
+		}
+
+		if (!$this->definition->hasOption($name)) {
+			throw new InvalidArgumentException(sprintf('The "%s" option does not exist.', $name));
+		}
+
+		return \array_key_exists($name, $this->options) ? $this->options[$name] : $this->definition->getOption($name)->getDefault();
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function setOption(string $name, $value)
+	{
+		if ($this->definition->hasNegation($name)) {
+			$this->options[$this->definition->negationToName($name)] = !$value;
+
+			return;
+		} elseif (!$this->definition->hasOption($name)) {
+			throw new InvalidArgumentException(sprintf('The "%s" option does not exist.', $name));
+		}
+
+		$this->options[$name] = $value;
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function hasOption(string $name)
+	{
+		return $this->definition->hasOption($name) || $this->definition->hasNegation($name);
+	}
+
+	/**
+	 * Escapes a token through escapeshellarg if it contains unsafe chars.
+	 *
+	 * @return string
+	 */
+	public function escapeToken(string $token)
+	{
+		return preg_match('{^[\w-]+$}', $token) ? $token : escapeshellarg($token);
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function setStream($stream)
+	{
+		$this->stream = $stream;
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function getStream()
+	{
+		return $this->stream;
+	}
 }

vendor/symfony/console/Input/ArrayInput.php

Indentation +182 added lines, -182 removed lines

@@ -25,186 +25,186 @@
  */
 class ArrayInput extends Input
 {
-    private $parameters;
-
-    public function __construct(array $parameters, InputDefinition $definition = null)
-    {
-        $this->parameters = $parameters;
-
-        parent::__construct($definition);
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function getFirstArgument()
-    {
-        foreach ($this->parameters as $param => $value) {
-            if ($param && \is_string($param) && '-' === $param[0]) {
-                continue;
-            }
-
-            return $value;
-        }
-
-        return null;
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function hasParameterOption($values, bool $onlyParams = false)
-    {
-        $values = (array) $values;
-
-        foreach ($this->parameters as $k => $v) {
-            if (!\is_int($k)) {
-                $v = $k;
-            }
-
-            if ($onlyParams && '--' === $v) {
-                return false;
-            }
-
-            if (\in_array($v, $values)) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function getParameterOption($values, $default = false, bool $onlyParams = false)
-    {
-        $values = (array) $values;
-
-        foreach ($this->parameters as $k => $v) {
-            if ($onlyParams && ('--' === $k || (\is_int($k) && '--' === $v))) {
-                return $default;
-            }
-
-            if (\is_int($k)) {
-                if (\in_array($v, $values)) {
-                    return true;
-                }
-            } elseif (\in_array($k, $values)) {
-                return $v;
-            }
-        }
-
-        return $default;
-    }
-
-    /**
-     * Returns a stringified representation of the args passed to the command.
-     *
-     * @return string
-     */
-    public function __toString()
-    {
-        $params = [];
-        foreach ($this->parameters as $param => $val) {
-            if ($param && \is_string($param) && '-' === $param[0]) {
-                $glue = ('-' === $param[1]) ? '=' : ' ';
-                if (\is_array($val)) {
-                    foreach ($val as $v) {
-                        $params[] = $param.('' != $v ? $glue.$this->escapeToken($v) : '');
-                    }
-                } else {
-                    $params[] = $param.('' != $val ? $glue.$this->escapeToken($val) : '');
-                }
-            } else {
-                $params[] = \is_array($val) ? implode(' ', array_map([$this, 'escapeToken'], $val)) : $this->escapeToken($val);
-            }
-        }
-
-        return implode(' ', $params);
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    protected function parse()
-    {
-        foreach ($this->parameters as $key => $value) {
-            if ('--' === $key) {
-                return;
-            }
-            if (str_starts_with($key, '--')) {
-                $this->addLongOption(substr($key, 2), $value);
-            } elseif (str_starts_with($key, '-')) {
-                $this->addShortOption(substr($key, 1), $value);
-            } else {
-                $this->addArgument($key, $value);
-            }
-        }
-    }
-
-    /**
-     * Adds a short option value.
-     *
-     * @throws InvalidOptionException When option given doesn't exist
-     */
-    private function addShortOption(string $shortcut, $value)
-    {
-        if (!$this->definition->hasShortcut($shortcut)) {
-            throw new InvalidOptionException(sprintf('The "-%s" option does not exist.', $shortcut));
-        }
-
-        $this->addLongOption($this->definition->getOptionForShortcut($shortcut)->getName(), $value);
-    }
-
-    /**
-     * Adds a long option value.
-     *
-     * @throws InvalidOptionException When option given doesn't exist
-     * @throws InvalidOptionException When a required value is missing
-     */
-    private function addLongOption(string $name, $value)
-    {
-        if (!$this->definition->hasOption($name)) {
-            if (!$this->definition->hasNegation($name)) {
-                throw new InvalidOptionException(sprintf('The "--%s" option does not exist.', $name));
-            }
-
-            $optionName = $this->definition->negationToName($name);
-            $this->options[$optionName] = false;
-
-            return;
-        }
-
-        $option = $this->definition->getOption($name);
-
-        if (null === $value) {
-            if ($option->isValueRequired()) {
-                throw new InvalidOptionException(sprintf('The "--%s" option requires a value.', $name));
-            }
-
-            if (!$option->isValueOptional()) {
-                $value = true;
-            }
-        }
-
-        $this->options[$name] = $value;
-    }
-
-    /**
-     * Adds an argument value.
-     *
-     * @param string|int $name  The argument name
-     * @param mixed      $value The value for the argument
-     *
-     * @throws InvalidArgumentException When argument given doesn't exist
-     */
-    private function addArgument($name, $value)
-    {
-        if (!$this->definition->hasArgument($name)) {
-            throw new InvalidArgumentException(sprintf('The "%s" argument does not exist.', $name));
-        }
-
-        $this->arguments[$name] = $value;
-    }
+	private $parameters;
+
+	public function __construct(array $parameters, InputDefinition $definition = null)
+	{
+		$this->parameters = $parameters;
+
+		parent::__construct($definition);
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function getFirstArgument()
+	{
+		foreach ($this->parameters as $param => $value) {
+			if ($param && \is_string($param) && '-' === $param[0]) {
+				continue;
+			}
+
+			return $value;
+		}
+
+		return null;
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function hasParameterOption($values, bool $onlyParams = false)
+	{
+		$values = (array) $values;
+
+		foreach ($this->parameters as $k => $v) {
+			if (!\is_int($k)) {
+				$v = $k;
+			}
+
+			if ($onlyParams && '--' === $v) {
+				return false;
+			}
+
+			if (\in_array($v, $values)) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function getParameterOption($values, $default = false, bool $onlyParams = false)
+	{
+		$values = (array) $values;
+
+		foreach ($this->parameters as $k => $v) {
+			if ($onlyParams && ('--' === $k || (\is_int($k) && '--' === $v))) {
+				return $default;
+			}
+
+			if (\is_int($k)) {
+				if (\in_array($v, $values)) {
+					return true;
+				}
+			} elseif (\in_array($k, $values)) {
+				return $v;
+			}
+		}
+
+		return $default;
+	}
+
+	/**
+	 * Returns a stringified representation of the args passed to the command.
+	 *
+	 * @return string
+	 */
+	public function __toString()
+	{
+		$params = [];
+		foreach ($this->parameters as $param => $val) {
+			if ($param && \is_string($param) && '-' === $param[0]) {
+				$glue = ('-' === $param[1]) ? '=' : ' ';
+				if (\is_array($val)) {
+					foreach ($val as $v) {
+						$params[] = $param.('' != $v ? $glue.$this->escapeToken($v) : '');
+					}
+				} else {
+					$params[] = $param.('' != $val ? $glue.$this->escapeToken($val) : '');
+				}
+			} else {
+				$params[] = \is_array($val) ? implode(' ', array_map([$this, 'escapeToken'], $val)) : $this->escapeToken($val);
+			}
+		}
+
+		return implode(' ', $params);
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	protected function parse()
+	{
+		foreach ($this->parameters as $key => $value) {
+			if ('--' === $key) {
+				return;
+			}
+			if (str_starts_with($key, '--')) {
+				$this->addLongOption(substr($key, 2), $value);
+			} elseif (str_starts_with($key, '-')) {
+				$this->addShortOption(substr($key, 1), $value);
+			} else {
+				$this->addArgument($key, $value);
+			}
+		}
+	}
+
+	/**
+	 * Adds a short option value.
+	 *
+	 * @throws InvalidOptionException When option given doesn't exist
+	 */
+	private function addShortOption(string $shortcut, $value)
+	{
+		if (!$this->definition->hasShortcut($shortcut)) {
+			throw new InvalidOptionException(sprintf('The "-%s" option does not exist.', $shortcut));
+		}
+
+		$this->addLongOption($this->definition->getOptionForShortcut($shortcut)->getName(), $value);
+	}
+
+	/**
+	 * Adds a long option value.
+	 *
+	 * @throws InvalidOptionException When option given doesn't exist
+	 * @throws InvalidOptionException When a required value is missing
+	 */
+	private function addLongOption(string $name, $value)
+	{
+		if (!$this->definition->hasOption($name)) {
+			if (!$this->definition->hasNegation($name)) {
+				throw new InvalidOptionException(sprintf('The "--%s" option does not exist.', $name));
+			}
+
+			$optionName = $this->definition->negationToName($name);
+			$this->options[$optionName] = false;
+
+			return;
+		}
+
+		$option = $this->definition->getOption($name);
+
+		if (null === $value) {
+			if ($option->isValueRequired()) {
+				throw new InvalidOptionException(sprintf('The "--%s" option requires a value.', $name));
+			}
+
+			if (!$option->isValueOptional()) {
+				$value = true;
+			}
+		}
+
+		$this->options[$name] = $value;
+	}
+
+	/**
+	 * Adds an argument value.
+	 *
+	 * @param string|int $name  The argument name
+	 * @param mixed      $value The value for the argument
+	 *
+	 * @throws InvalidArgumentException When argument given doesn't exist
+	 */
+	private function addArgument($name, $value)
+	{
+		if (!$this->definition->hasArgument($name)) {
+			throw new InvalidArgumentException(sprintf('The "%s" argument does not exist.', $name));
+		}
+
+		$this->arguments[$name] = $value;
+	}
 }

vendor/symfony/console/SignalRegistry/SignalRegistry.php

Indentation +39 added lines, -39 removed lines

@@ -13,53 +13,53 @@
 
 final class SignalRegistry
 {
-    private $signalHandlers = [];
+	private $signalHandlers = [];
 
-    public function __construct()
-    {
-        if (\function_exists('pcntl_async_signals')) {
-            pcntl_async_signals(true);
-        }
-    }
+	public function __construct()
+	{
+		if (\function_exists('pcntl_async_signals')) {
+			pcntl_async_signals(true);
+		}
+	}
 
-    public function register(int $signal, callable $signalHandler): void
-    {
-        if (!isset($this->signalHandlers[$signal])) {
-            $previousCallback = pcntl_signal_get_handler($signal);
+	public function register(int $signal, callable $signalHandler): void
+	{
+		if (!isset($this->signalHandlers[$signal])) {
+			$previousCallback = pcntl_signal_get_handler($signal);
 
-            if (\is_callable($previousCallback)) {
-                $this->signalHandlers[$signal][] = $previousCallback;
-            }
-        }
+			if (\is_callable($previousCallback)) {
+				$this->signalHandlers[$signal][] = $previousCallback;
+			}
+		}
 
-        $this->signalHandlers[$signal][] = $signalHandler;
+		$this->signalHandlers[$signal][] = $signalHandler;
 
-        pcntl_signal($signal, [$this, 'handle']);
-    }
+		pcntl_signal($signal, [$this, 'handle']);
+	}
 
-    public static function isSupported(): bool
-    {
-        if (!\function_exists('pcntl_signal')) {
-            return false;
-        }
+	public static function isSupported(): bool
+	{
+		if (!\function_exists('pcntl_signal')) {
+			return false;
+		}
 
-        if (\in_array('pcntl_signal', explode(',', ini_get('disable_functions')))) {
-            return false;
-        }
+		if (\in_array('pcntl_signal', explode(',', ini_get('disable_functions')))) {
+			return false;
+		}
 
-        return true;
-    }
+		return true;
+	}
 
-    /**
-     * @internal
-     */
-    public function handle(int $signal): void
-    {
-        $count = \count($this->signalHandlers[$signal]);
+	/**
+	 * @internal
+	 */
+	public function handle(int $signal): void
+	{
+		$count = \count($this->signalHandlers[$signal]);
 
-        foreach ($this->signalHandlers[$signal] as $i => $signalHandler) {
-            $hasNext = $i !== $count - 1;
-            $signalHandler($signal, $hasNext);
-        }
-    }
+		foreach ($this->signalHandlers[$signal] as $i => $signalHandler) {
+			$hasNext = $i !== $count - 1;
+			$signalHandler($signal, $hasNext);
+		}
+	}
 }

vendor/symfony/console/CommandLoader/FactoryCommandLoader.php

Indentation +39 added lines, -39 removed lines

@@ -20,43 +20,43 @@
  */
 class FactoryCommandLoader implements CommandLoaderInterface
 {
-    private $factories;
-
-    /**
-     * @param callable[] $factories Indexed by command names
-     */
-    public function __construct(array $factories)
-    {
-        $this->factories = $factories;
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function has(string $name)
-    {
-        return isset($this->factories[$name]);
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function get(string $name)
-    {
-        if (!isset($this->factories[$name])) {
-            throw new CommandNotFoundException(sprintf('Command "%s" does not exist.', $name));
-        }
-
-        $factory = $this->factories[$name];
-
-        return $factory();
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function getNames()
-    {
-        return array_keys($this->factories);
-    }
+	private $factories;
+
+	/**
+	 * @param callable[] $factories Indexed by command names
+	 */
+	public function __construct(array $factories)
+	{
+		$this->factories = $factories;
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function has(string $name)
+	{
+		return isset($this->factories[$name]);
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function get(string $name)
+	{
+		if (!isset($this->factories[$name])) {
+			throw new CommandNotFoundException(sprintf('Command "%s" does not exist.', $name));
+		}
+
+		$factory = $this->factories[$name];
+
+		return $factory();
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function getNames()
+	{
+		return array_keys($this->factories);
+	}
 }