Walker::pushAll() - Code Metrics - Inspection of "Merge pull request #25 from b2pweb/walker" - b2pweb/bdf-prime - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 5197c9...313b01 )

by Sébastien
created 2021-03-10 13:59 UTC
Walker::pushAll() A

↳ Parent: Walker
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	2
Importance

Changes
Metric	Value
eloc	1
dl	0
loc	3
ccs	0
cts	2
cp	0
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	1
crap	2
<?php

namespace Bdf\Prime\Query\Pagination;

use BadMethodCallException;
use Bdf\Prime\Exception\PrimeException;
use Bdf\Prime\PrimeSerializable;
use Bdf\Prime\Query\Contract\ReadOperation;
use Bdf\Prime\Query\Pagination\WalkStrategy\PaginationWalkStrategy;
use Bdf\Prime\Query\Pagination\WalkStrategy\WalkCursor;
use Bdf\Prime\Query\Pagination\WalkStrategy\WalkStrategyInterface;
use Bdf\Prime\Query\ReadCommandInterface;
use LogicException;

/**
 * Query Walker
 * 
 * Permet de parcourir des collections contenant de gros volume d'entités.
 * Le parcourt se fait par paquet d'entités définis par la limit de la query
 * Une fois la limite atteinte, la classe lance la requête suivante

 * 
 * Attention, le walker ne gère pas les objects collection
 *
 * @author  Seb

 * @package Bdf\Prime\Query\Pagination

 */
class Walker extends PrimeSerializable implements \Iterator, PaginatorInterface
{
    const DEFAULT_PAGE  = 1;
    const DEFAULT_LIMIT = 150;
    
    /**
     * First page
     * 
     * @var int

     */
    protected $startPage;

    /**
     * The current offset
     *
     * @var int

     */
    protected $offset;

    /**
     * @var array|null
     */
    private $collection;

    /**
     * @var WalkStrategyInterface
     */
    private $strategy;

    /**
     * @var WalkCursor
     */
    private $cursor;

    /**
     * @var ReadCommandInterface
     */
    private $query;

    /**
     * @var int

     */
    private $page;

    /**
     * @var int

     */
    private $maxRows;

    /**
     * Create a query walker
     * 
     * @param ReadCommandInterface $query
     * @param int            $maxRows

     * @param int            $page

     */
    public function __construct(ReadCommandInterface $query, $maxRows = null, $page = null)
    {
        $this->query = $query;
        $this->page = 0;
        $this->maxRows = $maxRows ?: self::DEFAULT_LIMIT;

        $this->startPage = $page ?: self::DEFAULT_PAGE;

    }

    /**
     * Change the walk strategy
     *
     * @param WalkStrategyInterface $strategy
     *
     * @return Walker
     */

    public function setStrategy(WalkStrategyInterface $strategy): self
    {
        if ($this->cursor !== null) {
            throw new LogicException('Cannot change walk strategy during walk');
        }

        $this->strategy = $strategy;

        return $this;
    }

    /**
     * Get the current active walk strategy
     *
     * @return WalkStrategyInterface
     */
    public function getStrategy(): WalkStrategyInterface
    {
        if ($this->strategy) {
            return $this->strategy;
        }

        return $this->strategy = new PaginationWalkStrategy();

    }

    /**
     * Load the first page of collection
     *
     * @throws PrimeException
     */
    #[ReadOperation]

    public function load()

    {
        $this->page = $this->startPage;
        $this->cursor = $this->getStrategy()->initialize($this->query, $this->maxRows, $this->page);
        $this->loadCollection();
    }

    /**
     * @return ReadCommandInterface
     */
    public function query(): ReadCommandInterface
    {
        if ($this->cursor) {
            return $this->cursor->query;
        }

        return $this->query;
    }

    /**
     * {@inheritdoc}
     */
    public function collection()
    {
        return $this->collection;
    }

    /**
     * {@inheritdoc}
     */
    public function size()
    {
        return $this->query->paginationCount();
        return $this->query->/** @scrutinizer ignore-call */ paginationCount();
    }

    /**

     * {@inheritdoc}
     */
    public function order($attribute = null)
    {
        $orders = $this->query()->getOrders();
        $orders = $this->query()->/** @scrutinizer ignore-call */ getOrders();

        if ($attribute === null) {
            return $orders;
        }

        return isset($orders[$attribute]) ? $orders[$attribute] : null;
    }

    /**
     * {@inheritdoc}
     */
    public function limit()
    {
        return $this->cursor->query->getLimit();
        return $this->cursor->query->/** @scrutinizer ignore-call */ getLimit();
    }

    /**
     * {@inheritdoc}
     */
    public function offset()
    {
        return $this->cursor->query->getOffset();
        return $this->cursor->query->/** @scrutinizer ignore-call */ getOffset();
    }

    /**
     * {@inheritdoc}
     */
    public function page()
    {
        return $this->page;
    }

    /**
     * {@inheritdoc}
     */
    public function pageMaxRows()
    {
        return $this->maxRows;
    }

    /**
     * {@inheritdoc}
     */
    protected function loadCollection()
    {
        $this->cursor = $this->strategy->next($this->cursor);
        $this->collection = $this->cursor->entities;

        // Test if the collection has numerical keys.
        // We have to add the offset to the numerical key.
        if (isset($this->collection[0])) {
            $this->offset = ($this->page - $this->startPage) * $this->maxRows;

        } else {
            $this->offset = null;
        }
    }

