Borobudur\Cqrs\Serializer\SerializerTrait

Complexity

Total Complexity

26

Size/Duplication

Total Lines	177
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	6
Bugs	1	Features	1

8 Methods

Rating	Name	Duplication	Size	Complexity
A	deserialize()	0	13	2
A	buildParameters()	0	9	2
A	buildValue()	0	14	2
D	buildObjectParameter()	0	26	9
A	serialize()	0	21	4
A	normalize()	0	12	3
A	resolveFlat()	0	14	3
A	isInternal()	0	4	1

<?php
/*
 * This file is part of the Borobudur-Cqrs package.
 *
 * (c) Hexacodelabs <http://hexacodelabs.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Borobudur\Cqrs\Serializer;

use Borobudur\Cqrs\IdentifierInterface;
use Borobudur\Cqrs\ParameterBag;
use DateTime;
use DateTimeZone;
use ReflectionClass;
use ReflectionObject;
use ReflectionParameter;
use ReflectionProperty;

/**
 * @author      Iqbal Maulana <iq.bluejack@gmail.com>
 * @created     8/18/15
 */
trait SerializerTrait
{
    use DataTypeCasterTrait;

    /**
     * {@inheritdoc}
     *
     * @return static
     */
    public static function deserialize(ParameterBag $data)
    {
        $class = get_called_class();
        $reflection = new ReflectionClass($class);
        $constructor = $reflection->getConstructor();
        $parameters = $constructor->getParameters();

        if (!empty($parameters)) {
            return $reflection->newInstanceArgs(self::buildParameters($parameters, $data));
        }

        return $reflection->newInstance();
    }

    /**
     * Build parameters.
     *
     * @param ReflectionParameter[] $parameters
     * @param ParameterBag          $data
     *
     * @return array
     */
    protected static function buildParameters(array $parameters, ParameterBag $data)
    {
        $built = array();
        foreach ($parameters as $param) {
            $built[] = self::buildValue($param, $data);
        }

        return $built;
    }

    /**
     * Build value.
     *
     * @param ReflectionParameter $parameter
     * @param ParameterBag        $data
     *
     * @return array|mixed|null
     */
    protected static function buildValue(ReflectionParameter $parameter, ParameterBag $data)
    {
        $class = $parameter->getClass();
        $name = $parameter->getName();
        $value = $data->get($name);

        if (null === $class) {
            return self::castType($value, $value, '');
        }

        $value = array_merge($data->all(), (array) $value);

        return self::buildObjectParameter($class, $value, $name);
    }

    /**
     * Build object parameter.
     *
     * @param ReflectionClass $class
     * @param mixed           $value
     * @param string          $name
     *
     * @return mixed|null
     */
    protected static function buildObjectParameter(ReflectionClass $class, $value, $name)
    {
        $className = $class->getName();

        if ($class->hasMethod('__toString')) {
            return (string) $value;
        }

        if (in_array('Borobudur\Cqrs\IdentifierInterface', class_implements($className))) {
            if (is_array($value) && isset($value[$name]) && is_string($value[$name])) {
                return $className::{'fromString'}($value[$name]);
            }
        }

        if (in_array('Borobudur\Cqrs\Serializer\SerializableInterface', class_implements($className))) {
            return $className::{'deserialize'}(new ParameterBag($value));
        }

        if ('DateTime' === $className && isset($value[$name])) {
            $value[$name] = (array) $value[$name];

            return new DateTime($value[$name]['date'], new DateTimeZone($value[$name]['timezone']));
        }

        return null;
    }

    /**
     * {@inheritdoc}
     */
    public function serialize()
    {
        $reflection = new ReflectionObject($this);
        $properties = $reflection->getProperties();
        $data = array();

        foreach ($properties as $property) {
            if ($this->isInternal($property)) {
                continue;
            }

            $property->setAccessible(true);
            $data[$property->getName()] = $this->normalize($property->getValue($this));
        }

        if ($this instanceof FlatSerializerInterface) {
            return $this->resolveFlat($data);
        }

        return $data;
    }

    /**
     * Normalize value.
     *
     * @param $value
     *
     * @return array|string
     */
    protected function normalize($value)
    {
        if ($value instanceof IdentifierInterface) {
            return (string) $value;
        }

        if ($value instanceof SerializableInterface) {
            return $value->serialize();
        }

        return $value;
    }

    /**
     * @param array $data
     *
     * @return array
     */
    protected function resolveFlat(array $data)
    {
        $flat = array();
        foreach ($data as $index => $value) {
            if (is_array($value)) {
                $flat = array_merge($flat, $this->resolveFlat($value));
                continue;
            }

            $flat[$index] = $value;
        }

        return $flat;
    }

    /**
     * Check if property is internal use (@internal annotation).
     *
     * @param ReflectionProperty $property
     *
     * @return bool
     */
    protected function isInternal(ReflectionProperty $property)
    {
        return (bool) preg_match('#@internal\n#s', $property->getDocComment());
    }
}