Consolidation\AnnotatedCommand\CommandData

Complexity

Total Complexity

15

Size/Duplication

Total Lines	124
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	2
Bugs	0	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	14	1
A	setUseIOInterfaces()	0	6	1
A	setIncludeOptionsInArgs()	0	5	1
A	annotationData()	0	4	1
A	input()	0	4	1
A	output()	0	4	1
A	arguments()	0	4	1
A	options()	0	4	1
A	setFilePath()	0	4	1
A	filePath()	0	4	1
A	getArgsWithoutAppName()	0	20	3
A	getArgsAndOptions()	0	9	2

<?php
namespace Consolidation\AnnotatedCommand;

use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;

class CommandData
{
    /** var AnnotationData */
    protected $annotationData;
    /** var InputInterface */
    protected $input;
    /** var OutputInterface */
    protected $output;
    /** var boolean */
    protected $usesInputInterface;
    /** var boolean */
    protected $usesOutputInterface;
    /** var boolean */
    protected $includeOptionsInArgs;
    /** var string */
    protected $filePath;

    public function __construct(
        AnnotationData $annotationData,
        InputInterface $input,
        OutputInterface $output,
        $usesInputInterface = false,

The parameter $usesInputInterface is not used and could be removed.

        $usesOutputInterface = false

The parameter $usesOutputInterface is not used and could be removed.

    ) {
        $this->annotationData = $annotationData;
        $this->input = $input;
        $this->output = $output;
        $this->usesInputInterface = false;
        $this->usesOutputInterface = false;
        $this->includeOptionsInArgs = true;
    }

    /**
     * For internal use only; indicates that the function to be called
     * should be passed an InputInterface &/or an OutputInterface.
     * @param booean $usesInputInterface
     * @param boolean $usesOutputInterface
     * @return self
     */
    public function setUseIOInterfaces($usesInputInterface, $usesOutputInterface)
    {
        $this->usesInputInterface = $usesInputInterface;
        $this->usesOutputInterface = $usesOutputInterface;
        return $this;
    }

    /**
     * For backwards-compatibility mode only: disable addition of
     * options on the end of the arguments list.
     */
    public function setIncludeOptionsInArgs($includeOptionsInArgs)
    {
        $this->includeOptionsInArgs = $includeOptionsInArgs;
        return $this;
    }

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

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

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

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

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

    // TODO: This should be a required constructor argument, but
    // implementing it this way to maintain backwards compatibility.
    public function setFilePath($filePath)
    {
        $this->filePath = $filePath;
    }

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

    public function getArgsWithoutAppName()
    {
        $args = $this->arguments();

        // When called via the Application, the first argument
        // will be the command name. The Application alters the
        // input definition to match, adding a 'command' argument
        // to the beginning.
        array_shift($args);

        if ($this->usesInputInterface) {
            array_unshift($args, $this->input());
        }

        if ($this->usesOutputInterface) {
            array_unshift($args, $this->output());
        }

        return $args;
    }

    public function getArgsAndOptions()
    {
        // Get passthrough args, and add the options on the end.
        $args = $this->getArgsWithoutAppName();
        if ($this->includeOptionsInArgs) {
            $args['options'] = $this->options();
        }
        return $args;
    }
}