Kunstmaan\GeneratorBundle\Helper\CommandAssistant

Complexity

Total Complexity

24

Size/Duplication

Total Lines	231
Duplicated Lines	19.05 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

6%

Importance

Changes

0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	setInput()	0	4	1
A	getOutput()	0	4	1
A	setQuestionHelper()	0	4	1
A	getKernel()	0	4	1
A	setKernel()	0	4	1
A	writeSection()	0	4	1
A	getQuestionHelper()	0	4	1
A	write()	0	7	1
A	writeError()	12	12	2
A	askAndValidate()	19	19	1
A	setOutput()	0	4	1
A	writeLine()	0	4	1
A	askConfirmation()	0	21	1
A	askSelect()	0	37	3
A	setOption()	0	4	1
A	hasOption()	0	4	1
A	getOption()	0	4	1
A	isInteractive()	0	4	1
A	ask()	13	14	1
A	getOptionOrDefault()	0	6	2

<?php

namespace Kunstmaan\GeneratorBundle\Helper;

use Sensio\Bundle\GeneratorBundle\Command\Helper\QuestionHelper;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Question\ChoiceQuestion;
use Symfony\Component\Console\Question\ConfirmationQuestion;
use Symfony\Component\Console\Question\Question;
use Symfony\Component\HttpKernel\Kernel;

class CommandAssistant
{
    /**
     * @var InputInterface
     */
    private $input;

    /**
     * @var OutputInterface
     */
    private $output;

    /**
     * @var QuestionHelper
     */
    private $questionHelper;

    /**
     * @var Kernel
     */
    private $kernel;

    /**
     * @param $input InputInterface
     */
    public function setInput(InputInterface $input)
    {
        $this->input = $input;
    }

    /**
     * @return OutputInterface
     */
    public function getOutput()
    {
        return $this->output;
    }

    /**
     * @param $output OutputInterface
     */
    public function setOutput(OutputInterface $output)
    {
        $this->output = $output;
    }

    /**
     * @param $questionHelper QuestionHelper
     */
    public function setQuestionHelper(QuestionHelper $questionHelper)
    {
        $this->questionHelper = $questionHelper;
    }

    /**
     * @return Kernel
     */
    public function getKernel()
    {
        return $this->kernel;
    }

    /**
     * @param $kernel Kernel
     */
    public function setKernel(Kernel $kernel)
    {
        $this->kernel = $kernel;
    }

    public function writeSection($text, $style = 'bg=blue;fg=white')
    {
        $this->getQuestionHelper()->writeSection($this->output, $text, $style);
    }

    /**
     * @return Questionhelper

Should the return type not be QuestionHelper?

     */
    private function getQuestionHelper()
    {
        return $this->questionHelper;
    }

    public function writeLine($text, $type = OutputInterface::OUTPUT_NORMAL)
    {
        $this->output->writeln($text, $type);
    }

    public function write(
        $text,
        $newLine = false,
        $type = OutputInterface::OUTPUT_NORMAL
    ) {
        $this->output->write($text, $newLine, $type);
    }

    public function writeError($message, $exit = false)

This method seems to be duplicated in your project.

    {
        $this->output->writeln(
            $this->getQuestionHelper()
                ->getHelperSet()
                ->get('formatter')
                ->formatBlock($message, 'error')
        );
        if ($exit) {
            exit;
        }
    }

    public function askAndValidate(

This method seems to be duplicated in your project.

        $question,
        $validator,
        $defaultValue = null,
        array $autoComplete = null
    ) {
        $validationQuestion = new Question(
            $this->getQuestionHelper()->getQuestion($question, $defaultValue),
            $defaultValue
        );
        $validationQuestion->setAutocompleterValues($autoComplete);

It seems like $autoComplete defined by parameter $autoComplete on line 126 can also be of type array; however, Symfony\Component\Console\Question\Question::setAutocompleterValues() does only seem to accept object<Symfony\Component\Console\Question\iterable>|null, maybe add an additional type check?

        $validationQuestion->setValidator($validator);

        return $this->getQuestionHelper()->ask(
            $this->input,
            $this->output,
            $validationQuestion
        );
    }

    public function askConfirmation(
        $question,
        $defaultString,
        $separator = '?',
        $defaultValue = true
    ) {
        $confirmationQuestion = new ConfirmationQuestion(
            $this->getQuestionHelper()->getQuestion(
                $question,
                $defaultString,
                $separator
            ),
            $defaultValue
        );

        return $this->getQuestionHelper()->ask(
            $this->input,
            $this->output,
            $confirmationQuestion
        );
    }

    public function ask($question, $default = null, array $autoComplete = null)

This method seems to be duplicated in your project.

    {
        $askQuestion = new Question(
            $this->questionHelper->getQuestion($question, $default),
            $default
        );
        $askQuestion->setAutocompleterValues($autoComplete);

It seems like $autoComplete defined by parameter $autoComplete on line 164 can also be of type array; however, Symfony\Component\Console\Question\Question::setAutocompleterValues() does only seem to accept object<Symfony\Component\Console\Question\iterable>|null, maybe add an additional type check?

        return $this->getQuestionHelper()->ask(
            $this->input,
            $this->output,
            $askQuestion
        );
    }

    public function askSelect(
        $question,
        $choices,
        $default = null,
        $multiSelect = false,
        $errorMessage = 'Value "%s" is invalid'
    ) {
        $bundleQuestion = new ChoiceQuestion(
            $this->getQuestionHelper()->getQuestion($question, $default),
            $choices
        );
        $bundleQuestion->setErrorMessage($errorMessage);
        $bundleQuestion->setMultiselect($multiSelect);
        if ($multiSelect) {
            $toReturn = array();
            foreach ($this->getQuestionHelper()->ask(
                $this->input,
                $this->output,
                $bundleQuestion
            ) as $each) {
                array_push(
                    $toReturn,
                    array_search($each, $bundleQuestion->getChoices())
                );
            }

            return $toReturn;
        } else {
            $value = $this->getQuestionHelper()->ask(
                $this->input,
                $this->output,
                $bundleQuestion
            );

            return array_search($value, $bundleQuestion->getChoices());
        }
    }

    public function setOption($name, $value)
    {
        $this->input->setOption($name, $value);
    }

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

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

    public function isInteractive()
    {
        return $this->input->isInteractive();
    }

    public function getOptionOrDefault($option, $default = null)

The return type could not be reliably inferred; please add a @return annotation.

    {
        return $this->input->hasOption($option) ? $this->input->getOption(
            $option
        ) : $default;
    }
}