CompletionHandler::getAllOptions() - Code Metrics - Inspection of "Support completing array arguments multiple times" - stecman/symfony-console-completion - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#66)

by Carson

created 2016-02-24 01:59 UTC

CompletionHandler::getAllOptions() A

↳ Parent: CompletionHandler

Complexity

Conditions	2
Paths	2

Size

Total Lines	11
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes	6
Bugs	0	Features	1

Metric	Value
c	6
b	0
f	1
dl	0
loc	11
rs	9.4285
cc	2
eloc	6
nc	2
nop	0

<?php

namespace Stecman\Component\Symfony\Console\BashCompletion;

use Stecman\Component\Symfony\Console\BashCompletion\Completion\CompletionAwareInterface;
use Stecman\Component\Symfony\Console\BashCompletion\Completion\CompletionInterface;
use Symfony\Component\Console\Application;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\ArrayInput;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputOption;

class CompletionHandler
{
    /**
     * Application to complete for
     * @var \Symfony\Component\Console\Application
     */
    protected $application;

    /**
     * @var Command
     */
    protected $command;

    /**
     * @var CompletionContext
     */
    protected $context;

    /**
     * Array of completion helpers.
     * @var CompletionInterface[]
     */
    protected $helpers = array();

    public function __construct(Application $application, CompletionContext $context = null)
    {
        $this->application = $application;
        $this->context = $context;

        $this->addHandler(
            new Completion(
                'help',
                'command_name',
                Completion::TYPE_ARGUMENT,
                array_keys($application->all())
            )
        );

        $this->addHandler(
            new Completion(
                'list',
                'namespace',
                Completion::TYPE_ARGUMENT,
                $application->getNamespaces()
            )
        );
    }

    public function setContext(CompletionContext $context)
    {
        $this->context = $context;
    }

    /**
     * @return CompletionContext
     */
    public function getContext()
    {
        return $this->context;
    }

    /**
     * @param CompletionInterface[] $array
     */
    public function addHandlers(array $array)
    {
        $this->helpers = array_merge($this->helpers, $array);
    }

    /**
     * @param CompletionInterface $helper
     */
    public function addHandler(CompletionInterface $helper)
    {
        $this->helpers[] = $helper;
    }

    /**
     * Do the actual completion, returning an array of strings to provide to the parent shell's completion system
     *
     * @throws \RuntimeException
     * @return string[]
     */
    public function runCompletion()
    {
        if (!$this->context) {
            throw new \RuntimeException('A CompletionContext must be set before requesting completion.');
        }

        $cmdName = $this->getInput()->getFirstArgument();

        try {
            $this->command = $this->application->find($cmdName);
        } catch (\InvalidArgumentException $e) {
            // Exception thrown, when multiple or none commands are found.
        }

        $process = array(
            'completeForOptionValues',
            'completeForOptionShortcuts',
            'completeForOptionShortcutValues',
            'completeForOptions',
            'completeForCommandName',
            'completeForCommandArguments'
        );

        foreach ($process as $methodName) {
            $result = $this->{$methodName}();

            if (false !== $result) {
                // Return the result of the first completion mode that matches
                return $this->filterResults((array) $result);
            }
        }

        return array();
    }

    /**
     * Get an InputInterface representation of the completion context
     *
     * @return ArrayInput
     */
    public function getInput()
    {
        // Filter the command line content to suit ArrayInput
        $words = $this->context->getWords();
        array_shift($words);
        $words = array_filter($words);

        return new ArrayInput($words);
    }

    /**
     * Attempt to complete the current word as a long-form option (--my-option)
     *
     * @return array|false
     */
    protected function completeForOptions()
    {
        $word = $this->context->getCurrentWord();

        if (strpos($word, '-') === 0) {
            $options = array();

            foreach ($this->getAllOptions() as $opt) {
                $options[] = '--'.$opt->getName();
            }

            return $options;
        }

        return false;
    }

