Bdf\Prime\Query\Pagination\Walker

Complexity

Total Complexity

56

Size/Duplication

Total Lines	464
Duplicated Lines	0 %

Test Coverage

Coverage

53.77%

Importance

Changes	1
Bugs	0	Features	0

40 Methods

Rating	Name	Duplication	Size	Complexity
A	pushAll()	0	3	1
A	clear()	0	3	1
A	getStrategy()	0	11	2
A	offsetGet()	0	3	1
A	size()	0	7	2
A	indexOf()	0	3	1
A	load()	0	6	1
A	remove()	0	3	1
A	keys()	0	3	1
A	valid()	0	3	1
A	loadCollection()	0	11	2
A	setStrategy()	0	9	2
A	pageMaxRows()	0	3	1
A	has()	0	3	1
A	rewind()	0	7	3
A	limit()	0	7	2
A	all()	0	3	1
A	next()	0	6	2
A	query()	0	7	2
A	contains()	0	3	1
A	current()	0	3	1
A	map()	0	3	1
A	merge()	0	3	1
A	offsetSet()	0	3	1
A	offset()	0	7	2
A	filter()	0	3	1
A	count()	0	3	1
A	page()	0	3	1
A	push()	0	3	1
A	order()	0	15	4
A	offsetUnset()	0	3	1
A	key()	0	8	2
A	put()	0	3	1
A	get()	0	3	1
A	collection()	0	3	1
A	sort()	0	3	1
A	groupBy()	0	3	1
A	isEmpty()	0	3	1
A	__construct()	0	6	3
A	offsetExists()	0	3	1

<?php

namespace Bdf\Prime\Query\Pagination;

use BadMethodCallException;
use Bdf\Prime\Connection\ConnectionInterface;
use Bdf\Prime\Exception\PrimeException;
use Bdf\Prime\PrimeSerializable;
use Bdf\Prime\Query\Contract\Limitable;
use Bdf\Prime\Query\Contract\Orderable;
use Bdf\Prime\Query\Contract\Paginable;
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 Iterator;
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

Doc comment long description must end with a full stop

 * 
 * Attention, le walker ne gère pas les objects collection
 *
 * @template R as array|object
 *
 * @implements PaginatorInterface<R>
 * @implements Iterator<array-key, R>
 */
class Walker extends PrimeSerializable implements Iterator, PaginatorInterface
{
    const DEFAULT_PAGE  = 1;
    const DEFAULT_LIMIT = 150;
    
    /**
     * First page
     * 
     * @var int

Expected "integer" but found "int" for @var tag in member variable comment

     */
    protected $startPage;

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

Expected "integer|null" but found "int|null" for @var tag in member variable comment

     */
    protected $offset;

    /**
     * @var R[]
     */
    private $collection = [];

    /**
     * @var WalkStrategyInterface<R>

Expected "WalkStrategyInterfaceR" but found "WalkStrategyInterface<R>" for @var tag in member variable comment

     */
    private $strategy;

    /**
     * @var WalkCursor<R>

Expected "WalkCursorR" but found "WalkCursor<R>" for @var tag in member variable comment

     */
    private $cursor;

    /**
     * @var ReadCommandInterface<ConnectionInterface, R>

Expected "ReadCommandInterfaceConnectionInterfaceR" but found "ReadCommandInterface<ConnectionInterface, R>" for @var tag in member variable comment

     */
    private $query;

    /**
     * @var int

Expected "integer" but found "int" for @var tag in member variable comment

     */
    private $page;

    /**
     * @var int

Expected "integer" but found "int" for @var tag in member variable comment

     */
    private $maxRows;

    /**
     * Create a query walker
     * 
     * @param ReadCommandInterface<ConnectionInterface, R> $query

Parameter type "ReadCommandInterface<ConnectionInterface, R>" must not contain spaces

     * @param int            $maxRows

Expected "integer" but found "int" for parameter type

     * @param int            $page

Expected "integer" but found "int" for parameter type

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

Inline shorthand IF statement requires brackets around comparison

The value of a comparison must not be assigned to a variable

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

Inline shorthand IF statement requires brackets around comparison

The value of a comparison must not be assigned to a variable

    }

    /**
     * Change the walk strategy
     *
     * @param WalkStrategyInterface<R> $strategy

Expected "WalkStrategyInterfaceR" but found "WalkStrategyInterface<R>" for parameter type

     *
     * @return $this
     */

Missing @throws tag in function comment

    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<R>

Expected "WalkStrategyInterfaceR" but found "WalkStrategyInterface<R>" for function return type

     */
    public function getStrategy(): WalkStrategyInterface
    {
        if ($this->strategy) {
            return $this->strategy;
        }

        /**

Block comments must be started with /*

Inline doc block comments are not allowed; use "/* Comment */" or "// Comment" instead

         * @var WalkStrategyInterface<R>
         * @psalm-suppress InvalidPropertyAssignmentValue
         */
        return $this->strategy = new PaginationWalkStrategy();

Assignments must be the first block of code on a line

    }

