Adsmurai\Currency\CurrencyFactory

Complexity

Total Complexity

26

Size/Duplication

Total Lines	113
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

97.96%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	fromDataPath()	0	7	1
A	fromDataArray()	0	6	1
B	validateCurrenciesData()	0	17	7
A	hasValidISOCode()	0	4	2
A	hasValidSymbol()	0	7	3
A	hasValidNumFractionalDigits()	0	4	2
A	getSupportedCurrencyISOCodes()	0	4	1
A	hasValidSymbolPlacement()	0	13	3
B	buildFromISOCode()	0	20	5

<?php

declare(strict_types=1);

namespace Adsmurai\Currency;

use Adsmurai\Currency\Contracts\Currency as CurrencyContract;
use Adsmurai\Currency\Contracts\CurrencyFactory as CurrencyFactoryContract;
use Adsmurai\Currency\Errors\InvalidCurrenciesDataError;
use Adsmurai\Currency\Errors\UnsupportedCurrencyISOCodeError;

final class CurrencyFactory implements CurrencyFactoryContract
{
    const DEFAULT_DATA_PATH = __DIR__.'/Data/CurrencyTypes.php';

    /** @var array */
    private $data;

    /** @var Currency[] */
    private $currencies;

    private function __construct(array $data)
    {
        $this->data = $data;
        $this->currencies = [];
    }

    public static function fromDataPath(string $dataPath = self::DEFAULT_DATA_PATH): CurrencyFactory
    {
        /** @var array $data */
        $data = include $dataPath;

        return self::fromDataArray($data);
    }

    public static function fromDataArray(array $data): CurrencyFactory
    {
        self::validateCurrenciesData($data);

        return new self($data);
    }

    /**
     * @param array $currenciesData
     *
     * @throws InvalidCurrenciesDataError
     */
    private static function validateCurrenciesData(array $currenciesData)
    {
        if (empty($currenciesData)) {
            throw new InvalidCurrenciesDataError();
        }

        foreach ($currenciesData as $ISOCode => $currencyData) {
            if (
                !self::hasValidISOCode($ISOCode)
                || !self::hasValidSymbol($currencyData)
                || !self::hasValidSymbolPlacement($currencyData)
                || !self::hasValidNumFractionalDigits($currencyData)
            ) {
                throw new InvalidCurrenciesDataError();
            }
        }
    }

    private static function hasValidISOCode($ISOCode): bool
    {
        return \is_string($ISOCode) && !empty($ISOCode);
    }

    private static function hasValidSymbol(array $currencyData): bool
    {
        return
            isset($currencyData['symbol'])
            && \is_string($currencyData['symbol'])
            && !empty($currencyData['symbol']);
    }

    private static function hasValidSymbolPlacement(array $currencyData): bool
    {
        return
            isset($currencyData['symbolPlacement'])
            && \is_int($currencyData['symbolPlacement'])
            && \in_array(
                $currencyData['symbolPlacement'],
                [
                    CurrencyContract::BEFORE_PLACEMENT,
                    CurrencyContract::AFTER_PLACEMENT,
                ]
            );
    }

    private static function hasValidNumFractionalDigits(array $currencyData): bool
    {
        return isset($currencyData['numFractionalDigits']) && \is_int($currencyData['numFractionalDigits']);
    }

    public function buildFromISOCode(string $ISOCode): CurrencyContract
    {
        if (!isset($this->data[$ISOCode])) {
            throw new UnsupportedCurrencyISOCodeError($ISOCode);
        }

        if (!isset($this->currencies[$ISOCode])) {
            $this->currencies[$ISOCode] = new Currency(
                $ISOCode,
                $this->data[$ISOCode]['symbol'],
                $this->data[$ISOCode]['numFractionalDigits'],
                $this->data[$ISOCode]['symbolPlacement'],
                (isset($this->data[$ISOCode]['name']) && !empty($this->data[$ISOCode]['name']))
                    ? $this->data[$ISOCode]['name']
                    : ''
            );
        }

        return $this->currencies[$ISOCode];
    }

    /** @return string[] */
    public function getSupportedCurrencyISOCodes(): array
    {
        return \array_keys($this->data);
    }
}