HyphenatedRangeParser::getLowerConstraint() - Code Metrics - Inspection of "Simplify branch, tilde and wildcard parsing by add..." - ptlis/semantic-version - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 578d3f...fb2c6d )

by brian

created 2017-02-12 23:34 UTC

HyphenatedRangeParser::getLowerConstraint() A

↳ Parent: HyphenatedRangeParser

Complexity

Conditions	2
Paths	2

Size

Total Lines	13
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	8
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	13
ccs	8
cts	8
cp	1
rs	9.4285
c	0
b	0
f	0
cc	2
eloc	8
nc	2
nop	2
crap	2

<?php

/**
 * @copyright   (c) 2014-2017 brian ridley
 * @author      brian ridley <[email protected]>
 * @license     http://opensource.org/licenses/MIT MIT
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace ptlis\SemanticVersion\Parse\RangeMatcher;

use ptlis\SemanticVersion\Comparator\ComparatorInterface;
use ptlis\SemanticVersion\Parse\Token;
use ptlis\SemanticVersion\Parse\VersionParser;
use ptlis\SemanticVersion\Version\Label\LabelBuilder;
use ptlis\SemanticVersion\Version\Version;
use ptlis\SemanticVersion\VersionRange\ComparatorVersion;
use ptlis\SemanticVersion\VersionRange\LogicalAnd;
use ptlis\SemanticVersion\VersionRange\VersionRangeInterface;

/**
 * Parser for hyphenated ranges.
 *
 * Hyphenated ranges are implemented as described @ https://getcomposer.org/doc/articles/versions.md#range-hyphen-
 */
final class HyphenatedRangeParser implements RangeParserInterface
{
    use ChunkByDash;

    /** @var VersionParser */
    private $versionParser;

    /** @var ComparatorInterface */
    private $greaterOrEqualTo;

    /** @var ComparatorInterface */
    private $lessThan;

    /** @var ComparatorInterface */
    private $lessOrEqualTo;


    /**
     * Constructor.
     *
     * @param VersionParser $versionParser
     * @param ComparatorInterface $greaterOrEqualTo
     * @param ComparatorInterface $lessThan
     * @param ComparatorInterface $lessOrEqualTo
     */
    public function __construct(
        VersionParser $versionParser,
        ComparatorInterface $greaterOrEqualTo,
        ComparatorInterface $lessThan,
        ComparatorInterface $lessOrEqualTo
    ) {
        $this->versionParser = $versionParser;
        $this->greaterOrEqualTo = $greaterOrEqualTo;
        $this->lessThan = $lessThan;
        $this->lessOrEqualTo = $lessOrEqualTo;
    }

    /**
     * Returns true if the token list can be parsed as a hyphenated range.
     *
     * @param Token[] $tokenList
     *
     * @return boolean
     */
    public function canParse(array $tokenList)
    {
        $validConfigurations = [
            [Token::DIGITS, Token::DIGITS],
            [Token::DIGITS, Token::LABEL_STRING, Token::DIGITS],
            [Token::DIGITS, Token::DIGITS, Token::LABEL_STRING],
            [Token::DIGITS, Token::LABEL_STRING, Token::DIGITS, Token::LABEL_STRING]
        ];

        $isRange = false;
        $chunkedList = $this->chunk($tokenList);
        foreach ($validConfigurations as $configuration) {
            $isRange = $isRange || $this->chunksMatchConfiguration($chunkedList, $configuration);
            // TODO: Needs to check for valid verisons too (by joining to label etc)
        }

        return $isRange;
    }

    /**
     * Returns true if the provided token
     *
     * @param Token[][] $chunkedList
     * @param string[] $configuration
     *
     * @return boolean
     */
    private function chunksMatchConfiguration(
        array $chunkedList,
        array $configuration
    ) {
        $matches = count($chunkedList) === count($configuration);

        foreach ($configuration as $index => $token) {
            if ($matches) {
                $matches = $chunkedList[$index][0]->getType() === $token;
            }
        }

        return $matches;
    }

