Version\Constraint\ComparisonConstraintParser

Complexity

Total Complexity

18

Size/Duplication

Total Lines	114
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

97.92%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	parse()	0	18	3
A	isMultiPartConstraint()	0	4	1
A	splitConstraintParts()	0	5	1
A	buildConstraint()	0	17	4
A	parseConstraint()	0	15	3
B	buildCompositeConstraint()	0	26	5
A	error()	0	4	1

<?php

declare(strict_types=1);

namespace Version\Constraint;

use Version\Exception\ExceptionInterface;
use Version\Exception\InvalidComparisonConstraintStringException;
use Version\Version;

/**
 * @author Nikola Posa <posa.nikola@gmail.com>
 */
class ComparisonConstraintParser
{
    public const OPERATOR_OR = '||';

    /**
     * @var string
     */
    protected $constraintString;

    /**
     * @var array
     */
    protected $constraintParts = [];

    /**
     * @param string $constraintString
     * @return ComparisonConstraint|CompositeConstraint
     */
    public function parse(string $constraintString)
    {
        $constraintString = trim($constraintString);

        if ('' === $constraintString) {
            throw InvalidComparisonConstraintStringException::forEmptyString();
        }

        $this->constraintString = $constraintString;

        if (! $this->isMultiPartConstraint()) {
            return $this->buildConstraint($this->constraintString);
        }

        $this->splitConstraintParts();

        return $this->buildCompositeConstraint();
    }

    protected function isMultiPartConstraint() : bool
    {
        return (false !== strpos($this->constraintString, ' '));
    }

    protected function splitConstraintParts() : void
    {
        $constraintParts = explode(' ', $this->constraintString);
        $this->constraintParts = array_map('trim', $constraintParts);
    }

    protected function buildConstraint(string $constraintPart) : ComparisonConstraint
    {
        [$operator, $operandString] = array_values($this->parseConstraint($constraintPart));

The variable $operator does not exist. Did you forget to declare it?

The variable $operandString does not exist. Did you forget to declare it?

        if (empty($operandString)) {
            $this->error();
        }

        try {
            return new ComparisonConstraint(
                $operator ?: ComparisonConstraint::OPERATOR_EQ,
                Version::fromString($operandString)
            );
        } catch (ExceptionInterface $ex) {
            $this->error();
        }
    }

    protected function parseConstraint(string $constraintStringUnit) : array
    {
        $i = 0;
        while (isset($constraintStringUnit[$i]) && !ctype_digit($constraintStringUnit[$i])) {
            $i++;
        }

        $operator = substr($constraintStringUnit, 0, $i);
        $operand = substr($constraintStringUnit, $i);

        return [
            'operator' => $operator,
            'operand' => $operand,
        ];
    }

    protected function buildCompositeConstraint() : CompositeConstraint
    {
        $compositeAndConstraints = $compositeOrConstraints = [];

        foreach ($this->constraintParts as $constraintPart) {
            if (self::OPERATOR_OR === $constraintPart) {
                $compositeOrConstraints[] = CompositeConstraint::and(...$compositeAndConstraints);
                $compositeAndConstraints = []; //reset collected AND constraints
            } else {
                $compositeAndConstraints[] = $this->buildConstraint($constraintPart);
            }
        }

        if (!empty($compositeOrConstraints)) {
            if (empty($compositeAndConstraints)) {
                //invalid OR constraint; no right side
                $this->error();
            }

            $compositeOrConstraints[] = CompositeConstraint::and(...$compositeAndConstraints);

            return CompositeConstraint::or(...$compositeOrConstraints);
        }

        return CompositeConstraint::and(...$compositeAndConstraints);
    }

    protected function error() : void
    {
        throw InvalidComparisonConstraintStringException::forUnparsableString($this->constraintString);
    }
}