Filter::castUsing() - Code Metrics - Inspection of "Cast value to typed array (#166)" - zingimmick/laravel-query-builder - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 3ca966...bbe27c )

by Zing

created 2022-02-24 07:27 UTC

Filter::castUsing() A

↳ Parent: Filter

Complexity

Conditions	5
Paths	1

Size

Total Lines	20
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	10
CRAP Score	5.0187

Importance

Changes

Metric	Value
cc	5
eloc	10
nc	1
nop	1
dl	0
loc	20
ccs	10
cts	11
cp	0.9091
crap	5.0187
rs	9.6111
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace Zing\QueryBuilder;

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Support\Collection;
use Zing\QueryBuilder\Concerns\FilterCreator;
use Zing\QueryBuilder\Enums\CastType;

class Filter
{
    use FilterCreator;

    /**
     * @param mixed $value
     */
    public function filter(Builder $query, $value): Builder
    {
        $value = $this->resolveValueForFiltering($value);
        if ($value === null) {
            return $query;
        }

        if ($value === '') {
            return $query;
        }

        return $this->filter->apply($query, $value, $this->column);
    }

    public function getProperty(): string
    {
        return $this->property;
    }

    public function isForProperty(string $property): bool
    {
        return $this->property === $property;
    }

    /**
     * @return \Illuminate\Database\Query\Expression|string
     */
    public function getColumn()
    {
        return $this->column;
    }

    public function withCast(string $cast): self
    {
        $this->cast = $cast;

        return $this;
    }

    public function hasCast(): bool
    {
        return $this->cast !== null;
    }

    public function getCast(): ?string
    {
        return $this->cast;
    }

    /**
     * @param mixed[] $values
     */
    public function ignore(array $values): self
    {
        $this->ignored = ($this->ignored === null ? collect($values) : $this->ignored
            ->merge($values))
            ->flatten();

        return $this;
    }

    /**
     * @return \Illuminate\Support\Collection<int, mixed>
     */
    public function getIgnored(): Collection
    {
        return $this->ignored ?: collect();
    }

    /**
     * @param mixed $value
     */
    public function default($value): self
    {
        $this->default = $value;

        return $this;
    }

    /**
     * @return mixed|null
     */
    public function getDefault()
    {
        return $this->default;
    }

    public function hasDefault(): bool
    {
        return $this->default !== null;
    }

    /**
     * @param mixed $value
     *
     * @return false|mixed|string[]
     */
    protected function castValue($value)
    {
        $cast = $this->getCast();
        if (! \is_string($value)) {
            return $value;
        }

        if ($cast === CastType::STRING) {
            return $value;
        }

        return collect(explode($this->delimiter, $value))
            ->map($this->castUsing($cast))
            ->whenNotEmpty(function (Collection $collection) {
                return $collection->count() === 1 ? $collection->first() : $collection->all();
            });
    }

    protected function castUsing(?string $cast): \Closure
    {
        return function ($value) use ($cast) {
            if ($cast === CastType::STRING) {
                return (string) $value;
            }

            if ($cast === CastType::INTEGER) {
                return (int) $value;
            }

            if ($cast === CastType::BOOLEAN) {
                return filter_var($value, FILTER_VALIDATE_BOOLEAN);
            }

            if (\in_array(strtolower($value), ['true', 'false'], true)) {
                return filter_var($value, FILTER_VALIDATE_BOOLEAN);
            }

            return $value;
        };
    }

    /**
     * @param mixed $value
     *
     * @return mixed[]|mixed|null
     */
    protected function resolveValueForFiltering($value)
    {
        if (\is_string($value)) {
            $value = $this->castValue($value);
        }

        if (\is_array($value)) {
            $remainingProperties = array_diff($value, $this->getIgnored()->toArray());

            return empty($remainingProperties) ? null : $remainingProperties;
        }

        return $this->getIgnored()
            ->contains($value) ? null : $value;
    }