    /**
     * Build a ComparatorVersion representing the hyphenated range.
     *
     * @param Token[] $tokenList
     *
     * @return VersionRangeInterface
     */
    public function parse(array $tokenList)
    {
        if (!$this->canParse($tokenList)) {
            throw new \RuntimeException('Invalid version');
        }

        $chunkedList = $this->chunk($tokenList);

        switch (count($chunkedList)) {


            // No labels
            case 2:
                $lowerVersionConstraint = $this->getLowerConstraint($chunkedList[0]);

                $upperVersionConstraint = $this->getUpperConstraint($chunkedList[1]);

                break;

            // Label on one version
            case 3:
                // Label belongs to first version
                if (Token::LABEL_STRING === $chunkedList[1][0]->getType()) {
                    $lowerVersionConstraint = $this->getLowerConstraint($chunkedList[0], $chunkedList[1]);
                    $upperVersionConstraint = $this->getUpperConstraint($chunkedList[2]);

                // Label belongs to second version
                } else {
                    $lowerVersionConstraint = $this->getLowerConstraint($chunkedList[0]);
                    $upperVersionConstraint = $this->getUpperConstraint($chunkedList[1], $chunkedList[2]);
                }

                break;

            // Label on both versions
            case 4:
                $lowerVersionConstraint = $this->getLowerConstraint($chunkedList[0], $chunkedList[1]);
                $upperVersionConstraint = $this->getUpperConstraint($chunkedList[2], $chunkedList[3]);
                break;
        }

        return new LogicalAnd(
            $lowerVersionConstraint,
            $upperVersionConstraint
        );
    }

    /**
     * Determines the correct lower version constraint for a hyphenated range.
     *
     * @param Token[] $versionTokenList
     * @param Token[] $labelTokenList
     *
     * @return VersionRangeInterface
     */
    private function getLowerConstraint(array $versionTokenList, array $labelTokenList = [])
    {
        $tokenList = $versionTokenList;
        if (count($labelTokenList)) {
            $tokenList[] = new Token(Token::DASH_SEPARATOR, '-');
            $tokenList = array_merge($tokenList, $labelTokenList);
        }

        return new ComparatorVersion(
            $this->greaterOrEqualTo,
            $this->versionParser->parse($tokenList)
        );
    }

    /**
     * Determines the correct upper version constraint for a hyphenated range.
     *
     * @param Token[] $versionTokenList
     * @param Token[] $labelTokenList
     *
     * @return VersionRangeInterface
     */
    private function getUpperConstraint(array $versionTokenList, array $labelTokenList = [])
    {
        $major = 0;
        $minor = 0;
        $patch = 0;
        $comparator = $this->lessThan;
        $labelBuilder = new LabelBuilder();

        switch (count($versionTokenList)) {
            case 1:
                $major = $versionTokenList[0]->getValue() + 1;
                break;

            case 3:
                $major = $versionTokenList[0]->getValue();
                $minor = $versionTokenList[2]->getValue() + 1;
                break;

            case 5:
                $comparator = $this->lessOrEqualTo;
                $major = $versionTokenList[0]->getValue();
                $minor = $versionTokenList[2]->getValue();
                $patch = $versionTokenList[4]->getValue();
                break;
        }

        return new ComparatorVersion(
            $comparator,
            new Version(
                $major,
                $minor,
                $patch,
                $labelBuilder->buildFromTokens($labelTokenList)
            )
        );
    }
}


