Spatie\ValidationRules\Rules\Delimited

Complexity

Total Complexity

20

Size/Duplication

Total Lines	144
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

91.53%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	min()	0	6	1
A	max()	0	6	1
A	allowDuplicates()	0	6	1
A	separatedBy()	0	6	1
A	doNotTrimItems()	0	6	1
A	validationMessageWord()	0	6	1
C	passes()	0	58	11
A	message()	0	4	1
A	validate()	0	11	1

<?php

namespace Spatie\ValidationRules\Rules;

use Illuminate\Support\Str;
use Illuminate\Contracts\Validation\Rule;
use Illuminate\Support\Facades\Validator;

class Delimited implements Rule
{
    /** @var string|array|\Illuminate\Contracts\Validation\Rule */
    protected $rule;

    protected $minimum = null;

    protected $maximum = null;

    protected $allowDuplicates = false;

    protected $message = '';

    protected $separatedBy = ',';

    /** @var bool */
    protected $trimItems = true;

    /** @var string */
    protected $validationMessageWord = 'item';

    public function __construct($rule)
    {
        $this->rule = $rule;
    }

    public function min(int $minimum)
    {
        $this->minimum = $minimum;

        return $this;
    }

    public function max(int $maximum)
    {
        $this->maximum = $maximum;

        return $this;
    }

    public function allowDuplicates(bool $allowed = true)
    {
        $this->allowDuplicates = $allowed;

        return $this;
    }

    public function separatedBy(string $separator)
    {
        $this->separatedBy = $separator;

        return $this;
    }

    public function doNotTrimItems()
    {
        $this->trimItems = false;

        return true;
    }

    public function validationMessageWord(string $word)
    {
        $this->validationMessageWord = $word;

        return $this;
    }

    public function passes($attribute, $value)
    {
        if ($this->trimItems) {
            $value = trim($value);
        }

        $items = collect(explode($this->separatedBy, $value))->filter();

        if (! is_null($this->minimum)) {
            if ($items->count() < $this->minimum) {
                $this->message = __('validation.delimited.min', [

It seems like __('validation.delimited.min', array('minimum' => $this->minimum, 'actual' => $items->count(), 'item' => \Illuminate\Support\Str::plural($this->validationMessageWord, $items->count()))) can also be of type array. However, the property $message is declared as type string. Maybe add an additional type check?

                    'minimum' => $this->minimum,
                    'actual' => $items->count(),
                    'item' => Str::plural($this->validationMessageWord, $items->count()),
                ]);

                return false;
            }
        }

        if (! is_null($this->maximum)) {
            if ($items->count() > $this->maximum) {
                $this->message = __('validation.delimited.max', [

It seems like __('validation.delimited.max', array('maximum' => $this->maximum, 'actual' => $items->count(), 'item' => \Illuminate\Support\Str::plural($this->validationMessageWord, $items->count()))) can also be of type array. However, the property $message is declared as type string. Maybe add an additional type check?

                    'maximum' => $this->maximum,
                    'actual' => $items->count(),
                    'item' => Str::plural($this->validationMessageWord, $items->count()),
                ]);

                return false;
            }
        }

        if ($this->trimItems) {
            $items = $items->map(function (string $item) {
                return trim($item);
            });
        }

        foreach ($items as $item) {
            [$isValid, $validationMessage] = $this->validate($attribute, $item);

The variable $isValid does not exist. Did you forget to declare it?

The variable $validationMessage does not exist. Did you forget to declare it?

            if (! $isValid) {
                $this->message = $validationMessage;

                return false;
            }
        }

        if (! $this->allowDuplicates) {
            if ($items->unique()->count() !== $items->count()) {
                $this->message = __('validation.delimited.unique');

It seems like __('validation.delimited.unique') can also be of type array. However, the property $message is declared as type string. Maybe add an additional type check?

                return false;
            }
        }

        return true;
    }

    public function message()
    {
        return $this->message;
    }

    protected function validate(string $attribute, string $item): array
    {
        $attribute = Str::after($attribute, '.');

        $validator = Validator::make([$attribute => $item], [$attribute => $this->rule]);

        return [
            $validator->passes(),
            $validator->getMessageBag()->first($attribute),
        ];
    }
}