    /**
     * 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<ConnectionInterface, R>
     */
    public function query(): ReadCommandInterface
    {
        if ($this->cursor) {
            return $this->cursor->query;
        }

        return $this->query;
    }

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

    /**
     * {@inheritdoc}
     */

Missing @throws tag in function comment

    public function size()
    {
        if (!$this->query instanceof Paginable) {
            throw new BadMethodCallException(__METHOD__.' should be called with a Paginable query');
        }

        return $this->query->paginationCount();
    }

    /**

Parameter $attribute should have a doc-comment as per coding-style.

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

        if (!$query instanceof Orderable) {
            return $attribute ? null : [];

The expression return $attribute ? null : array() also could return the type array which is incompatible with the return type mandated by Bdf\Prime\Query\Pagination\PaginatorInterface::order() of Bdf\Prime\Query\Contract\Orderable.

Inline shorthand IF statement requires brackets around comparison

        }

        $orders = $query->getOrders();

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

The expression return $orders returns the type array which is incompatible with the return type mandated by Bdf\Prime\Query\Pagination\PaginatorInterface::order() of Bdf\Prime\Query\Contract\Orderable.

        }

        return $orders[$attribute] ?? null;

Operation must be bracketed

    }

    /**
     * {@inheritdoc}
     */
    public function limit(): ?int
    {
        if ($this->cursor->query instanceof Limitable) {
            return $this->cursor->query->getLimit();
        }

        return 0;
    }

    /**
     * {@inheritdoc}
     */
    public function offset(): ?int
    {
        if ($this->cursor->query instanceof Limitable) {
            return $this->cursor->query->getOffset();
        }

        return 0;
    }

    /**
     * {@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;

Operation must be bracketed

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

    /**
     * SPL - Iterator
     *
     * {@inheritdoc}
     */
    public function current()
    {
        return current($this->collection);
    }
    
    /**
     * SPL - Iterator
     *
     * {@inheritdoc}
     */
    public function key()
    {
        if ($this->offset !== null) {
            /** @var array<int, mixed> $this->collection */

Inline doc block comments are not allowed; use "/* Comment */" or "// Comment" instead

The open comment tag must be the only content on the line

The close comment tag must be the only content on the line

Block comments must be started with /*

            return $this->offset + key($this->collection);

Operation must be bracketed

        }

        return key($this->collection);
    }
    
    /**
     * SPL - Iterator
     *
     * {@inheritdoc}
     *
     * @throws PrimeException
     */
    #[ReadOperation]
    public function next()
    {
        if (false === next($this->collection)) {
            $this->page++;
            $this->loadCollection();
        }
    }
    
    /**
     * SPL - Iterator
     *
     * {@inheritdoc}
     */
    public function valid()
    {
        return false !== current($this->collection);
    }
    
    /**
     * SPL - Iterator
     *
     * {@inheritdoc}
     *
     * @throws PrimeException
     */
    #[ReadOperation]
    public function rewind()
    {
        if (($this->page == $this->startPage) && count($this->collection)) {
            reset($this->collection);
        } else {
            $this->load();
        }
    }

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

    /**

Parameter $items should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */

Missing @throws tag in function comment

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

    /**

Parameter $item should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */

Missing @throws tag in function comment

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

    /**

Parameter $item should have a doc-comment as per coding-style.

Parameter $key should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */

Missing @throws tag in function comment

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

    /**
     * {@inheritdoc}
     */

Missing @throws tag in function comment

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

    /**

Parameter $default should have a doc-comment as per coding-style.

Parameter $key should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */

Missing @throws tag in function comment

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

    /**

Parameter $key should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */

Missing @throws tag in function comment

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

    /**

Parameter $key should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */

Missing @throws tag in function comment

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

    /**
     * {@inheritdoc}
     */

Missing @throws tag in function comment

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

    /**
     * {@inheritdoc}
     */

Missing @throws tag in function comment

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

    /**
     * {@inheritdoc}
     */

Missing @throws tag in function comment

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

    /**

Parameter $callback should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */

Missing @throws tag in function comment

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

    /**

Parameter $callback should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */

Missing @throws tag in function comment

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

    /**

Parameter $mode should have a doc-comment as per coding-style.

Parameter $groupBy should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */

Missing @throws tag in function comment

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

    /**

Parameter $element should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */

Missing @throws tag in function comment

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

    /**

Parameter $strict should have a doc-comment as per coding-style.

Parameter $value should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */

Missing @throws tag in function comment

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

    /**

Parameter $items should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */

Missing @throws tag in function comment

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

    /**

Parameter $callback should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */

Missing @throws tag in function comment

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

    /**

Parameter $offset should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */

Missing @throws tag in function comment

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

    /**

Parameter $offset should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */

Missing @throws tag in function comment

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

    /**

Parameter $value should have a doc-comment as per coding-style.

Parameter $offset should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */

Missing @throws tag in function comment

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

    /**

Parameter $offset should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */

Missing @throws tag in function comment

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