DoctrineOffsetCursorPaginator::applyCursor() - Code Metrics - Inspection of "dump v1.2.2" - ynloultratech/graphql-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 540370...4c31d8 )

by Rafael

created 2018-07-25 13:19 UTC

DoctrineOffsetCursorPaginator::applyCursor() F

↳ Parent: DoctrineOffsetCursorPaginator

Complexity

Conditions	17
Paths	600

Size

Total Lines	67
Code Lines	40

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	30
CRAP Score	18.9573

Importance

Changes

Metric	Value
eloc	40
dl	0
loc	67
ccs	30
cts	37
cp	0.8108
rs	1.6055
c	0
b	0
f	0
cc	17
nc	600
nop	3
crap	18.9573

How to fix Long Method Complexity

<?php
/*******************************************************************************
 *  This file is part of the GraphQL Bundle package.
 *
 *  (c) YnloUltratech <[email protected]>
 *
 *  For the full copyright and license information, please view the LICENSE
 *  file that was distributed with this source code.
 ******************************************************************************/

namespace Ynlo\GraphQLBundle\Pagination;

use Doctrine\ORM\QueryBuilder;
use Ynlo\GraphQLBundle\Model\ConnectionInterface;
use Ynlo\GraphQLBundle\Model\NodeConnection;

/**
 * DoctrineOffsetCursorPaginator
 */
class DoctrineOffsetCursorPaginator implements DoctrineCursorPaginatorInterface
{
    /**
     * @var NodeConnection
     */
    protected $connection;

    /**
     * {@inheritdoc}
     */
    public function paginate(QueryBuilder $query, PaginationRequest $pagination, ConnectionInterface $connection)
    {
        $count = $this->getQueryTotal($query);
        $this->connection = $connection;
class Alien {}

class Dalek extends Alien {}

class Plot
{
    /** @var  Dalek */
    public $villain;
}

$alien = new Alien();
$plot = new Plot();
if ($alien instanceof Dalek) {
    $plot->villain = $alien;
}
        $this->connection->setTotalCount($count);

        $this->applyCursor($query, $count, $pagination);

        $limit = $pagination->getFirst() ?? $pagination->getLast();
        $query->setMaxResults($limit);

        $results = $query->getQuery()->execute();

        $offset = $query->getFirstResult();

        $cursorOffset = $offset - 1;
        foreach ($results as $result) {
            $cursorOffset ++;

            if (!$this->connection->getPageInfo()->getStartCursor()) {
                $this->connection->getPageInfo()->setStartCursor($this->encodeCursor($offset));
            }

            $cursor = $this->encodeCursor($cursorOffset);
            $this->connection->addEdge($this->connection->createEdge($result, $cursor));
            if ($limit > 0) {
                $this->connection->setPages((int) ceil($count / $limit));
                if ($offset > 0) {
                    $this->connection->getPageInfo()->setPage((int) ceil($offset / $limit) + 1);
                } else {
                    $this->connection->getPageInfo()->setPage(1);
                }
            } else {
                $this->connection->setPages(0);
                $this->connection->getPageInfo()->setPage(0);
            }
            $this->connection->getPageInfo()->setEndCursor($cursor);
        }
    }

    /**
     * @param QueryBuilder $qb
     *
     * @return int
     *
     * @throws \Doctrine\ORM\NonUniqueResultException
     */
    protected function getQueryTotal(QueryBuilder $qb): int
    {
        $countQuery = clone $qb;

        if (\count($qb->getParameters()) > 0) {
            $countQuery->setParameters($qb->getParameters());
        }

        if ($countQuery->getDQLPart('orderBy')) {
            $countQuery->resetDQLPart('orderBy');
        }

        $countQuery->setMaxResults(null);
        $countQuery->setFirstResult(0);

        $queryAlias = $qb->getAllAliases()[0];
        $countQuery->select(sprintf('count(DISTINCT %s.%s) as total', $queryAlias, 'id'));

        return $countQuery->getQuery()->getSingleScalarResult();
    }

    /**
     * @param QueryBuilder      $qb
     * @param int               $count
     * @param PaginationRequest $pagination
     */
    protected function applyCursor(QueryBuilder $qb, $count, PaginationRequest $pagination): void
    {
        $limit = $pagination->getFirst() ?? $pagination->getLast();
        $offset = 0;
        if (null !== $pagination->getBefore()) {
            $offset = $this->decodeCursor($pagination->getBefore()) - $limit;

            //when the offset is less than 0,
            //the limit of records will be modified to start in 0
            if ($offset < 0) {
                if ($pagination->getFirst()) {
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
                    $pagination->setFirst($pagination->getFirst() - abs($offset));
                    $pagination->setFirst(/** @scrutinizer ignore-type */ $pagination->getFirst() - abs($offset));
                } else {
                    $pagination->setLast($pagination->getLast() - abs($offset));
                    $pagination->setLast(/** @scrutinizer ignore-type */ $pagination->getLast() - abs($offset));
                }
                $offset = 0;
            }

            //first records before any cursor always start in 0
            if ($pagination->getFirst()) {
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
                $offset = 0;
            }
        } elseif (null !== $pagination->getAfter()) {
            //last records after any cursor always start in ($count - $limit)
            if ($pagination->getLast()) {
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
                $offset = $count - $pagination->getLast();
                if ($offset < $this->decodeCursor($pagination->getAfter())) {
                    $offset =  $this->decodeCursor($pagination->getAfter()) + 1;
                }
            } else {
                $offset = $this->decodeCursor($pagination->getAfter()) + 1;
            }
        }

        if ($pagination->getLast() && !$pagination->getBefore() && !$pagination->getAfter()) {
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
            $offset = $count - $pagination->getLast();
            if ($offset < 0) {
                $offset = 0;
            }
        }

        $page = $pagination->getPage();
        if ($page > 0) {
            $pages = (int) ceil($count / $limit);
            if ($page > $pages) {
                $page = $pages;
            }

            $offset = ($page - 1) * $limit;
            if ($offset < 0) {
                $offset = 0;
            }
        }

        if (0 === $offset) {
            $this->connection->getPageInfo()->setHasPreviousPage(false);
        } else {
            $this->connection->getPageInfo()->setHasPreviousPage(true);
        }

        if ($offset + $limit >= $count) {
            $this->connection->getPageInfo()->setHasNextPage(false);
        } else {
            $this->connection->getPageInfo()->setHasNextPage(true);
        }

        $qb->setFirstResult($offset);
    }

    /**
     * @param string $cursor
     *
     * @return int
     */
    protected function decodeCursor($cursor): int
    {
        [, $offset] = explode(':', base64_decode($cursor));

        return $offset;

    }

    /**
     * @param string $offset
     *
     * @return string
     */
    protected function encodeCursor($offset): string
    {
        return base64_encode(sprintf('cursor:%s', $offset));
    }
}


ynloultratech / graphql-bundle

Push — master ( 540370...4c31d8 )

DoctrineOffsetCursorPaginator::applyCursor() F

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like