VersionEngine::parseRange() - Code Metrics - Inspection of "Make property docblocks more terse" - ptlis/semantic-version - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 475c0f...a498f5 )

by brian

created 2017-02-04 21:23 UTC

VersionEngine::parseRange() A

↳ Parent: VersionEngine

Complexity

Conditions	2
Paths	2

Size

Total Lines	12
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	12
ccs	6
cts	6
cp	1
rs	9.4285
c	0
b	0
f	0
cc	2
eloc	7
nc	2
nop	1
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;

use ptlis\SemanticVersion\Comparator\ComparatorFactory;
use ptlis\SemanticVersion\Parse\Matcher\BranchParser;
use ptlis\SemanticVersion\Parse\Matcher\CaretRangeParser;
use ptlis\SemanticVersion\Parse\Matcher\ComparatorVersionParser;
use ptlis\SemanticVersion\Parse\Matcher\HyphenatedRangeParser;
use ptlis\SemanticVersion\Parse\Matcher\TildeRangeParser;
use ptlis\SemanticVersion\Parse\Matcher\WildcardRangeParser;
use ptlis\SemanticVersion\Parse\VersionParser;
use ptlis\SemanticVersion\Parse\VersionTokenizer;
use ptlis\SemanticVersion\Version\Label\LabelBuilder;
use ptlis\SemanticVersion\Version\VersionBuilder;
use ptlis\SemanticVersion\Version\VersionInterface;
use ptlis\SemanticVersion\VersionRange\ComparatorVersion;
use ptlis\SemanticVersion\VersionRange\VersionRangeInterface;

/**
 * Simple class to provide version parsing with good defaults.
 */
final class VersionEngine

{
    /** @var VersionTokenizer */
    private $tokenizer;

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


    /**
     * Constructor.
     */
    public function __construct()
    {
        $comparatorFactory = new ComparatorFactory();
        $versionBuilder = new VersionBuilder(new LabelBuilder());

        $wildcardParser = new WildcardRangeParser(
            $comparatorFactory->get('>='),
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
            $comparatorFactory->get('<')
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
        );

        $matcherList = [
            new CaretRangeParser(
                $comparatorFactory->get('>='),
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
                $comparatorFactory->get('<')
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
            ),
            new TildeRangeParser($wildcardParser),
            $wildcardParser,
            new BranchParser($wildcardParser),
            new ComparatorVersionParser(
                $comparatorFactory,
                $versionBuilder
            ),
            new HyphenatedRangeParser(
                $versionBuilder,
                $comparatorFactory->get('>='),
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
                $comparatorFactory->get('<'),
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
                $comparatorFactory->get('<=')
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
            )
        ];

        $this->tokenizer = new VersionTokenizer();
        $this->parser = new VersionParser($matcherList);
    }

    /**
     * Parse a semantic version string into an object implementing VersionInterface.
     *
     * @todo Hacky - create a better method for handling this.
     *
     * @param string $versionString
     *
     * @throws \InvalidArgumentException When version string is invalid.
     *
     * @return VersionInterface
     */
    public function parseVersion($versionString)
    {
        $tokenList = $this->tokenizer->tokenize($versionString);

        try {
            $range = $this->parser->parseRange($tokenList);
        } catch (\RuntimeException $e) {
            throw new \InvalidArgumentException('"' . $versionString . '" is not a valid semantic version number', $e->getCode(), $e);
        }

        if (!($range instanceof ComparatorVersion)) {
            throw new \InvalidArgumentException(
                '"' . $versionString . '" is not a valid semantic version number'
            );
        }

        return $range->getVersion();
    }

    /**
     * Parse a version range & return an object implementing VersionRangeInterface that encodes those rules.
     *
     * @param string $rangeString
     *
     * @throws \InvalidArgumentException When version range string is invalid.
     *
     * @return VersionRangeInterface
     */
    public function parseRange($rangeString)
    {
        $tokenList = $this->tokenizer->tokenize($rangeString);

        try {
            $range = $this->parser->parseRange($tokenList);
        } catch (\RuntimeException $e) {
            throw new \InvalidArgumentException('"' . $rangeString . '" is not a valid version range', $e->getCode(), $e);
        }

        return $range;
    }
}


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;
13
14		use ptlis\SemanticVersion\Comparator\ComparatorFactory;
15		use ptlis\SemanticVersion\Parse\Matcher\BranchParser;
16		use ptlis\SemanticVersion\Parse\Matcher\CaretRangeParser;
17		use ptlis\SemanticVersion\Parse\Matcher\ComparatorVersionParser;
18		use ptlis\SemanticVersion\Parse\Matcher\HyphenatedRangeParser;
19		use ptlis\SemanticVersion\Parse\Matcher\TildeRangeParser;
20		use ptlis\SemanticVersion\Parse\Matcher\WildcardRangeParser;
21		use ptlis\SemanticVersion\Parse\VersionParser;
22		use ptlis\SemanticVersion\Parse\VersionTokenizer;
23		use ptlis\SemanticVersion\Version\Label\LabelBuilder;
24		use ptlis\SemanticVersion\Version\VersionBuilder;
25		use ptlis\SemanticVersion\Version\VersionInterface;
26		use ptlis\SemanticVersion\VersionRange\ComparatorVersion;
27		use ptlis\SemanticVersion\VersionRange\VersionRangeInterface;
28
29		/**
30		* Simple class to provide version parsing with good defaults.
31		*/
32		final class VersionEngine
		0 ignored issues – show Complexity introduced 2017-01-30 21:43 UTC by Report Bug Copy Issue Report The class VersionEngine has a coupling between objects value of 18. Consider to reduce the number of dependencies under 13. Loading history...
