cerbero90 / dto

src/Traits/HasValues.php

<?php

namespace Cerbero\Dto\Traits;

use Cerbero\Dto\Exceptions\UnknownDtoPropertyException;
use Cerbero\Dto\Exceptions\UnsetDtoPropertyException;
use Cerbero\Dto\Manipulators\Listener;

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 values.
 *
 */
trait HasValues
{
    /**
     * The default values.
     *
     * @var array
     */
    protected static $defaultValues = [];

    /**
     * Retrieve the default values
     *
     * @return array
     */
    public static function getDefaultValues(): array
    {
        return static::$defaultValues;
    }

    /**
     * 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;
        } catch (UnknownDtoPropertyException $e) {
            return false;
        }
    }

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

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

        return $this->getListener()->getting(static::class, $property, $value);
    }

    /**
     * Retrieve the listener instance
     *
     * @return Listener
     */
    protected function getListener(): Listener
    {
        return Listener::instance();
    }

    /**
     * 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 {
            $value = $this->getListener()->setting(static::class, $property, $value);
            $dto->setPropertyValueOrMap($property, $value);

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

        } 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);
            return $this->set($property, $unsetDto);
        }

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

The property propertiesMap does not exist on Cerbero\Dto\Traits\HasValues. Since you implemented __get, consider adding a @property annotation.

            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\HasValues::__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 \Cerbero\Dto\Exceptions\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?

    }
}