Noitran\RQL\Processors\EloquentProcessor

Complexity

Total Complexity

10

Size/Duplication

Total Lines	114
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	applyComparison()	0	8	1
A	getBuilder()	0	3	1
A	process()	0	22	6
A	__construct()	0	3	1
A	applyIfValueIsArray()	0	7	1

<?php

namespace Noitran\RQL\Processors;

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Noitran\RQL\Contracts\Expression\ExprInterface;
use Noitran\RQL\Contracts\Processor\ProcessorInterface;
use Noitran\RQL\Expressions\AndExpr;
use Noitran\RQL\Expressions\OrExpr;
use Noitran\RQL\ExprQueue;

/**
 * Class EloquentProcessor
 */
class EloquentProcessor implements ProcessorInterface
{
    /**
     * @var Builder
     */
    protected $builder;

    /**
     * @var array
     */
    protected static $methodMap = [
        '$eq' => 'where',
        '$notEq' => 'where',
        '$lt' => 'where',
        '$lte' => 'where',
        '$gt' => 'where',
        '$gte' => 'where',
        '$like' => 'where',

        '$in' => 'whereIn',
        '$notIn' => 'whereNotIn',
        '$between' => 'whereBetween',

        '$or' => null,
        '$and' => null,
    ];

    /**
     * @var array
     */
    protected static $comparisonMethods = [
        '$eq',
        '$notEq',
        '$lt',
        '$lte',
        '$gt',
        '$gte',
    ];

    /**
     * EloquentProcessor constructor.
     *
     * @param Builder $builder
     */
    public function __construct($builder)
    {
        $this->builder = $builder;
    }

    /**
     * @return Builder|Model
     */
    public function getBuilder()
    {
        return $this->builder;
    }

    /**
     * @param ExprQueue $exprClasses
     *
     * @return Builder
     */
    public function process(ExprQueue $exprClasses): Builder
    {
        foreach ($exprClasses as $exprClass) {
            /** @var ExprInterface $exprClass */
            if (in_array($exprClass->getExpression(), self::$comparisonMethods, true)) {
                return $this->applyComparison($exprClass);
            }

            if (in_array($exprClass->getExpression(), ['$in', '$notIn', '$between'], true)) {
                return $this->applyIfValueIsArray($exprClass);
            }

            if ($exprClass instanceof OrExpr) {
                return $this->applyBetween($exprClass);

The method applyBetween() does not exist on Noitran\RQL\Processors\EloquentProcessor.

            }

            if ($exprClass instanceof AndExpr) {
                return $this->applyBetween($exprClass);
            }
        }

        return $this->getBuilder();
    }

    /**
     * @param ExprInterface $exprClass
     *
     * @return Builder
     */
    protected function applyComparison(ExprInterface $exprClass): Builder
    {
        $method = self::$methodMap[$exprClass->getExpression()];

        return $this->getBuilder()->{$method}(
            $exprClass->getColumn(),
            $exprClass->getOperator(),
            $exprClass->getValue()
        );
    }

    /**
     * @param ExprInterface $exprClass
     *
     * @return Builder
     */
    protected function applyIfValueIsArray(ExprInterface $exprClass): Builder
    {
        $method = self::$methodMap[$exprClass->getExpression()];

        return $this->getBuilder()->{$method}(
            $exprClass->getColumn(),
            $exprClass->getValue()
        );
    }
}