class InputDefinition in Zircon Profile 8

Same name and namespace in other branches

8.0 vendor/symfony/console/Input/InputDefinition.php \Symfony\Component\Console\Input\InputDefinition

A InputDefinition represents a set of valid command line arguments and options.

Usage:

$definition = new InputDefinition(array( new InputArgument('name', InputArgument::REQUIRED), new InputOption('foo', 'f', InputOption::VALUE_REQUIRED), ));

@author Fabien Potencier <fabien@symfony.com>

Hierarchy

class \Symfony\Component\Console\Input\InputDefinition

Expanded class hierarchy of InputDefinition

17 files declare their use of InputDefinition

AbstractDescriptorTest.php in vendor/symfony/console/Tests/Descriptor/AbstractDescriptorTest.php
Application.php in vendor/symfony/console/Application.php
ApplicationTest.php in vendor/symfony/console/Tests/ApplicationTest.php
ArgvInputTest.php in vendor/symfony/console/Tests/Input/ArgvInputTest.php
ArrayInputTest.php in vendor/symfony/console/Tests/Input/ArrayInputTest.php

... See full list

File

vendor/symfony/console/Input/InputDefinition.php, line 30

Namespace

Symfony\Component\Console\Input

View source

class InputDefinition {
  private $arguments;
  private $requiredCount;
  private $hasAnArrayArgument = false;
  private $hasOptional;
  private $options;
  private $shortcuts;

  /**
   * Constructor.
   *
   * @param array $definition An array of InputArgument and InputOption instance
   */
  public function __construct(array $definition = array()) {
    $this
      ->setDefinition($definition);
  }

