BenTools\Pager\Model\Pager

Complexity

Total Complexity

31

Size/Duplication

Total Lines	237
Duplicated Lines	0 %

Importance

Changes

0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	isFirstPage()	0	3	1
A	isNextPage()	0	3	1
A	setCurrentPageNumber()	0	4	1
A	asArray()	0	3	1
A	setNumFound()	0	4	1
A	getNumFound()	0	6	2
A	getFirstPage()	0	3	1
A	isLastPage()	0	3	1
A	isCurrentPage()	0	3	1
A	getNextPage()	0	7	2
A	getOffset()	0	3	1
A	getCurrentPage()	0	3	1
A	__construct()	0	5	1
A	getCurrentPageNumber()	0	6	2
A	getPage()	0	12	3
A	getPreviousPage()	0	6	2
A	getIterator()	0	4	2
A	isPreviousPage()	0	3	1
A	count()	0	3	1
A	getLastPage()	0	3	1
A	getPageOffset()	0	3	1
A	getPerPage()	0	6	2
A	setPerPage()	0	4	1

<?php

namespace BenTools\Pager\Model;

use BenTools\Pager\Contract\PageInterface;
use BenTools\Pager\Contract\PagerInterface;
use BenTools\Pager\Contract\PageUrlBuilderInterface;
use BenTools\Pager\Model\Exception\PagerException;

class Pager implements PagerInterface
{
    /**
     * @var int
     */
    private $perPage;

    /**
     * @var int
     */
    private $currentPageNumber;

    /**
     * @var int
     */
    private $numFound;

    /**
     * Pager constructor.
     * @param int|null                     $perPage
     * @param int|null                     $currentPageNumber
     * @param int|null                     $numFound
     * @throws \RuntimeException
     */
    public function __construct(int $perPage = null, int $currentPageNumber = null, int $numFound = null)
    {
        $this->perPage = $perPage;
        $this->currentPageNumber = $currentPageNumber;
        $this->numFound = $numFound;
    }

    /**
     * @inheritdoc
     */
    public function setCurrentPageNumber(int $currentPageNumber): PagerInterface
    {
        $this->currentPageNumber = $currentPageNumber;
        return $this;
    }

    /**
     * @inheritDoc
     */
    private function getCurrentPageNumber(): int
    {
        if (null === $this->currentPageNumber) {
            throw new PagerException(get_class($this) . '::currentPageNumber has not been set.');
        }
        return $this->currentPageNumber;
    }

    /**
     * @inheritDoc
     */
    public function getNumFound(): int
    {
        if (null === $this->numFound) {
            throw new PagerException(get_class($this) . '::$numFound has not been set.');
        }
        return $this->numFound;
    }

    /**
     * @param int $numFound
     * @return Pager
     */
    public function setNumFound(int $numFound): PagerInterface
    {
        $this->numFound = $numFound;
        return $this;
    }

    /**
     * @inheritDoc
     */
    public function getPerPage(): int
    {
        if (null === $this->perPage) {
            throw new PagerException(get_class($this) . '::$perPage has not been set.');
        }
        return $this->perPage;
    }

    /**
     * @param int $perPage
     * @return Pager
     */
    public function setPerPage(int $perPage): PagerInterface
    {
        $this->perPage = $perPage;
        return $this;
    }

    /**
     * @inheritDoc
     */
    public function getOffset(): int
    {
        return ($this->getCurrentPageNumber() - 1) * $this->getPerPage();
    }

    /**
     * @inheritDoc
     */
    public function count(): int
    {
        return (int) ceil($this->getNumFound() / $this->getPerPage());
    }

    /**
     * @inheritDoc
     */
    public function getIterator(): iterable
    {
        for ($nbPages = count($this), $pageNumber = 1; $pageNumber <= $nbPages; $pageNumber++) {
            yield $this->getPage($pageNumber);
        }

In this branch, the function will implicitly return null which is incompatible with the type-hinted return iterable. Consider adding a return statement or allowing null as return value.

    }

    /**
     * @inheritdoc
     */
    public function getPage(int $pageNumber): PageInterface
    {
        $nbPages = count($this);

        if ($pageNumber > $nbPages) {
            throw new PagerException(sprintf('Page number %d is invalid, the pager contains only %d pages.', $pageNumber, $nbPages));
        } elseif ($pageNumber === $nbPages) {
            $nbItems = ($this->getPerPage() - (($pageNumber * $this->getPerPage()) - $this->getNumFound()));
        } else {
            $nbItems = $this->getPerPage();
        }
        return new Page($pageNumber, $nbItems);
    }

    /**
     * @return array
     */
    public function asArray(): array
    {
        return iterator_to_array($this);
    }

    /**
     * @inheritDoc
     */
    public function getCurrentPage(): PageInterface
    {
        return $this->getPage($this->getCurrentPageNumber());
    }

    /**
     * @inheritDoc
     */
    public function isCurrentPage(PageInterface $page): bool
    {
        return $page->getPageNumber() === $this->getCurrentPageNumber();
    }

    /**
     * @inheritDoc
     */
    public function getPreviousPage(): ?PageInterface
    {
        if (1 === $this->getCurrentPageNumber()) {
            return null;
        }
        return $this->getPage($this->getCurrentPageNumber() - 1);
    }

    /**
     * @inheritDoc
     */
    public function isPreviousPage(PageInterface $page): bool
    {
        return (-1 + $this->getCurrentPageNumber()) === $page->getPageNumber();
    }

    /**
     * @inheritDoc
     */
    public function getNextPage(): ?PageInterface
    {
        $nbPages = count($this);
        if ($nbPages === $this->getCurrentPageNumber()) {
            return null;
        }
        return $this->getPage($this->getCurrentPageNumber() + 1);
    }

    /**
     * @inheritDoc
     */
    public function isNextPage(PageInterface $page): bool
    {
        return (1 + $this->getCurrentPageNumber()) === $page->getPageNumber();
    }

    /**
     * @inheritDoc
     */
    public function getFirstPage(): PageInterface
    {
        return $this->getPage(1);
    }

    /**
     * @inheritDoc
     */
    public function isFirstPage(PageInterface $page): bool
    {
        return 1 === $page->getPageNumber();
    }

    /**
     * @inheritDoc
     */
    public function getLastPage(): PageInterface
    {
        return $this->getPage(count($this));
    }

    /**
     * @inheritDoc
     */
    public function isLastPage(PageInterface $page): bool
    {
        return count($this) === $page->getPageNumber();
    }

    /**
     * @inheritDoc
     */
    public function getPageOffset(PageInterface $page): int
    {
        return ($page->getPageNumber() - 1) * $this->getPerPage();
    }
}