33		{
34		/** @var VersionTokenizer */
35		private $tokenizer;
36
37		/** @var VersionParser */
38		private $parser;
39
40
41		/**
42		* Constructor.
43		*/
44	7	public function __construct()
45		{
46	7	$comparatorFactory = new ComparatorFactory();
47	7	$versionBuilder = new VersionBuilder(new LabelBuilder());
48
49	7	$wildcardParser = new WildcardRangeParser(
50	7	$comparatorFactory->get('>='),
		0 ignored issues – show Bug introduced 2017-02-04 21:26 UTC by Report Bug Copy Issue Report It seems like `$comparatorFactory->get('>=')` can be `null`; however, `__construct()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
51	7	$comparatorFactory->get('<')
		0 ignored issues – show Bug introduced 2017-02-04 21:26 UTC by Report Bug Copy Issue Report It seems like `$comparatorFactory->get('<')` can be `null`; however, `__construct()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
52	7	);
53
54		$matcherList = [
55	7	new CaretRangeParser(
56	7	$comparatorFactory->get('>='),
		0 ignored issues – show Bug introduced 2017-01-30 21:43 UTC by Report Bug Copy Issue Report It seems like `$comparatorFactory->get('>=')` can be `null`; however, `__construct()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
57	7	$comparatorFactory->get('<')
		0 ignored issues – show Bug introduced 2017-01-30 21:43 UTC by Report Bug Copy Issue Report It seems like `$comparatorFactory->get('<')` can be `null`; however, `__construct()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
58	7	),
59	7	new TildeRangeParser($wildcardParser),
60	7	$wildcardParser,
61	7	new BranchParser($wildcardParser),
62	7	new ComparatorVersionParser(
63	7	$comparatorFactory,
64		$versionBuilder
65	7	),
66	7	new HyphenatedRangeParser(
67	7	$versionBuilder,
68	7	$comparatorFactory->get('>='),
		0 ignored issues – show Bug introduced 2017-01-30 21:43 UTC by Report Bug Copy Issue Report It seems like `$comparatorFactory->get('>=')` can be `null`; however, `__construct()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
69	7	$comparatorFactory->get('<'),
		0 ignored issues – show Bug introduced 2017-01-30 21:43 UTC by Report Bug Copy Issue Report It seems like `$comparatorFactory->get('<')` can be `null`; however, `__construct()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
70	7	$comparatorFactory->get('<=')
		0 ignored issues – show Bug introduced 2017-01-30 21:43 UTC by Report Bug Copy Issue Report It seems like `$comparatorFactory->get('<=')` can be `null`; however, `__construct()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
71	7	)
72	7	];
73
74	7	$this->tokenizer = new VersionTokenizer();
75	7	$this->parser = new VersionParser($matcherList);
76	7	}
77
78		/**
79		* Parse a semantic version string into an object implementing VersionInterface.
80		*
81		* @todo Hacky - create a better method for handling this.
82		*
83		* @param string $versionString
84		*
85		* @throws \InvalidArgumentException When version string is invalid.
86		*
87		* @return VersionInterface
88		*/
89	3	public function parseVersion($versionString)
90		{
91	3	$tokenList = $this->tokenizer->tokenize($versionString);
92
93		try {
94	3	$range = $this->parser->parseRange($tokenList);
95	3	} catch (\RuntimeException $e) {
96	1	throw new \InvalidArgumentException('"' . $versionString . '" is not a valid semantic version number', $e->getCode(), $e);
97		}
98
99	2	if (!($range instanceof ComparatorVersion)) {
100	1	throw new \InvalidArgumentException(
101	1	'"' . $versionString . '" is not a valid semantic version number'
102	1	);
103		}
104
105	1	return $range->getVersion();
106		}
107
108		/**
109		* Parse a version range & return an object implementing VersionRangeInterface that encodes those rules.
110		*
111		* @param string $rangeString
112		*
113		* @throws \InvalidArgumentException When version range string is invalid.
114		*
115		* @return VersionRangeInterface
116		*/
117	4	public function parseRange($rangeString)
118		{
119	4	$tokenList = $this->tokenizer->tokenize($rangeString);
120
121		try {
122	4	$range = $this->parser->parseRange($tokenList);
123	4	} catch (\RuntimeException $e) {
124	1	throw new \InvalidArgumentException('"' . $rangeString . '" is not a valid version range', $e->getCode(), $e);
125		}
126
127	3	return $range;
128		}
129		}
130

ptlis / semantic-version

Push — master ( 475c0f...a498f5 )

VersionEngine::parseRange() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like