MetaHydrator\MetaHydrator

Complexity

Total Complexity

9

Size/Duplication

Total Lines	86
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	hydrateObject()	0	6	1
A	hydrateNewObject()	0	5	1
B	parse()	0	27	6

<?php
namespace MetaHydrator;

use MetaHydrator\Exception\HydratingException;
use MetaHydrator\Exception\ValidationException;
use MetaHydrator\Handler\HydratingHandlerInterface;
use MetaHydrator\Validator\ValidatorInterface;
use Mouf\Hydrator\Hydrator;
use Mouf\Hydrator\TdbmHydrator;

/**
 * An implementation of Hydrator interface, designed to be configured at will per instance.
 *
 * Class MetaHydrator
 * @package MetaHhydrator
 */
class MetaHydrator implements Hydrator
{
    /** @var HydratingHandlerInterface[] */
    private $handlers = [];

    /** @var ValidatorInterface[] */
    private $validators = [];

    /** @var Hydrator */
    private $simpleHydrator;

    /**
     * MetaHydrator constructor.
     * @param HydratingHandlerInterface[] $handlers
     * @param ValidatorInterface[] $validators
     * @param Hydrator $simpleHydrator
     */
    public function __construct($handlers = [], $validators = [], $simpleHydrator = null)
    {
        $this->handlers = $handlers;
        $this->validators = $validators;
        $this->simpleHydrator = $simpleHydrator ?? new TdbmHydrator();
    }

    /**
     * @param array $data
     * @param $object
     * @return object
     *
     * @throws HydratingException
     */
    public function hydrateObject(array $data, $object)
    {
        $parsedData = $this->parse($data, $object);
        $this->simpleHydrator->hydrateObject($parsedData, $object);
        return $object;
    }

    /**
     * @param array $data
     * @param string $class

There is no parameter named $class. Was it maybe removed?

     * @return object
     *
     * @throws HydratingException
     */
    public function hydrateNewObject(array $data, string $className)
    {
        $parsedData = $this->parse($data);
        return $this->simpleHydrator->hydrateNewObject($parsedData, $className);
    }

    /**
     * @param $data
     * @param $contextObject
     * @return array
     *
     * @throws HydratingException
     */
    private function parse($data, $contextObject = null)
    {
        $parsedData = [];
        $errorsMap = [];

        foreach ($this->handlers as $handler) {
            try {
                $handler->handle($data, $parsedData, $contextObject);
            } catch (HydratingException $e) {
                $errorsMap = array_merge($e->getErrorsMap(), $errorsMap);
            }
        }

        foreach ($this->validators as $validator) {
            try {
                $validator->validate($parsedData, $contextObject);
            } catch (ValidationException $e) {
                $errorsMap = array_merge($e->getInnerError(), $errorsMap);
            }
        }

        if ($errorsMap) {

The expression $errorsMap of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            throw new HydratingException($errorsMap);
        }

        return $parsedData;
    }
}