Adsmurai\Currency\Currency

Complexity

Total Complexity

31

Size/Duplication

Total Lines	195
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	5

Test Coverage

Coverage

84.71%

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	2
A	fromFractionalUnits()	0	10	1
B	extractNumericAmount()	0	16	5
A	getAmountPlusIsoCodePattern()	0	6	1
A	getAmountPlusSymbolPattern()	0	8	2
A	getCurrencyType()	0	4	1
A	getAmountAsDecimal()	0	4	1
A	getAmountAsFractionalUnits()	0	9	1
B	decorate()	0	18	5
A	equals()	0	7	3
A	fromFloat()	0	13	3
A	fromString()	0	7	1
A	fromDecimal()	0	7	1
B	format()	0	24	4

<?php

declare(strict_types=1);

namespace Adsmurai\Currency;

use Adsmurai\Currency\Contracts\Currency as CurrencyInterface;
use Adsmurai\Currency\Contracts\CurrencyFormat as CurrencyFormatInterface;
use Adsmurai\Currency\Contracts\CurrencyType;

This use statement conflicts with another class in this namespace, Adsmurai\Currency\CurrencyType.

use InvalidArgumentException;
use Litipk\BigNumbers\Decimal;
use Litipk\BigNumbers\Errors\InfiniteInputError;
use Litipk\BigNumbers\Errors\NaNInputError;

final class Currency implements CurrencyInterface
{
    const DECIMAL_NUMBER_REGEXP = '(?P<amount> 0*(([1-9][0-9]*|[0-9])(\.[0-9]+)?))';
    const SIMPLE_CURRENCY_PATTERN = '/^'.self::DECIMAL_NUMBER_REGEXP.'$/x';
    const INNER_FRACTIONAL_DIGITS = 8;

    /** @var Decimal */
    private $amount;

    /** @var CurrencyType */
    private $currencyType;

    /**
     * @param Decimal      $amount
     * @param CurrencyType $currencyType
     */
    private function __construct(Decimal $amount, CurrencyType $currencyType)
    {
        if ($amount->isNegative()) {
            throw new InvalidArgumentException('Currency amounts must be positive');
        }

        $this->amount = $amount;
        $this->currencyType = $currencyType;
    }

    public static function fromFloat(float $amount, CurrencyType $currencyType): Currency
    {
        try {
            return new self(
                Decimal::fromFloat($amount, self::INNER_FRACTIONAL_DIGITS),
                $currencyType
            );
        } catch (InfiniteInputError $e) {
            throw new InvalidArgumentException('Currency amounts must be finite', 0, $e);
        } catch (NaNInputError $e) {
            throw new InvalidArgumentException('Currency amounts must be numbers', 0, $e);
        }
    }

    public static function fromFractionalUnits(int $amount, CurrencyType $currencyType): Currency
    {
        $decimalAmount = Decimal::fromInteger($amount)
            ->div(
                Decimal::fromInteger(10 ** $currencyType->getNumFractionalDigits()),
                self::INNER_FRACTIONAL_DIGITS
            );

        return new self($decimalAmount, $currencyType);
    }

    public static function fromString(string $amount, CurrencyType $currencyType): Currency
    {
        return new self(
            self::extractNumericAmount($amount, $currencyType),
            $currencyType
        );
    }

    private static function extractNumericAmount(string $amount, CurrencyType $currencyType): Decimal
    {
        try {
            if (
                1 === \preg_match(self::SIMPLE_CURRENCY_PATTERN, $amount, $matches) ||
                1 === \preg_match(self::getAmountPlusIsoCodePattern($currencyType), $amount, $matches) ||
                1 === \preg_match(self::getAmountPlusSymbolPattern($currencyType), $amount, $matches)
            ) {
                return Decimal::fromString($matches['amount'], self::INNER_FRACTIONAL_DIGITS);
            } else {
                throw new InvalidArgumentException('Invalid currency value');
            }
        } catch (NaNInputError $e) {
            throw new InvalidArgumentException('Currency amounts must be numbers', 0, $e);
        }
    }

