HasProperties::getNestedDto() - Code Metrics - Inspection of "Update unset method to work with nested DTOs" - cerbero90/dto - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — feature/concerns-into-traits (c2fa68)

by Andrea Marco

created 2020-03-22 06:04 UTC

HasProperties::getNestedDto() A

↳ Parent: HasProperties

Complexity

Conditions	3
Paths	3

Size

Total Lines	14
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	8
CRAP Score	3

Importance

Changes

Metric	Value
cc	3
eloc	7
c	0
b	0
f	0
nc	3
nop	1
dl	0
loc	14
ccs	8
cts	8
cp	1
crap	3
rs	10

<?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;

use const Cerbero\Dto\MUTABLE;

use const Cerbero\Dto\PARTIAL;


/**
 * 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;
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
        } 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();
        $flags = $this->getFlags();
        $dto = ($flags & MUTABLE) ? $this : $this->clone();
        $dto = ($flags & MUTABLE) ? $this : $this->/** @scrutinizer ignore-call */ clone();

        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);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
            return $this->set($property, $unsetDto);
        }

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

        $data = $this->toArray();
        $data = $this->toArray();
        unset($data[$property]);

        return new static($data, $flags);
        return /** @scrutinizer ignore-call */ new static($data, $flags);
    }

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

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

    /**
     * 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);
               offsetSet($property, $value);
    }
}


cerbero90 / dto

Branch — feature/concerns-into-traits (c2fa68)

HasProperties::getNestedDto() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like