ArrayInput.php 5.3 KB

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