CodinPro\DataTransferObject\DTOBase

Complexity

Total Complexity

19

Size/Duplication

Total Lines	123
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

100%

Importance

Changes	7
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	3
A	get()	0	8	2
A	__toString()	0	4	1
A	toArray()	0	8	2
A	serialize()	0	4	1
A	getSerializer()	0	4	1
A	setSerializer()	0	6	1
A	getDefault()	0	4	1
B	processChain()	0	16	7

<?php

namespace CodinPro\DataTransferObject;

use ArrayAccess;
use Countable;
use IteratorAggregate;

class DTOBase implements ArrayAccess, IteratorAggregate, Countable
{
    protected $data;
    protected $default = [];
    private $serializer = null;

    use DTOAccessorTrait;
    use DTOIteratorTrait;

    /**
     * DTO constructor.
     * @param array $default
     * @param array|object|string $data
     * @param DTOSerializerInterface $serializer
     * @throws \InvalidArgumentException
     */
    public function __construct($default = [], $data = [], DTOSerializerInterface $serializer = null)
    {
        if (count($default) > 0) {
            $this->default = $default;
        }

        $this->serializer = $serializer === null ? new JsonSerializer() : $serializer;

        (new DTOBaseBuilder($this))->build($data);
    }

    /**
     * Get value by key or nested structure
     * @param string $offset
     * @return mixed
     * @throws \InvalidArgumentException
     */
    public function get($offset)
    {
        if (strpos($offset, '.') === false) {
            return $this->offsetGetScalar($offset);
        } else {
            return $this->processChain($offset);
        }
    }

    /**
     * Converts data to string
     * @return string
     */
    public function __toString()
    {
        return $this->serialize();
    }

    /**
     * Converts data to string
     * @return string
     */
    public function toArray()
    {
        if ($this->serializer instanceof JsonSerializer) {
            return json_decode($this->serialize(), true);
        } else {
            return json_decode((new JsonSerializer())->serialize($this->data), true);
        }
    }

    /**
     * Serializes the data using serializer
     * @return string
     */
    private function serialize()
    {
        return $this->serializer->serialize($this->data);
    }

    /**
     * @return DTOSerializerInterface
     */
    public function getSerializer()
    {
        return $this->serializer;
    }

    /**
     * @param DTOSerializerInterface $serializer
     * @return DTOBase
     */
    public function setSerializer(DTOSerializerInterface $serializer)
    {
        $this->serializer = $serializer;

        return $this;
    }

    /**
     * @return array
     */
    public function getDefault()
    {
        return $this->default;
    }

    /**
     * Get nested values using "dot" notation
     * @param $offset
     * @return mixed
     * @throws \InvalidArgumentException
     */
    private function processChain($offset)
    {
        $keys = explode('.', $offset);
        $scope = $this->data;
        foreach ($keys as $key) {
            if ((is_array($scope) || $scope instanceof ArrayAccess) && isset($scope[$key])) {
                $scope = $scope[$key];
            } elseif (is_object($scope) && isset($scope->{$key})) {
                $scope = $scope->{$key};
            } else {
                throw new \InvalidArgumentException('Non existent offset given in offset chain: '.$key);
            }
        }

        return $scope;
    }
}