EloquentProcessor::process() - Code Metrics - Inspection of "Implemented expressions." - noitran/rql - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 1e50c2...24b8dd )

by noitran

created 2019-02-26 01:10 UTC

EloquentProcessor::process() A

↳ Parent: EloquentProcessor

Complexity

Conditions	6
Paths	6

Size

Total Lines	26
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	42

Importance

Changes

Metric	Value
eloc	10
dl	0
loc	26
ccs	0
cts	17
cp	0
rs	9.2222
c	0
b	0
f	0
cc	6
nc	6
nop	1
crap	42

<?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',
        '$like',
    ];

    /**
     * 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 LikeExpr) {
//                return $this->applyLike($exprClass);
//            }

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

            if ($exprClass instanceof AndExpr) {
                return $this->applyAnd($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()
        );
    }

    /**
     * @param ExprInterface $exprClass
     *
     * @return Builder
     */
    protected function applyOr(ExprInterface $exprClass): Builder
    {
    }
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}

    /**
     * @param ExprInterface $exprClass
     *
     * @return Builder
     */
    protected function applyAnd(ExprInterface $exprClass): Builder
    {
    }
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
}


1			<?php
2
3			namespace Noitran\RQL\Processors;
4
5			use Illuminate\Database\Eloquent\Builder;
6			use Illuminate\Database\Eloquent\Model;
7			use Noitran\RQL\Contracts\Expression\ExprInterface;
8			use Noitran\RQL\Contracts\Processor\ProcessorInterface;
9			use Noitran\RQL\Expressions\AndExpr;
10			use Noitran\RQL\Expressions\OrExpr;
11			use Noitran\RQL\ExprQueue;
12
13			/**
14			* Class EloquentProcessor
15			*/
16			class EloquentProcessor implements ProcessorInterface
17			{
18			/**
19			* @var Builder
20			*/
21			protected $builder;
22
23			/**
24			* @var array
25			*/
26			protected static $methodMap = [
27			'$eq' => 'where',
28			'$notEq' => 'where',
29			'$lt' => 'where',
30			'$lte' => 'where',
31			'$gt' => 'where',
32			'$gte' => 'where',
33			'$like' => 'where',
34
35			'$in' => 'whereIn',
36			'$notIn' => 'whereNotIn',
37			'$between' => 'whereBetween',
38
39			'$or' => null,
40			'$and' => null,
41			];
42
43			/**
44			* @var array
45			*/
46			protected static $comparisonMethods = [
47			'$eq',
48			'$notEq',
49			'$lt',
50			'$lte',
51			'$gt',
52			'$gte',
53			'$like',
54			];
55
56			/**
57			* EloquentProcessor constructor.
58			*
59			* @param Builder $builder
60			*/
61			public function __construct($builder)
62			{
63			$this->builder = $builder;
64			}
65
66			/**
67			* @return Builder\|Model
68			*/
69			public function getBuilder()
70			{
71			return $this->builder;
72			}
73
74			/**
75			* @param ExprQueue $exprClasses
76			*
77			* @return Builder
78			*/
79			public function process(ExprQueue $exprClasses): Builder
80			{
81			foreach ($exprClasses as $exprClass) {
82			/** @var ExprInterface $exprClass */
83			if (in_array($exprClass->getExpression(), self::$comparisonMethods, true)) {
84			return $this->applyComparison($exprClass);
85			}
86
87			if (in_array($exprClass->getExpression(), ['$in', '$notIn', '$between'], true)) {
88			return $this->applyIfValueIsArray($exprClass);
89			}
90
91			// if ($exprClass instanceof LikeExpr) {
92			// return $this->applyLike($exprClass);
93			// }
94
95			if ($exprClass instanceof OrExpr) {
96			return $this->applyOr($exprClass);
97			}
98
99			if ($exprClass instanceof AndExpr) {
100			return $this->applyAnd($exprClass);
101			}
102			}
103
104			return $this->getBuilder();
105			}
106
107			/**
108			* @param ExprInterface $exprClass
109			*
110			* @return Builder
111			*/
112			protected function applyComparison(ExprInterface $exprClass): Builder
113			{
114			$method = self::$methodMap[$exprClass->getExpression()];
115
116			return $this->getBuilder()->{$method}(
117			$exprClass->getColumn(),
118			$exprClass->getOperator(),
119			$exprClass->getValue()
120			);
121			}
122
123			/**
124			* @param ExprInterface $exprClass
125			*
126			* @return Builder
127			*/
128			protected function applyIfValueIsArray(ExprInterface $exprClass): Builder
129			{
130			$method = self::$methodMap[$exprClass->getExpression()];
131
132			return $this->getBuilder()->{$method}(
133			$exprClass->getColumn(),
134			$exprClass->getValue()
135			);
136			}
137
138			/**
139			* @param ExprInterface $exprClass
140			*
141			* @return Builder
142			*/
143			protected function applyOr(ExprInterface $exprClass): Builder
144			{
145			}
			0 ignored issues – show Bug Best Practice introduced 2019-02-26 01:12 UTC by Report Bug Copy Issue Report In this branch, the function will implicitly return `null` which is incompatible with the type-hinted return `Illuminate\Database\Eloquent\Builder`. Consider adding a return statement or allowing `null` as return value. For hinted functions/methods where all return statements with the correct type are only reachable via conditions, ?null? gets implicitly returned which may be incompatible with the hinted type. Let?s take a look at an example: interface ReturnsInt { public function returnsIntHinted(): int; } class MyClass implements ReturnsInt { public function returnsIntHinted(): int { if (foo()) { return 123; } // here: null is implicitly returned } } Loading history...
146
147			/**
148			* @param ExprInterface $exprClass
149			*
150			* @return Builder
151			*/
152			protected function applyAnd(ExprInterface $exprClass): Builder
153			{
154			}
			0 ignored issues – show Bug Best Practice introduced 2019-02-26 01:12 UTC by Report Bug Copy Issue Report In this branch, the function will implicitly return `null` which is incompatible with the type-hinted return `Illuminate\Database\Eloquent\Builder`. Consider adding a return statement or allowing `null` as return value. For hinted functions/methods where all return statements with the correct type are only reachable via conditions, ?null? gets implicitly returned which may be incompatible with the hinted type. Let?s take a look at an example: interface ReturnsInt { public function returnsIntHinted(): int; } class MyClass implements ReturnsInt { public function returnsIntHinted(): int { if (foo()) { return 123; } // here: null is implicitly returned } } Loading history...
155			}
156

noitran / rql

Push — master ( 1e50c2...24b8dd )

EloquentProcessor::process() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like