BespokeDocBlockParser::splitOutDefault() - Code Metrics - Inspection of "Default shorthand (#186)" - consolidation/annotated-command - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( ae811c...173f3e )

by Greg

created 2019-03-08 16:52 UTC

BespokeDocBlockParser::splitOutDefault() A

↳ Parent: BespokeDocBlockParser

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	8
rs	10
c	0
b	0
f	0
cc	2
nc	2
nop	1

<?php
namespace Consolidation\AnnotatedCommand\Parser\Internal;

use Consolidation\AnnotatedCommand\Parser\CommandInfo;
use Consolidation\AnnotatedCommand\Parser\DefaultsWithDescriptions;

/**
 * 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 an annotated Command.
 */
class BespokeDocBlockParser
{
    protected $fqcnCache;

    /**
     * @var array
     */
    protected $tagProcessors = [
        'command' => 'processCommandTag',
        'name' => 'processCommandTag',
        'arg' => 'processArgumentTag',
        'param' => 'processParamTag',
        'return' => 'processReturnTag',
        'option' => 'processOptionTag',
        'default' => 'processDefaultTag',
        'aliases' => 'processAliases',
        'usage' => 'processUsageTag',
        'description' => 'processAlternateDescriptionTag',
        'desc' => 'processAlternateDescriptionTag',
    ];

    public function __construct(CommandInfo $commandInfo, \ReflectionMethod $reflection, $fqcnCache = null)
    {
        $this->commandInfo = $commandInfo;
class MyClass { }

$x = new MyClass();
$x->foo = true;
        $this->reflection = $reflection;
class MyClass { }

$x = new MyClass();
$x->foo = true;
        $this->fqcnCache = $fqcnCache ?: new FullyQualifiedClassCache();
    }

    /**
     * Parse the docBlock comment for this command, and set the
     * fields of this class with the data thereby obtained.
     */
    public function parse()
    {
        $doc = $this->reflection->getDocComment();
        $this->parseDocBlock($doc);
    }

    /**
     * Save any tag that we do not explicitly recognize in the
     * 'otherAnnotations' map.
     */
    protected function processGenericTag($tag)
    {
        $this->commandInfo->addAnnotation($tag->getTag(), $tag->getContent());
    }

    /**
     * Set the name of the command from a @command or @name annotation.
     */
    protected function processCommandTag($tag)
    {
        if (!$tag->hasWordAndDescription($matches)) {

            throw new \Exception('Could not determine command name from tag ' . (string)$tag);
        }
        $commandName = $matches['word'];
        $this->commandInfo->setName($commandName);
        // We also store the name in the 'other annotations' so that is is
        // possible to determine if the method had a @command annotation.
        $this->commandInfo->addAnnotation($tag->getTag(), $commandName);
    }

    /**
     * The @description and @desc annotations may be used in
     * place of the synopsis (which we call 'description').
     * This is discouraged.
     *
     * @deprecated
     */
    protected function processAlternateDescriptionTag($tag)
    {
        $this->commandInfo->setDescription($tag->getContent());
    }

    /**
     * Store the data from a @param annotation in our argument descriptions.
     */
    protected function processParamTag($tag)
    {
        if ($tag->hasTypeVariableAndDescription($matches)) {
            if ($this->ignoredParamType($matches['type'])) {

                return;
            }
        }
        return $this->processArgumentTag($tag);
    }

    protected function ignoredParamType($paramType)
    {
        // TODO: We should really only allow a couple of types here,
        // e.g. 'string', 'array', 'bool'. Blacklist things we do not
        // want for now to avoid breaking commands with weird types.
        // Fix in the next major version.
        //
        // This works:
        //   return !in_array($paramType, ['string', 'array', 'integer', 'bool']);
        return preg_match('#(InputInterface|OutputInterface)$#', $paramType);
    }

    /**
     * Store the data from a @arg annotation in our argument descriptions.
     */
    protected function processArgumentTag($tag)

