Zing\QueryBuilder\Filter

Complexity

Total Complexity

31

Size/Duplication

Total Lines	174
Duplicated Lines	0 %

Test Coverage

Coverage

95.45%

Importance

Changes	6
Bugs	0	Features	0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	getColumn()	0	3	1
A	hasCast()	0	3	1
A	withCast()	0	5	1
A	getProperty()	0	3	1
A	isForProperty()	0	3	1
A	getCast()	0	3	1
A	getDefault()	0	3	1
A	default()	0	5	1
A	hasDefault()	0	3	1
A	delimiter()	0	5	1
A	resolveValueForFiltering()	0	14	5
A	ignore()	0	7	2
A	filter()	0	12	3
A	getIgnored()	0	3	2
A	castUsing()	0	20	5
A	castValue()	0	15	4

<?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

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.

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

        return $this;
    }
}