PommProject\ModelManager\Model\CollectionIterator

Complexity

Total Complexity

14

Size/Duplication

Total Lines	203
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	get()	0	4	1
A	registerFilter()	0	13	2
A	clearFilters()	0	6	1
A	__construct()	0	12	1
A	parseRow()	0	7	1
A	launchFilters()	0	12	3
A	extract()	0	10	2
A	slice()	0	4	1
A	map()	0	4	1
A	convertSlice()	0	12	1

<?php
/*
 * This file is part of the PommProject's 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\ResultIterator;
use PommProject\Foundation\Session\ResultHandler;
use PommProject\Foundation\Session\Session;
use PommProject\ModelManager\Converter\PgEntity;
use PommProject\ModelManager\Exception\ModelException;
use PommProject\ModelManager\Model\FlexibleEntity\FlexibleEntityInterface;

/**
 * CollectionIterator
 *
 * Iterator for query results.
 *
 * @package   ModelManager
 * @copyright 2014 - 2015 Grégoire HUBERT
 * @author    Grégoire HUBERT <hubert.greg@gmail.com>
 * @license   MIT/X11 {@link http://opensource.org/licenses/mit-license.php}
 */
class CollectionIterator extends ResultIterator
{
    /**
     * @var Session
     */
    protected $session;

    /**
     * @var Projection
     */
    protected $projection;

    /**
     * @var array
     */
    protected $filters = [];

    /**
     * @var HydrationPlan
     */
    protected $hydration_plan;

    /**
     * @var PgEntity
     */
    private $entity_converter;

    /**
     * __construct
     *
     * Constructor
     *
     * @access  public
     * @param   ResultHandler   $result
     * @param   Session         $session
     * @param   Projection      $projection
     */
    public function __construct(ResultHandler $result, Session $session, Projection $projection)
    {
        parent::__construct($result);
        $this->projection       = $projection;
        $this->session          = $session;
        $this->hydration_plan   = new HydrationPlan($projection, $session);
        $this->entity_converter = $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', $this->projection->getFlexibleEntityClass())
          ->getConverter()
          ;
    }

    /**
     * get
     *
     * @see     ResultIterator
     * @return  FlexibleEntityInterface
     */
    public function get($index)
    {
        return $this->parseRow(parent::get($index));

The return type of return $this->parseRow(parent::get($index)); (PommProject\ModelManager\Model\FlexibleEntity\FlexibleEntityInterface) is incompatible with the return type of the parent method PommProject\Foundation\ResultIterator::get of type array.

    }

    /**
     * parseRow
     *
     * Convert values from Pg.
     *
     * @access  protected
     * @param   array          $values
     * @return  FlexibleEntityInterface
     * @see     ResultIterator
     */
    public function parseRow(array $values)
    {
        $values = $this->launchFilters($values);
        $entity = $this->hydration_plan->hydrate($values);

        return $this->entity_converter->cacheEntity($entity);
    }

    /**
     * launchFilters
     *
     * Launch filters on the given values.
     *
     * @access  protected
     * @param   array $values
     * @throws  ModelException   if return is not an array.
     * @return  array
     */
    protected function launchFilters(array $values)
    {
        foreach ($this->filters as $filter) {
            $values = call_user_func($filter, $values);

            if (!is_array($values)) {
                throw new ModelException(sprintf("Filter error. Filters MUST return an array of values."));
            }
        }

        return $values;
    }

    /**
     * registerFilter
     *
     * Register a new callable filter. All filters MUST return an associative
     * array with field name as key.
     *
     * @access public
     * @param  callable   $callable the filter.
     * @return CollectionIterator $this
     * @throws ModelException
     */
    public function registerFilter($callable)
    {
        if (!is_callable($callable)) {
            throw new ModelException(sprintf(
                "Given filter is not a callable (type '%s').",
                gettype($callable)
            ));
        }

        $this->filters[] = $callable;

        return $this;
    }

    /**
     * clearFilters
     *
     * Empty the filter stack.
     */
    public function clearFilters()
    {
        $this->filters = [];

        return $this;
    }

    /**
     * extract
     *
     * Return an array of entities extracted as arrays.
     *
     * @access public
     * @return array
     */
    public function extract()
    {
        $results = [];

        foreach ($this as $result) {
            $results[] = $result->extract();

The method extract cannot be called on $result (of type array|null).

        }

        return $results;
    }

    /**
     * slice
     *
     * see @ResultIterator
     *
     * @access public
     * @param  string   $name
     * @return array
     */
    public function slice($name)
    {
        return $this->convertSlice(parent::slice($name), $name);
    }

    /**
     * @return array
     */
    public function map(\Closure $callback)
    {
        return array_map($callback, iterator_to_array($this));
    }

    /**
     * convertSlice
     *
     * Convert a slice.
     *
     * @access protected
     * @param  array  $values
     * @param  string $name
     * @return array
     */
    protected function convertSlice(array $values, $name)
    {
        $type = $this->projection->getFieldType($name);
        $converter = $this->hydration_plan->getConverterForField($name);

        return array_map(
            function ($val) use ($converter, $type) {
                return $converter->fromPg($val, $type, $this->session);
            },
            $values
        );
    }
}