Brazanation\Documents\AbstractDocument

Complexity

Total Complexity

12

Size/Duplication

Total Lines	133
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
A	__get()	0	4	1
A	__set()	0	4	1
A	validate()	0	9	3
A	isValid()	0	18	3
A	__toString()	0	4	1
A	extractBaseNumber()	0	4	1
A	extractCheckerDigit()	0	4	1

<?php

namespace Brazanation\Documents;

use Brazanation\Documents\Exception\InvalidDocument as InvalidDocumentException;
use Brazanation\Documents\Exception\Readonly;

/**
 * Class AbstractDocument
 *
 * @package Brazanation\Documents
 *
 * @property string $number
 * @property string $digit
 * @property int $length
 * @property int $numberOfDigits
 * @property string $type
 */
abstract class AbstractDocument implements DigitCalculable, Formattable
{
    /**
     * @var string
     */
    protected $number;

    /**
     * @var string
     */
    protected $digit;

    /**
     * @var int
     */
    protected $length;

    /**
     * @var int
     */
    protected $numberOfDigits;

    /**
     * @var string
     */
    protected $type;

    /**
     * AbstractDocument constructor.
     *
     * @param string $number         Numeric section with checker digit.
     * @param int    $length         Max length of document.
     * @param int    $numberOfDigits Max length of checker digits.
     * @param string $type           Document name/type.
     */
    public function __construct($number, $length, $numberOfDigits, $type)
    {
        $this->type = (string) $type;
        $this->numberOfDigits = (int) $numberOfDigits;
        $this->length = (int) $length;
        $this->digit = $this->extractCheckerDigit($number);
        $this->validate($number);
        $this->number = $number;
    }

    public function __get($name)
    {
        return $this->$name;
    }

    public function __set($name, $value)
    {
        throw Readonly::notAllowed(static::class, $name);
    }

    /**
     * Check if document number is valid.
     *
     * @param string $number Numeric section with checker digit.
     *
     * @throws InvalidDocumentException when number is empty
     * @throws InvalidDocumentException when number is not valid
     */
    protected function validate($number)
    {
        if (empty($number)) {
            throw InvalidDocumentException::notEmpty($this->type);
        }
        if (!$this->isValid($number)) {
            throw InvalidDocumentException::isNotValid($this->type, $number);
        }
    }

    /**
     * Validates number is a valid.
     *
     * @param string $number Numeric section with checker digit.
     *
     * @return bool Returns true if it is a valid number, otherwise false.
     */
    protected function isValid($number)
    {
        $baseNumber = $this->extractBaseNumber($number);

        if (!$baseNumber) {
            return false;
        }

        $isRepeated = preg_match("/^[{$baseNumber[0]}]+$/", $baseNumber);

        if ($isRepeated) {
            return false;
        }

        $digit = $this->calculateDigit($baseNumber);

        return "$digit" === "{$this->digit}";
    }

    /**
     * Handle number to string.
     *
     * @return string
     */
    public function __toString()
    {
        return "{$this->number}";
    }

    /**
     * Extracts the base number document.
     *
     * @param string $number Number of document.
     *
     * @return string Returns only base number without checker digit.
     */
    protected function extractBaseNumber($number)
    {
        return substr($number, 0, -($this->numberOfDigits));
    }

    /**
     * Extracts the checker digit from document number.
     *
     * @param string $number Number of document.
     *
     * @return string Returns only checker digit.
     */
    protected function extractCheckerDigit($number)
    {
        return substr($number, -($this->numberOfDigits));
    }
}