RDS\Hydrogen\Query

Complexity

Total Complexity

38

Size/Duplication

Total Lines	313
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	15

Test Coverage

Coverage

70.1%

Importance

Changes

0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	2
A	raw()	0	4	1
A	__callStatic()	0	6	1
A	has()	0	10	3
A	__get()	0	8	2
A	getClassName()	0	4	1
A	getEntityManager()	0	4	1
A	getMetadata()	0	4	1
A	column()	0	7	1
A	__call()	0	15	4
A	getCriteria()	0	4	1
A	add()	0	10	2
A	create()	0	10	2
A	scope()	0	6	1
A	new()	0	4	1
A	getScopes()	0	4	1
A	merge()	0	8	2
A	attach()	0	8	2
A	__clone()	0	13	3
A	getIterator()	0	6	2
A	isEmpty()	0	4	1
A	bootIfNotBooted()	0	9	2
A	dump()	0	4	1

<?php
/**
 * This file is part of Hydrogen package.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
declare(strict_types=1);

namespace RDS\Hydrogen;

use Doctrine\Common\Persistence\ObjectRepository;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\Mapping\ClassMetadata;
use Illuminate\Support\Traits\Macroable;
use RDS\Hydrogen\Criteria\CriterionInterface;
use RDS\Hydrogen\Processor\ProcessorInterface;
use RDS\Hydrogen\Query\AliasProvider;
use RDS\Hydrogen\Query\ExecutionsProvider;
use RDS\Hydrogen\Query\GroupByProvider;
use RDS\Hydrogen\Query\LimitAndOffsetProvider;
use RDS\Hydrogen\Query\ModeProvider;
use RDS\Hydrogen\Query\OrderProvider;
use RDS\Hydrogen\Query\RelationProvider;
use RDS\Hydrogen\Query\RepositoryProvider;
use RDS\Hydrogen\Query\SelectProvider;
use RDS\Hydrogen\Query\WhereProvider;

/**
 * Class Query
 */
class Query implements \IteratorAggregate
{
    use Macroable {
        Macroable::__call as __macroableCall;
        Macroable::__callStatic as __macroableCallStatic;
    }

    use ModeProvider;
    use AliasProvider;
    use WhereProvider;
    use OrderProvider;
    use SelectProvider;
    use GroupByProvider;
    use RelationProvider;
    use RepositoryProvider;
    use ExecutionsProvider;
    use LimitAndOffsetProvider;

    /**
     * @var bool
     */
    private static $booted = false;

    /**
     * @var CriterionInterface[]|\SplDoublyLinkedList
     */
    protected $criteria;

    /**
     * @var array|ObjectRepository[]
     */
    protected $scopes = [];

    /**
     * Query constructor.
     * @param ObjectRepository|null $repository
     */
    public function __construct(ObjectRepository $repository = null)
    {
        $this->criteria = new \SplDoublyLinkedList();

        if ($repository) {
            $this->from($repository);
        }
    }

    /**
     * @param string $stmt
     * @return string
     */
    public static function raw(string $stmt): string
    {
        return \sprintf("RAW('%s')", \addcslashes($stmt, "'"));
    }

    /**
     * @param string $method
     * @param array $parameters
     * @return mixed
     */
    public static function __callStatic(string $method, array $parameters = [])
    {
        $instance = new static();

        return $instance->$method(...$parameters);
    }

    /**
     * @param string $criterion
     * @return bool
     */
    public function has(string $criterion): bool
    {
        foreach ($this->criteria as $haystack) {
            if (\get_class($haystack) === $criterion) {
                return true;
            }
        }

        return false;
    }

    /**
     * @param string $name
     * @return null
     */
    public function __get(string $name)
    {
        if (\method_exists($this, $name)) {
            return $this->$name();
        }

        return null;
    }

    /**
     * @return string
     */
    public function getClassName(): string
    {
        return $this->getRepository()->getClassName();

The method getClassName does only exist in Doctrine\Common\Persistence\ObjectRepository, but not in RDS\Hydrogen\Hydrogen.

    }

    /**
     * @return EntityManagerInterface
     */
    public function getEntityManager(): EntityManagerInterface
    {
        return $this->getRepository()->getEntityManager();

The method getEntityManager does only exist in RDS\Hydrogen\Hydrogen, but not in Doctrine\Common\Persistence\ObjectRepository.

    }

