SelectDataReader::readOne() - Code Metrics - Inspection of "add SelectDataReader::readOne() method" - yiisoft/yii-cycle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#36)

by Alexander

created 2020-06-28 21:45 UTC

SelectDataReader::readOne() A

↳ Parent: SelectDataReader

Complexity

Conditions	4
Paths	3

Size

Total Lines	12
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	20

Importance

Changes	1
Bugs	0	Features	0

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

<?php

declare(strict_types=1);

namespace Yiisoft\Yii\Cycle\DataReader;

use Countable;
use Cycle\ORM\Select;
use InvalidArgumentException;
use IteratorAggregate;
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,
    IteratorAggregate
{
    /** @var Select|SelectQuery */
    private $query;
    private ?int $limit = null;
    private ?int $offset = null;
    private ?Sort $sorting = null;
    private CachedCount $countCache;
    private CachedCollection $itemsCache;
    private CachedCollection $oneItemCache;

    /**
     * @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();
        $this->oneItemCache = 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();
        }
        $query = $this->buildQuery();
        $this->itemsCache->setCollection($query->fetchAll());
        return $this->itemsCache->getCollection();
class A
{
    function getObject()
    {
        return null;
    }

}

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

    /**
     * @return mixed
     */
    public function readOne()
    {
        if (!$this->oneItemCache->isCollected()) {
            $item = $this->itemsCache->isCollected()
                // get first item from cached collection
                ? $this->itemsCache->getGenerator()->current()
                // read data with limit 1
                : $this->withLimit(1)->getIterator()->current();
            $this->oneItemCache->setCollection($item === null ? [] : [$item]);
        }

        return $this->oneItemCache->getGenerator()->current();
    }

    /**
     * Get Iterator without caching
     */
    public function getIterator(): \Generator
    {
        if ($this->itemsCache->getCollection() !== null) {
            yield from $this->itemsCache->getCollection();
        } else {
            yield from $this->buildQuery()->getIterator();
        }
    }

    private function setSort(?Sort $sorting): void
    {
        if ($this->sorting !== $sorting) {
            $this->sorting = $sorting;
            $this->itemsCache = new CachedCollection();
            $this->oneItemCache = 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();
            $this->oneItemCache = new CachedCollection();
        }
    }

    /**
     * @return Select|SelectQuery
     */
    private function buildQuery()
    {
        $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);
        }
        return $newQuery;
    }
}


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 IteratorAggregate;
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			IteratorAggregate
27			{
28			/** @var Select\|SelectQuery */
29			private $query;
30			private ?int $limit = null;
31			private ?int $offset = null;
32			private ?Sort $sorting = null;
33			private CachedCount $countCache;
34			private CachedCollection $itemsCache;
35			private CachedCollection $oneItemCache;
36
37			/**
38			* @param Select\|SelectQuery $query
39			*/
40			public function __construct($query)
41			{
42			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...
43			throw new InvalidArgumentException(sprintf('Query should implement %s interface', Countable::class));
44			}
45			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...
46			throw new InvalidArgumentException(
47			sprintf('Query should implement %s interface', PaginableInterface::class)
48			);
49			}
50			$this->query = clone $query;
51			$this->countCache = new CachedCount($this->query);
52			$this->itemsCache = new CachedCollection();
53			$this->oneItemCache = new CachedCollection();
54			}
55
56			public function getSort(): ?Sort
57			{
58			return $this->sorting;
59			}
60
61			public function withLimit(int $limit): self
62			{
63			$clone = clone $this;
64			$clone->setLimit($limit);
65			return $clone;
66			}
67
68			public function withOffset(int $offset): self
69			{
70			$clone = clone $this;
71			$clone->setOffset($offset);
72			return $clone;
73			}
74
75			public function withSort(?Sort $sorting): self
76			{
77			$clone = clone $this;
78			$clone->setSort($sorting);
79			return $clone;
80			}
81
82			public function count(): int
83			{
84			return $this->countCache->getCount();
85			}
86
87			public function read(): iterable
88			{
89			if ($this->itemsCache->getCollection() !== null) {
90			return $this->itemsCache->getCollection();
91			}
92			$query = $this->buildQuery();
93			$this->itemsCache->setCollection($query->fetchAll());
94			return $this->itemsCache->getCollection();
			0 ignored issues – show 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... 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...
95			}
96
97			/**
98			* @return mixed
99			*/
100			public function readOne()
101			{
102			if (!$this->oneItemCache->isCollected()) {
103			$item = $this->itemsCache->isCollected()
104			// get first item from cached collection
105			? $this->itemsCache->getGenerator()->current()
106			// read data with limit 1
107			: $this->withLimit(1)->getIterator()->current();
108			$this->oneItemCache->setCollection($item === null ? [] : [$item]);
109			}
110
111			return $this->oneItemCache->getGenerator()->current();
112			}
113
114			/**
115			* Get Iterator without caching
116			*/
117			public function getIterator(): \Generator
118			{
119			if ($this->itemsCache->getCollection() !== null) {
120			yield from $this->itemsCache->getCollection();
121			} else {
122			yield from $this->buildQuery()->getIterator();
123			}
124			}
125
126			private function setSort(?Sort $sorting): void
127			{
128			if ($this->sorting !== $sorting) {
129			$this->sorting = $sorting;
130			$this->itemsCache = new CachedCollection();
131			$this->oneItemCache = new CachedCollection();
132			}
133			}
134
135			private function setLimit(?int $limit): void
136			{
137			if ($this->limit !== $limit) {
138			$this->limit = $limit;
139			$this->itemsCache = new CachedCollection();
140			}
141			}
142
143			private function setOffset(?int $offset): void
144			{
145			if ($this->offset !== $offset) {
146			$this->offset = $offset;
147			$this->itemsCache = new CachedCollection();
148			$this->oneItemCache = new CachedCollection();
149			}
150			}
151
152			/**
153			* @return Select\|SelectQuery
154			*/
155			private function buildQuery()
156			{
157			$newQuery = clone $this->query;
158			if ($this->offset !== null) {
159			$newQuery->offset($this->offset);
160			}
161			if ($this->sorting !== null) {
162			$newQuery->orderBy($this->sorting->getOrder());
163			}
164			if ($this->limit !== null) {
165			$newQuery->limit($this->limit);
166			}
167			return $newQuery;
168			}
169			}
170

yiisoft / yii-cycle

Pull Request — master (#36)

SelectDataReader::readOne() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like