byrokrat\id\Formatter\Formatter

Complexity

Total Complexity

40

Size/Duplication

Total Lines	153
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
D	__construct()	0	53	27
A	format()	0	4	1
A	registerFormattingFunction()	0	11	2
A	formatCentury()	0	8	2
A	formatSerialPre()	0	4	1
A	formatSerialPost()	0	4	1
A	formatDelimiter()	0	4	1
A	formatCheckDigit()	0	4	1
A	formatSex()	0	4	1
A	formatAge()	0	4	1
A	formatLegalForm()	0	4	1
A	formatBirthCounty()	0	4	1

<?php

declare(strict_types=1);

namespace byrokrat\id\Formatter;

use byrokrat\id\IdInterface;
use byrokrat\id\Exception\LogicException;
use byrokrat\id\Exception\DateNotSupportedException;

class Formatter implements FormatTokens
{
    /**
     * Map of tokens to formatting function names
     */
    private const TOKEN_MAP = [
        self::TOKEN_DATE_CENTURY => 'formatCentury',
        self::TOKEN_SERIAL_PRE => 'formatSerialPre',
        self::TOKEN_SERIAL_POST => 'formatSerialPost',
        self::TOKEN_DELIMITER => 'formatDelimiter',
        self::TOKEN_CHECK_DIGIT => 'formatCheckDigit',
        self::TOKEN_SEX => 'formatSex',
        self::TOKEN_AGE => 'formatAge',
        self::TOKEN_LEGAL_FORM => 'formatLegalForm',
        self::TOKEN_BIRTH_COUNTY => 'formatBirthCounty',
    ];

    /**
     * @var \Closure Formatting function, takes an Id object and returns a string
     */
    private $formatter;

    /**
     * Create formatter from format string
     */
    public function __construct(string $format = '')
    {
        // Register empty formatting function
        $this->formatter = function () {
            return '';
        };

        // Used to track escaping state
        $escape = '';

        foreach (str_split($format) as $token) {
            switch ($escape . $token) {
                case self::TOKEN_DATE_YEAR_FULL:
                case self::TOKEN_DATE_YEAR:
                case self::TOKEN_DATE_MONTH:
                case self::TOKEN_DATE_MONTH_SHORT:
                case self::TOKEN_DATE_MONTH_TEXT:
                case self::TOKEN_DATE_MONTH_TEXT_SHORT:
                case self::TOKEN_DATE_MONTH_DAYS:
                case self::TOKEN_DATE_WEEK:
                case self::TOKEN_DATE_DAY:
                case self::TOKEN_DATE_DAY_SHORT:
                case self::TOKEN_DATE_DAY_TEXT:
                case self::TOKEN_DATE_DAY_TEST_SHORT:
                case self::TOKEN_DATE_DAY_NUMERIC:
                case self::TOKEN_DATE_DAY_NUMERIC_ISO:
                case self::TOKEN_DATE_DAY_OF_YEAR:
                    $this->registerFormattingFunction(function (IdInterface $idObject) use ($token) {
                        return $idObject->getBirthDate()->format($token);
                    });
                    break;
                case self::TOKEN_DATE_CENTURY:
                case self::TOKEN_SERIAL_PRE:
                case self::TOKEN_SERIAL_POST:
                case self::TOKEN_DELIMITER:
                case self::TOKEN_CHECK_DIGIT:
                case self::TOKEN_SEX:
                case self::TOKEN_AGE:
                case self::TOKEN_LEGAL_FORM:
                case self::TOKEN_BIRTH_COUNTY:
                    $this->registerFormattingFunction([$this, self::TOKEN_MAP[$token]]);
                    break;
                case self::TOKEN_ESCAPE:
                    $escape = $token;
                    break;
                default:
                    $escape = '';
                    $this->registerFormattingFunction(function () use ($token) {
                        return $token;
                    });
            }
        }
    }

    /**
     * Format id using registered formatting functions
     */
    public function format(IdInterface $idObject): string
    {
        return ($this->formatter)($idObject);
    }

    /**
     * Function must take an Id object and return a string
     *
     * @param mixed $formatter
     */
    private function registerFormattingFunction($formatter): void
    {
        if (!is_callable($formatter)) {
            throw new LogicException('Formatting function must be callable');
        }

        $oldFormatter = $this->formatter;
        $this->formatter = function (IdInterface $idObject) use ($oldFormatter, $formatter) {
            return $oldFormatter($idObject) . $formatter($idObject);
        };
    }

    private function formatCentury(IdInterface $idObject): string

This method is not used, and could be removed.

    {
        try {
            return $idObject->getCentury();
        } catch (DateNotSupportedException $e) {
            return '00';
        }
    }

    private function formatSerialPre(IdInterface $idObject): string

This method is not used, and could be removed.

    {
        return $idObject->getSerialPreDelimiter();
    }

    private function formatSerialPost(IdInterface $idObject): string

This method is not used, and could be removed.

    {
        return $idObject->getSerialPostDelimiter();
    }

    private function formatDelimiter(IdInterface $idObject): string

This method is not used, and could be removed.

    {
        return $idObject->getDelimiter();
    }

    private function formatCheckDigit(IdInterface $idObject): string

This method is not used, and could be removed.

    {
        return $idObject->getCheckDigit();
    }

    private function formatSex(IdInterface $idObject): string

This method is not used, and could be removed.

    {
        return $idObject->getSex();
    }

    private function formatAge(IdInterface $idObject): string

This method is not used, and could be removed.

    {
        return (string)$idObject->getAge();
    }

    private function formatLegalForm(IdInterface $idObject): string

This method is not used, and could be removed.

    {
        return $idObject->getLegalForm();
    }

    private function formatBirthCounty(IdInterface $idObject): string

This method is not used, and could be removed.

    {
        return $idObject->getBirthCounty();
    }
}