    /**
     * @return ClassMetadata
     */
    public function getMetadata(): ClassMetadata
    {
        return $this->getEntityManager()->getClassMetadata($this->getClassName());
    }

    /**
     * @param string $name
     * @return string
     */
    public function column(string $name): string
    {
        $name = \addcslashes($name, "'");
        $table = $this->getMetadata()->getTableName();

        return \sprintf("FIELD('%s', '%s', '%s')", $table, $this->getAlias(), $name);
    }

    /**
     * @param string $method
     * @param array $parameters
     * @return mixed|$this|Query
     */
    public function __call(string $method, array $parameters = [])
    {
        foreach ($this->scopes as $scope) {
            if (\method_exists($scope, $method)) {
                /** @var Query $query */
                $query = \is_object($scope)
                    ? clone $scope->$method(...$parameters)
                    : clone $scope::$method(...$parameters);

                return $this->merge($query);
            }
        }

        return $this->__macroableCall($method, $parameters);
    }

    /**
     * Returns a list of selection criteria.
     *
     * @return \Generator|CriterionInterface[]
     */
    public function getCriteria(): \Generator
    {
        yield from $this->criteria;
    }

    /**
     * Creates a new query (alias to the constructor).
     *
     * @param CriterionInterface $criterion
     * @return Query|$this
     */
    public function add(CriterionInterface $criterion): self
    {
        if (! $criterion->isAttached()) {
            $criterion->attach($this);
        }

        $this->criteria->push($criterion);

        return $this;
    }

    /**
     * Creates a new query using the current set of scopes.
     *
     * @return Query
     */
    public function create(): Query
    {
        $query = static::new()->scope(...$this->getScopes());

        if ($this->repository) {
            return $query->from($this->repository);

It seems like $this->repository can also be of type object<RDS\Hydrogen\Hydrogen>; however, RDS\Hydrogen\Query\RepositoryProvider::from() does only seem to accept object<Doctrine\Common\Persistence\ObjectRepository>, maybe add an additional type check?

        }

        return $query;
    }

    /**
     * Adds the specified set of scopes (method groups) to the query.
     *
     * @param object|string ...$scopes
     * @return Query|$this
     */
    public function scope(...$scopes): self
    {
        $this->scopes = \array_merge($this->scopes, $scopes);

        return $this;
    }

    /**
     * Creates a new query (alias to the constructor).
     *
     * @param ObjectRepository|null $repository
     * @return Query
     */
    public static function new(ObjectRepository $repository = null): Query
    {
        return new static($repository);
    }

    /**
     * Returns a set of scopes for the specified query.
     *
     * @return array|ObjectRepository[]
     */
    public function getScopes(): array
    {
        return $this->scopes;
    }

    /**
     * Copies a set of Criteria from the child query to the parent.
     *
     * @param Query $query
     * @return Query
     */
    public function merge(Query $query): Query
    {
        foreach ($query->getCriteria() as $criterion) {
            $criterion->attach($this);
        }

        return $this->attach($query);
    }

    /**
     * @param Query $query
     * @return Query
     */
    public function attach(Query $query): Query
    {
        foreach ($query->getCriteria() as $criterion) {
            $this->add($criterion);
        }

        return $this;
    }

    /**
     * @return void
     */
    public function __clone()
    {
        $reflection = new \ReflectionClass($this);

        foreach ($reflection->getProperties() as $property) {
            $property->setAccessible(true);
            $value = $property->getValue($this);

            if (\is_object($value)) {
                $property->setValue($this, clone $value);
            }
        }
    }

    /**
     * @return \Generator
     */
    public function getIterator(): \Generator
    {
        foreach ($this->get() as $result) {
            yield $result;
        }
    }

    /**
     * @return bool
     */
    public function isEmpty(): bool
    {
        return $this->criteria->count() === 0;
    }

    /**
     * @return void
     */
    private function bootIfNotBooted(): void
    {
        if (self::$booted === false) {
            self::$booted = true;

            $bootstrap = new Bootstrap();
            $bootstrap->register($this->getRepository()->getEntityManager());

The method getEntityManager does only exist in RDS\Hydrogen\Hydrogen, but not in Doctrine\Common\Persistence\ObjectRepository.

        }
    }

    /**
     * @return string
     */
    public function dump(): string
    {
        return $this->getRepository()->getProcessor()->dump($this);

The method getProcessor does only exist in RDS\Hydrogen\Hydrogen, but not in Doctrine\Common\Persistence\ObjectRepository.

    }
}