1		<?php
2
3		/**
4		* @copyright (c) 2014-2017 brian ridley
5		* @author brian ridley <[email protected]>
6		* @license http://opensource.org/licenses/MIT MIT
7		*
8		* For the full copyright and license information, please view the LICENSE
9		* file that was distributed with this source code.
10		*/
11
12		namespace ptlis\SemanticVersion\Parse\RangeMatcher;
13
14		use ptlis\SemanticVersion\Comparator\ComparatorInterface;
15		use ptlis\SemanticVersion\Parse\Token;
16		use ptlis\SemanticVersion\Parse\VersionParser;
17		use ptlis\SemanticVersion\Version\Label\LabelBuilder;
18		use ptlis\SemanticVersion\Version\Version;
19		use ptlis\SemanticVersion\VersionRange\ComparatorVersion;
20		use ptlis\SemanticVersion\VersionRange\LogicalAnd;
21		use ptlis\SemanticVersion\VersionRange\VersionRangeInterface;
22
23		/**
24		* Parser for hyphenated ranges.
25		*
26		* Hyphenated ranges are implemented as described @ https://getcomposer.org/doc/articles/versions.md#range-hyphen-
27		*/
28		final class HyphenatedRangeParser implements RangeParserInterface
29		{
30		use ChunkByDash;
31
32		/** @var VersionParser */
33		private $versionParser;
34
35		/** @var ComparatorInterface */
36		private $greaterOrEqualTo;
37
38		/** @var ComparatorInterface */
39		private $lessThan;
40
41		/** @var ComparatorInterface */
42		private $lessOrEqualTo;
43
44
45		/**
46		* Constructor.
47		*
48		* @param VersionParser $versionParser
49		* @param ComparatorInterface $greaterOrEqualTo
50		* @param ComparatorInterface $lessThan
51		* @param ComparatorInterface $lessOrEqualTo
52		*/
53	11	public function __construct(
54		VersionParser $versionParser,
55		ComparatorInterface $greaterOrEqualTo,
56		ComparatorInterface $lessThan,
57		ComparatorInterface $lessOrEqualTo
58		) {
59	11	$this->versionParser = $versionParser;
60	11	$this->greaterOrEqualTo = $greaterOrEqualTo;
61	11	$this->lessThan = $lessThan;
62	11	$this->lessOrEqualTo = $lessOrEqualTo;
63	11	}
64
65		/**
66		* Returns true if the token list can be parsed as a hyphenated range.
67		*
68		* @param Token[] $tokenList
69		*
70		* @return boolean
71		*/
72	11	public function canParse(array $tokenList)
73		{
74		$validConfigurations = [
75	11	[Token::DIGITS, Token::DIGITS],
76		[Token::DIGITS, Token::LABEL_STRING, Token::DIGITS],
77		[Token::DIGITS, Token::DIGITS, Token::LABEL_STRING],
78		[Token::DIGITS, Token::LABEL_STRING, Token::DIGITS, Token::LABEL_STRING]
79		];
80
81	11	$isRange = false;
82	11	$chunkedList = $this->chunk($tokenList);
83	11	foreach ($validConfigurations as $configuration) {
84	11	$isRange = $isRange \|\| $this->chunksMatchConfiguration($chunkedList, $configuration);
85		// TODO: Needs to check for valid verisons too (by joining to label etc)
86		}
87
88	11	return $isRange;
89		}
90
91		/**
92		* Returns true if the provided token
93		*
94		* @param Token[][] $chunkedList
95		* @param string[] $configuration
96		*
97		* @return boolean
98		*/
99	11	private function chunksMatchConfiguration(
100		array $chunkedList,
101		array $configuration
102		) {
103	11	$matches = count($chunkedList) === count($configuration);
104
105	11	foreach ($configuration as $index => $token) {
106	11	if ($matches) {
107	11	$matches = $chunkedList[$index][0]->getType() === $token;
108		}
109		}
110
111	11	return $matches;
112		}
113
114		/**
115		* Build a ComparatorVersion representing the hyphenated range.
116		*
117		* @param Token[] $tokenList
118		*
119		* @return VersionRangeInterface
120		*/
121	10	public function parse(array $tokenList)
122		{
123	10	if (!$this->canParse($tokenList)) {
124	4	throw new \RuntimeException('Invalid version');
125		}
126
127	6	$chunkedList = $this->chunk($tokenList);
128
129	6	switch (count($chunkedList)) {
		1 ignored issue – show Coding Style introduced 2017-01-30 21:43 UTC by Report Bug Copy Issue Report Blank line found at start of control structure Loading history...
130
131		// No labels
132	6	case 2:
133	3	$lowerVersionConstraint = $this->getLowerConstraint($chunkedList[0]);
		0 ignored issues – show Comprehensibility Naming introduced 2017-01-30 21:43 UTC by Report Bug Copy Issue Report The variable name `$lowerVersionConstraint` exceeds the maximum configured length of `20`. Very long variable names usually make code harder to read. It is therefore recommended not to make variable names too verbose. Loading history...
134	3	$upperVersionConstraint = $this->getUpperConstraint($chunkedList[1]);
		0 ignored issues – show Comprehensibility Naming introduced 2017-01-30 21:43 UTC by Report Bug Copy Issue Report The variable name `$upperVersionConstraint` exceeds the maximum configured length of `20`. Very long variable names usually make code harder to read. It is therefore recommended not to make variable names too verbose. Loading history...
135	3	break;
136
137		// Label on one version
138	3	case 3:
139		// Label belongs to first version
140	2	if (Token::LABEL_STRING === $chunkedList[1][0]->getType()) {
141	1	$lowerVersionConstraint = $this->getLowerConstraint($chunkedList[0], $chunkedList[1]);
142	1	$upperVersionConstraint = $this->getUpperConstraint($chunkedList[2]);
143
144		// Label belongs to second version
145		} else {
146	1	$lowerVersionConstraint = $this->getLowerConstraint($chunkedList[0]);
147	1	$upperVersionConstraint = $this->getUpperConstraint($chunkedList[1], $chunkedList[2]);
148		}
149
150	2	break;
151
152		// Label on both versions
153	1	case 4:
154	1	$lowerVersionConstraint = $this->getLowerConstraint($chunkedList[0], $chunkedList[1]);
155	1	$upperVersionConstraint = $this->getUpperConstraint($chunkedList[2], $chunkedList[3]);
156	1	break;
157		}
158
159	6	return new LogicalAnd(
160		$lowerVersionConstraint,
161		$upperVersionConstraint
162		);
163		}
164
165		/**
166		* Determines the correct lower version constraint for a hyphenated range.
167		*
168		* @param Token[] $versionTokenList
169		* @param Token[] $labelTokenList
170		*
171		* @return VersionRangeInterface
172		*/
173	6	private function getLowerConstraint(array $versionTokenList, array $labelTokenList = [])
174		{
175	6	$tokenList = $versionTokenList;
176	6	if (count($labelTokenList)) {
177	2	$tokenList[] = new Token(Token::DASH_SEPARATOR, '-');
178	2	$tokenList = array_merge($tokenList, $labelTokenList);
179		}
180
181	6	return new ComparatorVersion(
182	6	$this->greaterOrEqualTo,
183	6	$this->versionParser->parse($tokenList)
184		);
185		}
186
187		/**
188		* Determines the correct upper version constraint for a hyphenated range.
189		*
190		* @param Token[] $versionTokenList
191		* @param Token[] $labelTokenList
192		*
193		* @return VersionRangeInterface
194		*/
195	6	private function getUpperConstraint(array $versionTokenList, array $labelTokenList = [])
196		{
197	6	$major = 0;
198	6	$minor = 0;
199	6	$patch = 0;
200	6	$comparator = $this->lessThan;
201	6	$labelBuilder = new LabelBuilder();
202
203	6	switch (count($versionTokenList)) {
204	6	case 1:
205	1	$major = $versionTokenList[0]->getValue() + 1;
206	1	break;
207
208	5	case 3:
209	1	$major = $versionTokenList[0]->getValue();
210	1	$minor = $versionTokenList[2]->getValue() + 1;
211	1	break;
212
213	4	case 5:
214	4	$comparator = $this->lessOrEqualTo;
215	4	$major = $versionTokenList[0]->getValue();
216	4	$minor = $versionTokenList[2]->getValue();
217	4	$patch = $versionTokenList[4]->getValue();
218	4	break;
219		}
220
221	6	return new ComparatorVersion(
222		$comparator,
223	6	new Version(
224		$major,
225		$minor,
226		$patch,
227	6	$labelBuilder->buildFromTokens($labelTokenList)
228		)
229		);
230		}
231		}
232

ptlis / semantic-version

Push — master ( 578d3f...fb2c6d )

HyphenatedRangeParser::getLowerConstraint() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like