    {
        if (!$tag->hasVariable($matches)) {

            throw new \Exception('Could not determine argument name from tag ' . (string)$tag);
        }
        if ($matches['variable'] == $this->optionParamName()) {
            return;
        }
        $this->addOptionOrArgumentTag($tag, $this->commandInfo->arguments(), $matches['variable'], $matches['description']);
    }

    /**
     * Store the data from an @option annotation in our option descriptions.
     */
    protected function processOptionTag($tag)

    {
        if (!$tag->hasVariable($matches)) {

            throw new \Exception('Could not determine option name from tag ' . (string)$tag);
        }
        $this->addOptionOrArgumentTag($tag, $this->commandInfo->options(), $matches['variable'], $matches['description']);
    }

    protected function addOptionOrArgumentTag($tag, DefaultsWithDescriptions $set, $name, $description)

    {
        $variableName = $this->commandInfo->findMatchingOption($name);
        $description = static::removeLineBreaks($description);
        list($description, $defaultValue) = $this->splitOutDefault($description);
        $set->add($variableName, $description);
        if ($defaultValue !== null) {
            $set->setDefaultValue($variableName, $defaultValue);
        }
    }

    protected function splitOutDefault($description)
    {
        if (!preg_match('#(.*)(Default: *)(.*)#', trim($description), $matches)) {
            return [$description, null];
        }

        return [trim($matches[1]), $this->interpretDefaultValue(trim($matches[3]))];
    }

    /**
     * Store the data from a @default annotation in our argument or option store,
     * as appropriate.
     */
    protected function processDefaultTag($tag)
    {
        if (!$tag->hasVariable($matches)) {

            throw new \Exception('Could not determine parameter name for default value from tag ' . (string)$tag);
        }
        $variableName = $matches['variable'];
        $defaultValue = $this->interpretDefaultValue($matches['description']);
        if ($this->commandInfo->arguments()->exists($variableName)) {
            $this->commandInfo->arguments()->setDefaultValue($variableName, $defaultValue);
            return;
        }
        $variableName = $this->commandInfo->findMatchingOption($variableName);
        if ($this->commandInfo->options()->exists($variableName)) {
            $this->commandInfo->options()->setDefaultValue($variableName, $defaultValue);
        }
    }

    /**
     * Store the data from a @usage annotation in our example usage list.
     */
    protected function processUsageTag($tag)
    {
        $lines = explode("\n", $tag->getContent());
        $usage = trim(array_shift($lines));
        $description = static::removeLineBreaks(implode("\n", array_map(function ($line) {
            return trim($line);
        }, $lines)));

        $this->commandInfo->setExampleUsage($usage, $description);
    }

    /**
     * Process the comma-separated list of aliases
     */
    protected function processAliases($tag)
    {
        $this->commandInfo->setAliases((string)$tag->getContent());
    }

    /**
     * Store the data from a @return annotation in our argument descriptions.
     */
    protected function processReturnTag($tag)
    {
        // The return type might be a variable -- '$this'. It will
        // usually be a type, like RowsOfFields, or \Namespace\RowsOfFields.
        if (!$tag->hasVariableAndDescription($matches)) {

            throw new \Exception('Could not determine return type from tag ' . (string)$tag);
        }
        // Look at namespace and `use` statments to make returnType a fqdn
        $returnType = $matches['variable'];
        $returnType = $this->findFullyQualifiedClass($returnType);
        $this->commandInfo->setReturnType($returnType);
    }

    protected function findFullyQualifiedClass($className)
    {
        if (strpos($className, '\\') !== false) {
            return $className;
        }

        return $this->fqcnCache->qualify($this->reflection->getFileName(), $className);
    }

    private function parseDocBlock($doc)
    {
        // Remove the leading /** and the trailing */
        $doc = preg_replace('#^\s*/\*+\s*#', '', $doc);
        $doc = preg_replace('#\s*\*+/\s*#', '', $doc);

        // Nothing left? Exit.
        if (empty($doc)) {
            return;
        }

        $tagFactory = new TagFactory();
        $lines = [];

        foreach (explode("\n", $doc) as $row) {
            // Remove trailing whitespace and leading space + '*'s
            $row = rtrim($row);
            $row = preg_replace('#^[ \t]*\**#', '', $row);

            if (!$tagFactory->parseLine($row)) {
                $lines[] = $row;
            }
        }

        $this->processDescriptionAndHelp($lines);
        $this->processAllTags($tagFactory->getTags());
    }

