PommProject\ModelManager\Model\HydrationPlan

Complexity

Total Complexity

15

Size/Duplication

Total Lines	199
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	loadConverters()	0	22	3
A	getFieldType()	0	4	1
A	isArray()	0	4	1
A	hydrate()	0	6	1
A	dry()	0	4	1
A	freeze()	0	4	1
A	convert()	0	17	3
A	createEntity()	0	8	1
A	getConverterForField()	0	14	2

<?php
/*
 * This file is part of the PommProject/ModelManager package.
 *
 * (c) 2014 - 2015 Grégoire HUBERT <hubert.greg@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace PommProject\ModelManager\Model;

use PommProject\Foundation\Session\Session;
use PommProject\Foundation\Converter\ConverterClient;
use PommProject\ModelManager\Model\FlexibleEntity\FlexibleEntityInterface;

/**
 * HydrationPlan
 *
 * Tell the FlexibleEntityConverter how to hydrate fields.
 *
 * @package     ModelManager
 * @copyright   2014 - 2015 Grégoire HUBERT
 * @author      Grégoire HUBERT
 * @license     X11 {@link http://opensource.org/licenses/mit-license.php}
 */
class HydrationPlan
{
    protected $session;
    protected $projection;
    protected $converters = [];
    protected $field_types = [];


    /**
     * Construct
     *
     * @access  public
     * @param   Projection $projection
     * @param   Session    $session
     */
    public function __construct(Projection $projection, Session $session)
    {
        $this->projection = $projection;
        $this->session    = $session;

        $this->loadConverters();
    }

    /**
     * loadConverters
     *
     * Cache converters needed for this result set.
     *
     * @access protected
     * @return HydrationPlan    $this
     */
    protected function loadConverters()
    {
        foreach ($this->projection as $name => $type) {
            if ($this->projection->isArray($name)) {
                $this->converters[$name] = $this

It seems like you code against a concrete implementation and not the interface PommProject\Foundation\Client\ClientInterface as the method getConverter() does only exist in the following implementations of said interface: PommProject\Foundation\Converter\ConverterClient.

                    ->session
                    ->getClientUsingPooler('converter', 'array')
                    ->getConverter()
                    ;
            } else {
                $this->converters[$name] = $this

It seems like you code against a concrete implementation and not the interface PommProject\Foundation\Client\ClientInterface as the method getConverter() does only exist in the following implementations of said interface: PommProject\Foundation\Converter\ConverterClient.

                    ->session
                    ->getClientUsingPooler('converter', $type)
                    ->getConverter()
                    ;
            }

            $this->field_types[$name] = $type;
        }

        return $this;
    }


    /**
     * getFieldType
     *
     * Return the type of the given field. Proxy to Projection::getFieldType().
     *
     * @access public
     * @param  string $name
     * @return string
     */
    public function getFieldType($name)
    {
        return $this->projection->getFieldType($name);
    }

    /**
     * isArray
     *
     * Tell if the given field is an array or not.
     *
     * @access public
     * @param  string $name
     * @return bool
     */
    public function isArray($name)
    {
        return $this->projection->isArray($name);
    }


    /**
     * hydrate
     *
     * Take values fetched from the database, launch conversion system and
     * hydrate the FlexibleEntityInterface through the mapper.
     *
     * @access public
     * @param  array $values
     * @return FlexibleEntityInterface
     */
    public function hydrate(array $values)
    {
        $values = $this->convert('fromPg', $values);

        return $this->createEntity($values);
    }

    /**
     * dry
     *
     * Return values converted to Pg.
     *
     * @access public
     * @param  array    $values
     * @return array
     */
    public function dry(array $values)
    {
        return $this->convert('toPg', $values);
    }

    /**
     * freeze
     *
     * Return values converted to Pg standard output.
     *
     * @access public
     * @param  array $values
     * @return array converted values
     */
    public function freeze(array $values)
    {
        return $this->convert('toPgStandardFormat', $values);
    }

    /**
     * convert
     *
     * Convert values from / to postgres.
     *
     * @access protected
     * @param  string   $from_to
     * @param  array    $values
     * @return array
     */
    protected function convert($from_to, array $values)
    {
        $out_values = [];

        foreach ($values as $name => $value) {
            if (isset($this->converters[$name])) {
                $out_values[$name] = $this
                    ->converters[$name]
                    ->$from_to($value, $this->field_types[$name], $this->session)
                    ;
            } else {
                $out_values[$name] = $value;
            }
        }

        return $out_values;
    }

    /**
     * createEntity
     *
     * Instantiate FlexibleEntityInterface from converted values.
     *
     * @access protected
     * @param  array $values
     * @return FlexibleEntityInterface
     */
    protected function createEntity(array $values)
    {
        $class = $this->projection->getFlexibleEntityClass();

        return (new $class())
            ->hydrate($values)
            ;
    }

    /**
     * getConverterForField
     *
     * Return the converter client associated with a field.
     *
     * @access public
     * @param  string $field_name
     * @return ConverterClient
     */
    public function getConverterForField($field_name)
    {
        if (!isset($this->converters[$field_name])) {
            throw new \RuntimeException(
                sprintf(
                    "Error, '%s' field has no converters registered. Fields are {%s}.",
                    $field_name,
                    join(', ', array_keys($this->converters))
                )
            );
        }

        return $this->converters[$field_name];
    }
}