LibraryCatalog\Transformer\Serializer

Complexity

Total Complexity

23

Size/Duplication

Total Lines	127
Duplicated Lines	0 %

Test Coverage

Coverage

95.65%

Importance

Changes	1
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	extractFields()	0	9	4
A	serialize()	0	7	2
A	normalizeObject()	0	19	6
B	hydrate()	0	31	8
A	deserialize()	0	9	2
A	__construct()	0	3	1

<?php

declare(strict_types=1);

namespace LibraryCatalog\Transformer;

use LibraryCatalog\Transformer\Encoder\EncoderInterface;
use LibraryCatalog\Transformer\Serializer\Exception;
use LibraryCatalog\Transformer\Serializer\HydrateException;

class Serializer
{
    /** @var EncoderInterface */
    protected $encoder;

    /**
     * Serializer constructor.
     * @param EncoderInterface $encoder
     */
    public function __construct(EncoderInterface $encoder)
    {
        $this->encoder = $encoder;
    }

    /**
     * @param $data
     * @return string
     * @throws Encoder\Exception
     * @throws HydrateException
     */
    public function serialize($data): string
    {
        if (!is_object($data)) {
            throw new HydrateException();
        }

        return $this->encoder->encode($this->normalizeObject($data));
    }

    /**
     * @param string $value
     * @param string $classname
     * @return object
     * @throws Encoder\Exception
     * @throws Exception
     * @throws HydrateException
     */
    public function deserialize(string $value, string $classname = ''): object
    {
        $data = $this->encoder->decode($value);

        if (!is_array($data)) {
            throw new Exception("Not valid input data");
        }

        return $this->hydrate($data, $classname);

The expression return $this->hydrate($data, $classname) could return the type array which is incompatible with the type-hinted return object. Consider adding an additional type-check to rule them out.

    }

    /**
     * Extract all public fields (but not arrays and objects).
     *
     * @param object $object
     * @return array
     */
    public function extractFields(object $object): array
    {
        $res = get_object_vars($object);
        foreach ($res as $key => $value) {
            if (is_array($value) || is_object($value)) {
                unset($res[$key]);
            }
        }
        return $res;
    }

    /**
     * @param array $data
     * @param string $classname
     * @return mixed
     * @throws HydrateException
     */
    public function hydrate(array $data, string $classname = '')
    {
        try {
            if ($classname != '') {
                $object = new $classname();
            } elseif (isset($data['__cn'])) {
                $object = new $data['__cn']();
            } else {
                $object = [];
            }
        } catch (\Error $e) {
            throw new HydrateException($e->getMessage());
        }

        if (isset($data['__cn'])) {
            unset($data['__cn']);
        }

        foreach ($data as $key => $value) {
            if (is_array($value)) {
                if (is_array($object)) {
                    $object[$key] = $this->hydrate($value, '');
                } else {
                    $object->{$key} = $this->hydrate($value, '');
                }
            } else {
                $object->{$key} = $value;
            }
        }

        return $object;
    }

    /**
     * @param $data
     * @return mixed
     */
    protected function normalizeObject($data)
    {
        if (is_object($data)) {
            $data->__cn = get_class($data);

            foreach ($data as $key => $value) {
                if (is_object($value)) {
                    $data->{$key} = $this->normalizeObject($value);
                } elseif (is_array($value)) {
                    $data->{$key} = [];

                    foreach ($value as $keyIn => $valueIn) {
                        $data->{$key}[$keyIn] = $this->normalizeObject($valueIn);
                    }
                }
            }
        }

        return $data;
    }
}