MetaHydrator\Handler\SubHydratingHandler

Complexity

Total Complexity

26

Size/Duplication

Total Lines	121
Duplicated Lines	8.26 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	getKey()	0	1	1
A	setKey()	0	1	1
A	getClassName()	0	1	1
A	setClassName()	0	1	1
A	getHydrator()	0	1	1
A	setHydrator()	0	1	1
A	getValidators()	0	1	1
A	setValidators()	0	1	1
A	addValidator()	0	1	1
A	getErrorMessage()	0	1	1
A	setErrorMessage()	0	1	1
A	getGetter()	0	1	1
A	setGetter()	0	1	1
A	__construct()	0	9	1
C	handle()	0	32	7
A	validate()	10	10	3
A	getSubObject()	0	7	2

<?php
namespace MetaHydrator\Handler;

use MetaHydrator\Exception\HydratingException;
use MetaHydrator\Exception\ValidationException;
use MetaHydrator\MetaHydrator;
use MetaHydrator\Reflection\Getter;
use MetaHydrator\Reflection\GetterInterface;
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 implements HydratingHandlerInterface
{
    /** @var string */
    protected $key;
    public function getKey() { return $this->key; }
    public function setKey(string $key) { $this->key = $key; }

    /** @var string */
    protected $className;
    public function getClassName() { return $this->className; }
    public function setClassName(string $className) { $this->className = $className; }

    /** @var Hydrator */
    protected $hydrator;
    public function getHydrator() { return $this->hydrator; }
    public function setHydrator(Hydrator $hydrator) { $this->hydrator = $hydrator; }

    /** @var ValidatorInterface[] */
    protected $validators;
    public function getValidators() { return $this->validators; }
    public function setValidators(array $validators) { $this->validators = $validators; }
    public function addValidator(ValidatorInterface $validator) { $this->validators[] = $validator; }

    /** @var string */
    protected $errorMessage;
    public function getErrorMessage() { return $this->errorMessage; }
    public function setErrorMessage(string $errorMessage) { $this->errorMessage = $errorMessage; }

    /** @var GetterInterface */
    protected $getter;
    public function getGetter() { return $this->getter; }
    public function setGetter(GetterInterface $getter) { $this->getter = $getter; }

    /**
     * SubHydratingHandler constructor.
     * @param string $key
     * @param string $className
     * @param Hydrator $hydrator
     * @param ValidatorInterface[] $validators
     * @param string $errorMessage
     * @param GetterInterface $getter
     */
    public function __construct(string $key, string $className, Hydrator $hydrator, array $validators = [], string $errorMessage = "", GetterInterface $getter = null)
    {
        $this->key = $key;
        $this->className = $className;
        $this->hydrator = $hydrator;
        $this->validators = $validators;
        $this->errorMessage = $errorMessage;
        $this->getter = $getter ?? new Getter(false);
    }

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

            try {
                $subObject = $this->getSubObject($object);
                if ($subObject !== null) {
                    $this->hydrator->hydrateObject($subData, $subObject);
                } else {
                    $subObject = $this->hydrator->hydrateNewObject($subData, $this->className);
                    $targetData[$this->key] = $subObject;
                }
            } catch (HydratingException $exception) {
                throw new HydratingException([$this->key => $exception->getErrorsMap()]);
            }
        }

        $this->validate($subObject, $object);
    }

    /**
     * @param mixed $parsedValue
     * @param mixed $contextObject
     *
     * @throws HydratingException
     */
    private function validate($parsedValue, $contextObject = null)

This method seems to be duplicated in your project.

    {
        try {
            foreach ($this->validators as $validator) {
                $validator->validate($parsedValue, $contextObject);
            }
        } catch (ValidationException $exception) {
            throw new HydratingException([ $this->key => $exception->getInnerError() ]);
        }
    }

    /**
     * @param $object
     * @return mixed
     */
    protected function getSubObject($object)
    {
        if ($object === null) {
            return null;
        }
        return $this->getter->get($object, $this->key);
    }
}