HasByNonDependentSubqueryMacro::determineArgumentType() - Code Metrics - Inspection of "Add support for union argument in constraint calla..." - mpyw/eloquent-has-by-non-dependent-subquery - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#11)

unknown
created 2021-09-09 20:20 UTC
determineArgumentType() A

↳ Parent: HasByNonDependentSubqueryMacro
Complexity

Conditions	4
Paths	4
Size

Total Lines	18
Code Lines	8
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	20
Importance

Changes
Metric	Value
cc	4
eloc	8
nc	4
nop	2
dl	0
loc	18
ccs	0
cts	0
cp	0
crap	20
rs	10
c	0
b	0
f	0
<?php

namespace Mpyw\EloquentHasByNonDependentSubquery;

use DomainException;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Relations\Relation;
use ReflectionType;

/**
 * Class HasByNonDependentSubqueryMacro
 *
 * Convert has() and whereHas() constraints to non-dependent subqueries.
 */
class HasByNonDependentSubqueryMacro
{
    /**
     * @var \Illuminate\Database\Eloquent\Builder
     */
    protected $query;

    /**
     * HasByNonDependentSubqueryMacro constructor.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     */
    public function __construct(Builder $query)
    {
        $this->query = $query;
    }

    /**
     * @param  string|string[]                       $relationMethod
     * @param  callable[]|null[]                     $constraints
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function has($relationMethod, ?callable ...$constraints): Builder
    {
        return $this->apply($relationMethod, 'whereIn', ...$constraints);
    }

    /**
     * @param  string|string[]                       $relationMethod
     * @param  callable[]|null[]                     $constraints
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function orHas($relationMethod, ?callable ...$constraints): Builder
    {
        return $this->apply($relationMethod, 'orWhereIn', ...$constraints);
    }

    /**
     * @param  string|string[]                       $relationMethod
     * @param  callable[]|null[]                     $constraints
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function doesntHave($relationMethod, ?callable ...$constraints): Builder
    {
        return $this->apply($relationMethod, 'whereNotIn', ...$constraints);
    }

    /**
     * @param  string|string[]                       $relationMethod
     * @param  callable[]|null[]                     $constraints
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function orDoesntHave($relationMethod, ?callable ...$constraints): Builder
    {
        return $this->apply($relationMethod, 'orWhereNotIn', ...$constraints);
    }

    /**
     * Parse nested constraints and iterate them to apply.
     *
     * @param  string|string[]                       $relationMethod
     * @param  string                                $whereInMethod
     * @param  callable[]|null[]                     $constraints
     * @return \Illuminate\Database\Eloquent\Builder
     */
    protected function apply($relationMethod, string $whereInMethod, ?callable ...$constraints): Builder
    {
        // Extract dot-chained expressions
        $relationMethods = \is_string($relationMethod) ? \explode('.', $relationMethod) : \array_values($relationMethod);

        // Pick the first relation if exists
        if ($currentRelationMethod = \array_shift($relationMethods)) {
            $this->applyForCurrentRelation(
                $currentRelationMethod,
                $whereInMethod,
                function (Relation $query) use ($relationMethods, $whereInMethod, $constraints) {
                    // Apply optional constraints
                    if ($currentConstraints = \array_shift($constraints)) {
                        $currentConstraints($this->adjustArgumentTypeOfOptionalConstraints($currentConstraints, $query));
                    }
                    // Apply relations nested under
                    if ($relationMethods) {
                        (new static($query->getQuery()))->apply($relationMethods, $whereInMethod, ...$constraints);
                    }
                }
            );
        }

        return $this->query;
    }

    /**
     * Apply the current relation as a non-dependent subquery.
     *
     * @param string        $relationMethod
     * @param string        $whereInMethod
     * @param null|callable $constraints
     */
    protected function applyForCurrentRelation(string $relationMethod, string $whereInMethod, callable $constraints): void
    {
        // Unlike a JOIN-based approach, you don't need give table aliases.
        // Table names are never conflicted.
        if (\preg_match('/\s+as\s+/i', $relationMethod)) {
            throw new DomainException('Table aliases are not supported.');
        }

        // Create a Relation instance
        $relation = $this->query->getRelation($relationMethod);
        $relation = $this->query->getRelation($relationMethod);

        // Validate the relation and recognize key names
        $keys = new Keys($relation);

        // Apply optional constraints and relations nested under
        $constraints($relation);

        // Add an "whereIn" constraints for a non-dependent subquery
        $relation->select($keys->getQualifiedRelatedKeyName());
        if ($keys->needsPolymorphicRelatedConstraints()) {
            $relation->where($keys->getQualifiedRelatedMorphType(), $keys->getRelatedMorphClass());
        }
        $this->query->{$whereInMethod}($keys->getQualifiedSourceKeyName(), $relation->getQuery());
    }

    /**
     * From v1.1:
     *   Relation will be automatically converted to Builder to prevent common mistakes on demand.
     *
     * @param  callable                                                                               $constraint
     * @param  \Illuminate\Database\Eloquent\Relations\Relation                                       $relation
     * @return \Illuminate\Database\Eloquent\Builder|\Illuminate\Database\Eloquent\Relations\Relation
     */
    protected function adjustArgumentTypeOfOptionalConstraints(callable $constraint, Relation $relation)
    {
        $reflection = ReflectionCallable::from($constraint);

        $type = $reflection->getNumberOfParameters() > 0
            && ($parameter = $reflection->getParameters()[0])->hasType()
            ? $parameter->getType()
            : null;

        if (!$type) {
            return $relation;
        }

        return $this->determineArgumentType($type, $relation);
    }

    /**
     * @param  \ReflectionType                                                                        $type
     * @param  \Illuminate\Database\Eloquent\Relations\Relation                                       $relation
     * @return \Illuminate\Database\Eloquent\Builder|\Illuminate\Database\Eloquent\Relations\Relation
     */
    protected function determineArgumentType(ReflectionType $type, Relation $relation)
    {
        // https://www.php.net/manual/en/class.reflectionnamedtype.php
        if (method_exists($type, 'getName')) {
            return \is_a($type->getName(), Builder::class, true)
                ? $relation->getQuery()
                : $relation;
        }

        // https://www.php.net/manual/en/class.reflectionuniontype.php
        if (method_exists($type, 'getTypes')) {
            /** @var ReflectionType $firstType */
            $firstType = $type->getTypes()[0];

            return $this->determineArgumentType($firstType, $relation);
        }

        return $relation;
    }
}

mpyw / eloquent-has-by-non-dependent-subquery

Pull Request — master (#11)

determineArgumentType() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
