Larapie\DataTransferObject\Property\Property

Complexity

Total Complexity

33

Size/Duplication

Total Lines	177
Duplicated Lines	0 %

Test Coverage

Coverage

92.11%

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	reset()	0	8	2
A	__construct()	0	3	1
A	disableAutoValidation()	0	17	5
A	initViolations()	0	5	2
A	set()	0	6	1
A	boot()	0	4	1
A	setDefault()	0	3	1
A	getDefault()	0	3	1
A	isValid()	0	3	2
A	setViolations()	0	3	1
A	isImmutable()	0	3	1
A	isInitialized()	0	3	1
A	chainImmutable()	0	9	5
A	isVisible()	0	3	1
A	setVisible()	0	3	1
A	getValue()	0	3	1
A	getName()	0	3	1
A	getViolations()	0	3	1
A	validate()	0	15	4

<?php

declare(strict_types=1);

namespace Larapie\DataTransferObject\Property;

use ReflectionProperty;
use Symfony\Component\Validator\ValidatorBuilder;
use Larapie\DataTransferObject\Casters\TypeCaster;
use Larapie\DataTransferObject\DataTransferObject;
use Symfony\Component\Validator\ConstraintViolationList;
use Symfony\Component\Validator\ConstraintViolationListInterface;
use Larapie\DataTransferObject\Violations\PropertyRequiredViolation;
use Larapie\DataTransferObject\Violations\InvalidPropertyTypeViolation;

class Property
{
    /** @var PropertyData */
    protected $data;

    /** @var mixed */
    public $value;

    /** @var mixed */
    protected $default;

    /** @var bool */
    protected $initialized = false;

    /** @var bool */
    protected $visible = true;

    /** @var ConstraintViolationListInterface|null */
    protected $violations;

    /**
     * PropertyValue constructor.
     * @param ReflectionProperty $reflection
     */
    public function __construct(ReflectionProperty $reflection)
    {
        $this->boot($reflection);
    }

    public function boot(ReflectionProperty $property)
    {
        $this->data = new PropertyData($property);
        $this->initViolations();
    }

    protected function initViolations()
    {
        $this->setViolations(new ConstraintViolationList());
        if (! $this->data->isOptional()) {
            $this->violations->add(new PropertyRequiredViolation());

The method add() does not exist on null.

        }
    }

    public function set($value): void
    {
        $value = (new TypeCaster($this->data->getType()))->cast($value);
        $this->value = $this->disableAutoValidation($value);
        $this->initialized = true;
        $this->setViolations($this->validate($value));
    }

    protected function disableAutoValidation($value)
    {
        if (is_iterable($value)) {
            $values = [];
            foreach ($value as $potentialDto) {
                if ($potentialDto instanceof DataTransferObject) {
                    $potentialDto->disableValidation();
                    $values[] = $potentialDto;
                }
            }

            return $values;
        } elseif ($value instanceof DataTransferObject) {
            $value->disableValidation();
        }

        return $value;
    }

    public function reset()
    {
        $this->value = null;
        $this->initialized = false;
        $this->initViolations();

        if ($this->default !== null) {
            $this->set($this->default);
        }
    }

    public function isInitialized()
    {
        return $this->initialized;
    }

    public function validate($value): ?ConstraintViolationListInterface
    {
        $constraints = $this->data->getConstraints();

        $violations = (new ValidatorBuilder())->getValidator()->validate($value, $constraints);

        if (! $this->isInitialized() && ! $this->data->isOptional()) {
            $violations->add(new PropertyRequiredViolation());
        }

        if (! $this->data->getType()->isValid($value)) {
            $violations->add(new InvalidPropertyTypeViolation($this->data->getType()->getTypes()));
        }

        return $violations;
    }

    public function isValid()
    {
        return $this->violations === null || $this->violations->count() <= 0;
    }

    /**
     * @return ConstraintViolationListInterface|null
     */
    public function getViolations(): ?ConstraintViolationListInterface
    {
        return $this->violations;
    }

    public function setViolations(?ConstraintViolationListInterface $violationList): ?ConstraintViolationListInterface
    {
        return $this->violations = $violationList;
    }

    public function isImmutable()
    {
        return $this->data->isImmutable();
    }

    public function getValue()
    {
        return $this->value;
    }

    public function getName()
    {
        return $this->data->getName();
    }

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

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

    /**
     * @return mixed
     */
    public function getDefault()
    {
        return $this->default;
    }

    /**
     * @param mixed $default
     */
    public function setDefault($default): void
    {
        $this->default = $default;
    }

    public function chainImmutable($immutable)
    {
        $dto = $this->getValue();
        if ($dto instanceof DataTransferObject) {
            $dto->setImmutable($immutable);
        } elseif (is_iterable($dto)) {
            foreach ($dto as $aPotentialDto) {
                if ($aPotentialDto instanceof DataTransferObject) {
                    $aPotentialDto->setImmutable($immutable);
                }
            }
        }
    }
}