Cerbero\Dto\Traits\TurnsIntoArray::toSnakeCaseArray()

Complexity

Conditions	2
Paths	2

Size

Total Lines	10
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

1 Method

Rating	Name	Duplication	Size	Complexity
A	TurnsIntoArray::getIterator()	0	3	1

<?php

namespace Cerbero\Dto\Traits;

use ArrayIterator;
use Cerbero\Dto\Exceptions\ImmutableDtoException;
use Cerbero\Dto\Exceptions\UnknownDtoPropertyException;
use Cerbero\Dto\Exceptions\UnsetDtoPropertyException;
use Cerbero\Dto\Manipulators\ArrayConverter;
use Traversable;

use const Cerbero\Dto\MUTABLE;

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

/**
 * Trait to turn a DTO into an array.
 *
 */
trait TurnsIntoArray
{
    /**
     * Retrieve the DTO as an array
     *
     * @return array
     */
    public function toArray(): array
    {
        $data = [];

        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?

            $key = strtolower(preg_replace(ArrayConverter::RE_SNAKE_CASE, '_', $name));
            $data[$key] = ArrayConverter::instance()->convert($property->value(), true);
        }

        return $data;
    }

    /**
     * Retrieve the DTO as an iterator
     *
     * @return Traversable
     */
    public function getIterator(): Traversable
    {
        return new ArrayIterator($this->toArray(), ArrayIterator::ARRAY_AS_PROPS);
    }

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

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

    }

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

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

        return $value;
    }

    /**
     * Set the given property to the provided value
     *
     * @param mixed $property
     * @param mixed $value
     * @return void
     * @throws ImmutableDtoException
     * @throws UnknownDtoPropertyException
     */
    public function offsetSet($property, $value): void
    {
        if (!($this->getFlags() & MUTABLE)) {

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

            throw new ImmutableDtoException(static::class);
        }

        $this->set($property, $value);

It seems like set() 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 mixed $property
     * @return void
     * @throws ImmutableDtoException
     * @throws UnsetDtoPropertyException
     * @throws UnknownDtoPropertyException
     */
    public function offsetUnset($property): void
    {
        if (!($this->getFlags() & MUTABLE)) {
            throw new ImmutableDtoException(static::class);
        }

        $this->unset($property);

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

    }
}