vendor/symfony/console/Symfony/Component/Console/Input/ArrayInput.php

   1 <?php
   2
   3 /*
   4  * This file is part of the Symfony package.
   5  *
   6  * (c) Fabien Potencier <fabien@symfony.com>
   7  *
   8  * For the full copyright and license information, please view the LICENSE
   9  * file that was distributed with this source code.
  10  */
  11
  12 namespace Symfony\Component\Console\Input;
  13
  14 /**
  15  * ArrayInput represents an input provided as an array.
  16  *
  17  * Usage:
  18  *
  19  *     $input = new ArrayInput(array('name' => 'foo', '--bar' => 'foobar'));
  20  *
  21  * @author Fabien Potencier <fabien@symfony.com>
  22  *
  23  * @api
  24  */
  25 class ArrayInput extends Input
  26 {
  27     private $parameters;
  28
  29     /**
  30      * Constructor.
  31      *
  32      * @param array           $parameters An array of parameters
  33      * @param InputDefinition $definition A InputDefinition instance
  34      *
  35      * @api
  36      */
  37     public function __construct(array $parameters, InputDefinition $definition = null)
  38     {
  39         $this->parameters = $parameters;
  40
  41         parent::__construct($definition);
  42     }
  43
  44     /**
  45      * Returns the first argument from the raw parameters (not parsed).
  46      *
  47      * @return string The value of the first argument or null otherwise
  48      */
  49     public function getFirstArgument()
  50     {
  51         foreach ($this->parameters as $key => $value) {
  52             if ($key && '-' === $key[0]) {
  53                 continue;
  54             }
  55
  56             return $value;
  57         }
  58     }
  59
  60     /**
  61      * Returns true if the raw parameters (not parsed) contain a value.
  62      *
  63      * This method is to be used to introspect the input parameters
  64      * before they have been validated. It must be used carefully.
  65      *
  66      * @param string|array $values The values to look for in the raw parameters (can be an array)
  67      *
  68      * @return Boolean true if the value is contained in the raw parameters
  69      */
  70     public function hasParameterOption($values)
  71     {
  72         $values = (array) $values;
  73
  74         foreach ($this->parameters as $k => $v) {
  75             if (!is_int($k)) {
  76                 $v = $k;
  77             }
  78
  79             if (in_array($v, $values)) {
  80                 return true;
  81             }
  82         }
  83
  84         return false;
  85     }
  86
  87     /**
  88      * Returns the value of a raw option (not parsed).
  89      *
  90      * This method is to be used to introspect the input parameters
  91      * before they have been validated. It must be used carefully.
  92      *
  93      * @param string|array $values  The value(s) to look for in the raw parameters (can be an array)
  94      * @param mixed        $default The default value to return if no result is found
  95      *
  96      * @return mixed The option value
  97      */
  98     public function getParameterOption($values, $default = false)
  99     {
 100         $values = (array) $values;
 101
 102         foreach ($this->parameters as $k => $v) {
 103             if (is_int($k) && in_array($v, $values)) {
 104                 return true;
 105             } elseif (in_array($k, $values)) {
 106                 return $v;
 107             }
 108         }
 109
 110         return $default;
 111     }
 112
 113     /**
 114      * Processes command line arguments.
 115      */
 116     protected function parse()
 117     {
 118         foreach ($this->parameters as $key => $value) {
 119             if (0 === strpos($key, '--')) {
 120                 $this->addLongOption(substr($key, 2), $value);
 121             } elseif ('-' === $key[0]) {
 122                 $this->addShortOption(substr($key, 1), $value);
 123             } else {
 124                 $this->addArgument($key, $value);
 125             }
 126         }
 127     }
 128
 129     /**
 130      * Adds a short option value.
 131      *
 132      * @param string $shortcut The short option key
 133      * @param mixed  $value    The value for the option
 134      *
 135      * @throws \InvalidArgumentException When option given doesn't exist
 136      */
 137     private function addShortOption($shortcut, $value)
 138     {
 139         if (!$this->definition->hasShortcut($shortcut)) {
 140             throw new \InvalidArgumentException(sprintf('The "-%s" option does not exist.', $shortcut));
 141         }
 142
 143         $this->addLongOption($this->definition->getOptionForShortcut($shortcut)->getName(), $value);
 144     }
 145
 146     /**
 147      * Adds a long option value.
 148      *
 149      * @param string $name  The long option key
 150      * @param mixed  $value The value for the option
 151      *
 152      * @throws \InvalidArgumentException When option given doesn't exist
 153      * @throws \InvalidArgumentException When a required value is missing
 154      */
 155     private function addLongOption($name, $value)
 156     {
 157         if (!$this->definition->hasOption($name)) {
 158             throw new \InvalidArgumentException(sprintf('The "--%s" option does not exist.', $name));
 159         }
 160
 161         $option = $this->definition->getOption($name);
 162
 163         if (null === $value) {
 164             if ($option->isValueRequired()) {
 165                 throw new \InvalidArgumentException(sprintf('The "--%s" option requires a value.', $name));
 166             }
 167
 168             $value = $option->isValueOptional() ? $option->getDefault() : true;
 169         }
 170
 171         $this->options[$name] = $value;
 172     }
 173
 174     /**
 175      * Adds an argument value.
 176      *
 177      * @param string $name  The argument name
 178      * @param mixed  $value The value for the argument
 179      *
 180      * @throws \InvalidArgumentException When argument given doesn't exist
 181      */
 182     private function addArgument($name, $value)
 183     {
 184         if (!$this->definition->hasArgument($name)) {
 185             throw new \InvalidArgumentException(sprintf('The "%s" argument does not exist.', $name));
 186         }
 187
 188         $this->arguments[$name] = $value;
 189     }
 190 }