Cerbero\Dto\Traits\HasProperties

Complexity

Total Complexity

24

Size/Duplication

Total Lines	214
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	get()	0	3	1
A	set()	0	14	4
A	getProperty()	0	9	2
A	getProperties()	0	3	1
A	getPropertyNames()	0	3	1
A	unset()	0	23	4
A	hasProperty()	0	6	2
A	getNestedDto()	0	14	3
A	getPropertiesMap()	0	3	1
A	has()	0	6	2
A	__isset()	0	3	1
A	__set()	0	3	1
A	__get()	0	3	1

<?php

namespace Cerbero\Dto\Traits;

use Cerbero\Dto\DtoProperty;
use Cerbero\Dto\Exceptions\UnknownDtoPropertyException;
use Cerbero\Dto\Exceptions\UnsetDtoPropertyException;

use const Cerbero\Dto\IGNORE_UNKNOWN_PROPERTIES;

The constant Cerbero\Dto\IGNORE_UNKNOWN_PROPERTIES was not found. Maybe you did not declare it correctly or list all dependencies?

use const Cerbero\Dto\MUTABLE;

The constant Cerbero\Dto\MUTABLE was not found. Maybe you did not declare it correctly or list all dependencies?

use const Cerbero\Dto\PARTIAL;

The constant Cerbero\Dto\PARTIAL was not found. Maybe you did not declare it correctly or list all dependencies?

/**
 * Trait to interact with properties.
 *
 */
trait HasProperties
{
    /**
     * The properties map.
     *
     * @var array
     */
    protected $propertiesMap;

    /**
     * Retrieve the DTO properties map
     *
     * @return array
     */
    public function getPropertiesMap(): array
    {
        return $this->propertiesMap;
    }

    /**
     * Retrieve the DTO property names
     *
     * @return array
     */
    public function getPropertyNames(): array
    {
        return array_keys($this->getPropertiesMap());
    }

    /**
     * Retrieve the DTO properties
     *
     * @return DtoProperty[]
     */
    public function getProperties(): array
    {
        return array_values($this->getPropertiesMap());
    }

    /**
     * Determine whether the given property is set (even if its value is NULL)
     *
     * @param string $property
     * @return bool
     */
    public function hasProperty(string $property): bool
    {
        try {
            return !!$this->getProperty($property);
        } catch (UnknownDtoPropertyException $e) {
            return false;
        }
    }

    /**
     * Retrieve the given DTO property (support dot notation)
     *
     * @param string $property
     * @return DtoProperty
     * @throws UnknownDtoPropertyException
     */
    public function getProperty(string $property): DtoProperty
    {
        if (isset($this->propertiesMap[$property])) {
            return $this->propertiesMap[$property];
        }

        $nestedProperty = substr($property, strrpos($property, '.') + 1);

        return $this->getNestedDto($property)->getProperty($nestedProperty);
    }

    /**
     * Retrieve the given nested DTO
     *
     * @param string $property
     * @return self
     * @throws UnknownDtoPropertyException
     */
    protected function getNestedDto(string $property): self
    {
        if (strpos($property, '.') === false) {
            throw new UnknownDtoPropertyException(static::class, $property);
        }

        [$property, $nestedProperty] = explode('.', $property, 2);
        $presumedDto = $this->get($property);

        if ($presumedDto instanceof self) {
            return $presumedDto;
        }

        throw new UnknownDtoPropertyException(static::class, $nestedProperty);
    }

    /**
     * Determine whether the given property has a value (return FALSE if the value is NULL)
     *
     * @param string $property
     * @return bool
     */
    public function has(string $property): bool
    {
        try {
            return $this->get($property) !== null;

Are you sure the usage of $this->get($property) targeting Cerbero\Dto\Traits\HasProperties::get() seems to always return null.

        } catch (UnknownDtoPropertyException $e) {
            return false;
        }
    }

    /**
     * Retrieve the given property value
     *
     * @param string $property
     * @return mixed
     * @throws UnknownDtoPropertyException
     */
    public function get(string $property)
    {
        return $this->getProperty($property)->value();
    }

    /**
     * Set the given property to the provided value
     *
     * @param string $property
     * @param mixed $value
     * @return self
     * @throws UnknownDtoPropertyException
     */
    public function set(string $property, $value): self
    {
        $flags = $this->getFlags();

It seems like getFlags() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $dto = ($flags & MUTABLE) ? $this : $this->clone();

It seems like clone() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        try {
            $dto->getProperty($property)->setValue($value, $flags);
        } catch (UnknownDtoPropertyException $e) {
            if (!($flags & IGNORE_UNKNOWN_PROPERTIES)) {
                throw $e;
            }
        }

        return $dto;
    }

    /**
     * Unset the given property
     *
     * @param string $property
     * @return self
     * @throws UnsetDtoPropertyException
     * @throws UnknownDtoPropertyException
     */
    public function unset(string $property): self
    {
        $flags = $this->getFlags();

        if (!($flags & PARTIAL)) {
            throw new UnsetDtoPropertyException(static::class, $property);
        }

        if (strpos($property, '.') !== false) {
            [$property, $nestedProperty] = explode('.', $property, 2);
            $unsetDto = $this->get($property)->unset($nestedProperty);

Are you sure the usage of $this->get($property) targeting Cerbero\Dto\Traits\HasProperties::get() seems to always return null.

            return $this->set($property, $unsetDto);
        }

        if ($flags & MUTABLE) {
            unset($this->propertiesMap[$property]);
            return $this;
        }

        $data = $this->toArray();

It seems like toArray() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        unset($data[$property]);

        return new static($data, $flags);

The call to Cerbero\Dto\Traits\HasProperties::__construct() has too many arguments starting with $data.

    }

    /**
     * Determine whether a given property has a value
     *
     * @param string $property
     * @return bool
     */
    public function __isset(string $property): bool
    {
        return $this->offsetExists($property);

It seems like offsetExists() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * Retrieve the given property value
     *
     * @param string $property
     * @return mixed
     * @throws UnknownDtoPropertyException
     */
    public function &__get(string $property)
    {
        return $this->offsetGet($property);

It seems like offsetGet() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * Set the given property to the provided value
     *
     * @param string $property
     * @param mixed $value
     * @return void
     * @throws ImmutableDtoException
     * @throws UnknownDtoPropertyException
     */
    public function __set(string $property, $value): void
    {
        $this->offsetSet($property, $value);

It seems like offsetSet() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }
}