Paginator::perPage() - Code Metrics - Inspection of "Merge pull request #832 from hydephp/cherry-pick-p..." - hydephp/develop - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 989b30...0f788a )

by Caen
created 2023-01-14 11:21 UTC
Paginator::perPage() A

↳ Parent: Paginator
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Importance

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

declare(strict_types=1);

namespace Hyde\Framework\Features;

use function collect;
use Hyde\Hyde;
use Hyde\Support\Models\Route;
use Illuminate\Contracts\Support\Arrayable;
use Illuminate\Support\Collection;
use InvalidArgumentException;
use function range;
use function sprintf;

/**
 * @see \Hyde\Framework\Testing\Feature\PaginatorTest
 */
class Paginator
{
    protected Collection $paginatedItems;

    protected int $pageSize = 25;
    protected int $currentPage = 1;

    /**
     * Optionally provide a route basename to be used in generating the pagination links.
     */
    protected string $routeBasename;

    public function __construct(Arrayable|array $items = [], int $pageSize = 25, int $currentPageNumber = null, string $paginationRouteBasename = null)
    {
        $this->pageSize = $pageSize;

        $this->generate(collect($items));
        $this->generate(collect(/** @scrutinizer ignore-type */ $items));

        if ($currentPageNumber) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
            $this->setCurrentPage($currentPageNumber);
        }

        if ($paginationRouteBasename) {
            $this->routeBasename = $paginationRouteBasename;
        }
    }

    protected function generate(Collection $items): void
    {
        $this->paginatedItems = $items->chunk($this->perPage());
    }

    /** Set the current page number. */
    public function setCurrentPage(int $currentPage): Paginator
    {
        $this->validateCurrentPageValue($currentPage);

        $this->currentPage = $currentPage;

        return $this;
    }

    /** Get the current page number (which is used as a cursor). */
    public function currentPage(): int
    {
        return $this->currentPage;
    }

    /** Get the paginated collection */
    public function getPaginatedItems(): Collection
    {
        return $this->paginatedItems;
    }

    public function getItemsForPage(): Collection
    {
        return $this->paginatedItems->get($this->currentPage - 1);
    }

    public function getPageLinks(): array
    {
        $array = [];
        $pageRange = range(1, $this->totalPages());
        if (isset($this->routeBasename)) {
            foreach ($pageRange as $number) {
                $array[$number] = Route::get("$this->routeBasename/page-$number") ?? Hyde::formatLink("$this->routeBasename/page-$number");
            }
        } else {
            foreach ($pageRange as $number) {
                $array[$number] = Hyde::formatLink("page-$number.html");
            }
        }

        return $array;
    }

    /** The number of items to be shown per page. */
    public function perPage(): int
    {
        return $this->pageSize;
    }

    /** Get the total number of pages. */
    public function totalPages(): int
    {
        return $this->paginatedItems->count();
    }

    /** Determine if there are enough items to split into multiple pages. */
    public function hasMultiplePages(): bool
    {
        return $this->totalPages() > 1;
    }

    /** Get the page number of the last available page. */
    public function lastPage(): int
    {
        return $this->totalPages();
    }

    /** Determine if there are fewer items after the cursor in the data store. */
    public function canNavigateBack(): bool
    {
        return $this->currentPage > $this->firstPage();
    }

    /** Determine if there are more items after the cursor in the data store. */
    public function canNavigateForward(): bool
    {
        return $this->currentPage < $this->lastPage();
    }

    public function previousPageNumber(): false|int
    {
        if (! $this->canNavigateBack()) {
            return false;
        }

        return $this->currentPage - 1;
    }

    public function nextPageNumber(): false|int
    {
        if (! $this->canNavigateForward()) {
            return false;
        }

        return $this->currentPage + 1;
    }

    public function previous(): false|string|Route
    {
        if (! $this->canNavigateBack()) {
            return false;
        }

        if (! isset($this->routeBasename)) {
            return $this->formatLink(-1);
        }

        return $this->getRoute(-1);
    }

    public function next(): false|string|Route
    {
        if (! $this->canNavigateForward()) {
            return false;
        }

        if (! isset($this->routeBasename)) {
            return $this->formatLink(+1);
        }

        return $this->getRoute(+1);
    }

    public function firstItemNumberOnPage(): int
    {
        return (($this->currentPage - 1) * $this->perPage()) + 1;
    }

    protected function validateCurrentPageValue(int $currentPage): void
    {
        if ($currentPage < $this->firstPage()) {
            throw new InvalidArgumentException('Current page number must be greater than 0.');
        }

        if ($currentPage > $this->lastPage()) {
            throw new InvalidArgumentException('Current page number must be less than or equal to the last page number.');
        }
    }

    protected function formatPageName(int $offset): string
    {
        return sprintf('page-%d', $this->currentPage + $offset);
    }

    protected function formatLink(int $offset): string
    {
        return Hyde::formatLink("{$this->formatPageName($offset)}.html");
    }

    protected function getRoute(int $offset): Route|string
    {
        return Route::get("$this->routeBasename/{$this->formatPageName($offset)}") ?? Hyde::formatLink("$this->routeBasename/{$this->formatPageName($offset)}");
    }

    protected function firstPage(): int
    {
        return 1;
    }
}

hydephp / develop

Push — master ( 989b30...0f788a )

Paginator::perPage() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
