vendor/symfony/console/Symfony/Component/Console/Input/Input.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  * Input is the base class for all concrete Input classes.
  16  *
  17  * Three concrete classes are provided by default:
  18  *
  19  *  * `ArgvInput`: The input comes from the CLI arguments (argv)
  20  *  * `StringInput`: The input is provided as a string
  21  *  * `ArrayInput`: The input is provided as an array
  22  *
  23  * @author Fabien Potencier <fabien@symfony.com>
  24  */
  25 abstract class Input implements InputInterface
  26 {
  27     protected $definition;
  28     protected $options;
  29     protected $arguments;
  30     protected $interactive = true;
  31
  32     /**
  33      * Constructor.
  34      *
  35      * @param InputDefinition $definition A InputDefinition instance
  36      */
  37     public function __construct(InputDefinition $definition = null)
  38     {
  39         if (null === $definition) {
  40             $this->definition = new InputDefinition();
  41         } else {
  42             $this->bind($definition);
  43             $this->validate();
  44         }
  45     }
  46
  47     /**
  48      * Binds the current Input instance with the given arguments and options.
  49      *
  50      * @param InputDefinition $definition A InputDefinition instance
  51      */
  52     public function bind(InputDefinition $definition)
  53     {
  54         $this->arguments = array();
  55         $this->options = array();
  56         $this->definition = $definition;
  57
  58         $this->parse();
  59     }
  60
  61     /**
  62      * Processes command line arguments.
  63      */
  64     abstract protected function parse();
  65
  66     /**
  67      * Validates the input.
  68      *
  69      * @throws \RuntimeException When not enough arguments are given
  70      */
  71     public function validate()
  72     {
  73         if (count($this->arguments) < $this->definition->getArgumentRequiredCount()) {
  74             throw new \RuntimeException('Not enough arguments.');
  75         }
  76     }
  77
  78     /**
  79      * Checks if the input is interactive.
  80      *
  81      * @return Boolean Returns true if the input is interactive
  82      */
  83     public function isInteractive()
  84     {
  85         return $this->interactive;
  86     }
  87
  88     /**
  89      * Sets the input interactivity.
  90      *
  91      * @param Boolean $interactive If the input should be interactive
  92      */
  93     public function setInteractive($interactive)
  94     {
  95         $this->interactive = (Boolean) $interactive;
  96     }
  97
  98     /**
  99      * Returns the argument values.
 100      *
 101      * @return array An array of argument values
 102      */
 103     public function getArguments()
 104     {
 105         return array_merge($this->definition->getArgumentDefaults(), $this->arguments);
 106     }
 107
 108     /**
 109      * Returns the argument value for a given argument name.
 110      *
 111      * @param string $name The argument name
 112      *
 113      * @return mixed The argument value
 114      *
 115      * @throws \InvalidArgumentException When argument given doesn't exist
 116      */
 117     public function getArgument($name)
 118     {
 119         if (!$this->definition->hasArgument($name)) {
 120             throw new \InvalidArgumentException(sprintf('The "%s" argument does not exist.', $name));
 121         }
 122
 123         return isset($this->arguments[$name]) ? $this->arguments[$name] : $this->definition->getArgument($name)->getDefault();
 124     }
 125
 126     /**
 127      * Sets an argument value by name.
 128      *
 129      * @param string $name  The argument name
 130      * @param string $value The argument value
 131      *
 132      * @throws \InvalidArgumentException When argument given doesn't exist
 133      */
 134     public function setArgument($name, $value)
 135     {
 136         if (!$this->definition->hasArgument($name)) {
 137             throw new \InvalidArgumentException(sprintf('The "%s" argument does not exist.', $name));
 138         }
 139
 140         $this->arguments[$name] = $value;
 141     }
 142
 143     /**
 144      * Returns true if an InputArgument object exists by name or position.
 145      *
 146      * @param string|integer $name The InputArgument name or position
 147      *
 148      * @return Boolean true if the InputArgument object exists, false otherwise
 149      */
 150     public function hasArgument($name)
 151     {
 152         return $this->definition->hasArgument($name);
 153     }
 154
 155     /**
 156      * Returns the options values.
 157      *
 158      * @return array An array of option values
 159      */
 160     public function getOptions()
 161     {
 162         return array_merge($this->definition->getOptionDefaults(), $this->options);
 163     }
 164
 165     /**
 166      * Returns the option value for a given option name.
 167      *
 168      * @param string $name The option name
 169      *
 170      * @return mixed The option value
 171      *
 172      * @throws \InvalidArgumentException When option given doesn't exist
 173      */
 174     public function getOption($name)
 175     {
 176         if (!$this->definition->hasOption($name)) {
 177             throw new \InvalidArgumentException(sprintf('The "%s" option does not exist.', $name));
 178         }
 179
 180         return isset($this->options[$name]) ? $this->options[$name] : $this->definition->getOption($name)->getDefault();
 181     }
 182
 183     /**
 184      * Sets an option value by name.
 185      *
 186      * @param string $name  The option name
 187      * @param string $value The option value
 188      *
 189      * @throws \InvalidArgumentException When option given doesn't exist
 190      */
 191     public function setOption($name, $value)
 192     {
 193         if (!$this->definition->hasOption($name)) {
 194             throw new \InvalidArgumentException(sprintf('The "%s" option does not exist.', $name));
 195         }
 196
 197         $this->options[$name] = $value;
 198     }
 199
 200     /**
 201      * Returns true if an InputOption object exists by name.
 202      *
 203      * @param string $name The InputOption name
 204      *
 205      * @return Boolean true if the InputOption object exists, false otherwise
 206      */
 207     public function hasOption($name)
 208     {
 209         return $this->definition->hasOption($name);
 210     }
 211 }