SelectDataReader::makeFilterClosure() - Code Metrics - Inspection of "Add ability to filter SelectDataReader (#48)" - yiisoft/yii-cycle - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 6a1165...134c40 )

by Alexander
created 2020-08-26 09:40 UTC
SelectDataReader::makeFilterClosure() A

↳ Parent: SelectDataReader
Complexity

Conditions	2
Paths	1
Size

Total Lines	12
Code Lines	8
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	6
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
eloc	8
c	1
b	0
f	0
dl	0
loc	12
ccs	0
cts	9
cp	0
rs	10
cc	2
nc	1
nop	0
crap	6
<?php

declare(strict_types=1);

namespace Yiisoft\Yii\Cycle\DataReader;

use Closure;
use Countable;
use Cycle\ORM\Select;
use Cycle\ORM\Select\QueryBuilder;
use InvalidArgumentException;
use Spiral\Database\Query\SelectQuery;
use Spiral\Pagination\PaginableInterface;
use Yiisoft\Data\Reader\DataReaderInterface;
use Yiisoft\Data\Reader\Filter\FilterInterface;
use Yiisoft\Data\Reader\Filter\FilterProcessorInterface;
use Yiisoft\Data\Reader\Sort;
use Yiisoft\Yii\Cycle\DataReader\Cache\CachedCount;
use Yiisoft\Yii\Cycle\DataReader\Cache\CachedCollection;
use Yiisoft\Yii\Cycle\DataReader\Processor;
use Yiisoft\Yii\Cycle\DataReader\Processor\QueryBuilderProcessor;

final class SelectDataReader implements DataReaderInterface
{
    /** @var Select|SelectQuery */
    private $query;
    private ?int $limit = null;
    private ?int $offset = null;
    private ?Sort $sorting = null;
    private ?FilterInterface $filter = null;
    private CachedCount $countCache;
    private CachedCollection $itemsCache;
    private CachedCollection $oneItemCache;
    /** @var FilterProcessorInterface[]|QueryBuilderProcessor[] */
    private array $filterProcessors = [];

    /**
     * @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();
        $this->setFilterProcessors(
            new Processor\All(),
            new Processor\Any(),
            new Processor\Equals(),
            new Processor\GreaterThan(),
            new Processor\GreaterThanOrEqual(),
            new Processor\In(),
            new Processor\LessThan(),
            new Processor\LessThanOrEqual(),
            new Processor\Like(),
            // new Processor\Not()
        );
    }

    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 withFilter(FilterInterface $filter): self
    {
        $clone = clone $this;
        $clone->setFilter($filter);
        return $clone;
    }

    public function withFilterProcessors(FilterProcessorInterface ...$filterProcessors): self
    {
        $clone = clone $this;
        $clone->setFilterProcessors(...$filterProcessors);
        $clone->resetCountCache();
        $clone->itemsCache = new CachedCollection();
        $clone->oneItemCache = new CachedCollection();
        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();
        }
    }

    /**
     * Convert to SQL string
     */
    public function __toString(): string
    {
        return $this->getSql();
    }

    public function getSql(): string
    {
        return $this->buildQuery()->sqlStatement();
    }

    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();
        }
    }

    private function setFilter(FilterInterface $filter): void
    {
        if ($this->filter !== $filter) {
            $this->filter = $filter;
            $this->itemsCache = new CachedCollection();
            $this->oneItemCache = new CachedCollection();
        }
    }

    private function setFilterProcessors(FilterProcessorInterface ...$filterProcessors): void
    {
        $processors = [];
        foreach ($filterProcessors as $filterProcessor) {
            if ($filterProcessor instanceof QueryBuilderProcessor) {
                $processors[$filterProcessor->getOperator()] = $filterProcessor;
            }
        }
        $this->filterProcessors = array_merge($this->filterProcessors, $processors);
    }

    /**
     * @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);
        }
        if ($this->filter !== null) {
            $newQuery->andWhere($this->makeFilterClosure());
        }
        return $newQuery;
    }
    private function makeFilterClosure(): Closure
    {
        return function (QueryBuilder $select) {
            $filter = $this->filter->toArray();
            $filter = $this->filter->toArray();
            $operation = array_shift($filter);
            $arguments = $filter;

            $processor = $this->filterProcessors[$operation] ?? null;
            if ($processor === null) {
                throw new \RuntimeException(sprintf('Filter operator "%s" is not supported.', $operation));
            }
            $select->where(...$processor->getAsWhereArguments($arguments, $this->filterProcessors));
        };
    }
    private function resetCountCache(): void
    {
        $newQuery = clone $this->query;
        if ($this->filter !== null) {
            $newQuery->andWhere($this->makeFilterClosure());
        }
        $this->countCache = new CachedCount($newQuery);
    }
}

yiisoft / yii-cycle

Push — master ( 6a1165...134c40 )

SelectDataReader::makeFilterClosure() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
