IbanGenerator\Iban

Complexity

Total Complexity

22

Size/Duplication

Total Lines	245
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	1

Importance

Changes	1
Bugs	0	Features	0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	1
A	fromString()	0	20	2
A	fromBbanAndCountry()	0	12	1
A	countryCode()	0	4	1
A	ibanCheckDigits()	0	4	1
A	bankCode()	0	4	1
A	branchCode()	0	4	1
A	countryCheckDigits()	0	4	1
A	accountNumber()	0	4	1
A	__toString()	0	6	1
A	validateCountryCodeFormat()	0	6	2
A	validateCheckDigitsFormat()	0	6	2
A	validateControlDigit()	0	11	2
A	validateSupportedCountry()	0	11	2
A	validateChecksum()	0	12	1
A	digitToInt()	0	8	2

<?php

namespace IbanGenerator;

use IbanGenerator\Bban\BbanInterface;
use IbanGenerator\Bban\SpainBban;
use InvalidArgumentException;

class Iban
{
    /**
     * @var BbanInterface
     */
    private $bban;

    /**
     * @var string
     */
    private $countryCode;

    /**
     * @var string
     */
    private $checkDigits;

    /**
     * @var array
     */
    private static $countriesSupported = [
        'ES' => SpainBban::class,
    ];

    /**
     * Iban constructor.
     *
     * @param string $countryCode
     * @param string $checkDigits
     * @param BbanInterface $bban
     *
     * @throws InvalidArgumentException
     */
    public function __construct($countryCode, $checkDigits, BbanInterface $bban)
    {
        $countryCode = strtoupper($countryCode);
        static::validateCountryCodeFormat($countryCode);

Since validateCountryCodeFormat() is declared private, calling it with static will lead to errors in possible sub-classes. You can either use self, or increase the visibility of validateCountryCodeFormat() to at least protected.

        static::validateCheckDigitsFormat($checkDigits);

Since validateCheckDigitsFormat() is declared private, calling it with static will lead to errors in possible sub-classes. You can either use self, or increase the visibility of validateCheckDigitsFormat() to at least protected.

        static::validateControlDigit($countryCode, $checkDigits, $bban);

Since validateControlDigit() is declared private, calling it with static will lead to errors in possible sub-classes. You can either use self, or increase the visibility of validateControlDigit() to at least protected.

        $this->countryCode = $countryCode;
        $this->checkDigits = $checkDigits;
        $this->bban = $bban;
    }

    /**
     * @param string $iban
     *
     * @throws InvalidArgumentException
     *
     * @return static
     */
    public static function fromString($iban)
    {
        if (! preg_match('/^[0-9A-Z]{16,34}$/', $iban)) {
            throw new InvalidArgumentException('Iban should be between 16 and 34 characters');
        }

        $countryCode = substr($iban, 0, 2);
        $checkDigits = substr($iban, 2, 2);
        $bbanString = substr($iban, 4);

        self::validateSupportedCountry($countryCode);
        $bbanClass = self::$countriesSupported[$countryCode];

        /**
         * @var BbanInterface
         */
        $bban = $bbanClass::fromString($bbanString);

        return new static($countryCode, $checkDigits, $bban);
    }

    /**
     * @param BbanInterface $bban
     * @param string $countryCode
     *
     * @throws InvalidArgumentException
     *
     * @return static
     */
    public static function fromBbanAndCountry(BbanInterface $bban, $countryCode)
    {
        static::validateCountryCodeFormat($countryCode);

Since validateCountryCodeFormat() is declared private, calling it with static will lead to errors in possible sub-classes. You can either use self, or increase the visibility of validateCountryCodeFormat() to at least protected.

        static::validateCountryCodeFormat($countryCode);

Since validateCountryCodeFormat() is declared private, calling it with static will lead to errors in possible sub-classes. You can either use self, or increase the visibility of validateCountryCodeFormat() to at least protected.

        static::validateSupportedCountry($countryCode);

Since validateSupportedCountry() is declared private, calling it with static will lead to errors in possible sub-classes. You can either use self, or increase the visibility of validateSupportedCountry() to at least protected.

        $checksum = self::validateChecksum($countryCode, '00', $bban);
        $checkDigit = 98 - (int) $checksum;
        $checkDigit = str_pad($checkDigit, 2, 0, STR_PAD_LEFT);

        return new static($countryCode, $checkDigit, $bban);
    }

    /**
     * @return string
     */
    public function countryCode()
    {
        return $this->countryCode;
    }

    /**
     * @return string
     */
    public function ibanCheckDigits()
    {
        return $this->checkDigits;
    }

    /**
     * @return string
     */
    public function bankCode()
    {
        return $this->bban->bankCode();
    }

    /**
     * @return string
     */
    public function branchCode()
    {
        return $this->bban->branchCode();
    }

    /**
     * @return string
     */
    public function countryCheckDigits()
    {
        return $this->bban->checkDigits();
    }

    /**
     * @return string
     */
    public function accountNumber()
    {
        return $this->bban->accountNumber();
    }

    /**
     * @return string
     */
    public function __toString()
    {
        $bbanString = $this->bban;

        return $this->countryCode . $this->checkDigits . $bbanString;
    }

    /**
     * @param $countryCode
     *
     * @throws InvalidArgumentException
     */
    private static function validateCountryCodeFormat($countryCode)
    {
        if (! preg_match('/^[A-Z]{2}$/', $countryCode)) {
            throw new InvalidArgumentException('The country code should be 2 letters');
        }
    }

    /**
     * @param $checkDigits
     *
     * @throws InvalidArgumentException
     */
    private static function validateCheckDigitsFormat($checkDigits)
    {
        if (! preg_match('/^[\d]{2}$/', $checkDigits)) {
            throw new InvalidArgumentException('The IBAN checksum must be 2 numeric characters');
        }
    }

    /**
     * @param string $countryCode
     * @param string $checkDigits
     * @param BbanInterface $bban
     *
     * @throws InvalidArgumentException
     */
    private static function validateControlDigit(
        $countryCode,
        $checkDigits,
        BbanInterface $bban
    ) {
        $checksum = self::validateChecksum($countryCode, $checkDigits, $bban);

        if ($checksum !== '01') {
            throw new InvalidArgumentException('The IBAN checksum digits are not valid');
        }
    }

    /**
     * @param $countryCode
     *
     * @throws InvalidArgumentException
     */
    private static function validateSupportedCountry($countryCode)
    {
        if (!array_key_exists($countryCode, self::$countriesSupported)) {
            throw new InvalidArgumentException(
                sprintf(
                    'The country code %s is not supported',
                    $countryCode
                )
            );
        }
    }

    /**
     * @param $countryCode
     * @param $checkDigits
     * @param BbanInterface $bban
     *
     * @return string
     */
    private static function validateChecksum($countryCode, $checkDigits, BbanInterface $bban)
    {
        $rearranged = (string) $bban . $countryCode . $checkDigits;
        $digitsList = str_split($rearranged);

        $digitsList = array_map(['self', 'digitToInt'], $digitsList);
        $stringToCompute = implode('', $digitsList);

        $checksum = bcmod($stringToCompute, '97');

        return str_pad($checksum, 2, 0, STR_PAD_LEFT);
    }

    /**
     * @param string $value
     *
     * @return int
     */
    private static function digitToInt($value)

This method is not used, and could be removed.

    {
        if (is_numeric($value)) {
            return (int) $value;
        }

        return ord($value) - 55;
    }
}