MetaHydrator\Handler\SubHydratingHandler

Complexity

Total Complexity

12

Size/Duplication

Total Lines	91
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	handle()	0	17	4
A	getSubObject()	0	11	3
A	getSubData()	0	15	4

<?php
namespace MetaHydrator\Handler;

use MetaHydrator\Exception\HydratingException;
use MetaHydrator\MetaHydrator;
use MetaHydrator\Utils\ReflectionUtils;
use MetaHydrator\Validator\ValidatorInterface;
use Mouf\Hydrator\Hydrator;

/**
 * An implementation of HydratingHandlerInterface aiming to manage partial edition of sub-objects
 *
 * Class SubHydratingHandler
 * @package MetaHydrator\Handler
 */
class SubHydratingHandler extends MetaHydrator implements HydratingHandlerInterface
{
    /** @var string */
    protected $key;

    /** @var string */
    protected $className;

    /** @var mixed */
    protected $errorMessage;

    /**
     * SubHydratingHandler constructor.
     * @param string $key
     * @param string $className
     * @param HydratingHandlerInterface[] $handlers
     * @param ValidatorInterface[] $validators
     * @param mixed $errorMessage
     * @param Hydrator $simpleHydrator
     */
    public function __construct(string $key, string $className, $handlers, $validators = [], $errorMessage = null, $simpleHydrator = null)
    {
        parent::__construct($handlers, $validators, $simpleHydrator);
        $this->key = $key;
        $this->className = $className;
        $this->errorMessage = $errorMessage;
    }

    /**
     * @param array $data
     * @param array $targetData
     * @param $object
     *
     * @throws HydratingException
     */
    public function handle(array $data, array &$targetData, $object = null)
    {
        $subData = $this->getSubData($data, $object);
        if ($subData === null) {
            return;
        }
        try {
            $subObject = $this->getSubObject($object);
            if ($subObject !== null) {
                $this->hydrateObject($subData, $subObject);
            } else {
                $targetData[$this->key] = $this->hydrateNewObject($subData, $this->className);
            }
        } catch (HydratingException $exception) {
            throw new HydratingException([$this->key => $exception->getErrorsMap()]);
        }
    }

    /**
     * @param $object
     * @return mixed
     */
    protected function getSubObject($object)
    {
        if ($object === null) {
            return null;
        }
        try {
            return ReflectionUtils::getFieldValue($object, $this->key);
        } catch (\ReflectionException $exception) {
            return null;
        }
    }

    /**
     * @param $data
     * @param $object
     * @return array
     * @throws HydratingException
     */
    protected function getSubData($data, $object)
    {
        if (array_key_exists($this->key, $data)) {
            $subData = $data[$this->key];
            if (!is_array($subData)) {
                throw new HydratingException([$this->key => $this->errorMessage]);
            } else {
                return $subData;
            }
        } else if ($object === null) {
            return [];
        } else {
            return null;
        }
    }
}