CompletionHandler::__construct() - Code Metrics - Inspection of "Refactor and improve documentation for CompletionH..." - stecman/symfony-console-completion - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 902f29...8b1d65 )

by Stephen

created 2017-06-01 09:41 UTC

CompletionHandler::__construct() B

↳ Parent: CompletionHandler

Complexity

Conditions	1
Paths	1

Size

Total Lines	24
Code Lines	15

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	24
rs	8.9713
cc	1
eloc	15
nc	1
nop	2

<?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;

        // Set up completions for commands that are built-into Application
        $this->addHandler(
            new Completion(
                'help',
                'command_name',
                Completion::TYPE_ARGUMENT,
                $this->getCommandNames()
            )
        );

        $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 (substr($word, 0, 2) === '--') {
            $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)) {
            return $this->getCommandNames();
        }

        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()
        );
    }

    /**
     * Get command names available for completion
     *
     * Filters out hidden commands where supported.
     *
     * @return string[]
     */
    protected function getCommandNames()
    {
        // Command::Hidden isn't supported before Symfony Console 3.2.0
        // We don't complete hidden command names as these are intended to be private
        if (method_exists('\Symfony\Component\Console\Command\Command', 'isHidden')) {
            $commands = array();

            foreach ($this->application->all() as $name => $command) {
                if (!$command->isHidden()) {
                    $commands[] = $name;
                }
            }

            return $commands;

        } else {

            // Fallback for compatibility with Symfony Console < 3.2.0
            // This was the behaviour prior to pull #75
            $commands = $this->application->all();
            unset($commands['_completion']);

            return array_keys($commands);
        }
    }
}


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

stecman / symfony-console-completion

Push — master ( 902f29...8b1d65 )

CompletionHandler::__construct() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like