Igni\Storage\Migration\Version

Complexity

Total Complexity

23

Size/Duplication

Total Lines	114
Duplicated Lines	0 %

Test Coverage

Coverage

94.64%

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	fromString()	0	8	2
A	__construct()	0	5	1
A	equals()	0	3	1
A	getPatch()	0	3	1
A	lowerOrEquals()	0	3	1
B	compare()	0	17	7
A	getNextMajor()	0	6	1
A	greaterThan()	0	3	1
A	getNextMinor()	0	6	1
A	__toString()	0	3	1
A	lowerThan()	0	3	1
A	greaterOrEquals()	0	3	1
A	getNextPatch()	0	6	1
A	getMinor()	0	3	1
A	getMajor()	0	3	1
A	equalsLiteral()	0	3	1

<?php declare(strict_types=1);

namespace Igni\Storage\Migration;

use Igni\Storage\Exception\VersionException;

final class Version
{
    private $major;
    private $minor;
    private $patch;

    public function __construct(int $major, int $minor, int $patch)
    {
        $this->major = $major;
        $this->minor = $minor;
        $this->patch = $patch;
    }

    public function getMajor(): int
    {
        return $this->major;
    }

    public function getMinor(): int
    {
        return $this->minor;
    }

    public function getPatch(): int
    {
        return $this->patch;
    }

    public function compare(Version $version): int
    {
        if ($version->major > $this->major) {
            return 1;
        } else if ($this->major > $version->major) {
            return -1;
        } else if ($version->minor > $this->minor) {
            return 1;
        } else if ($this->minor > $version->minor) {
            return -1;
        } else if ($version->patch > $this->patch) {
            return 1;
        } else if ($this->patch > $version->patch) {
            return -1;
        }

        return 0;
    }

    public function lowerThan(Version $version): bool
    {
        return $this->compare($version) === 1;
    }

    public function lowerOrEquals(Version $version): bool
    {
        return $this->compare($version) >= 0;
    }

    public function greaterThan(Version $version): bool
    {
        return $this->compare($version) === -1;
    }

    public function greaterOrEquals(Version $version): bool
    {
        return $this->compare($version) <= 0;
    }

    public function equals(Version $version): bool
    {
        return $this->compare($version) === 0;
    }

    public function equalsLiteral(string $version): bool
    {
        return (string) $this === $version;
    }

    public function getNextPatch(): self
    {
        $instance = clone $this;
        $instance->patch++;

        return $instance;
    }

    public function getNextMinor(): self
    {
        $instance = clone $this;
        $instance->minor++;

        return $instance;
    }

    public function getNextMajor(): self
    {
        $instance = clone $this;
        $instance->major++;

        return $instance;
    }

    public static function fromString(string $version): self
    {
        $version = explode('.', $version);
        if (count($version) !== 3) {
            throw VersionException::forParseError(implode('.', $version));
        }

        return new self((int) $version[0], (int) $version[1], (int) $version[2]);
    }

    public function __toString(): string
    {
        return "{$this->major}.{$this->minor}.{$this->patch}";
    }
}