cerbero90 / dto

src/Traits/ManipulatesData.php

<?php

namespace Cerbero\Dto\Traits;

use Cerbero\Dto\Manipulators\ArrayConverter;

use const Cerbero\Dto\CAMEL_CASE_ARRAY;

The constant Cerbero\Dto\CAMEL_CASE_ARRAY 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\NONE;

The constant Cerbero\Dto\NONE 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 manipulate a DTO data.
 *
 */
trait ManipulatesData
{
    /**
     * Merge the given data in the DTO
     *
     * @param iterable $data
     * @param int $flags
     * @return self
     */
    public function merge(iterable $data, int $flags = NONE): self
    {
        $mergedFlags = $this->getFlags() | $flags;

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

        $snakeCase = !($mergedFlags & CAMEL_CASE_ARRAY);
        $replacements = ArrayConverter::instance()->convert($data, $snakeCase);
        $mergedData = array_replace_recursive($this->toArray(), $replacements);

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

It seems like $replacements can also be of type iterable; however, parameter $replacements of array_replace_recursive() does only seem to accept array, maybe add an additional type check?

        if (!($this->getFlags() & MUTABLE)) {
            return new static($mergedData, $mergedFlags);

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

        }

        $this->flags = $mergedFlags;

The property flags does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->propertiesMap = $this->mapData($mergedData);

The property propertiesMap does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

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

        return $this;
    }

    /**
     * Retrieve the DTO including only the given properties
     *
     * @param array $properties
     * @param int $flags
     * @return self
     */
    public function only(array $properties, int $flags = NONE): self
    {
        $data = [];
        $isMutable = $this->getFlags() & MUTABLE;
        $mergedFlags = $this->getFlags() | $flags | PARTIAL;

        foreach ($this->getPropertiesMap() as $name => $property) {

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

            if (in_array($name, $properties) && !$isMutable) {
                $data[$name] = $property->value();
            } elseif (!in_array($name, $properties) && $isMutable) {
                unset($this->propertiesMap[$name]);
            }
        }

        if ($isMutable) {
            $this->flags = $mergedFlags;

The property flags does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

            return $this;
        }

        return new static($data, $mergedFlags);

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

    }

    /**
     * Retrieve the DTO excluding the given properties
     *
     * @param array $properties
     * @param int $flags
     * @return self
     */
    public function except(array $properties, int $flags = NONE): self
    {
        $propertiesToKeep = array_diff($this->getPropertyNames(), $properties);

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

        return $this->only($propertiesToKeep, $flags);
    }

    /**
     * Make the DTO mutable while calling the given callback
     *
     * @param callable $callback
     * @return self
     */
    public function mutate(callable $callback): self
    {
        $wasMutable = $this->getFlags() & MUTABLE;
        $this->flags |= MUTABLE;

        $callback($this);

        if (!$wasMutable) {
            $this->flags ^= MUTABLE;
        }

        return $this;
    }
}