CompletionHandler - Code Metrics - Inspection of "Add support for autocomplete descriptions" - stecman/symfony-console-completion - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#90)

unknown

created 2020-01-18 17:15 UTC

CompletionHandler F

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	498
Duplicated Lines	9.84 %

Coupling/Cohesion

Components	1
Dependencies	11

Importance

Changes

Metric	Value
wmc	80
lcom	1
cbo	11
dl	49
loc	498
rs	2
c	0
b	0
f	0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	24	1
A	setContext()	0	4	1
A	getContext()	0	4	1
A	addHandlers()	0	4	1
A	addHandler()	0	4	1
A	runCompletion()	0	31	5
A	completeForOptions()	0	16	3
A	completeForOptionShortcuts()	0	14	5
B	completeForOptionShortcutValues()	25	25	8
B	completeForOptionValues()	24	24	7
A	completeForCommandName()	0	8	3
B	completeForCommandArguments()	0	28	8
B	getCompletionHelper()	0	16	7
A	completeOption()	0	12	3
B	mapArgumentsToWords()	0	32	8
A	getOptionWordsWithValues()	0	16	4
A	filterResult()	0	13	2
A	getAllOptions()	0	11	2
A	getCommands()	0	25	4
B	detectCommand()	0	31	6

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like CompletionHandler often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use CompletionHandler, and based on these observations, apply Extract Interface, too.

<?php

namespace Stecman\Component\Symfony\Console\BashCompletion;

