Larapie\DataTransferObject\Property\PropertyType

Complexity

Total Complexity

23

Size/Duplication

Total Lines	131
Duplicated Lines	0 %

Test Coverage

Coverage

95.56%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	setTypes()	0	3	1
A	getArrayTypes()	0	3	1
A	setInitialized()	0	3	1
A	setArrayTypes()	0	3	1
A	isNullable()	0	3	1
A	setNullable()	0	3	1
A	getTypes()	0	3	1
A	isValidGenericCollection()	0	15	4
A	assertTypeEquals()	0	12	5
A	isValid()	0	19	6
A	isInitialized()	0	3	1

<?php

namespace Larapie\DataTransferObject\Property;

class PropertyType
{
    /** @var array */
    protected const TYPE_MAPPING = [
        'int' => 'integer',
        'bool' => 'boolean',
        'float' => 'double',
    ];

    protected $types = [];

    protected $arrayTypes = [];

    protected $nullable = false;

    protected $initialized = false;

    /**
     * @return array
     */
    public function getTypes(): array
    {
        return $this->types;
    }

    /**
     * @param array $types
     */
    public function setTypes(array $types): void
    {
        $this->types = $types;
    }

    /**
     * @return array
     */
    public function getArrayTypes(): array
    {
        return $this->arrayTypes;
    }

    /**
     * @param array $arrayTypes
     */
    public function setArrayTypes(array $arrayTypes): void
    {
        $this->arrayTypes = $arrayTypes;
    }

    /**
     * @return bool
     */
    public function isNullable(): bool
    {
        return $this->nullable;
    }

    /**
     * @param bool $nullable
     */
    public function setNullable(bool $nullable): void
    {
        $this->nullable = $nullable;
    }

    /**
     * @return bool
     */
    public function isInitialized(): bool
    {
        return $this->initialized;
    }

    /**
     * @param bool $initialized
     */
    public function setInitialized(bool $initialized): void
    {
        $this->initialized = $initialized;
    }

    public function isValid($value): bool
    {
        if (! $this->initialized) {
            return true;
        }

        if ($this->nullable && $value === null) {
            return true;
        }

        foreach ($this->types as $currentType) {
            $isValidType = $this->assertTypeEquals($currentType, $value);

            if ($isValidType) {
                return true;
            }
        }

        return false;
    }

    protected function assertTypeEquals(string $type, $value): bool
    {
        if (strpos($type, '[]') !== false) {
            return $this->isValidGenericCollection($type, $value);
        }

        if ($type === 'mixed' && $value !== null) {
            return true;
        }

        return $value instanceof $type
            || gettype($value) === (self::TYPE_MAPPING[$type] ?? $type);
    }

    protected function isValidGenericCollection(string $type, $collection): bool
    {
        if (! is_array($collection)) {
            return false;
        }

        $valueType = str_replace('[]', '', $type);

        foreach ($collection as $value) {
            if (! $this->assertTypeEquals($valueType, $value)) {
                return false;
            }
        }

        return true;
    }
}