BespokeDocBlockParser::processArgumentTag() - Code Metrics - Inspection of "Bespoke parser" - consolidation/annotated-command - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#130)

by Greg

created 2017-10-12 19:59 UTC

BespokeDocBlockParser::processArgumentTag() A

↳ Parent: BespokeDocBlockParser

Complexity

Conditions	3
Paths	3

Size

Total Lines	10
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	10
rs	9.4285
c	0
b	0
f	0
cc	3
eloc	6
nc	3
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 extends AbstractCommandDocBlockParser
{
    /**
     * 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 @arg annotation in our argument descriptions.
     */
    protected function processArgumentTag($tag)
    {
        if (!$this->pregMatchNameAndDescription((string)$tag->getContent(), $match)) {
            return;
        }
        if ($match['name'] == $this->optionParamName()) {
            return;
        }
        $this->addOptionOrArgumentTag($tag, $this->commandInfo->arguments(), $match);
    }

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

    {
        if (!$this->pregMatchOptionNameAndDescription((string)$tag->getContent(), $match)) {
            return;
        }
        $this->addOptionOrArgumentTag($tag, $this->commandInfo->options(), $match);
    }

    protected function addOptionOrArgumentTag($tag, DefaultsWithDescriptions $set, $nameAndDescription)

    {
        $variableName = $this->commandInfo->findMatchingOption($nameAndDescription['name']);
        $desc = $nameAndDescription['description'];
        $description = static::removeLineBreaks($desc);
        $set->add($variableName, $description);
    }

    /**
     * Store the data from a @default annotation in our argument or option store,
     * as appropriate.
     */
    protected function processDefaultTag($tag)

    {
        if (!$this->pregMatchNameAndDescription((string)$tag->getContent(), $match)) {
            return;
        }
        $variableName = $match['name'];
        $defaultValue = $this->interpretDefaultValue($match['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)
    {
        if (!$tag->hasWordAndDescription($matches)) {

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

    private function parseDocBlock($doc)
    {
        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);

            // Throw out the /** and */ lines ('*' trimmed from beginning)
            if ($row == '/**' || $row == '/') {
                continue;
            }

            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 (!empty($lines) && !empty(trim($lines[0]))) {
            $description .= ' ' . array_shift($lines);
        }

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

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

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


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 extends AbstractCommandDocBlockParser
13		{
14		/**
15		* Parse the docBlock comment for this command, and set the
16		* fields of this class with the data thereby obtained.
17		*/
18		public function parse()
19		{
20		$doc = $this->reflection->getDocComment();
21		$this->parseDocBlock($doc);
22		}
23
24		/**
25		* Save any tag that we do not explicitly recognize in the
26		* 'otherAnnotations' map.
27		*/
28		protected function processGenericTag($tag)
29		{
30		$this->commandInfo->addAnnotation($tag->getTag(), $tag->getContent());
31		}
32
33		/**
34		* Set the name of the command from a @command or @name annotation.
35		*/
36		protected function processCommandTag($tag)
37		{
38		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...
39		throw new \Exception('Could not determine command name from tag ' . (string)$tag);
40		}
41		$commandName = $matches['word'];
42		$this->commandInfo->setName($commandName);
43		// We also store the name in the 'other annotations' so that is is
44		// possible to determine if the method had a @command annotation.
45		$this->commandInfo->addAnnotation($tag->getTag(), $commandName);
46		}
47
48		/**
49		* The @description and @desc annotations may be used in
50		* place of the synopsis (which we call 'description').
51		* This is discouraged.
52		*
53		* @deprecated
54		*/
55		protected function processAlternateDescriptionTag($tag)
56		{
57		$this->commandInfo->setDescription($tag->getContent());
58		}
59
60		/**
61		* Store the data from a @arg annotation in our argument descriptions.
62		*/
63		protected function processArgumentTag($tag)
64		{
65		if (!$this->pregMatchNameAndDescription((string)$tag->getContent(), $match)) {
66		return;
67		}
68		if ($match['name'] == $this->optionParamName()) {
69		return;
70		}
71		$this->addOptionOrArgumentTag($tag, $this->commandInfo->arguments(), $match);
72		}
73
74		/**
75		* Store the data from an @option annotation in our option descriptions.
76		*/
77	View Code Duplication	protected function processOptionTag($tag)
		0 ignored issues – show Duplication introduced 2017-10-12 20:03 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...
78		{
79		if (!$this->pregMatchOptionNameAndDescription((string)$tag->getContent(), $match)) {
80		return;
81		}
82		$this->addOptionOrArgumentTag($tag, $this->commandInfo->options(), $match);
83		}
84
85	View Code Duplication	protected function addOptionOrArgumentTag($tag, DefaultsWithDescriptions $set, $nameAndDescription)
		0 ignored issues – show Duplication introduced 2017-10-12 20:03 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...
86		{
87		$variableName = $this->commandInfo->findMatchingOption($nameAndDescription['name']);
88		$desc = $nameAndDescription['description'];
89		$description = static::removeLineBreaks($desc);
90		$set->add($variableName, $description);
91		}
92
93		/**
94		* Store the data from a @default annotation in our argument or option store,
95		* as appropriate.
96		*/
97	View Code Duplication	protected function processDefaultTag($tag)
		0 ignored issues – show Duplication introduced 2017-10-12 20:03 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...
98		{
99		if (!$this->pregMatchNameAndDescription((string)$tag->getContent(), $match)) {
100		return;
101		}
102		$variableName = $match['name'];
103		$defaultValue = $this->interpretDefaultValue($match['description']);
104		if ($this->commandInfo->arguments()->exists($variableName)) {
105		$this->commandInfo->arguments()->setDefaultValue($variableName, $defaultValue);
106		return;
107		}
108		$variableName = $this->commandInfo->findMatchingOption($variableName);
109		if ($this->commandInfo->options()->exists($variableName)) {
110		$this->commandInfo->options()->setDefaultValue($variableName, $defaultValue);
111		}
112		}
113
114		/**
115		* Store the data from a @usage annotation in our example usage list.
116		*/
117		protected function processUsageTag($tag)
118		{
119		$lines = explode("\n", $tag->getContent());
120		$usage = trim(array_shift($lines));
121		$description = static::removeLineBreaks(implode("\n", array_map(function ($line) {
122		return trim($line);
123		}, $lines)));
124
125		$this->commandInfo->setExampleUsage($usage, $description);
126		}
127
128		/**
129		* Process the comma-separated list of aliases
130		*/
131		protected function processAliases($tag)
132		{
133		$this->commandInfo->setAliases((string)$tag->getContent());
134		}
135
136		/**
137		* Store the data from a @return annotation in our argument descriptions.
138		*/
139		protected function processReturnTag($tag)
140		{
141		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...
142		throw new \Exception('Could not determine return type from tag ' . (string)$tag);
143		}
144		// TODO: look at namespace and `use` statments to make returnType a fqdn
145		$returnType = $matches['word'];
146		$this->commandInfo->setReturnType($returnType);
147		}
148
149		private function parseDocBlock($doc)
150		{
151		if (empty($doc)) {
152		return;
153		}
154
155		$tagFactory = new TagFactory();
156		$lines = [];
157
158		foreach (explode("\n", $doc) as $row) {
159		// Remove trailing whitespace and leading space + '*'s
160		$row = rtrim($row);
161		$row = preg_replace('#^[ \t]\*#', '', $row);
162
163		// Throw out the /** and / lines ('' trimmed from beginning)
164		if ($row == '/**' \|\| $row == '/') {
165		continue;
166		}
167
168		if (!$tagFactory->parseLine($row)) {
169		$lines[] = $row;
170		}
171		}
172
173		$this->processDescriptionAndHelp($lines);
174		$this->processAllTags($tagFactory->getTags());
175		}
176
177		protected function processDescriptionAndHelp($lines)
178		{
179		// Trim all of the lines individually.
180		$lines =
181		array_map(
182		function ($line) {
183		return trim($line);
184		},
185		$lines
186		);
187
188		// Everything up to the first blank line goes in the description.
189		$description = array_shift($lines);
190		while (!empty($lines) && !empty(trim($lines[0]))) {
191		$description .= ' ' . array_shift($lines);
192		}
193
194		// Everything else goes in the help.
195		$help = trim(implode(PHP_EOL, $lines));
196
197		$this->commandInfo->setDescription($description);
198		$this->commandInfo->setHelp($help);
199		}
200
201	View Code Duplication	protected function processAllTags($tags)
		0 ignored issues – show Duplication introduced 2017-10-12 20:03 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...
202		{
203		// Iterate over all of the tags, and process them as necessary.
204		foreach ($tags as $tag) {
205		$processFn = [$this, 'processGenericTag'];
206		if (array_key_exists($tag->getTag(), $this->tagProcessors)) {
207		$processFn = [$this, $this->tagProcessors[$tag->getTag()]];
208		}
209		$processFn($tag);
210		}
211		}
212		}
213

consolidation / annotated-command

Pull Request — master (#130)

BespokeDocBlockParser::processArgumentTag() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like