RepositoryProxy::assertCountLessThan() - Code Metrics - Inspection of "[minor] migrate to new scrutinizer analysis engine" - zenstruck/foundry - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 829500...1175ab )

by Kevin

created 2020-06-05 16:38 UTC

RepositoryProxy::assertCountLessThan() A

↳ Parent: RepositoryProxy

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

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

<?php

namespace Zenstruck\Foundry;

use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\EntityRepository;
use Doctrine\Persistence\ObjectRepository;
use PHPUnit\Framework\Assert;

/**
 * @mixin EntityRepository
 *
 * @author Kevin Bond <[email protected]>
 */
final class RepositoryProxy implements ObjectRepository
{
    private ObjectRepository $repository;

    public function __construct(ObjectRepository $repository)
    {
        $this->repository = $repository;
    }

    public function __call(string $method, array $arguments)
    {
        return $this->proxyResult($this->repository->{$method}(...$arguments));
    }

    public function getCount(): int
    {
        if ($this->repository instanceof EntityRepository) {
            return $this->repository->count([]);
            return $this->repository->/** @scrutinizer ignore-call */ count([]);
        }

        return \count($this->findAll());
    }

    public function assertEmpty(): self
    {
        return $this->assertCount(0);
    }

    public function assertCount(int $expectedCount): self
    {
        // todo add message
        Assert::assertSame($expectedCount, $this->getCount());

        return $this;
    }

    public function assertCountGreaterThan(int $expected): self
    {
        // todo add message
        Assert::assertGreaterThan($expected, $this->getCount());

        return $this;
    }

    public function assertCountGreaterThanOrEqual(int $expected): self
    {
        // todo add message
        Assert::assertGreaterThanOrEqual($expected, $this->getCount());

        return $this;
    }

    public function assertCountLessThan(int $expected): self
    {
        // todo add message
        Assert::assertLessThan($expected, $this->getCount());

        return $this;
    }

    public function assertCountLessThanOrEqual(int $expected): self
    {
        // todo add message
        Assert::assertLessThanOrEqual($expected, $this->getCount());

        return $this;
    }

    /**
     * @param object|array|mixed $criteria
     */
    public function assertExists($criteria): self
    {
        // todo add message
        Assert::assertNotNull($this->find($criteria));

        return $this;
    }

    /**
     * @param object|array|mixed $criteria
     */
    public function assertNotExists($criteria): self
    {
        // todo add message
        Assert::assertNull($this->find($criteria));

        return $this;
    }

    /**
     * @return Proxy|object|null
     */
    public function first(): ?object
    {
        return $this->findOneBy([]);
    }

    /**
     * Remove all rows.
     */
    public function truncate(): void
    {
        $om = PersistenceManager::objectManagerFor($this->getClassName());

        if (!$om instanceof EntityManagerInterface) {
            throw new \RuntimeException('This operation is only available when using doctrine/orm');
        }

        $om->createQuery("DELETE {$this->getClassName()} e")->execute();
    }

    /**
     * @param object|array|mixed $criteria
     *
     * @return Proxy|object|null
     */
    public function find($criteria): ?object
    {
        if ($criteria instanceof Proxy) {
            $criteria = $criteria->object();
        }

        if (!\is_array($criteria)) {
            return $this->proxyResult($this->repository->find($criteria));
        }

        return $this->findOneBy($criteria);
    }

    /**
     * @return Proxy[]|object[]
     */
    public function findAll(): array
    {
        return $this->proxyResult($this->repository->findAll());
    }

    /**
     * @return Proxy[]|object[]
     */
    public function findBy(array $criteria, ?array $orderBy = null, $limit = null, $offset = null): array
    {
        return $this->proxyResult($this->repository->findBy(self::normalizeCriteria($criteria), $orderBy, $limit, $offset));
    }

    /**
     * @return Proxy|object|null
     */
    public function findOneBy(array $criteria): ?object
    {
        return $this->proxyResult($this->repository->findOneBy(self::normalizeCriteria($criteria)));
    }

    public function getClassName(): string
    {
        return $this->repository->getClassName();
    }

    /**
     * @param mixed $result
     *
     * @return Proxy|Proxy[]|object|object[]|mixed
     */
    private function proxyResult($result)
    {
        if (\is_object($result) && $this->getClassName() === \get_class($result)) {
            return PersistenceManager::proxy($result);
        }

        if (\is_array($result)) {
            return \array_map([$this, 'proxyResult'], $result);
        }

        return $result;
    }

    private static function normalizeCriteria(array $criteria): array
    {
        return \array_map(
            function($value) {
                return $value instanceof Proxy ? $value->object() : $value;
            },
            $criteria
        );
    }
}


zenstruck / foundry

Push — master ( 829500...1175ab )

RepositoryProxy::assertCountLessThan() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like