Daikon\Money\ValueObject\Money

Complexity

Total Complexity

19

Size/Duplication

Total Lines	117
Duplicated Lines	0 %

Test Coverage

Coverage

64.71%

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	isNegative()	0	3	1
A	asBaseMoney()	0	3	1
A	isZero()	0	3	1
A	multiply()	0	5	1
A	isLessThanOrEqual()	0	4	1
A	subtract()	0	6	1
A	getAmount()	0	3	1
A	add()	0	6	1
A	divide()	0	5	1
A	isPositive()	0	3	1
A	__toString()	0	3	1
A	zero()	0	4	1
A	equals()	0	4	1
A	__construct()	0	3	1
A	isGreaterThanOrEqual()	0	4	1
A	fromNative()	0	8	2
A	getCurrency()	0	3	1
A	toNative()	0	3	1

<?php declare(strict_types=1);
/**
 * This file is part of the daikon-cqrs/money-interop project.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Daikon\Money\ValueObject;

use Assert\Assertion;
use Daikon\Money\ValueObject\MoneyInterface;
use InvalidArgumentException;
use Money\Currency as PhpCurrency;
use Money\Money as PhpMoney;

final class Money implements MoneyInterface
{
    private PhpMoney $money;

    /** @param self $comparator */
    public function equals($comparator): bool
    {
        Assertion::isInstanceOf($comparator, self::class);
        return $this->toNative() === $comparator->toNative();
    }

    public function getAmount(): string
    {
        return $this->money->getAmount();
    }

    public function getCurrency(): string
    {
        return $this->money->getCurrency()->getCode();
    }

    /** @param float|int|string $multiplier */
    public function multiply($multiplier, int $roundingMode = self::ROUND_HALF_UP): self
    {
        Assertion::numeric($multiplier, 'Multipler must be numeric.');
        $multiplied = $this->money->multiply($multiplier, $roundingMode);
        return new self($multiplied);
    }

    /** @param float|int|string $divisor */
    public function divide($divisor, int $roundingMode = self::ROUND_HALF_UP): self
    {
        Assertion::numeric($divisor, 'Divider must be numeric.');
        $divided = $this->money->divide($divisor, $roundingMode);
        return new self($divided);
    }

    public function add(MoneyInterface $money): self
    {
        $added = $this->money->add(
            self::asBaseMoney($money->getAmount(), $money->getCurrency())
        );
        return new self($added);
    }

    public function subtract(MoneyInterface $money): self
    {
        $subtracted = $this->money->subtract(
            self::asBaseMoney($money->getAmount(), $money->getCurrency())
        );
        return new self($subtracted);
    }

    public function isZero(): bool
    {
        return $this->money->isZero();
    }

    public function isPositive(): bool
    {
        return $this->money->isPositive();
    }

    public function isNegative(): bool
    {
        return $this->money->isNegative();
    }

    public function isLessThanOrEqual(MoneyInterface $money): bool
    {
        return $this->money->lessThanOrEqual(
            self::asBaseMoney($money->getAmount(), $money->getCurrency())
        );
    }

    public function isGreaterThanOrEqual(MoneyInterface $money): bool
    {
        return $this->money->greaterThanOrEqual(
            self::asBaseMoney($money->getAmount(), $money->getCurrency())
        );
    }

    /** @param string $value */
    public static function fromNative($value): self
    {
        Assertion::string($value, 'Must be a string.');
        if (!preg_match('#^(?<amount>-?[0-9]+)(?<currency>[A-Z][A-Z0-9]*)$#', $value, $matches)) {
            throw new InvalidArgumentException('Invalid amount.');
        }

        return new self(self::asBaseMoney($matches['amount'], $matches['currency']));
    }

    public static function zero($currency = null): self
    {
        Assertion::regex($currency, '#^[A-Z][A-Z0-9]*$#', 'Invalid currency.');
        return self::fromNative('0'.(string)$currency);
    }

    public function toNative(): string
    {
        return $this->getAmount().$this->getCurrency();
    }

    public function __toString(): string
    {
        return $this->toNative();
    }

    private static function asBaseMoney(string $amount, string $currency): PhpMoney
    {
        return new PhpMoney($amount, new PhpCurrency($currency));
    }

    private function __construct(PhpMoney $money)
    {
        $this->money = $money;
    }
}