Consolidation\AnnotatedCommand\CommandInfo

Complexity

Total Complexity

65

Size/Duplication

Total Lines	378
Duplicated Lines	0 %

Coupling/Cohesion

Components	5
Dependencies	1

Importance

Changes	4
Bugs	0	Features	0

37 Methods

Rating	Name	Duplication	Size	Complexity
A	setDescription()	0	4	1
A	__construct()	0	8	1
A	initializeFromParameters()	0	8	1
A	getMethodName()	0	4	1
A	getParameters()	0	4	1
A	getDescription()	0	4	1
A	getHelp()	0	4	1
A	setHelp()	0	4	1
A	getAliases()	0	4	1
A	setAliases()	0	7	2
A	getExampleUsages()	0	4	1
A	getName()	0	4	1
A	setDefaultName()	0	4	1
A	setName()	0	4	1
A	determineAgumentClassifications()	0	14	4
A	getArguments()	0	4	1
A	hasArgument()	0	4	1
A	setArgumentDefaultValue()	0	4	1
A	addArgument()	0	10	4
B	getArgumentClassification()	0	19	6
A	getOptions()	0	4	1
A	hasOption()	0	4	1
A	setOptionDefaultValue()	0	4	1
A	addOption()	0	10	4
A	determineOptionsFromParameters()	0	14	4
A	getArgumentDescription()	0	8	2
A	getOptionDescription()	0	8	2
A	isAssoc()	0	7	2
A	getAnnotations()	0	4	1
A	getAnnotation()	0	8	2
A	hasAnnotation()	0	4	1
A	convertName()	0	7	1
A	setExampleUsage()	0	4	1
A	parseDocBlock()	0	5	1
A	addOtherAnnotation()	0	4	1
C	findMatchingOption()	0	28	7
A	convertListToCommaSeparated()	0	4	1

<?php
namespace Consolidation\AnnotatedCommand;

/**
 * Given a class and method name, parse the annotations in the
 * DocBlock comment, and provide accessor methods for all of
 * the elements that are needed to create a Symfony Console Command.
 */
class CommandInfo
{
    /**
     * @var \ReflectionParameter
     */
    protected $params;

    /**
     * @var string
     */
    protected $name;

    /**
     * @var string
     */
    protected $description = '';

    /**
     * @var string
     */
    protected $help = '';

    /**
     * @var array
     */
    protected $options = [];

    /**
     * @var array
     */
    protected $arguments = [];

    /**
     * @var array
     */
    protected $argumentDescriptions = [];

    /**
     * @var array
     */
    protected $optionDescriptions = [];

    /**
     * @var array
     */
    protected $exampleUsage = [];

    /**
     * @var array
     */
    protected $otherAnnotations = [];

    /**
     * @var array
     */
    protected $aliases = [];

    /**
     * @var string
     */
    protected $methodName;

    public function __construct($classNameOrInstance, $methodName)
    {
        $reflectionMethod = new \ReflectionMethod($classNameOrInstance, $methodName);
        $this->methodName = $methodName;
        $this->setDefaultName($methodName);
        $this->initializeFromParameters($reflectionMethod->getParameters());
        $this->parseDocBlock($reflectionMethod->getDocComment());
    }

    protected function initializeFromParameters($params)
    {
        // Set up a default name for the command from the method name.
        // This can be overridden via @command or @name annotations.
        $this->params = $params;
        $this->options = $this->determineOptionsFromParameters($this->params);
        $this->arguments = $this->determineAgumentClassifications($this->params);
    }

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

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

    /**
     * Get the synopsis of the command (~first line).
     */
    public function getDescription()
    {
        return $this->description;
    }

    public function setDescription($description)
    {
        $this->description = $description;
    }

    /**
     * Get the help text of the command (the description)
     */
    public function getHelp()
    {
        return $this->help;
    }

    public function setHelp($help)
    {
        $this->help = $help;
    }

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

    public function setAliases($aliases)
    {
        if (is_string($aliases)) {
            $aliases = explode(',', static::convertListToCommaSeparated($aliases));
        }
        $this->aliases = array_filter($aliases);
    }

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

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

    public function setDefaultName($methodName)
    {
        $this->name = $this->convertName($methodName);
    }

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

    protected function determineAgumentClassifications($params)
    {
        $args = [];
        if (!empty($this->determineOptionsFromParameters($params))) {
            array_pop($params);
        }
        foreach ($params as $param) {
            $defaultValue = $this->getArgumentClassification($param);
            if ($defaultValue !== false) {
                $args[$param->name] = $defaultValue;
            }
        }
        return $args;
    }

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

    public function hasArgument($name)
    {
        return array_key_exists($name, $this->arguments);
    }

    public function setArgumentDefaultValue($name, $defaultValue)
    {
        $this->arguments[$name] = $defaultValue;
    }

