SelectDataReader::setSort() - Code Metrics - Inspection of "Cycle Select DataReader" - yiisoft/yii-cycle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#17)

unknown

created 2020-02-04 20:43 UTC

SelectDataReader::setSort() A

↳ Parent: SelectDataReader

Complexity

Conditions	2
Paths	2

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
cc	2
eloc	3
nc	2
nop	1
dl	0
loc	5
ccs	0
cts	5
cp	0
crap	6
rs	10
c	1
b	0
f	1

<?php

declare(strict_types=1);

namespace Yiisoft\Yii\Cycle\DataReader;

use Countable;
use Cycle\ORM\Select;
use InvalidArgumentException;
use Spiral\Database\Query\QueryInterface;
use Spiral\Database\Query\SelectQuery;
use Spiral\Pagination\PaginableInterface;
use Yiisoft\Data\Reader\CountableDataInterface;
use Yiisoft\Data\Reader\DataReaderInterface;
use Yiisoft\Data\Reader\OffsetableDataInterface;
use Yiisoft\Data\Reader\Sort;
use Yiisoft\Data\Reader\SortableDataInterface;
use Yiisoft\Yii\Cycle\DataReader\Cache\CachedCount;
use Yiisoft\Yii\Cycle\DataReader\Cache\CachedCollection;

