Bdf\Prime\Query\Extension\CompilableTrait

Complexity

Total Complexity

16

Size/Duplication

Total Lines	84
Duplicated Lines	0 %

Test Coverage

Coverage

91.67%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	setType()	0	5	2
A	compile()	0	9	3
A	getBindings()	0	3	1
A	type()	0	3	1
B	doCompilation()	0	17	9

<?php

namespace Bdf\Prime\Query\Extension;

use Bdf\Prime\Exception\PrimeException;
use Bdf\Prime\Query\Compiler\CompilerState;
use Bdf\Prime\Query\Compiler\DeleteCompilerInterface;
use Bdf\Prime\Query\Compiler\InsertCompilerInterface;
use Bdf\Prime\Query\Compiler\SelectCompilerInterface;
use Bdf\Prime\Query\Compiler\UpdateCompilerInterface;
use Bdf\Prime\Query\Contract\Compilable;

/**
 * Simple implementation for @see Compilable
 *
 * @property CompilerState $compilerState
 * @property object $compiler
 *
 * @psalm-require-implements Compilable
 */
trait CompilableTrait
{
    /**
     * @var Compilable::TYPE_*
     */
    protected $type = Compilable::TYPE_SELECT;

    /**
     * {@inheritdoc}
     */
    public function compile(bool $forceRecompile = false)
    {
        if ($forceRecompile) {
            $this->compilerState->invalidate('prepared');
        } elseif ($this->compilerState->compiled) {
            return $this->compilerState->compiled;
        }

        return $this->compilerState->compiled = $this->doCompilation($this->type, $this->compiler);

$this->type of type Bdf\Prime\Query\Contract\Compilable is incompatible with the type string expected by parameter $type of Bdf\Prime\Query\Extension\CompilableTrait::doCompilation().

    }

    /**
     * {@inheritdoc}
     */
    public function getBindings(): array
    {
        return $this->compiler->getBindings($this);
    }

    /**
     * {@inheritdoc}
     *
     * @return Compilable::TYPE_*
     */
    public function type(): string
    {
        return $this->type;

The expression return $this->type returns the type Bdf\Prime\Query\Contract\Compilable which is incompatible with the type-hinted return string.

    }

    /**
     * Change the query type
     * This action will invalidate the current query
     *
     * @param Compilable::TYPE_* $type One of the Compilable::TYPE_* constant
     *
     * @return void
     */
    protected function setType(string $type): void
    {
        if ($this->type !== $type) {

The condition $this->type !== $type is always true.

            $this->compilerState->invalidate();
            $this->type = $type;

It seems like $type of type string is incompatible with the declared type Bdf\Prime\Query\Contract\Compilable of property $type.

        }
    }

    /**
     * Perform the query compilation
     * Can be overridden for perform custom compilation process
     *
     * @param Compilable::TYPE_* $type The query type
     * @param object $compiler The related compiler
     *
     * @return mixed The compiled query
     *
     * @throws PrimeException When the compilation fail
     * @throws \LogicException If type is not supported by the query or the compiler
     */
    protected function doCompilation(string $type, object $compiler)
    {
        switch (true) {
            case $type === Compilable::TYPE_SELECT && $compiler instanceof SelectCompilerInterface:
                return $compiler->compileSelect($this);

$this of type Bdf\Prime\Query\Extension\CompilableTrait is incompatible with the type Bdf\Prime\Query\CompilableClause expected by parameter $query of Bdf\Prime\Query\Compiler\SelectCompilerInterface::compileSelect().

            case $type === Compilable::TYPE_UPDATE && $compiler instanceof UpdateCompilerInterface:
                return $compiler->compileUpdate($this);

The method compileUpdate() does not exist on Bdf\Prime\Query\Compiler\SelectCompilerInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Bdf\Prime\Query\Compiler\SelectCompilerInterface.

$this of type Bdf\Prime\Query\Extension\CompilableTrait is incompatible with the type Bdf\Prime\Query\CompilableClause expected by parameter $query of Bdf\Prime\Query\Compiler\UpdateCompilerInterface::compileUpdate().

            case $type === Compilable::TYPE_INSERT && $compiler instanceof InsertCompilerInterface:
                return $compiler->compileInsert($this);

$this of type Bdf\Prime\Query\Extension\CompilableTrait is incompatible with the type Bdf\Prime\Query\CompilableClause expected by parameter $query of Bdf\Prime\Query\Compiler\InsertCompilerInterface::compileInsert().

The method compileInsert() does not exist on Bdf\Prime\Query\Compiler\SelectCompilerInterface. Did you maybe mean compileSelect()?

The method compileInsert() does not exist on Bdf\Prime\Query\Compiler\UpdateCompilerInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Bdf\Prime\Query\Compiler\UpdateCompilerInterface.

            case $type === Compilable::TYPE_DELETE && $compiler instanceof DeleteCompilerInterface:
                return $compiler->compileDelete($this);

The method compileDelete() does not exist on Bdf\Prime\Query\Compiler\SelectCompilerInterface. Did you maybe mean compileSelect()?

The method compileDelete() does not exist on Bdf\Prime\Query\Compiler\InsertCompilerInterface. Did you maybe mean compileInsert()?

The method compileDelete() does not exist on Bdf\Prime\Query\Compiler\UpdateCompilerInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Bdf\Prime\Query\Compiler\UpdateCompilerInterface.

$this of type Bdf\Prime\Query\Extension\CompilableTrait is incompatible with the type Bdf\Prime\Query\CompilableClause expected by parameter $query of Bdf\Prime\Query\Compiler\DeleteCompilerInterface::compileDelete().

            default:
                throw new \LogicException('The query ' . static::class . ' do not supports type ' . $type);
        }
    }
}