    /**
     * @param non-empty-string $delimiter

     */
    public function delimiter(string $delimiter): self
    {
        $this->delimiter = $delimiter;

        return $this;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Zing\QueryBuilder;
6
7		use Illuminate\Database\Eloquent\Builder;
8		use Illuminate\Support\Collection;
9		use Zing\QueryBuilder\Concerns\FilterCreator;
10		use Zing\QueryBuilder\Enums\CastType;
11
12		class Filter
13		{
14		use FilterCreator;
15
16		/**
17		* @param mixed $value
18		*/
19	46	public function filter(Builder $query, $value): Builder
20		{
21	46	$value = $this->resolveValueForFiltering($value);
22	46	if ($value === null) {
23	1	return $query;
24		}
25
26	45	if ($value === '') {
27	1	return $query;
28		}
29
30	44	return $this->filter->apply($query, $value, $this->column);
31		}
32
33	44	public function getProperty(): string
34		{
35	44	return $this->property;
36		}
37
38	3	public function isForProperty(string $property): bool
39		{
40	3	return $this->property === $property;
41		}
42
43		/**
44		* @return \Illuminate\Database\Query\Expression\|string
45		*/
46	1	public function getColumn()
47		{
48	1	return $this->column;
49		}
50
51	10	public function withCast(string $cast): self
52		{
53	10	$this->cast = $cast;
54
55	10	return $this;
56		}
57
58	1	public function hasCast(): bool
59		{
60	1	return $this->cast !== null;
61		}
62
63	37	public function getCast(): ?string
64		{
65	37	return $this->cast;
66		}
67
68		/**
69		* @param mixed[] $values
70		*/
71	1	public function ignore(array $values): self
72		{
73	1	$this->ignored = ($this->ignored === null ? collect($values) : $this->ignored
74		->merge($values))
75	1	->flatten();
76
77	1	return $this;
78		}
79
80		/**
81		* @return \Illuminate\Support\Collection<int, mixed>
82		*/
83	47	public function getIgnored(): Collection
84		{
85	47	return $this->ignored ?: collect();
86		}
87
88		/**
89		* @param mixed $value
90		*/
91	6	public function default($value): self
92		{
93	6	$this->default = $value;
94
95	6	return $this;
96		}
97
98		/**
99		* @return mixed\|null
100		*/
101	7	public function getDefault()
102		{
103	7	return $this->default;
104		}
105
106	6	public function hasDefault(): bool
107		{
108	6	return $this->default !== null;
109		}
110
111		/**
112		* @param mixed $value
113		*
114		* @return false\|mixed\|string[]
115		*/
116	37	protected function castValue($value)
117		{
118	37	$cast = $this->getCast();
119	37	if (! \is_string($value)) {
120		return $value;
121		}
122
123	37	if ($cast === CastType::STRING) {
124	2	return $value;
125		}
126
127	35	return collect(explode($this->delimiter, $value))
128	35	->map($this->castUsing($cast))
129	35	->whenNotEmpty(function (Collection $collection) {
130	35	return $collection->count() === 1 ? $collection->first() : $collection->all();
131		});
132		}
133
134	35	protected function castUsing(?string $cast): \Closure
135		{
136	35	return function ($value) use ($cast) {
137	35	if ($cast === CastType::STRING) {
138		return (string) $value;
139		}
140
141	35	if ($cast === CastType::INTEGER) {
142	1	return (int) $value;
143		}
144
145	34	if ($cast === CastType::BOOLEAN) {
146	4	return filter_var($value, FILTER_VALIDATE_BOOLEAN);
147		}
148
149	32	if (\in_array(strtolower($value), ['true', 'false'], true)) {
150	2	return filter_var($value, FILTER_VALIDATE_BOOLEAN);
151		}
152
153	30	return $value;
154		};
155		}
156
157		/**
158		* @param mixed $value
159		*
160		* @return mixed[]\|mixed\|null
161		*/
162	47	protected function resolveValueForFiltering($value)
163		{
164	47	if (\is_string($value)) {
165	37	$value = $this->castValue($value);
166		}
167
168	47	if (\is_array($value)) {
169	17	$remainingProperties = array_diff($value, $this->getIgnored()->toArray());
170
171	17	return empty($remainingProperties) ? null : $remainingProperties;
172		}
173
174	32	return $this->getIgnored()
175	32	->contains($value) ? null : $value;
176		}
177
178		/**
179		* @param non-empty-string $delimiter
		0 ignored issues – show Documentation Bug introduced 2021-11-11 12:14 UTC by Report Bug Copy Issue Report The doc comment `non-empty-string` at position `0` could not be parsed: Unknown type name 'non-empty-string' at position 0 in non-empty-string. Loading history...
180		*/
181	1	public function delimiter(string $delimiter): self
182		{
183	1	$this->delimiter = $delimiter;
184
185	1	return $this;
186		}
187		}
188

zingimmick / laravel-query-builder

Push — master ( 3ca966...bbe27c )

Filter::castUsing() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like