  /**
   * Sets the definition of the input.
   *
   * @param array $definition The definition array
   */
  public function setDefinition(array $definition) {
    $arguments = array();
    $options = array();
    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($arguments = array()) {
    $this->arguments = array();
    $this->requiredCount = 0;
    $this->hasOptional = false;
    $this->hasAnArrayArgument = false;
    $this
      ->addArguments($arguments);
  }

  /**
   * Adds an array of InputArgument objects.
   *
   * @param InputArgument[] $arguments An array of InputArgument objects
   */
  public function addArguments($arguments = array()) {
    if (null !== $arguments) {
      foreach ($arguments as $argument) {
        $this
          ->addArgument($argument);
      }
    }
  }

  /**
   * Adds an InputArgument object.
   *
   * @param InputArgument $argument An InputArgument object
   *
   * @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 ($this->hasAnArrayArgument) {
      throw new \LogicException('Cannot add an argument after an array argument.');
    }
    if ($argument
      ->isRequired() && $this->hasOptional) {
      throw new \LogicException('Cannot add a required argument after an optional one.');
    }
    if ($argument
      ->isArray()) {
      $this->hasAnArrayArgument = true;
    }
    if ($argument
      ->isRequired()) {
      ++$this->requiredCount;
    }
    else {
      $this->hasOptional = true;
    }
    $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 $this->hasAnArrayArgument ? 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;
  }

  /**
   * Gets the default values.
   *
   * @return array An array of default values
   */
  public function getArgumentDefaults() {
    $values = array();
    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($options = array()) {
    $this->options = array();
    $this->shortcuts = array();
    $this
      ->addOptions($options);
  }

  /**
   * Adds an array of InputOption objects.
   *
   * @param InputOption[] $options An array of InputOption objects
   */
  public function addOptions($options = array()) {
    foreach ($options as $option) {
      $this
        ->addOption($option);
    }
  }

  /**
   * Adds an InputOption object.
   *
   * @param InputOption $option An InputOption object
   *
   * @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 ($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();
      }
    }
  }

  /**
   * Returns an InputOption by name.
   *
   * @param string $name The InputOption name
   *
   * @return InputOption A InputOption object
   *
   * @throws \InvalidArgumentException When option given doesn't exist
   */
  public function getOption($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.
   *
   * @param string $name The InputOption name
   *
   * @return bool true if the InputOption object exists, false otherwise
   */
  public function hasOption($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.
   *
   * @param string $name The InputOption shortcut
   *
   * @return bool true if the InputOption object exists, false otherwise
   */
  public function hasShortcut($name) {
    return isset($this->shortcuts[$name]);
  }

  /**
   * Gets an InputOption by shortcut.
   *
   * @param string $shortcut the Shortcut name
   *
   * @return InputOption An InputOption object
   */
  public function getOptionForShortcut($shortcut) {
    return $this
      ->getOption($this
      ->shortcutToName($shortcut));
  }

  /**
   * Gets an array of default values.
   *
   * @return array An array of all default values
   */
  public function getOptionDefaults() {
    $values = array();
    foreach ($this->options as $option) {
      $values[$option
        ->getName()] = $option
        ->getDefault();
    }
    return $values;
  }

  /**
   * Returns the InputOption name given a shortcut.
   *
   * @param string $shortcut The shortcut
   *
   * @return string The InputOption name
   *
   * @throws \InvalidArgumentException When option given does not exist
   */
  private function shortcutToName($shortcut) {
    if (!isset($this->shortcuts[$shortcut])) {
      throw new \InvalidArgumentException(sprintf('The "-%s" option does not exist.', $shortcut));
    }
    return $this->shortcuts[$shortcut];
  }

  /**
   * Gets the synopsis.
   *
   * @param bool $short Whether to return the short version (with options folded) or not
   *
   * @return string The synopsis
   */
  public function getSynopsis($short = false) {
    $elements = array();
    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()) : '';
        $elements[] = sprintf('[%s--%s%s]', $shortcut, $option
          ->getName(), $value);
      }
    }
    if (count($elements) && $this
      ->getArguments()) {
      $elements[] = '[--]';
    }
    foreach ($this
      ->getArguments() as $argument) {
      $element = '<' . $argument
        ->getName() . '>';
      if (!$argument
        ->isRequired()) {
        $element = '[' . $element . ']';
      }
      elseif ($argument
        ->isArray()) {
        $element = $element . ' (' . $element . ')';
      }
      if ($argument
        ->isArray()) {
        $element .= '...';
      }
      $elements[] = $element;
    }
    return implode(' ', $elements);
  }

  /**
   * Returns a textual representation of the InputDefinition.
   *
   * @return string A string representing the InputDefinition
   *
   * @deprecated since version 2.3, to be removed in 3.0.
   */
  public function asText() {
    @trigger_error('The ' . __METHOD__ . ' method is deprecated since version 2.3 and will be removed in 3.0.', E_USER_DEPRECATED);
    $descriptor = new TextDescriptor();
    $output = new BufferedOutput(BufferedOutput::VERBOSITY_NORMAL, true);
    $descriptor
      ->describe($output, $this, array(
      'raw_output' => true,
    ));
    return $output
      ->fetch();
  }

  /**
   * Returns an XML representation of the InputDefinition.
   *
   * @param bool $asDom Whether to return a DOM or an XML string
   *
   * @return string|\DOMDocument An XML string representing the InputDefinition
   *
   * @deprecated since version 2.3, to be removed in 3.0.
   */
  public function asXml($asDom = false) {
    @trigger_error('The ' . __METHOD__ . ' method is deprecated since version 2.3 and will be removed in 3.0.', E_USER_DEPRECATED);
    $descriptor = new XmlDescriptor();
    if ($asDom) {
      return $descriptor
        ->getInputDefinitionDocument($this);
    }
    $output = new BufferedOutput();
    $descriptor
      ->describe($output, $this);
    return $output
      ->fetch();
  }

}

Members

Name	Modifiers	Type	Description
InputDefinition::$arguments	private	property
InputDefinition::$hasAnArrayArgument	private	property
InputDefinition::$hasOptional	private	property
InputDefinition::$options	private	property
InputDefinition::$requiredCount	private	property
InputDefinition::$shortcuts	private	property
InputDefinition::addArgument	public	function	Adds an InputArgument object.
InputDefinition::addArguments	public	function	Adds an array of InputArgument objects.
InputDefinition::addOption	public	function	Adds an InputOption object.
InputDefinition::addOptions	public	function	Adds an array of InputOption objects.
InputDefinition::asText Deprecated	public	function	Returns a textual representation of the InputDefinition.
InputDefinition::asXml Deprecated	public	function	Returns an XML representation of the InputDefinition.
InputDefinition::getArgument	public	function	Returns an InputArgument by name or by position.
InputDefinition::getArgumentCount	public	function	Returns the number of InputArguments.
InputDefinition::getArgumentDefaults	public	function	Gets the default values.
InputDefinition::getArgumentRequiredCount	public	function	Returns the number of required InputArguments.
InputDefinition::getArguments	public	function	Gets the array of InputArgument objects.
InputDefinition::getOption	public	function	Returns an InputOption by name.
InputDefinition::getOptionDefaults	public	function	Gets an array of default values.
InputDefinition::getOptionForShortcut	public	function	Gets an InputOption by shortcut.
InputDefinition::getOptions	public	function	Gets the array of InputOption objects.
InputDefinition::getSynopsis	public	function	Gets the synopsis.
InputDefinition::hasArgument	public	function	Returns true if an InputArgument object exists by name or position.
InputDefinition::hasOption	public	function	Returns true if an InputOption object exists by name.
InputDefinition::hasShortcut	public	function	Returns true if an InputOption object exists by shortcut.
InputDefinition::setArguments	public	function	Sets the InputArgument objects.
InputDefinition::setDefinition	public	function	Sets the definition of the input.
InputDefinition::setOptions	public	function	Sets the InputOption objects.
InputDefinition::shortcutToName	private	function	Returns the InputOption name given a shortcut.
InputDefinition::__construct	public	function	Constructor.

You are here

class InputDefinition in Zircon Profile 8

Hierarchy

File

Namespace

Members

API Navigation