    public function addArgument($name, $description, $defaultValue = null)
    {
        if (!$this->hasArgument($name) || isset($defaultValue)) {
            $this->arguments[$name] = $defaultValue;
        }
        unset($this->argumentDescriptions[$name]);
        if (isset($description)) {
            $this->argumentDescriptions[$name] = $description;
        }
    }

    /**
     * Examine the provided parameter, and determine whether it
     * is a parameter that will be filled in with a positional
     * commandline argument.
     *
     * @return false|null|string|array
     */
    protected function getArgumentClassification($param)
    {
        $defaultValue = null;
        if ($param->isDefaultValueAvailable()) {
            $defaultValue = $param->getDefaultValue();
            if ($this->isAssoc($defaultValue)) {
                return false;
            }
        }
        if ($param->isArray()) {
            return [];
        }
        // Commandline arguments must be strings, so ignore
        // any parameter that is typehinted to anything else.
        if (($param->getClass() != null) && ($param->getClass() != 'string')) {
            return false;
        }
        return $defaultValue;
    }

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

    public function hasOption($name)
    {
        return array_key_exists($name, $this->options);
    }

    public function setOptionDefaultValue($name, $defaultValue)
    {
        $this->options[$name] = $defaultValue;
    }

    public function addOption($name, $description, $defaultValue = false)
    {
        if (!$this->hasOption($name) || $defaultValue) {
            $this->options[$name] = $defaultValue;
        }
        unset($this->optionDescriptions[$name]);
        if (isset($description)) {
            $this->optionDescriptions[$name] = $description;
        }
    }

    public function determineOptionsFromParameters($params)
    {
        if (empty($params)) {
            return [];
        }
        $param = end($params);
        if (!$param->isDefaultValueAvailable()) {
            return [];
        }
        if (!$this->isAssoc($param->getDefaultValue())) {
            return [];
        }
        return $param->getDefaultValue();
    }

    public function getArgumentDescription($name)
    {
        if (array_key_exists($name, $this->argumentDescriptions)) {
            return $this->argumentDescriptions[$name];
        }

        return '';
    }

    public function getOptionDescription($name)
    {
        if (array_key_exists($name, $this->optionDescriptions)) {
            return $this->optionDescriptions[$name];
        }

        return '';
    }

    protected function isAssoc($arr)
    {
        if (!is_array($arr)) {
            return false;
        }
        return array_keys($arr) !== range(0, count($arr) - 1);
    }

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

    public function getAnnotation($annotation)
    {
        // hasAnnotation parses the docblock
        if (!$this->hasAnnotation($annotation)) {
            return null;
        }
        return $this->otherAnnotations[$annotation];
    }

    public function hasAnnotation($annotation)
    {
        return array_key_exists($annotation, $this->otherAnnotations);
    }

    protected function convertName($camel)
    {
        $splitter="-";
        $camel=preg_replace('/(?!^)[[:upper:]][[:lower:]]/', '$0', preg_replace('/(?!^)[[:upper:]]+/', $splitter.'$0', $camel));
        $camel = preg_replace("/$splitter/", ':', $camel, 1);
        return strtolower($camel);
    }

    public function setExampleUsage($usage, $description)
    {
        $this->exampleUsage[$usage] = $description;
    }

    /**
     * Parse the docBlock comment for this command, and set the
     * fields of this class with the data thereby obtained.
     */
    protected function parseDocBlock($docblock)
    {
        $parser = new CommandDocBlockParser($this);
        $parser->parse($docblock);
    }

    /**
     * Save any tag that we do not explicitly recognize in the
     * 'otherAnnotations' map.
     */
    public function addOtherAnnotation($name, $content)
    {
        $this->otherAnnotations[$name] = $content;
    }

    /**
     * An option might have a name such as 'silent|s'. In this
     * instance, we will allow the @option or @default tag to
     * reference the option only by name (e.g. 'silent' or 's'
     * instead of 'silent|s').
     */
    public function findMatchingOption($optionName)
    {
        // Exit fast if there's an exact match
        if (isset($this->options[$optionName])) {
            return $optionName;
        }
        // Check to see if we can find the option name in an existing option,
        // e.g. if the options array has 'silent|s' => false, and the annotation
        // is @silent.
        foreach ($this->options as $name => $default) {
            if (in_array($optionName, explode('|', $name))) {
                return $name;
            }
        }
        // Check the other direction: if the annotation contains @silent|s
        // and the options array has 'silent|s'.
        $checkMatching = explode('|', $optionName);
        if (count($checkMatching) > 1) {
            foreach ($checkMatching as $checkName) {
                if (isset($this->options[$checkName])) {
                    $this->options[$optionName] = $this->options[$checkName];
                    unset($this->options[$checkName]);
                    return $optionName;
                }
            }
        }
        return $optionName;
    }
    /**
     * Given a list that might be 'a b c' or 'a, b, c' or 'a,b,c',
     * convert the data into the last of these forms.
     */
    protected static function convertListToCommaSeparated($text)
    {
        return preg_replace('#[ \t\n\r,]+#', ',', $text);
    }
}