    /**
     * Attempt to complete the current word as an option shortcut.
     *
     * If the shortcut exists it will be completed, but a list of possible shortcuts is never returned for completion.
     *
     * @return array|false
     */
    protected function completeForOptionShortcuts()
    {
        $word = $this->context->getCurrentWord();

        if (strpos($word, '-') === 0 && strlen($word) == 2) {
            $definition = $this->command ? $this->command->getNativeDefinition() : $this->application->getDefinition();

            if ($definition->hasShortcut(substr($word, 1))) {
                return array($word);
            }
        }

        return false;
    }

    /**
     * Attempt to complete the current word as the value of an option shortcut
     *
     * @return array|false
     */
    protected function completeForOptionShortcutValues()
    {
        $wordIndex = $this->context->getWordIndex();

        if ($this->command && $wordIndex > 1) {
            $left = $this->context->getWordAtIndex($wordIndex - 1);

            // Complete short options
            if ($left[0] == '-' && strlen($left) == 2) {
                $shortcut = substr($left, 1);
                $def = $this->command->getNativeDefinition();

                if (!$def->hasShortcut($shortcut)) {
                    return false;
                }

                $opt = $def->getOptionForShortcut($shortcut);
                if ($opt->isValueRequired() || $opt->isValueOptional()) {
                    return $this->completeOption($opt);
                }
            }
        }

        return false;
    }

    /**
     * Attemp to complete the current word as the value of a long-form option
     *
     * @return array|false
     */
    protected function completeForOptionValues()
    {
        $wordIndex = $this->context->getWordIndex();

        if ($this->command && $wordIndex > 1) {
            $left = $this->context->getWordAtIndex($wordIndex - 1);

            if (strpos($left, '--') === 0) {
                $name = substr($left, 2);
                $def = $this->command->getNativeDefinition();

                if (!$def->hasOption($name)) {
                    return false;
                }

                $opt = $def->getOption($name);
                if ($opt->isValueRequired() || $opt->isValueOptional()) {
                    return $this->completeOption($opt);
                }
            }
        }

        return false;
    }

    /**
     * Attempt to complete the current word as a command name
     *
     * @return array|false
     */
    protected function completeForCommandName()
    {
        if (!$this->command || (count($this->context->getWords()) == 2 && $this->context->getWordIndex() == 1)) {
            $commands = $this->application->all();
            $names = array_keys($commands);

            if ($key = array_search('_completion', $names)) {
                unset($names[$key]);
            }

            return $names;
        }

        return false;
    }

    /**
     * Attempt to complete the current word as a command argument value
     *
     * @see Symfony\Component\Console\Input\InputArgument
     * @return array|false
     */
    protected function completeForCommandArguments()
    {
        if (!$this->command || strpos($this->context->getCurrentWord(), '-') === 0) {
            return false;
        }

        $definition = $this->command->getNativeDefinition();
        $argWords = $this->mapArgumentsToWords($definition->getArguments());
        $wordIndex = $this->context->getWordIndex();

        if (isset($argWords[$wordIndex])) {
            $name = $argWords[$wordIndex];
        } elseif (!empty($argWords) && $definition->getArgument(end($argWords))->isArray()) {
            $name = end($argWords);
        } else {
            return false;
        }

        if ($helper = $this->getCompletionHelper($name, Completion::TYPE_ARGUMENT)) {
            return $helper->run();
        }

        if ($this->command instanceof CompletionAwareInterface) {
            return $this->command->completeArgumentValues($name, $this->context);
        }

        return false;
    }

    /**
     * Find a CompletionInterface that matches the current command, target name, and target type
     *
     * @param string $name
     * @param string $type
     * @return CompletionInterface|null
     */
    protected function getCompletionHelper($name, $type)
    {
        foreach ($this->helpers as $helper) {
            if ($helper->getType() != $type && $helper->getType() != CompletionInterface::ALL_TYPES) {
                continue;
            }

            if ($helper->getCommandName() == CompletionInterface::ALL_COMMANDS || $helper->getCommandName() == $this->command->getName()) {
                if ($helper->getTargetName() == $name) {
                    return $helper;
                }
            }
        }

        return null;
    }

