EloquentSource::applyFilters() - Code Metrics - Inspection of "change name of the class" - adam-boduch/laravel-grid - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( dec13a...141805 )

by Adam

created 2016-10-11 16:36 UTC

EloquentSource::applyFilters() A

↳ Parent: EloquentSource

Complexity

Conditions	4
Paths	3

Size

Total Lines	9
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	4
eloc	4
c	1
b	0
f	0
nc	3
nop	1
dl	0
loc	9
rs	9.2

<?php

namespace Boduch\Grid\Source;

use Boduch\Grid\Column;
use Boduch\Grid\Filters\FilterOperator;
use Boduch\Grid\Order;
use Illuminate\Database\Eloquent\Builder;

class EloquentSource implements SourceInterface
{
    /**
     * @var \Illuminate\Database\Eloquent\Builder|\Illuminate\Database\Eloquent\Model
     */
    protected $source;

    /**
     * @param \Illuminate\Database\Eloquent\Builder|\Illuminate\Database\Eloquent\Model $source
     */
    public function __construct($source)
    {
        $this->source = $source;
    }

    /**
     * @param Column[] $columns
     */
    public function applyFilters($columns)
    {
        foreach ($columns as $column) {
            /** @var \Boduch\Grid\Column $column */
            if ($column->isFilterable() && !$column->getFilter()->isEmpty()) {
                $this->buildQuery($column);
            }
        }
    }

    /**
     * @param int $perPage
     * @param int $currentPage
     * @param Order $order
     * @return \Illuminate\Contracts\Pagination\LengthAwarePaginator
     */
    public function execute($perPage, $currentPage, Order $order)
    {
        return $this
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->source
            ->when($order->getColumn(), function (Builder $builder) use ($order) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                return $builder->orderBy($order->getColumn(), $order->getDirection());
            })
            ->forPage($currentPage, $perPage)
            ->get();
    }

    /**
     * @return int
     */
    public function total()
    {
        return $this->source->count();
    }

    /**
     * @param Column $column
     */
    protected function buildQuery(Column $column)
    {
        $name = $column->getFilter()->getName();
        $input = $column->getFilter()->getInput();

        if ($column->getFilter()->getOperator() == FilterOperator::OPERATOR_BETWEEN) {
            $this->source->whereBetween($name, $input);
        } else {
            $this->source->where(
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                $name,
                $column->getFilter()->getOperator(),
                $this->normalizeValue($input, $column->getFilter()->getOperator())
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            );
        }
    }

    /**
     * @param string|string[] $value
     * @param string $operator
     * @return mixed
     */
    protected function normalizeValue($value, $operator)
    {
        if (is_array($value)) {
            $value = array_filter($value);
        }

        if ($operator == FilterOperator::OPERATOR_LIKE || $operator == FilterOperator::OPERATOR_ILIKE) {
            $value = str_replace('*', '%', $value);
        }

        return $value;
    }
}


1			<?php
2
3			namespace Boduch\Grid\Source;
4
5			use Boduch\Grid\Column;
6			use Boduch\Grid\Filters\FilterOperator;
7			use Boduch\Grid\Order;
8			use Illuminate\Database\Eloquent\Builder;
9
10			class EloquentSource implements SourceInterface
11			{
12			/**
13			* @var \Illuminate\Database\Eloquent\Builder\|\Illuminate\Database\Eloquent\Model
14			*/
15			protected $source;
16
17			/**
18			* @param \Illuminate\Database\Eloquent\Builder\|\Illuminate\Database\Eloquent\Model $source
19			*/
20			public function __construct($source)
21			{
22			$this->source = $source;
23			}
24
25			/**
26			* @param Column[] $columns
27			*/
28			public function applyFilters($columns)
29			{
30			foreach ($columns as $column) {
31			/** @var \Boduch\Grid\Column $column */
32			if ($column->isFilterable() && !$column->getFilter()->isEmpty()) {
33			$this->buildQuery($column);
34			}
35			}
36			}
37
38			/**
39			* @param int $perPage
40			* @param int $currentPage
41			* @param Order $order
42			* @return \Illuminate\Contracts\Pagination\LengthAwarePaginator
43			*/
44			public function execute($perPage, $currentPage, Order $order)
45			{
46			return $this
			0 ignored issues – show Bug introduced 2016-10-11 16:38 UTC by Report Bug Copy Issue Report The method `when` does only exist in `Illuminate\Database\Eloquent\Builder`, but not in `Illuminate\Database\Eloquent\Model`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
47			->source
48			->when($order->getColumn(), function (Builder $builder) use ($order) {
			0 ignored issues – show Documentation introduced 2016-08-02 20:19 UTC by Report Bug Copy Issue Report `$order->getColumn()` is of type `string`, but the function expects a `boolean`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
49			return $builder->orderBy($order->getColumn(), $order->getDirection());
50			})
51			->forPage($currentPage, $perPage)
52			->get();
53			}
54
55			/**
56			* @return int
57			*/
58			public function total()
59			{
60			return $this->source->count();
61			}
62
63			/**
64			* @param Column $column
65			*/
66			protected function buildQuery(Column $column)
67			{
68			$name = $column->getFilter()->getName();
69			$input = $column->getFilter()->getInput();
70
71			if ($column->getFilter()->getOperator() == FilterOperator::OPERATOR_BETWEEN) {
72			$this->source->whereBetween($name, $input);
73			} else {
74			$this->source->where(
			0 ignored issues – show Bug introduced 2016-10-11 16:38 UTC by Report Bug Copy Issue Report The method `where` does only exist in `Illuminate\Database\Eloquent\Builder`, but not in `Illuminate\Database\Eloquent\Model`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
75			$name,
76			$column->getFilter()->getOperator(),
77			$this->normalizeValue($input, $column->getFilter()->getOperator())
			0 ignored issues – show Bug introduced 2016-10-11 16:38 UTC by Report Bug Copy Issue Report It seems like `$input` defined by `$column->getFilter()->getInput()` on line `69` can also be of type `array`; however, `Boduch\Grid\Source\Eloqu...ource::normalizeValue()` does only seem to accept `string\|array<integer,string>`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
78			);
79			}
80			}
81
82			/**
83			* @param string\|string[] $value
84			* @param string $operator
85			* @return mixed
86			*/
87			protected function normalizeValue($value, $operator)
88			{
89			if (is_array($value)) {
90			$value = array_filter($value);
91			}
92
93			if ($operator == FilterOperator::OPERATOR_LIKE \|\| $operator == FilterOperator::OPERATOR_ILIKE) {
94			$value = str_replace('*', '%', $value);
95			}
96
97			return $value;
98			}
99			}
100

adam-boduch / laravel-grid

Push — master ( dec13a...141805 )

EloquentSource::applyFilters() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like