upstream / vendor / symfony / console / Input / InputDefinition.php

InputDefinition.php in UpStream: a Project Management Plugin for WordPress trunk, at vendor/symfony/console/Input/InputDefinition.php

405 lines 11.0 KB

Raw Download Zip

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	use Symfony\Component\Console\Exception\InvalidArgumentException;
15	use Symfony\Component\Console\Exception\LogicException;
16
17	/**
18	* A InputDefinition represents a set of valid command line arguments and options.
19	*
20	* Usage:
21	*
22	* $definition = new InputDefinition([
23	* new InputArgument('name', InputArgument::REQUIRED),
24	* new InputOption('foo', 'f', InputOption::VALUE_REQUIRED),
25	* ]);
26	*
27	* @author Fabien Potencier <fabien@symfony.com>
28	*/
29	class InputDefinition
30	{
31	private $arguments;
32	private $requiredCount;
33	private $hasAnArrayArgument = false;
34	private $hasOptional;
35	private $options;
36	private $shortcuts;
37
38	/**
39	* @param array $definition An array of InputArgument and InputOption instance
40	*/
41	public function __construct(array $definition = [])
42	{
43	$this->setDefinition($definition);
44	}
45
46	/**
47	* Sets the definition of the input.
48	*/
49	public function setDefinition(array $definition)
50	{
51	$arguments = [];
52	$options = [];
53	foreach ($definition as $item) {
54	if ($item instanceof InputOption) {
55	$options[] = $item;
56	} else {
57	$arguments[] = $item;
58	}
59	}
60
61	$this->setArguments($arguments);
62	$this->setOptions($options);
63	}
64
65	/**
66	* Sets the InputArgument objects.
67	*
68	* @param InputArgument[] $arguments An array of InputArgument objects
69	*/
70	public function setArguments($arguments = [])
71	{
72	$this->arguments = [];
73	$this->requiredCount = 0;
74	$this->hasOptional = false;
75	$this->hasAnArrayArgument = false;
76	$this->addArguments($arguments);
77	}
78
79	/**
80	* Adds an array of InputArgument objects.
81	*
82	* @param InputArgument[] $arguments An array of InputArgument objects
83	*/
84	public function addArguments($arguments = [])
85	{
86	if (null !== $arguments) {
87	foreach ($arguments as $argument) {
88	$this->addArgument($argument);
89	}
90	}
91	}
92
93	/**
94	* @throws LogicException When incorrect argument is given
95	*/
96	public function addArgument(InputArgument $argument)
97	{
98	if (isset($this->arguments[$argument->getName()])) {
99	throw new LogicException(sprintf('An argument with name "%s" already exists.', $argument->getName()));
100	}
101
102	if ($this->hasAnArrayArgument) {
103	throw new LogicException('Cannot add an argument after an array argument.');
104	}
105
106	if ($argument->isRequired() && $this->hasOptional) {
107	throw new LogicException('Cannot add a required argument after an optional one.');
108	}
109
110	if ($argument->isArray()) {
111	$this->hasAnArrayArgument = true;
112	}
113
114	if ($argument->isRequired()) {
115	++$this->requiredCount;
116	} else {
117	$this->hasOptional = true;
118	}
119
120	$this->arguments[$argument->getName()] = $argument;
121	}
122
123	/**
124	* Returns an InputArgument by name or by position.
125	*
126	* @param string\|int $name The InputArgument name or position
127	*
128	* @return InputArgument An InputArgument object
129	*
130	* @throws InvalidArgumentException When argument given doesn't exist
131	*/
132	public function getArgument($name)
133	{
134	if (!$this->hasArgument($name)) {
135	throw new InvalidArgumentException(sprintf('The "%s" argument does not exist.', $name));
136	}
137
138	$arguments = \is_int($name) ? array_values($this->arguments) : $this->arguments;
139
140	return $arguments[$name];
141	}
142
143	/**
144	* Returns true if an InputArgument object exists by name or position.
145	*
146	* @param string\|int $name The InputArgument name or position
147	*
148	* @return bool true if the InputArgument object exists, false otherwise
149	*/
150	public function hasArgument($name)
151	{
152	$arguments = \is_int($name) ? array_values($this->arguments) : $this->arguments;
153
154	return isset($arguments[$name]);
155	}
156
157	/**
158	* Gets the array of InputArgument objects.
159	*
160	* @return InputArgument[] An array of InputArgument objects
161	*/
162	public function getArguments()
163	{
164	return $this->arguments;
165	}
166
167	/**
168	* Returns the number of InputArguments.
169	*
170	* @return int The number of InputArguments
171	*/
172	public function getArgumentCount()
173	{
174	return $this->hasAnArrayArgument ? \PHP_INT_MAX : \count($this->arguments);
175	}
176
177	/**
178	* Returns the number of required InputArguments.
179	*
180	* @return int The number of required InputArguments
181	*/
182	public function getArgumentRequiredCount()
183	{
184	return $this->requiredCount;
185	}
186
187	/**
188	* Gets the default values.
189	*
190	* @return array An array of default values
191	*/
192	public function getArgumentDefaults()
193	{
194	$values = [];
195	foreach ($this->arguments as $argument) {
196	$values[$argument->getName()] = $argument->getDefault();
197	}
198
199	return $values;
200	}
201
202	/**
203	* Sets the InputOption objects.
204	*
205	* @param InputOption[] $options An array of InputOption objects
206	*/
207	public function setOptions($options = [])
208	{
209	$this->options = [];
210	$this->shortcuts = [];
211	$this->addOptions($options);
212	}
213
214	/**
215	* Adds an array of InputOption objects.
216	*
217	* @param InputOption[] $options An array of InputOption objects
218	*/
219	public function addOptions($options = [])
220	{
221	foreach ($options as $option) {
222	$this->addOption($option);
223	}
224	}
225
226	/**
227	* @throws LogicException When option given already exist
228	*/
229	public function addOption(InputOption $option)
230	{
231	if (isset($this->options[$option->getName()]) && !$option->equals($this->options[$option->getName()])) {
232	throw new LogicException(sprintf('An option named "%s" already exists.', $option->getName()));
233	}
234
235	if ($option->getShortcut()) {
236	foreach (explode('\|', $option->getShortcut()) as $shortcut) {
237	if (isset($this->shortcuts[$shortcut]) && !$option->equals($this->options[$this->shortcuts[$shortcut]])) {
238	throw new LogicException(sprintf('An option with shortcut "%s" already exists.', $shortcut));
239	}
240	}
241	}
242
243	$this->options[$option->getName()] = $option;
244	if ($option->getShortcut()) {
245	foreach (explode('\|', $option->getShortcut()) as $shortcut) {
246	$this->shortcuts[$shortcut] = $option->getName();
247	}
248	}
249	}
250
251	/**
252	* Returns an InputOption by name.
253	*
254	* @param string $name The InputOption name
255	*
256	* @return InputOption A InputOption object
257	*
258	* @throws InvalidArgumentException When option given doesn't exist
259	*/
260	public function getOption($name)
261	{
262	if (!$this->hasOption($name)) {
263	throw new InvalidArgumentException(sprintf('The "--%s" option does not exist.', $name));
264	}
265
266	return $this->options[$name];
267	}
268
269	/**
270	* Returns true if an InputOption object exists by name.
271	*
272	* This method can't be used to check if the user included the option when
273	* executing the command (use getOption() instead).
274	*
275	* @param string $name The InputOption name
276	*
277	* @return bool true if the InputOption object exists, false otherwise
278	*/
279	public function hasOption($name)
280	{
281	return isset($this->options[$name]);
282	}
283
284	/**
285	* Gets the array of InputOption objects.
286	*
287	* @return InputOption[] An array of InputOption objects
288	*/
289	public function getOptions()
290	{
291	return $this->options;
292	}
293
294	/**
295	* Returns true if an InputOption object exists by shortcut.
296	*
297	* @param string $name The InputOption shortcut
298	*
299	* @return bool true if the InputOption object exists, false otherwise
300	*/
301	public function hasShortcut($name)
302	{
303	return isset($this->shortcuts[$name]);
304	}
305
306	/**
307	* Gets an InputOption by shortcut.
308	*
309	* @param string $shortcut The Shortcut name
310	*
311	* @return InputOption An InputOption object
312	*/
313	public function getOptionForShortcut($shortcut)
314	{
315	return $this->getOption($this->shortcutToName($shortcut));
316	}
317
318	/**
319	* Gets an array of default values.
320	*
321	* @return array An array of all default values
322	*/
323	public function getOptionDefaults()
324	{
325	$values = [];
326	foreach ($this->options as $option) {
327	$values[$option->getName()] = $option->getDefault();
328	}
329
330	return $values;
331	}
332
333	/**
334	* Returns the InputOption name given a shortcut.
335	*
336	* @param string $shortcut The shortcut
337	*
338	* @return string The InputOption name
339	*
340	* @throws InvalidArgumentException When option given does not exist
341	*
342	* @internal
343	*/
344	public function shortcutToName($shortcut)
345	{
346	if (!isset($this->shortcuts[$shortcut])) {
347	throw new InvalidArgumentException(sprintf('The "-%s" option does not exist.', $shortcut));
348	}
349
350	return $this->shortcuts[$shortcut];
351	}
352
353	/**
354	* Gets the synopsis.
355	*
356	* @param bool $short Whether to return the short version (with options folded) or not
357	*
358	* @return string The synopsis
359	*/
360	public function getSynopsis($short = false)
361	{
362	$elements = [];
363
364	if ($short && $this->getOptions()) {
365	$elements[] = '[options]';
366	} elseif (!$short) {
367	foreach ($this->getOptions() as $option) {
368	$value = '';
369	if ($option->acceptValue()) {
370	$value = sprintf(
371	' %s%s%s',
372	$option->isValueOptional() ? '[' : '',
373	strtoupper($option->getName()),
374	$option->isValueOptional() ? ']' : ''
375	);
376	}
377
378	$shortcut = $option->getShortcut() ? sprintf('-%s\|', $option->getShortcut()) : '';
379	$elements[] = sprintf('[%s--%s%s]', $shortcut, $option->getName(), $value);
380	}
381	}
382
383	if (\count($elements) && $this->getArguments()) {
384	$elements[] = '[--]';
385	}
386
387	foreach ($this->getArguments() as $argument) {
388	$element = '<'.$argument->getName().'>';
389	if (!$argument->isRequired()) {
390	$element = '['.$element.']';
391	} elseif ($argument->isArray()) {
392	$element .= ' ('.$element.')';
393	}
394
395	if ($argument->isArray()) {
396	$element .= '...';
397	}
398
399	$elements[] = $element;
400	}
401
402	return implode(' ', $elements);
403	}
404	}
405