use Stecman\Component\Symfony\Console\BashCompletion\Completion\CompletionAwareInterface;
use Stecman\Component\Symfony\Console\BashCompletion\Completion\CompletionInterface;
use Stecman\Component\Symfony\Console\BashCompletion\Completion\CompletionResult;
use Stecman\Component\Symfony\Console\BashCompletion\Completion\CompletionResultInterface;
use Stecman\Component\Symfony\Console\BashCompletion\Completion\DescriptiveCompletion;
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();

    /**
     * Index the command name was detected at
     *
     * @var int
     */
    private $commandWordIndex;

    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 \Stecman\Component\Symfony\Console\BashCompletion\Completion\DescriptiveCompletion(
                'help',
                'command_name',
                Completion::TYPE_ARGUMENT,
                $this->getCommands()
            )
        );

        $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
     *
     * @return CompletionResultInterface
     * @throws \RuntimeException
     */
    public function runCompletion()
    {
        if (!$this->context) {
            throw new \RuntimeException('A CompletionContext must be set before requesting completion.');
        }

        // Set the command to query options and arugments from
        $this->command = $this->detectCommand();

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

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

            if (false !== $result) {
                if (!$result instanceof CompletionResultInterface) {
                    $result = new CompletionResult((array)$result);
                }
                return $this->filterResult($result);
            }
        }

        return new CompletionResult(array());
    }

    /**
     * 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 \Stecman\Component\Symfony\Console\BashCompletion\Completion\CompletionResultInterface|false
     */
    protected function completeForCommandName()
    {
        if (!$this->command || ($this->context->getWordIndex() == $this->commandWordIndex)) {
            return new CompletionResult($this->getCommands(), true);
        }

        return false;
    }

    /**
     * Attempt to complete the current word as a command argument value
     *
     * @return CompletionResultInterface|array|false
     * @see Symfony\Component\Console\Input\InputArgument
     */
    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();
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }

        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 == 0
                || $wordIndex === $this->commandWordIndex
                || ($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 CompletionResultInterface $result
     * @return CompletionResultInterface
     */
    protected function filterResult($result)
    {
        $curWord = $this->context->getCurrentWord();

        $values = $result->getValues();
        $desc = $result->isDescriptive();

        $values = array_filter($values, function ($val) use ($curWord) {
            return fnmatch($curWord . '*', $val);
        }, $result->isDescriptive() ? ARRAY_FILTER_USE_KEY : 0);

        return new CompletionResult($values, $desc);
    }

    /**
     * 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 getCommands()
    {
        // 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] = $command->getDescription();
                }
            }

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

    /**
     * Find the current command name in the command-line
     *
     * Note this only cares about flag-type options. Options with values cannot
     * appear before a command name in Symfony Console application.
     *
     * @return Command|null
     */
    private function detectCommand()
    {
        // Always skip the first word (program name)
        $skipNext = true;

        foreach ($this->context->getWords() as $index => $word) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }

            // Skip word if flagged
            if ($skipNext) {
                $skipNext = false;
                continue;
            }

            // Skip empty words and words that look like options
            if (strlen($word) == 0 || $word[0] === '-') {
                continue;
            }

            // Return the first unambiguous match to argument-like words
            try {
                $cmd = $this->application->find($word);
                $this->commandWordIndex = $index;
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
                return $cmd;
            } catch (\InvalidArgumentException $e) {
                // Exception thrown, when multiple or no commands are found.
            }
        }

        // No command found
        return null;
    }
}


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 Stecman\Component\Symfony\Console\BashCompletion\Completion\CompletionResult;
8		use Stecman\Component\Symfony\Console\BashCompletion\Completion\CompletionResultInterface;
9		use Stecman\Component\Symfony\Console\BashCompletion\Completion\DescriptiveCompletion;
10		use Symfony\Component\Console\Application;
11		use Symfony\Component\Console\Command\Command;
12		use Symfony\Component\Console\Input\ArrayInput;
13		use Symfony\Component\Console\Input\InputArgument;
14		use Symfony\Component\Console\Input\InputOption;
15
16		class CompletionHandler
17		{
18		/**
19		* Application to complete for
20		*
21		* @var \Symfony\Component\Console\Application
22		*/
23		protected $application;
24
25		/**
26		* @var Command
27		*/
28		protected $command;
29
30		/**
31		* @var CompletionContext
32		*/
33		protected $context;
34
35		/**
36		* Array of completion helpers.
37		*
38		* @var CompletionInterface[]
39		*/
40		protected $helpers = array();
41
42		/**
43		* Index the command name was detected at
44		*
45		* @var int
46		*/
47		private $commandWordIndex;
48
49		public function __construct(Application $application, CompletionContext $context = null)
50		{
51		$this->application = $application;
52		$this->context = $context;
53
54		// Set up completions for commands that are built-into Application
55		$this->addHandler(
56		new \Stecman\Component\Symfony\Console\BashCompletion\Completion\DescriptiveCompletion(
57		'help',
58		'command_name',
59		Completion::TYPE_ARGUMENT,
60		$this->getCommands()
61		)
62		);
63
64		$this->addHandler(
65		new Completion(
66		'list',
67		'namespace',
68		Completion::TYPE_ARGUMENT,
69		$application->getNamespaces()
70		)
71		);
72		}
73
74		public function setContext(CompletionContext $context)
75		{
76		$this->context = $context;
77		}
78
79		/**
80		* @return CompletionContext
81		*/
82		public function getContext()
83		{
84		return $this->context;
85		}
86
87		/**
88		* @param CompletionInterface[] $array
89		*/
90		public function addHandlers(array $array)
91		{
92		$this->helpers = array_merge($this->helpers, $array);
93		}
94
95		/**
96		* @param CompletionInterface $helper
97		*/
98		public function addHandler(CompletionInterface $helper)
99		{
100		$this->helpers[] = $helper;
101		}
102
103		/**
104		* Do the actual completion, returning an array of strings to provide to the parent shell's completion system
105		*
106		* @return CompletionResultInterface
107		* @throws \RuntimeException
108		*/
109		public function runCompletion()
110		{
111		if (!$this->context) {
112		throw new \RuntimeException('A CompletionContext must be set before requesting completion.');
113		}
114
115		// Set the command to query options and arugments from
116		$this->command = $this->detectCommand();
117
118		$process = array(
119		'completeForOptionValues',
120		'completeForOptionShortcuts',
121		'completeForOptionShortcutValues',
122		'completeForOptions',
123		'completeForCommandName',
124		'completeForCommandArguments'
125		);
126
127		foreach ($process as $methodName) {
128		$result = $this->{$methodName}();
129
130		if (false !== $result) {
131		if (!$result instanceof CompletionResultInterface) {
132		$result = new CompletionResult((array)$result);
133		}
134		return $this->filterResult($result);
135		}
136		}
137
138		return new CompletionResult(array());
139		}
140
141		/**
142		* Attempt to complete the current word as a long-form option (--my-option)
143		*
144		* @return array\|false
145		*/
146		protected function completeForOptions()
147		{
148		$word = $this->context->getCurrentWord();
149
150		if (substr($word, 0, 2) === '--') {
151		$options = array();
152
153		foreach ($this->getAllOptions() as $opt) {
154		$options[] = '--' . $opt->getName();
155		}
156
157		return $options;
158		}
159
160		return false;
161		}
162
163		/**
164		* Attempt to complete the current word as an option shortcut.
165		*
166		* If the shortcut exists it will be completed, but a list of possible shortcuts is never returned for completion.
167		*
168		* @return array\|false
169		*/
170		protected function completeForOptionShortcuts()
171		{
172		$word = $this->context->getCurrentWord();
173
174		if (strpos($word, '-') === 0 && strlen($word) == 2) {
175		$definition = $this->command ? $this->command->getNativeDefinition() : $this->application->getDefinition();
176
177		if ($definition->hasShortcut(substr($word, 1))) {
178		return array($word);
179		}
180		}
181
182		return false;
183		}
184
185		/**
186		* Attempt to complete the current word as the value of an option shortcut
187		*
188		* @return array\|false
189		*/
190	View Code Duplication	protected function completeForOptionShortcutValues()
191		{
192		$wordIndex = $this->context->getWordIndex();
193
194		if ($this->command && $wordIndex > 1) {
195		$left = $this->context->getWordAtIndex($wordIndex - 1);
196
197		// Complete short options
198		if ($left[0] == '-' && strlen($left) == 2) {
199		$shortcut = substr($left, 1);
200		$def = $this->command->getNativeDefinition();
201
202		if (!$def->hasShortcut($shortcut)) {
203		return false;
204		}
205
206		$opt = $def->getOptionForShortcut($shortcut);
207		if ($opt->isValueRequired() \|\| $opt->isValueOptional()) {
208		return $this->completeOption($opt);
209		}
210		}
211		}
212
213		return false;
214		}
215
216		/**
217		* Attemp to complete the current word as the value of a long-form option
218		*
219		* @return array\|false
220		*/
221	View Code Duplication	protected function completeForOptionValues()
222		{
223		$wordIndex = $this->context->getWordIndex();
224
225		if ($this->command && $wordIndex > 1) {
226		$left = $this->context->getWordAtIndex($wordIndex - 1);
227
228		if (strpos($left, '--') === 0) {
229		$name = substr($left, 2);
230		$def = $this->command->getNativeDefinition();
231
232		if (!$def->hasOption($name)) {
233		return false;
234		}
235
236		$opt = $def->getOption($name);
237		if ($opt->isValueRequired() \|\| $opt->isValueOptional()) {
238		return $this->completeOption($opt);
239		}
240		}
241		}
242
243		return false;
244		}
245
246		/**
247		* Attempt to complete the current word as a command name
248		*
249		* @return \Stecman\Component\Symfony\Console\BashCompletion\Completion\CompletionResultInterface\|false
250		*/
251		protected function completeForCommandName()
252		{
253		if (!$this->command \|\| ($this->context->getWordIndex() == $this->commandWordIndex)) {
254		return new CompletionResult($this->getCommands(), true);
255		}
256
257		return false;
258		}
259
260		/**
261		* Attempt to complete the current word as a command argument value
262		*
263		* @return CompletionResultInterface\|array\|false
264		* @see Symfony\Component\Console\Input\InputArgument
265		*/
266		protected function completeForCommandArguments()
267		{
268		if (!$this->command \|\| strpos($this->context->getCurrentWord(), '-') === 0) {
269		return false;
270		}
271
272		$definition = $this->command->getNativeDefinition();
273		$argWords = $this->mapArgumentsToWords($definition->getArguments());
274		$wordIndex = $this->context->getWordIndex();
275
276		if (isset($argWords[$wordIndex])) {
277		$name = $argWords[$wordIndex];
278		} elseif (!empty($argWords) && $definition->getArgument(end($argWords))->isArray()) {
279		$name = end($argWords);
280		} else {
281		return false;
282		}
283
284		if ($helper = $this->getCompletionHelper($name, Completion::TYPE_ARGUMENT)) {
285		return $helper->run();
286		}
287
288		if ($this->command instanceof CompletionAwareInterface) {
289		return $this->command->completeArgumentValues($name, $this->context);
290		}
291
292		return false;
293		}
294
295		/**
296		* Find a CompletionInterface that matches the current command, target name, and target type
297		*
298		* @param string $name
299		* @param string $type
300		* @return CompletionInterface\|null
301		*/
302		protected function getCompletionHelper($name, $type)
303		{
304		foreach ($this->helpers as $helper) {
305		if ($helper->getType() != $type && $helper->getType() != CompletionInterface::ALL_TYPES) {
306		continue;
307		}
308
309		if ($helper->getCommandName() == CompletionInterface::ALL_COMMANDS \|\| $helper->getCommandName() == $this->command->getName()) {
310		if ($helper->getTargetName() == $name) {
311		return $helper;
312		}
313		}
314		}
315
316		return null;
317		}
318
319		/**
320		* Complete the value for the given option if a value completion is availble
321		*
322		* @param InputOption $option
323		* @return array\|false
324		*/
325		protected function completeOption(InputOption $option)
326		{
327		if ($helper = $this->getCompletionHelper($option->getName(), Completion::TYPE_OPTION)) {
328		return $helper->run();
		0 ignored issues – show Bug Best Practice introduced 2020-01-08 09:48 UTC by Report Bug Copy Issue Report The return type of `return $helper->run();` (`Stecman\Component\Symfon...mpletionResultInterface`) is incompatible with the return type documented by `Stecman\Component\Symfon...Handler::completeOption` of type `array\|false`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
329		}
330
331		if ($this->command instanceof CompletionAwareInterface) {
332		return $this->command->completeOptionValues($option->getName(), $this->context);
333		}
334
335		return false;
336		}
337
338		/**
339		* Step through the command line to determine which word positions represent which argument values
340		*
341		* The word indexes of argument values are found by eliminating words that are known to not be arguments (options,
342		* option values, and command names). Any word that doesn't match for elimination is assumed to be an argument
343		* value,
344		*
345		* @param InputArgument[] $argumentDefinitions
346		* @return array as [argument name => word index on command line]
347		*/
348		protected function mapArgumentsToWords($argumentDefinitions)
349		{
350		$argumentPositions = array();
351		$argumentNumber = 0;
352		$previousWord = null;
353		$argumentNames = array_keys($argumentDefinitions);
354
355		// Build a list of option values to filter out
356		$optionsWithArgs = $this->getOptionWordsWithValues();
357
358		foreach ($this->context->getWords() as $wordIndex => $word) {
359		// Skip program name, command name, options, and option values
360		if ($wordIndex == 0
361		\|\| $wordIndex === $this->commandWordIndex
362		\|\| ($word && '-' === $word[0])
363		\|\| in_array($previousWord, $optionsWithArgs)) {
364		$previousWord = $word;
365		continue;
366		} else {
367		$previousWord = $word;
368		}
369
370		// If argument n exists, pair that argument's name with the current word
371		if (isset($argumentNames[$argumentNumber])) {
372		$argumentPositions[$wordIndex] = $argumentNames[$argumentNumber];
373		}
374
375		$argumentNumber++;
376		}
377
378		return $argumentPositions;
379		}
380
381		/**
382		* Build a list of option words/flags that will have a value after them
383		* Options are returned in the format they appear as on the command line.
384		*
385		* @return string[] - eg. ['--myoption', '-m', ... ]
386		*/
387		protected function getOptionWordsWithValues()
388		{
389		$strings = array();
390
391		foreach ($this->getAllOptions() as $option) {
392		if ($option->isValueRequired()) {
393		$strings[] = '--' . $option->getName();
394
395		if ($option->getShortcut()) {
396		$strings[] = '-' . $option->getShortcut();
397		}
398		}
399		}
400
401		return $strings;
402		}
403
404		/**
405		* Filter out results that don't match the current word on the command line
406		*
407		* @param CompletionResultInterface $result
408		* @return CompletionResultInterface
409		*/
410		protected function filterResult($result)
411		{
412		$curWord = $this->context->getCurrentWord();
413
414		$values = $result->getValues();
415		$desc = $result->isDescriptive();
416
417		$values = array_filter($values, function ($val) use ($curWord) {
418		return fnmatch($curWord . '*', $val);
419		}, $result->isDescriptive() ? ARRAY_FILTER_USE_KEY : 0);
420
421		return new CompletionResult($values, $desc);
422		}
423
424		/**
425		* Get the combined options of the application and entered command
426		*
427		* @return InputOption[]
428		*/
429		protected function getAllOptions()
430		{
431		if (!$this->command) {
432		return $this->application->getDefinition()->getOptions();
433		}
434
435		return array_merge(
436		$this->command->getNativeDefinition()->getOptions(),
437		$this->application->getDefinition()->getOptions()
438		);
439		}
440
441		/**
442		* Get command names available for completion
443		*
444		* Filters out hidden commands where supported.
445		*
446		* @return string[]
447		*/
448		protected function getCommands()
449		{
450		// Command::Hidden isn't supported before Symfony Console 3.2.0
451		// We don't complete hidden command names as these are intended to be private
452		if (method_exists('\Symfony\Component\Console\Command\Command', 'isHidden')) {
453		$commands = array();
454
455		foreach ($this->application->all() as $name => $command) {
456		if (!$command->isHidden()) {
457		$commands[$name] = $command->getDescription();
458		}
459		}
460
461		return $commands;
462
463		} else {
464
465		// Fallback for compatibility with Symfony Console < 3.2.0
466		// This was the behaviour prior to pull #75
467		$commands = $this->application->all();
468		unset($commands['_completion']);
469
470		return array_keys($commands);
471		}
472		}
473
474		/**
475		* Find the current command name in the command-line
476		*
477		* Note this only cares about flag-type options. Options with values cannot
478		* appear before a command name in Symfony Console application.
479		*
480		* @return Command\|null
481		*/
482		private function detectCommand()
483		{
484		// Always skip the first word (program name)
485		$skipNext = true;
486
487		foreach ($this->context->getWords() as $index => $word) {
		0 ignored issues – show Bug introduced 2019-05-06 11:34 UTC by Report Bug Copy Issue Report The expression `$this->context->getWords()` of type `null\|array<integer,string>` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
488
489		// Skip word if flagged
490		if ($skipNext) {
491		$skipNext = false;
492		continue;
493		}
494
495		// Skip empty words and words that look like options
496		if (strlen($word) == 0 \|\| $word[0] === '-') {
497		continue;
498		}
499
500		// Return the first unambiguous match to argument-like words
501		try {
502		$cmd = $this->application->find($word);
503		$this->commandWordIndex = $index;
		0 ignored issues – show Documentation Bug introduced 2019-05-06 11:34 UTC by Report Bug Copy Issue Report It seems like `$index` can also be of type `string`. However, the property `$commandWordIndex` is declared as type `integer`. Maybe add an additional type check? Our type inference engine has found a suspicous assignment of a value to a property. This check raises an issue when a value that can be of a mixed type is assigned to a property that is type hinted more strictly. For example, imagine you have a variable `$accountId` that can either hold an Id object or false (if there is no account id yet). Your code now assigns that value to the `id` property of an instance of the `Account` class. This class holds a proper account, so the id value must no longer be false. Either this assignment is in error or a type check should be added for that assignment. class Id { public $id; public function __construct($id) { $this->id = $id; } } class Account { /** @var Id $id */ public $id; } $account_id = false; if (starsAreRight()) { $account_id = new Id(42); } $account = new Account(); if ($account instanceof Id) { $account->id = $account_id; } Loading history...
504		return $cmd;
505		} catch (\InvalidArgumentException $e) {
506		// Exception thrown, when multiple or no commands are found.
507		}
508		}
509
510		// No command found
511		return null;
512		}
513		}
514

stecman / symfony-console-completion