    /**
     * @param CurrencyType $currencyType
     *
     * @return string
     */
    private static function getAmountPlusIsoCodePattern(CurrencyType $currencyType): string
    {
        $amountPlusIsoCodePattern = '/^'.self::DECIMAL_NUMBER_REGEXP.'\s*'.$currencyType->getISOCode().'$/x';

        return $amountPlusIsoCodePattern;
    }

    private static function getAmountPlusSymbolPattern(CurrencyType $currencyType): string
    {
        $escapedSymbol = \preg_quote($currencyType->getSymbol());

        return (CurrencyType::BEFORE_PLACEMENT === $currencyType->getSymbolPlacement())
            ? '/^'.$escapedSymbol.'\s*'.self::DECIMAL_NUMBER_REGEXP.'$/x'
            : '/^'.self::DECIMAL_NUMBER_REGEXP.'\s*'.$escapedSymbol.'$/x';
    }

    public static function fromDecimal(Decimal $amount, CurrencyType $currencyType): Currency
    {
        return new self(
            Decimal::fromDecimal($amount, self::INNER_FRACTIONAL_DIGITS),
            $currencyType
        );
    }

    public function getCurrencyType(): CurrencyType
    {
        return $this->currencyType;
    }

    /**
     * {@inheritdoc}
     */
    public function getAmountAsDecimal(): Decimal
    {
        return $this->amount;
    }

    /**
     * {@inheritdoc}
     */
    public function getAmountAsFractionalUnits(): int
    {
        return $this->amount
            ->mul(
                Decimal::fromInteger(10 ** $this->currencyType->getNumFractionalDigits()),
                self::INNER_FRACTIONAL_DIGITS
            )
            ->asInteger();
    }

    /**
     * {@inheritdoc}
     */
    public function format(CurrencyFormatInterface $currencyFormat = null): string
    {
        if (is_null($currencyFormat)) {
            $currencyFormat = CurrencyFormat::default();
        }

        $nDecimals = $currencyFormat->getPrecision();
        if (is_null($nDecimals)) {
            $nDecimals = $this->currencyType->getNumFractionalDigits() + $currencyFormat->getExtraPrecision();
        }

        $amount = Decimal::fromDecimal($this->amount, $nDecimals);

        $number = ('' === $currencyFormat->getThousandsSeparator())
            ? \str_replace('.', $currencyFormat->getDecimalsSeparator(), $amount->__toString())  // This is safer!
            : \number_format(
                $amount->asFloat(),
                $nDecimals,
                $currencyFormat->getDecimalsSeparator(),
                $currencyFormat->getThousandsSeparator()
            );

        return $this->decorate($number, $currencyFormat);
    }

    /**
     * @param string                  $number
     * @param CurrencyFormatInterface $currencyFormat
     *
     * @return string
     */
    private function decorate(string $number, CurrencyFormatInterface $currencyFormat): string
    {
        $separator = (CurrencyFormat::DECORATION_WITH_SPACE === $currencyFormat->getDecorationSpace())
            ? ' '
            : '';
        switch ($currencyFormat->getDecorationType()) {
            case CurrencyFormat::DECORATION_NO_DECORATION:
                return $number;
                break;

break is not strictly necessary here and could be removed.

            case CurrencyFormat::DECORATION_ISO_CODE:
                return $number.$separator.$this->currencyType->getISOCode();
                break;

break is not strictly necessary here and could be removed.

            default:
                return (CurrencyType::BEFORE_PLACEMENT === $this->currencyType->getSymbolPlacement())
                    ? $this->currencyType->getSymbol().$separator.$number
                    : $number.$separator.$this->currencyType->getSymbol();
        }
    }

    /**
     * {@inheritdoc}
     */
    public function equals(CurrencyInterface $currency): bool
    {
        return $currency === $this || (
                $this->amount->equals($currency->getAmountAsDecimal()) &&
                $this->currencyType->equals($currency->getCurrencyType())
            );
    }
}