    protected function processDescriptionAndHelp($lines)
    {
        // Trim all of the lines individually.
        $lines =
            array_map(
                function ($line) {
                    return trim($line);
                },
                $lines
            );

        // Everything up to the first blank line goes in the description.
        $description = array_shift($lines);
        while ($this->nextLineIsNotEmpty($lines)) {
            $description .= ' ' . array_shift($lines);
        }

        // Everything else goes in the help.
        $help = trim(implode("\n", $lines));

        $this->commandInfo->setDescription($description);
        $this->commandInfo->setHelp($help);
    }

    protected function nextLineIsNotEmpty($lines)
    {
        if (empty($lines)) {
            return false;
        }

        $nextLine = trim($lines[0]);
        return !empty($nextLine);
    }

    protected function processAllTags($tags)
    {
        // Iterate over all of the tags, and process them as necessary.
        foreach ($tags as $tag) {
            $processFn = [$this, 'processGenericTag'];
            if (array_key_exists($tag->getTag(), $this->tagProcessors)) {
                $processFn = [$this, $this->tagProcessors[$tag->getTag()]];
            }
            $processFn($tag);
        }
    }

    protected function lastParameterName()
    {
        $params = $this->commandInfo->getParameters();
        $param = end($params);
        if (!$param) {
            return '';
        }
        return $param->name;
    }

    /**
     * Return the name of the last parameter if it holds the options.
     */
    public function optionParamName()
    {
        // Remember the name of the last parameter, if it holds the options.
        // We will use this information to ignore @param annotations for the options.
        if (!isset($this->optionParamName)) {
            $this->optionParamName = '';
class MyClass { }

$x = new MyClass();
$x->foo = true;
            $options = $this->commandInfo->options();
            if (!$options->isEmpty()) {
                $this->optionParamName = $this->lastParameterName();
            }
        }

        return $this->optionParamName;
    }

    protected function interpretDefaultValue($defaultValue)
    {
        $defaults = [
            'null' => null,
            'true' => true,
            'false' => false,
            "''" => '',
            '[]' => [],
        ];
        foreach ($defaults as $defaultName => $defaultTypedValue) {
            if ($defaultValue == $defaultName) {
                return $defaultTypedValue;
            }
        }
        return $defaultValue;
    }

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

    /**
     * Take a multiline description and convert it into a single
     * long unbroken line.
     */
    protected static function removeLineBreaks($text)
    {
        return trim(preg_replace('#[ \t\n\r]+#', ' ', $text));
    }
}