    /**
     * Complete the value for the given option if a value completion is availble
     *
     * @param InputOption $option
     * @return array|false
     */
    protected function completeOption(InputOption $option)
    {
        if ($helper = $this->getCompletionHelper($option->getName(), Completion::TYPE_OPTION)) {
            return $helper->run();
        }

        if ($this->command instanceof CompletionAwareInterface) {
            return $this->command->completeOptionValues($option->getName(), $this->context);
        }

        return false;
    }

    /**
     * Step through the command line to determine which word positions represent which argument values
     *
     * The word indexes of argument values are found by eliminating words that are known to not be arguments (options,
     * option values, and command names). Any word that doesn't match for elimination is assumed to be an argument value,
     *
     * @param InputArgument[] $argumentDefinitions
     * @return array as [argument name => word index on command line]
     */
    protected function mapArgumentsToWords($argumentDefinitions)
    {
        $argumentPositions = array();
        $argumentNumber = 0;
        $previousWord = null;
        $argumentNames = array_keys($argumentDefinitions);

        // Build a list of option values to filter out
        $optionsWithArgs = $this->getOptionWordsWithValues();

        foreach ($this->context->getWords() as $wordIndex => $word) {
            // Skip program name, command name, options, and option values
            if ($wordIndex < 2
                || ($word && '-' === $word[0])
                || in_array($previousWord, $optionsWithArgs)) {
                $previousWord = $word;
                continue;
            } else {
                $previousWord = $word;
            }

            // If argument n exists, pair that argument's name with the current word
            if (isset($argumentNames[$argumentNumber])) {
                $argumentPositions[$wordIndex] = $argumentNames[$argumentNumber];
            }

            $argumentNumber++;
        }

        return $argumentPositions;
    }

    /**
     * Build a list of option words/flags that will have a value after them
     * Options are returned in the format they appear as on the command line.
     *
     * @return string[] - eg. ['--myoption', '-m', ... ]
     */
    protected function getOptionWordsWithValues()
    {
        $strings = array();

        foreach ($this->getAllOptions() as $option) {
            if ($option->isValueRequired()) {
                $strings[] = '--' . $option->getName();

                if ($option->getShortcut()) {
                    $strings[] = '-' . $option->getShortcut();
                }
            }
        }

        return $strings;
    }

    /**
     * Filter out results that don't match the current word on the command line
     *
     * @param string[] $array
     * @return string[]
     */
    protected function filterResults(array $array)
    {
        $curWord = $this->context->getCurrentWord();

        return array_filter($array, function($val) use ($curWord) {
            return fnmatch($curWord.'*', $val);
        });
    }

    /**
     * Get the combined options of the application and entered command
     *
     * @return InputOption[]
     */
    protected function getAllOptions()
    {
        if (!$this->command) {
            return $this->application->getDefinition()->getOptions();
        }

        return array_merge(
            $this->command->getNativeDefinition()->getOptions(),
            $this->application->getDefinition()->getOptions()
        );
    }
}