final class SelectDataReader implements
    DataReaderInterface,
    OffsetableDataInterface,
    CountableDataInterface,
    SortableDataInterface
{
    /** @var Select|SelectQuery */
    private $query;
    private ?int $limit = null;
    private ?int $offset = null;
    private ?Sort $sorting = null;
    private CachedCount $countCache;
    private CachedCollection $itemsCache;

    /**
     * @param Select|SelectQuery $query
     */
    public function __construct($query)
    {
        if (!$query instanceof Countable) {

            throw new InvalidArgumentException(sprintf('Query should implement %s interface', Countable::class));
        }
        if (!$query instanceof PaginableInterface) {

            throw new InvalidArgumentException(
                sprintf('Query should implement %s interface', PaginableInterface::class)
            );
        }
        $this->query = clone $query;
        $this->countCache = new CachedCount($this->query);
        $this->itemsCache = new CachedCollection();
    }

    public function getSort(): ?Sort
    {
        return $this->sorting;
    }

    public function withLimit(int $limit): self
    {
        $clone = clone $this;
        $clone->setLimit($limit);
        return $clone;
    }

    public function withOffset(int $offset): self
    {
        $clone = clone $this;
        $clone->setOffset($offset);
        return $clone;
    }

    public function withSort(?Sort $sorting): self
    {
        $clone = clone $this;
        $clone->setSort($sorting);
        return $clone;
    }

    public function count(): int
    {
        return $this->countCache->getCount();
    }

    public function read(): iterable
    {
        if ($this->itemsCache->getCollection() !== null) {
            return $this->itemsCache->getCollection();
        }
        $newQuery = clone $this->query;
        if ($this->offset !== null) {
            $newQuery->offset($this->offset);
        }
        if ($this->sorting !== null) {
            $newQuery->orderBy($this->sorting->getOrder());
        }
        if ($this->limit !== null) {
            $newQuery->limit($this->limit);
        }
        $this->itemsCache->setCollection($newQuery->fetchAll());
        return $this->itemsCache->getCollection();
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
    }

    private function setSort(?Sort $sorting): void
    {
        if ($this->sorting !== $sorting) {
            $this->sorting = $sorting;
            $this->itemsCache = new CachedCollection();
        }
    }

    private function setLimit(?int $limit): void
    {
        if ($this->limit !== $limit) {
            $this->limit = $limit;
            $this->itemsCache = new CachedCollection();
        }
    }

    private function setOffset(?int $offset): void
    {
        if ($this->offset !== $offset) {
            $this->offset = $offset;
            $this->itemsCache = new CachedCollection();
        }
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Yiisoft\Yii\Cycle\DataReader;
6
7			use Countable;
8			use Cycle\ORM\Select;
9			use InvalidArgumentException;
10			use Spiral\Database\Query\QueryInterface;
11			use Spiral\Database\Query\SelectQuery;
12			use Spiral\Pagination\PaginableInterface;
13			use Yiisoft\Data\Reader\CountableDataInterface;
14			use Yiisoft\Data\Reader\DataReaderInterface;
15			use Yiisoft\Data\Reader\OffsetableDataInterface;
16			use Yiisoft\Data\Reader\Sort;
17			use Yiisoft\Data\Reader\SortableDataInterface;
18			use Yiisoft\Yii\Cycle\DataReader\Cache\CachedCount;
19			use Yiisoft\Yii\Cycle\DataReader\Cache\CachedCollection;
20
21			final class SelectDataReader implements
22			DataReaderInterface,
23			OffsetableDataInterface,
24			CountableDataInterface,
25			SortableDataInterface
26			{
27			/** @var Select\|SelectQuery */
28			private $query;
29			private ?int $limit = null;
30			private ?int $offset = null;
31			private ?Sort $sorting = null;
32			private CachedCount $countCache;
33			private CachedCollection $itemsCache;
34
35			/**
36			* @param Select\|SelectQuery $query
37			*/
38			public function __construct($query)
39			{
40			if (!$query instanceof Countable) {
			0 ignored issues – show introduced 2020-02-04 20:45 UTC by Report Bug Copy Issue Report `$query` is always a sub-type of `Countable`. Loading history...
41			throw new InvalidArgumentException(sprintf('Query should implement %s interface', Countable::class));
42			}
43			if (!$query instanceof PaginableInterface) {
			0 ignored issues – show introduced 2020-02-04 20:45 UTC by Report Bug Copy Issue Report `$query` is always a sub-type of `Spiral\Pagination\PaginableInterface`. Loading history...
44			throw new InvalidArgumentException(
45			sprintf('Query should implement %s interface', PaginableInterface::class)
46			);
47			}
48			$this->query = clone $query;
49			$this->countCache = new CachedCount($this->query);
50			$this->itemsCache = new CachedCollection();
51			}
52
53			public function getSort(): ?Sort
54			{
55			return $this->sorting;
56			}
57
58			public function withLimit(int $limit): self
59			{
60			$clone = clone $this;
61			$clone->setLimit($limit);
62			return $clone;
63			}
64
65			public function withOffset(int $offset): self
66			{
67			$clone = clone $this;
68			$clone->setOffset($offset);
69			return $clone;
70			}
71
72			public function withSort(?Sort $sorting): self
73			{
74			$clone = clone $this;
75			$clone->setSort($sorting);
76			return $clone;
77			}
78
79			public function count(): int
80			{
81			return $this->countCache->getCount();
82			}
83
84			public function read(): iterable
85			{
86			if ($this->itemsCache->getCollection() !== null) {
87			return $this->itemsCache->getCollection();
88			}
89			$newQuery = clone $this->query;
90			if ($this->offset !== null) {
91			$newQuery->offset($this->offset);
92			}
93			if ($this->sorting !== null) {
94			$newQuery->orderBy($this->sorting->getOrder());
95			}
96			if ($this->limit !== null) {
97			$newQuery->limit($this->limit);
98			}
99			$this->itemsCache->setCollection($newQuery->fetchAll());
100			return $this->itemsCache->getCollection();
			0 ignored issues – show Bug introduced 2020-02-04 16:56 UTC by Report Bug Copy Issue Report Are you sure the usage of `$this->itemsCache->getCollection()` targeting `Yiisoft\Yii\Cycle\DataRe...ection::getCollection()` seems to always return null. This check looks for function or method calls that always return null and whose return value is used. class A { function getObject() { return null; } } $a = new A(); if ($a->getObject()) { The method `getObject()` can return nothing but null, so it makes no sense to use the return value. The reason is most likely that a function or method is imcomplete or has been reduced for debug purposes. Loading history... Bug Best Practice introduced 2020-02-04 16:56 UTC by Report Bug Copy Issue Report The expression `return $this->itemsCache->getCollection()` returns the type `null` which is incompatible with the type-hinted return `iterable`. Loading history...
101			}
102
103			private function setSort(?Sort $sorting): void
104			{
105			if ($this->sorting !== $sorting) {
106			$this->sorting = $sorting;
107			$this->itemsCache = new CachedCollection();
108			}
109			}
110
111			private function setLimit(?int $limit): void
112			{
113			if ($this->limit !== $limit) {
114			$this->limit = $limit;
115			$this->itemsCache = new CachedCollection();
116			}
117			}
118
119			private function setOffset(?int $offset): void
120			{
121			if ($this->offset !== $offset) {
122			$this->offset = $offset;
123			$this->itemsCache = new CachedCollection();
124			}
125			}
126			}
127

yiisoft / yii-cycle

Pull Request — master (#17)

SelectDataReader::setSort() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like