MetaHydrator\Handler\SimpleHydratingHandler

Complexity

Total Complexity

17

Size/Duplication

Total Lines	83
Duplicated Lines	12.05 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	getKey()	0	1	1
A	setKey()	0	1	1
A	getParser()	0	1	1
A	setParser()	0	1	1
A	getValidators()	0	1	1
A	setValidators()	0	1	1
A	addValidator()	0	1	1
A	getDefaultValue()	0	1	1
A	setDefaultValue()	0	1	1
A	__construct()	0	7	1
A	handle()	0	20	4
A	validate()	10	10	3

<?php
namespace MetaHydrator\Handler;

use MetaHydrator\Exception\HydratingException;
use MetaHydrator\Exception\ValidationException;
use MetaHydrator\Exception\ParsingException;
use MetaHydrator\Parser\ParserInterface;
use MetaHydrator\Validator\ValidatorInterface;

/**
 * An implementation of HydratingHandlerInterface, as a one to one value parsing/validation.
 *
 * Class SimpleHydratingHandler
 * @package MetaHhydrator\Handler
 */
class SimpleHydratingHandler implements HydratingHandlerInterface
{
    /** @var string */
    private $key;
    public function getKey() { return $this->key; }
    public function setKey(string $key) { $this->key = $key; }

    /** @var ParserInterface */
    private $parser;
    public function getParser() { return $this->parser; }
    public function setParser(ParserInterface $parser) { $this->parser = $parser; }

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

    /** @var mixed */
    private $defaultValue;
    public function getDefaultValue() { return $this->defaultValue; }
    public function setDefaultValue($defaultValue) { $this->defaultValue = $defaultValue; }

    /**
     * SimpleHydratingHandler constructor.
     * @param string $key
     * @param ParserInterface $parser
     * @param ValidatorInterface[] $validators
     * @param mixed $default

There is no parameter named $default. Did you maybe mean $defaultValue?

     */
    public function __construct(string $key, ParserInterface $parser, array $validators = [], $defaultValue = null)
    {
        $this->key = $key;
        $this->parser = $parser;
        $this->validators = $validators;
        $this->defaultValue = $defaultValue;
    }

    /**
     * @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)) {
            $rawValue = $data[$this->key];
        } else if ($object === null) {
            $rawValue = $this->defaultValue;
        } else {
            return;
        }

        try {
            $parsedValue = $this->parser->parse($rawValue);
        } catch (ParsingException $exception) {
            throw new HydratingException([ $this->key => $exception->getInnerError() ]);
        }

        $this->validate($parsedValue, $object);

        $targetData[$this->key] = $parsedValue;
    }

    /**
     * @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() ]);
        }
    }
}