1		<?php
2
3		namespace Stecman\Component\Symfony\Console\BashCompletion;
4
5		use Stecman\Component\Symfony\Console\BashCompletion\Completion\CompletionAwareInterface;
6		use Stecman\Component\Symfony\Console\BashCompletion\Completion\CompletionInterface;
7		use Symfony\Component\Console\Application;
8		use Symfony\Component\Console\Command\Command;
9		use Symfony\Component\Console\Input\ArrayInput;
10		use Symfony\Component\Console\Input\InputArgument;
11		use Symfony\Component\Console\Input\InputOption;
12
13		class CompletionHandler
14		{
15		/**
16		* Application to complete for
17		* @var \Symfony\Component\Console\Application
18		*/
19		protected $application;
20
21		/**
22		* @var Command
23		*/
24		protected $command;
25
26		/**
27		* @var CompletionContext
28		*/
29		protected $context;
30
31		/**
32		* Array of completion helpers.
33		* @var CompletionInterface[]
34		*/
35		protected $helpers = array();
36
37		public function __construct(Application $application, CompletionContext $context = null)
38		{
39		$this->application = $application;
40		$this->context = $context;
41
42		$this->addHandler(
43		new Completion(
44		'help',
45		'command_name',
46		Completion::TYPE_ARGUMENT,
47		array_keys($application->all())
48		)
49		);
50
51		$this->addHandler(
52		new Completion(
53		'list',
54		'namespace',
55		Completion::TYPE_ARGUMENT,
56		$application->getNamespaces()
57		)
58		);
59		}
60
61		public function setContext(CompletionContext $context)
62		{
63		$this->context = $context;
64		}
65
66		/**
67		* @return CompletionContext
68		*/
69		public function getContext()
70		{
71		return $this->context;
72		}
73
74		/**
75		* @param CompletionInterface[] $array
76		*/
77		public function addHandlers(array $array)
78		{
79		$this->helpers = array_merge($this->helpers, $array);
80		}
81
82		/**
83		* @param CompletionInterface $helper
84		*/
85		public function addHandler(CompletionInterface $helper)
86		{
87		$this->helpers[] = $helper;
88		}
89
90		/**
91		* Do the actual completion, returning an array of strings to provide to the parent shell's completion system
92		*
93		* @throws \RuntimeException
94		* @return string[]
95		*/
96		public function runCompletion()
97		{
98		if (!$this->context) {
99		throw new \RuntimeException('A CompletionContext must be set before requesting completion.');
100		}
101
102		$cmdName = $this->getInput()->getFirstArgument();
103
104		try {
105		$this->command = $this->application->find($cmdName);
106		} catch (\InvalidArgumentException $e) {
107		// Exception thrown, when multiple or none commands are found.
108		}
109
110		$process = array(
111		'completeForOptionValues',
112		'completeForOptionShortcuts',
113		'completeForOptionShortcutValues',
114		'completeForOptions',
115		'completeForCommandName',
116		'completeForCommandArguments'
117		);
118
119		foreach ($process as $methodName) {
120		$result = $this->{$methodName}();
121
122		if (false !== $result) {
123		// Return the result of the first completion mode that matches
124		return $this->filterResults((array) $result);
125		}
126		}
127
128		return array();
129		}
130
131		/**
132		* Get an InputInterface representation of the completion context
133		*
134		* @return ArrayInput
135		*/
136		public function getInput()
137		{
138		// Filter the command line content to suit ArrayInput
139		$words = $this->context->getWords();
140		array_shift($words);
141		$words = array_filter($words);
142
143		return new ArrayInput($words);
144		}
145
146		/**
147		* Attempt to complete the current word as a long-form option (--my-option)
148		*
149		* @return array\|false
150		*/
151		protected function completeForOptions()
152		{
153		$word = $this->context->getCurrentWord();
154
155		if (strpos($word, '-') === 0) {
156		$options = array();
157
158		foreach ($this->getAllOptions() as $opt) {
159		$options[] = '--'.$opt->getName();
160		}
161
162		return $options;
163		}
164
165		return false;
166		}
167
168		/**
169		* Attempt to complete the current word as an option shortcut.
170		*
171		* If the shortcut exists it will be completed, but a list of possible shortcuts is never returned for completion.
172		*
173		* @return array\|false
174		*/
175		protected function completeForOptionShortcuts()
176		{
177		$word = $this->context->getCurrentWord();
178
179		if (strpos($word, '-') === 0 && strlen($word) == 2) {
180		$definition = $this->command ? $this->command->getNativeDefinition() : $this->application->getDefinition();
181
182		if ($definition->hasShortcut(substr($word, 1))) {
183		return array($word);
184		}
185		}
186
187		return false;
188		}
189
190		/**
191		* Attempt to complete the current word as the value of an option shortcut
192		*
193		* @return array\|false
194		*/
195	View Code Duplication	protected function completeForOptionShortcutValues()
196		{
197		$wordIndex = $this->context->getWordIndex();
198
199		if ($this->command && $wordIndex > 1) {
200		$left = $this->context->getWordAtIndex($wordIndex - 1);
201
202		// Complete short options
203		if ($left[0] == '-' && strlen($left) == 2) {
204		$shortcut = substr($left, 1);
205		$def = $this->command->getNativeDefinition();
206
207		if (!$def->hasShortcut($shortcut)) {
208		return false;
209		}
210
211		$opt = $def->getOptionForShortcut($shortcut);
212		if ($opt->isValueRequired() \|\| $opt->isValueOptional()) {
213		return $this->completeOption($opt);
214		}
215		}
216		}
217
218		return false;
219		}
220
221		/**
222		* Attemp to complete the current word as the value of a long-form option
223		*
224		* @return array\|false
225		*/
226	View Code Duplication	protected function completeForOptionValues()
227		{
228		$wordIndex = $this->context->getWordIndex();
229
230		if ($this->command && $wordIndex > 1) {
231		$left = $this->context->getWordAtIndex($wordIndex - 1);
232
233		if (strpos($left, '--') === 0) {
234		$name = substr($left, 2);
235		$def = $this->command->getNativeDefinition();
236
237		if (!$def->hasOption($name)) {
238		return false;
239		}
240
241		$opt = $def->getOption($name);
242		if ($opt->isValueRequired() \|\| $opt->isValueOptional()) {
243		return $this->completeOption($opt);
244		}
245		}
246		}
247
248		return false;
249		}
250
251		/**
252		* Attempt to complete the current word as a command name
253		*
254		* @return array\|false
255		*/
256		protected function completeForCommandName()
257		{
258		if (!$this->command \|\| (count($this->context->getWords()) == 2 && $this->context->getWordIndex() == 1)) {
259		$commands = $this->application->all();
260		$names = array_keys($commands);
261
262		if ($key = array_search('_completion', $names)) {
263		unset($names[$key]);
264		}
265
266		return $names;
267		}
268
269		return false;
270		}
271
272		/**
273		* Attempt to complete the current word as a command argument value
274		*
275		* @see Symfony\Component\Console\Input\InputArgument
276		* @return array\|false
277		*/
278		protected function completeForCommandArguments()
279		{
280		if (!$this->command \|\| strpos($this->context->getCurrentWord(), '-') === 0) {
281		return false;
282		}
283
284		$definition = $this->command->getNativeDefinition();
285		$argWords = $this->mapArgumentsToWords($definition->getArguments());
286		$wordIndex = $this->context->getWordIndex();
287
288		if (isset($argWords[$wordIndex])) {
289		$name = $argWords[$wordIndex];
290		} elseif (!empty($argWords) && $definition->getArgument(end($argWords))->isArray()) {
291		$name = end($argWords);
292		} else {
293		return false;
294		}
295
296		if ($helper = $this->getCompletionHelper($name, Completion::TYPE_ARGUMENT)) {
297		return $helper->run();
298		}
299
300		if ($this->command instanceof CompletionAwareInterface) {
301		return $this->command->completeArgumentValues($name, $this->context);
302		}
303
304		return false;
305		}
306
307		/**
308		* Find a CompletionInterface that matches the current command, target name, and target type
309		*
310		* @param string $name
311		* @param string $type
312		* @return CompletionInterface\|null
313		*/
314		protected function getCompletionHelper($name, $type)
315		{
316		foreach ($this->helpers as $helper) {
317		if ($helper->getType() != $type && $helper->getType() != CompletionInterface::ALL_TYPES) {
318		continue;
319		}
320
321		if ($helper->getCommandName() == CompletionInterface::ALL_COMMANDS \|\| $helper->getCommandName() == $this->command->getName()) {
322		if ($helper->getTargetName() == $name) {
323		return $helper;
324		}
325		}
326		}
327
328		return null;
329		}
330
331		/**
332		* Complete the value for the given option if a value completion is availble
333		*
334		* @param InputOption $option
335		* @return array\|false
336		*/
337		protected function completeOption(InputOption $option)
338		{
339		if ($helper = $this->getCompletionHelper($option->getName(), Completion::TYPE_OPTION)) {
340		return $helper->run();
341		}
342
343		if ($this->command instanceof CompletionAwareInterface) {
344		return $this->command->completeOptionValues($option->getName(), $this->context);
345		}
346
347		return false;
348		}
349
350		/**
351		* Step through the command line to determine which word positions represent which argument values
352		*
353		* The word indexes of argument values are found by eliminating words that are known to not be arguments (options,
354		* option values, and command names). Any word that doesn't match for elimination is assumed to be an argument value,
355		*
356		* @param InputArgument[] $argumentDefinitions
357		* @return array as [argument name => word index on command line]
358		*/
359		protected function mapArgumentsToWords($argumentDefinitions)
360		{
361		$argumentPositions = array();
362		$argumentNumber = 0;
363		$previousWord = null;
364		$argumentNames = array_keys($argumentDefinitions);
365
366		// Build a list of option values to filter out
367		$optionsWithArgs = $this->getOptionWordsWithValues();
368
369		foreach ($this->context->getWords() as $wordIndex => $word) {
370		// Skip program name, command name, options, and option values
371		if ($wordIndex < 2
372		\|\| ($word && '-' === $word[0])
373		\|\| in_array($previousWord, $optionsWithArgs)) {
374		$previousWord = $word;
375		continue;
376		} else {
377		$previousWord = $word;
378		}
379
380		// If argument n exists, pair that argument's name with the current word
381		if (isset($argumentNames[$argumentNumber])) {
382		$argumentPositions[$wordIndex] = $argumentNames[$argumentNumber];
383		}
384
385		$argumentNumber++;
386		}
387
388		return $argumentPositions;
389		}
390
391		/**
392		* Build a list of option words/flags that will have a value after them
393		* Options are returned in the format they appear as on the command line.
394		*
395		* @return string[] - eg. ['--myoption', '-m', ... ]
396		*/
397		protected function getOptionWordsWithValues()
398		{
399		$strings = array();
400
401		foreach ($this->getAllOptions() as $option) {
402		if ($option->isValueRequired()) {
403		$strings[] = '--' . $option->getName();
404
405		if ($option->getShortcut()) {
406		$strings[] = '-' . $option->getShortcut();
407		}
408		}
409		}
410
411		return $strings;
412		}
413
414		/**
415		* Filter out results that don't match the current word on the command line
416		*
417		* @param string[] $array
418		* @return string[]
419		*/
420		protected function filterResults(array $array)
421		{
422		$curWord = $this->context->getCurrentWord();
423
424		return array_filter($array, function($val) use ($curWord) {
425		return fnmatch($curWord.'*', $val);
426		});
427		}
428
429		/**
430		* Get the combined options of the application and entered command
431		*
432		* @return InputOption[]
433		*/
434		protected function getAllOptions()
435		{
436		if (!$this->command) {
437		return $this->application->getDefinition()->getOptions();
438		}
439
440		return array_merge(
441		$this->command->getNativeDefinition()->getOptions(),
442		$this->application->getDefinition()->getOptions()
443		);
444		}
445		}
446

stecman / symfony-console-completion

Pull Request — master (#66)

CompletionHandler::getAllOptions() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like