1		<?php
2		namespace Consolidation\AnnotatedCommand\Parser\Internal;
3
4		use Consolidation\AnnotatedCommand\Parser\CommandInfo;
5		use Consolidation\AnnotatedCommand\Parser\DefaultsWithDescriptions;
6
7		/**
8		* Given a class and method name, parse the annotations in the
9		* DocBlock comment, and provide accessor methods for all of
10		* the elements that are needed to create an annotated Command.
11		*/
12		class BespokeDocBlockParser
13		{
14		protected $fqcnCache;
15
16		/**
17		* @var array
18		*/
19		protected $tagProcessors = [
20		'command' => 'processCommandTag',
21		'name' => 'processCommandTag',
22		'arg' => 'processArgumentTag',
23		'param' => 'processParamTag',
24		'return' => 'processReturnTag',
25		'option' => 'processOptionTag',
26		'default' => 'processDefaultTag',
27		'aliases' => 'processAliases',
28		'usage' => 'processUsageTag',
29		'description' => 'processAlternateDescriptionTag',
30		'desc' => 'processAlternateDescriptionTag',
31		];
32
33		public function __construct(CommandInfo $commandInfo, \ReflectionMethod $reflection, $fqcnCache = null)
34		{
35		$this->commandInfo = $commandInfo;
		0 ignored issues – show Bug introduced 2017-10-12 23:17 UTC by Report Bug Copy Issue Report The property `commandInfo` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
36		$this->reflection = $reflection;
		0 ignored issues – show Bug introduced 2017-10-12 23:17 UTC by Report Bug Copy Issue Report The property `reflection` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
37		$this->fqcnCache = $fqcnCache ?: new FullyQualifiedClassCache();
38		}
39
40		/**
41		* Parse the docBlock comment for this command, and set the
42		* fields of this class with the data thereby obtained.
43		*/
44		public function parse()
45		{
46		$doc = $this->reflection->getDocComment();
47		$this->parseDocBlock($doc);
48		}
49
50		/**
51		* Save any tag that we do not explicitly recognize in the
52		* 'otherAnnotations' map.
53		*/
54		protected function processGenericTag($tag)
55		{
56		$this->commandInfo->addAnnotation($tag->getTag(), $tag->getContent());
57		}
58
59		/**
60		* Set the name of the command from a @command or @name annotation.
61		*/
62		protected function processCommandTag($tag)
63		{
64		if (!$tag->hasWordAndDescription($matches)) {
		0 ignored issues – show Bug introduced 2017-10-12 20:03 UTC by Report Bug Copy Issue Report The variable `$matches` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history...
65		throw new \Exception('Could not determine command name from tag ' . (string)$tag);
66		}
67		$commandName = $matches['word'];
68		$this->commandInfo->setName($commandName);
69		// We also store the name in the 'other annotations' so that is is
70		// possible to determine if the method had a @command annotation.
71		$this->commandInfo->addAnnotation($tag->getTag(), $commandName);
72		}
73
74		/**
75		* The @description and @desc annotations may be used in
76		* place of the synopsis (which we call 'description').
77		* This is discouraged.
78		*
79		* @deprecated
80		*/
81		protected function processAlternateDescriptionTag($tag)
82		{
83		$this->commandInfo->setDescription($tag->getContent());
84		}
85
86		/**
87		* Store the data from a @param annotation in our argument descriptions.
88		*/
89		protected function processParamTag($tag)
90		{
91		if ($tag->hasTypeVariableAndDescription($matches)) {
92		if ($this->ignoredParamType($matches['type'])) {
		0 ignored issues – show Bug introduced 2018-12-21 03:34 UTC by Report Bug Copy Issue Report The variable `$matches` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history...
93		return;
94		}
95		}
96		return $this->processArgumentTag($tag);
97		}
98
99		protected function ignoredParamType($paramType)
100		{
101		// TODO: We should really only allow a couple of types here,
102		// e.g. 'string', 'array', 'bool'. Blacklist things we do not
103		// want for now to avoid breaking commands with weird types.
104		// Fix in the next major version.
105		//
106		// This works:
107		// return !in_array($paramType, ['string', 'array', 'integer', 'bool']);
108		return preg_match('#(InputInterface\|OutputInterface)$#', $paramType);
109		}
110
111		/**
112		* Store the data from a @arg annotation in our argument descriptions.
113		*/
114	View Code Duplication	protected function processArgumentTag($tag)
		0 ignored issues – show Duplication introduced 2017-10-12 23:17 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
115		{
116		if (!$tag->hasVariable($matches)) {
		0 ignored issues – show Bug introduced 2017-10-12 23:17 UTC by Report Bug Copy Issue Report The variable `$matches` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history...
117		throw new \Exception('Could not determine argument name from tag ' . (string)$tag);
118		}
119		if ($matches['variable'] == $this->optionParamName()) {
120		return;
121		}
122		$this->addOptionOrArgumentTag($tag, $this->commandInfo->arguments(), $matches['variable'], $matches['description']);
123		}
124
125		/**
126		* Store the data from an @option annotation in our option descriptions.
127		*/
128	View Code Duplication	protected function processOptionTag($tag)
		0 ignored issues – show Duplication introduced 2017-10-12 23:17 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
129		{
130		if (!$tag->hasVariable($matches)) {
		0 ignored issues – show Bug introduced 2017-10-12 23:17 UTC by Report Bug Copy Issue Report The variable `$matches` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history...
131		throw new \Exception('Could not determine option name from tag ' . (string)$tag);
132		}
133		$this->addOptionOrArgumentTag($tag, $this->commandInfo->options(), $matches['variable'], $matches['description']);
134		}
135
136		protected function addOptionOrArgumentTag($tag, DefaultsWithDescriptions $set, $name, $description)
		0 ignored issues – show Unused Code introduced 2017-10-12 23:17 UTC by Report Bug Copy Issue Report The parameter `$tag` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
137		{
138		$variableName = $this->commandInfo->findMatchingOption($name);
139		$description = static::removeLineBreaks($description);
140		list($description, $defaultValue) = $this->splitOutDefault($description);
141		$set->add($variableName, $description);
142		if ($defaultValue !== null) {
143		$set->setDefaultValue($variableName, $defaultValue);
144		}
145		}
146
147		protected function splitOutDefault($description)
148		{
149		if (!preg_match('#(.)(Default: )(.*)#', trim($description), $matches)) {
150		return [$description, null];
151		}
152
153		return [trim($matches[1]), $this->interpretDefaultValue(trim($matches[3]))];
154		}
155
156		/**
157		* Store the data from a @default annotation in our argument or option store,
158		* as appropriate.
159		*/
160		protected function processDefaultTag($tag)
161		{
162		if (!$tag->hasVariable($matches)) {
		0 ignored issues – show Bug introduced 2017-10-13 19:21 UTC by Report Bug Copy Issue Report The variable `$matches` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history...
163		throw new \Exception('Could not determine parameter name for default value from tag ' . (string)$tag);
164		}
165		$variableName = $matches['variable'];
166		$defaultValue = $this->interpretDefaultValue($matches['description']);
167		if ($this->commandInfo->arguments()->exists($variableName)) {
168		$this->commandInfo->arguments()->setDefaultValue($variableName, $defaultValue);
169		return;
170		}
171		$variableName = $this->commandInfo->findMatchingOption($variableName);
172		if ($this->commandInfo->options()->exists($variableName)) {
173		$this->commandInfo->options()->setDefaultValue($variableName, $defaultValue);
174		}
175		}
176
177		/**
178		* Store the data from a @usage annotation in our example usage list.
179		*/
180		protected function processUsageTag($tag)
181		{
182		$lines = explode("\n", $tag->getContent());
183		$usage = trim(array_shift($lines));
184		$description = static::removeLineBreaks(implode("\n", array_map(function ($line) {
185		return trim($line);
186		}, $lines)));
187
188		$this->commandInfo->setExampleUsage($usage, $description);
189		}
190
191		/**
192		* Process the comma-separated list of aliases
193		*/
194		protected function processAliases($tag)
195		{
196		$this->commandInfo->setAliases((string)$tag->getContent());
197		}
198
199		/**
200		* Store the data from a @return annotation in our argument descriptions.
201		*/
202		protected function processReturnTag($tag)
203		{
204		// The return type might be a variable -- '$this'. It will
205		// usually be a type, like RowsOfFields, or \Namespace\RowsOfFields.
206		if (!$tag->hasVariableAndDescription($matches)) {
		0 ignored issues – show Bug introduced 2017-10-13 19:29 UTC by Report Bug Copy Issue Report The variable `$matches` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history...
207		throw new \Exception('Could not determine return type from tag ' . (string)$tag);
208		}
209		// Look at namespace and `use` statments to make returnType a fqdn
210		$returnType = $matches['variable'];
211		$returnType = $this->findFullyQualifiedClass($returnType);
212		$this->commandInfo->setReturnType($returnType);
213		}
214
215		protected function findFullyQualifiedClass($className)
216		{
217		if (strpos($className, '\\') !== false) {
218		return $className;
219		}
220
221		return $this->fqcnCache->qualify($this->reflection->getFileName(), $className);
222		}
223
224		private function parseDocBlock($doc)
225		{
226		// Remove the leading /** and the trailing */
227		$doc = preg_replace('#^\s/\+\s*#', '', $doc);
228		$doc = preg_replace('#\s\+/\s*#', '', $doc);
229
230		// Nothing left? Exit.
231		if (empty($doc)) {
232		return;
233		}
234
235		$tagFactory = new TagFactory();
236		$lines = [];
237
238		foreach (explode("\n", $doc) as $row) {
239		// Remove trailing whitespace and leading space + '*'s
240		$row = rtrim($row);
241		$row = preg_replace('#^[ \t]\*#', '', $row);
242
243		if (!$tagFactory->parseLine($row)) {
244		$lines[] = $row;
245		}
246		}
247
248		$this->processDescriptionAndHelp($lines);
249		$this->processAllTags($tagFactory->getTags());
250		}
251
252		protected function processDescriptionAndHelp($lines)
253		{
254		// Trim all of the lines individually.
255		$lines =
256		array_map(
257		function ($line) {
258		return trim($line);
259		},
260		$lines
261		);
262
263		// Everything up to the first blank line goes in the description.
264		$description = array_shift($lines);
265		while ($this->nextLineIsNotEmpty($lines)) {
266		$description .= ' ' . array_shift($lines);
267		}
268
269		// Everything else goes in the help.
270		$help = trim(implode("\n", $lines));
271
272		$this->commandInfo->setDescription($description);
273		$this->commandInfo->setHelp($help);
274		}
275
276		protected function nextLineIsNotEmpty($lines)
277		{
278		if (empty($lines)) {
279		return false;
280		}
281
282		$nextLine = trim($lines[0]);
283		return !empty($nextLine);
284		}
285
286		protected function processAllTags($tags)
287		{
288		// Iterate over all of the tags, and process them as necessary.
289		foreach ($tags as $tag) {
290		$processFn = [$this, 'processGenericTag'];
291		if (array_key_exists($tag->getTag(), $this->tagProcessors)) {
292		$processFn = [$this, $this->tagProcessors[$tag->getTag()]];
293		}
294		$processFn($tag);
295		}
296		}
297
298		protected function lastParameterName()
299		{
300		$params = $this->commandInfo->getParameters();
301		$param = end($params);
302		if (!$param) {
303		return '';
304		}
305		return $param->name;
306		}
307
308		/**
309		* Return the name of the last parameter if it holds the options.
310		*/
311		public function optionParamName()
312		{
313		// Remember the name of the last parameter, if it holds the options.
314		// We will use this information to ignore @param annotations for the options.
315		if (!isset($this->optionParamName)) {
316		$this->optionParamName = '';
		0 ignored issues – show Bug introduced 2017-10-12 23:17 UTC by Report Bug Copy Issue Report The property `optionParamName` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
317		$options = $this->commandInfo->options();
318		if (!$options->isEmpty()) {
319		$this->optionParamName = $this->lastParameterName();
320		}
321		}
322
323		return $this->optionParamName;
324		}
325
326		protected function interpretDefaultValue($defaultValue)
327		{
328		$defaults = [
329		'null' => null,
330		'true' => true,
331		'false' => false,
332		"''" => '',
333		'[]' => [],
334		];
335		foreach ($defaults as $defaultName => $defaultTypedValue) {
336		if ($defaultValue == $defaultName) {
337		return $defaultTypedValue;
338		}
339		}
340		return $defaultValue;
341		}
342
343		/**
344		* Given a list that might be 'a b c' or 'a, b, c' or 'a,b,c',
345		* convert the data into the last of these forms.
346		*/
347		protected static function convertListToCommaSeparated($text)
348		{
349		return preg_replace('#[ \t\n\r,]+#', ',', $text);
350		}
351
352		/**
353		* Take a multiline description and convert it into a single
354		* long unbroken line.
355		*/
356		protected static function removeLineBreaks($text)
357		{
358		return trim(preg_replace('#[ \t\n\r]+#', ' ', $text));
359		}
360		}
361

consolidation / annotated-command

Push — master ( ae811c...173f3e )

BespokeDocBlockParser::splitOutDefault() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like