    /**
     * SPL - Iterator
     *
     * {@inheritdoc}
     */
    public function current()
    {
        return current($this->collection);
        return current(/** @scrutinizer ignore-type */ $this->collection);
    }
    
    /**
     * SPL - Iterator
     *
     * {@inheritdoc}
     */
    public function key()
    {
        if ($this->offset !== null) {
            return $this->offset + key($this->collection);
            return $this->offset + key(/** @scrutinizer ignore-type */ $this->collection);
        }

        return key($this->collection);
    }
    
    /**
     * SPL - Iterator
     *
     * {@inheritdoc}
     *
     * @throws PrimeException
     */
    #[ReadOperation]

    public function next()

    {
        if (false === next($this->collection)) {
        if (false === next(/** @scrutinizer ignore-type */ $this->collection)) {
            $this->page++;
            $this->loadCollection();
        }
    }
    
    /**
     * SPL - Iterator
     *
     * {@inheritdoc}
     */
    public function valid()
    {
        return false !== current($this->collection);
        return false !== current(/** @scrutinizer ignore-type */ $this->collection);
    }
    
    /**
     * SPL - Iterator
     *
     * {@inheritdoc}
     *
     * @throws PrimeException
     */
    #[ReadOperation]

    public function rewind()

    {
        if (($this->page == $this->startPage) && count($this->collection)) {
        if (($this->page == $this->startPage) && count(/** @scrutinizer ignore-type */ $this->collection)) {
            reset($this->collection);
            reset(/** @scrutinizer ignore-type */ $this->collection);
        } else {
            $this->load();
        }
    }

    /**
     * {@inheritdoc}
     */
    public function count()
    {
        return count($this->collection);
        return count(/** @scrutinizer ignore-type */ $this->collection);
    }

    /**

     * {@inheritdoc}
     */

    public function pushAll(array $items)
    {
        throw new BadMethodCallException('Collection methods are not supported by the Walker');
    }

    /**

     * {@inheritdoc}
     */

    public function push($item)
    {
        throw new BadMethodCallException('Collection methods are not supported by the Walker');
    }

    /**

     * {@inheritdoc}
     */

    public function put($key, $item)
    {
        throw new BadMethodCallException('Collection methods are not supported by the Walker');
    }

    /**
     * {@inheritdoc}
     */

    public function all()
    {
        throw new BadMethodCallException('Collection methods are not supported by the Walker');
    }

    /**

     * {@inheritdoc}
     */

    public function get($key, $default = null)
    {
        throw new BadMethodCallException('Collection methods are not supported by the Walker');
    }

    /**

     * {@inheritdoc}
     */

    public function has($key)
    {
        throw new BadMethodCallException('Collection methods are not supported by the Walker');
    }

    /**

     * {@inheritdoc}
     */

    public function remove($key)
    {
        throw new BadMethodCallException('Collection methods are not supported by the Walker');
    }

    /**
     * {@inheritdoc}
     */

    public function clear()
    {
        throw new BadMethodCallException('Collection methods are not supported by the Walker');
    }

    /**
     * {@inheritdoc}
     */

    public function keys()
    {
        throw new BadMethodCallException('Collection methods are not supported by the Walker');
    }

    /**
     * {@inheritdoc}
     */

    public function isEmpty()
    {
        throw new BadMethodCallException('Collection methods are not supported by the Walker');
    }

    /**

     * {@inheritdoc}
     */

    public function map($callback)
    {
        throw new BadMethodCallException('Collection methods are not supported by the Walker');
    }

    /**

     * {@inheritdoc}
     */

    public function filter($callback = null)
    {
        throw new BadMethodCallException('Collection methods are not supported by the Walker');
    }

    /**

     * {@inheritdoc}
     */

    public function groupBy($groupBy, $mode = self::GROUPBY)
    {
        throw new BadMethodCallException('Collection methods are not supported by the Walker');
    }

    /**

     * {@inheritdoc}
     */

    public function contains($element)
    {
        throw new BadMethodCallException('Collection methods are not supported by the Walker');
    }

    /**

     * {@inheritdoc}
     */

    public function indexOf($value, $strict = false)
    {
        throw new BadMethodCallException('Collection methods are not supported by the Walker');
    }

    /**

     * {@inheritdoc}
     */

    public function merge($items)
    {
        throw new BadMethodCallException('Collection methods are not supported by the Walker');
    }

    /**

     * {@inheritdoc}
     */

    public function sort(callable $callback = null)
    {
        throw new BadMethodCallException('Collection methods are not supported by the Walker');
    }

    /**

     * {@inheritdoc}
     */

    public function offsetExists($offset)
    {
        throw new BadMethodCallException('Collection methods are not supported by the Walker');
    }

    /**

     * {@inheritdoc}
     */

    public function offsetGet($offset)
    {
        throw new BadMethodCallException('Collection methods are not supported by the Walker');
    }

    /**

     * {@inheritdoc}
     */

    public function offsetSet($offset, $value)
    {
        throw new BadMethodCallException('Collection methods are not supported by the Walker');
    }

    /**

     * {@inheritdoc}
     */

    public function offsetUnset($offset)
    {
        throw new BadMethodCallException('Collection methods are not supported by the Walker');
    }
}

b2pweb / bdf-prime

Push — master ( 5197c9...313b01 )

Walker::pushAll() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
