ptlis\SemanticVersion\VersionEngine

Complexity

Total Complexity

6

Size/Duplication

Total Lines	98
Duplicated Lines	0 %

Coupling/Cohesion

Dependencies

12

Test Coverage

Coverage

100%

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	0	33	1
A	parseVersion()	0	18	3
A	parseRange()	0	12	2

<?php

/**
 * @copyright   (c) 2014-2017 brian ridley
 * @author      brian ridley <ptlis@ptlis.net>
 * @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

The class VersionEngine has a coupling between objects value of 18. Consider to reduce the number of dependencies under 13.

{
    /** @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('>='),

It seems like $comparatorFactory->get('>=') can be null; however, __construct() does not accept null, maybe add an additional type check?

            $comparatorFactory->get('<')

It seems like $comparatorFactory->get('<') can be null; however, __construct() does not accept null, maybe add an additional type check?

        );

        $matcherList = [
            new CaretRangeParser(
                $comparatorFactory->get('>='),

It seems like $comparatorFactory->get('>=') can be null; however, __construct() does not accept null, maybe add an additional type check?

                $comparatorFactory->get('<')

It seems like $comparatorFactory->get('<') can be null; however, __construct() does not accept null, maybe add an additional type check?

            ),
            new TildeRangeParser($wildcardParser),
            $wildcardParser,
            new BranchParser($wildcardParser),
            new ComparatorVersionParser(
                $comparatorFactory,
                $versionBuilder
            ),
            new HyphenatedRangeParser(
                $versionBuilder,
                $comparatorFactory->get('>='),

It seems like $comparatorFactory->get('>=') can be null; however, __construct() does not accept null, maybe add an additional type check?

                $comparatorFactory->get('<'),

It seems like $comparatorFactory->get('<') can be null; however, __construct() does not accept null, maybe add an additional type check?

                $comparatorFactory->get('<=')

It seems like $comparatorFactory->get('<=') can be null; however, __construct() does not accept null, maybe add an additional type check?

            )
        ];

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