Marek\Toggable\Hydrator\ObjectProperty

Complexity

Total Complexity

20

Size/Duplication

Total Lines	158
Duplicated Lines	10.13 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
B	extract()	0	22	5
B	hydrate()	0	33	5
A	canHydrate()	0	4	1
A	addStrategy()	0	6	1
A	getStrategy()	0	4	1
A	hasStrategy()	0	4	1
A	removeStrategy()	0	6	1
A	extractValue()	8	8	2
A	hydrateValue()	8	8	2

<?php

namespace Marek\Toggable\Hydrator;

use ReflectionClass;
use ReflectionProperty;
use ArrayObject;
use BadMethodCallException;
use InvalidArgumentException;

/**
 * Class ObjectProperty
 * @package Marek\Toggable\Hydrator
 */
class ObjectProperty implements HydratorInterface, StrategyEnabledInterface
{
    /**
    * The list with strategies that this hydrator has.
    *
    * @var \ArrayObject
    */
    protected $strategies;

    /**
     * Initializes a new instance of this class.
     */
    public function __construct()
    {
        $this->strategies = new ArrayObject();
    }

    /**
     * {@inheritdoc}
     */
    public function extract($object)
    {
        if (!is_object($object)) {
            throw new BadMethodCallException(
                sprintf('%s expects the provided $object to be a PHP object)', __METHOD__)
            );
        }

        $data = get_object_vars($object);

        $vars = array();
        foreach ($data as $name => $value) {

            $data[$name] = $this->extractValue($name, $value);

            if (!empty($data[$name]) || $data[$name] === false) {
                $vars[$name] = $data[$name];
            }
        }

        return $vars;
    }

    /**
     * @inheritDoc
     */
    public function hydrate(array $data, $object)
    {
        if (!is_object($object)) {
            throw new BadMethodCallException(
                sprintf('%s expects the provided $object to be a PHP object)', __METHOD__)
            );
        }

        $reflection = new ReflectionClass($object);

        $properties = $reflection->getProperties(
            ReflectionProperty::IS_PRIVATE
            + ReflectionProperty::IS_PROTECTED
            + ReflectionProperty::IS_PUBLIC
        );

        $props = array();
        /** @var ReflectionProperty $property */
        foreach ($properties as $property) {
            $props[$property->getName()] = true;
        }

        foreach ($data as $name => $value) {

            if (!isset($props[$name])) {
                continue;
            }

            $object->$name = $this->hydrateValue($name, $value);
        }

        return $object;
    }

    /**
     * @inheritDoc
     */
    public function canHydrate($object)
    {
        return true;
    }

    /**
     * @inheritDoc
     */
    public function addStrategy($name, StrategyInterface $strategy)
    {
        $this->strategies[$name] = $strategy;

        return $this;
    }

    /**
     * @inheritDoc
     */
    public function getStrategy($name)
    {
        return $this->strategies[$name];
    }

    /**
     * @inheritDoc
     */
    public function hasStrategy($name)
    {
        return array_key_exists($name, $this->strategies);
    }

    /**
     * @inheritDoc
     */
    public function removeStrategy($name)
    {
        unset($this->strategies[$name]);

        return $this;
    }

    /**
     * Converts a value for extraction. If no strategy exists the plain value is returned.
     *
     * @param  string $name  The name of the strategy to use.
     * @param  mixed  $value  The value that should be converted.
     *
     * @return mixed
     */
    public function extractValue($name, $value)

This method seems to be duplicated in your project.

    {
        if ($this->hasStrategy($name)) {
            $strategy = $this->getStrategy($name);
            $value = $strategy->extract($value);
        }
        return $value;
    }

    /**
     * Converts a value for hydration. If no strategy exists the plain value is returned.
     *
     * @param string $name The name of the strategy to use.
     * @param mixed $value The value that should be converted.
     *
     * @return mixed
     */
    public function hydrateValue($name, $value)

This method seems to be duplicated in your project.

    {
        if ($this->hasStrategy($name)) {
            $strategy = $this->getStrategy($name);
            $value = $strategy->hydrate($value);
        }
        return $value;
    }
}