ValidArray::__call() - Code Metrics - Inspection of "move file, add ability to define named rules" - Laravel-Backpack/CRUD - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — upload-validation ( 131a8f...ac355e )

by Pedro
created 2023-04-21 16:12 UTC
ValidArray::__call() A

↳ Parent: ValidArray
Complexity

Conditions	2
Paths	2
Size

Total Lines	10
Code Lines	5
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	1
Metric	Value
cc	2
eloc	5
c	1
b	0
f	1
nc	2
nop	2
dl	0
loc	10
rs	10
<?php

namespace Backpack\CRUD\app\Library\Validation\Rules;

use Backpack\CRUD\app\Library\CrudPanel\CrudPanelFacade;
use Closure;
use Illuminate\Contracts\Validation\DataAwareRule;
use Illuminate\Contracts\Validation\ValidationRule;
filter:
    dependency_paths: ["lib/*"]
use Illuminate\Contracts\Validation\ValidatorAwareRule;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Validator;
use Illuminate\Validation\Rules\File;
use Illuminate\Support\Str;

class ValidArray implements ValidationRule, DataAwareRule, ValidatorAwareRule
{
    /**
     * @var \Illuminate\Contracts\Validation\Validator
     */
    protected $validator;

    protected array $data;

    public array $arrayRules = [];

    public array $itemRules = [];

    public array $namedItemRules = [];

    public ?Model $entry;

    public static function make(): self
    {
        $instance = new static();
        $entry = CrudPanelFacade::getCurrentEntry();
        $entry = CrudPanelFacade::getCurrentEntry();
        $instance->entry = $entry !== false ? $entry : null;

        return $instance;
    }

    /**
     * Run the validation rule.
     *
     * @param  string  $attribute
     * @param  mixed  $value
     * @param  Closure(string): \Illuminate\Translation\PotentiallyTranslatedString  $fail
     * @return void
     */
    public function validate(string $attribute, mixed $value, Closure $fail): void
    {
        if (! is_array($value)) {
            try {
                $value = json_decode($value, true);
            } catch (\Exception $e) {
                $fail('Unable to determine the value type.');

                return;
            }
        }
        
        $this->validateArrayData($attribute, $fail, $value);
        $this->validateItemsAsArray($attribute, $value, $fail);
    }

    /**
     * Set the performing validator.
     *
     * @param  \Illuminate\Contracts\Validation\Validator  $validator
     * @return $this
     */
    public function setValidator($validator)
    {
        $this->validator = $validator;

        return $this;
    }

    /**
     * Set the data under validation.
     *
     * @param  array  $data
     * @return $this
     */
    public function setData($data)
    {
        $this->data = $data;

        return $this;
    }

    /**
     * Set the rules that apply to the "array" aka the field, if it's required, min, max etc.
     */
    public function arrayRules(string|array|File $rules): self
    {
        if (is_string($rules)) {

            $rules = explode('|', $rules);
        }

        if (! in_array('array', $rules)) {
            $rules[] = 'array';
        }

        $this->arrayRules = $rules;

        return $this;
    }

    /**
     * Set the rules that apply to the items beeing sent in array.
     */
    public function itemRules(string|array|File $rules): self
    {
        if (is_string($rules)) {

            $rules = explode('|', $rules);
        }

        if (! is_array($rules)) {

            $rules = [$rules];
        }

        $this->itemRules = $rules;

        return $this;
    }

    /**
     * Performs the validation on the array of items, item by item, using the item validation array.
     *
     * @param  string  $attribute
     * @param  array  $files
     * @param  Closure  $fail
     * @return void
     */
    protected function validateItems($attribute, $items, $fail)
    {
        foreach ($items as $item) {
            $validator = Validator::make([$attribute => $item], [
                $attribute => $this->itemRules,
            ], $this->validator->customMessages, $this->validator->customAttributes);


            if ($validator->fails()) {
                foreach ($validator->errors()->messages()[$attribute] as $message) {
                    $fail($message)->translate();
                }
            }
        }
    }

    /**
     * Performs the validation on the array of items, using the item validation array.
     *
     * @param  string  $attribute
     * @param  array  $files
     * @param  Closure  $fail
     * @return void
     */
    protected function validateItemsAsArray($attribute, $items, $fail)
    {
        if (! empty($this->namedItemRules)) {
            $this->validateNamedItemRules($attribute, $items, $fail);
            $this->validateNamedItemRules(/** @scrutinizer ignore-type */ $attribute, $items, $fail);
        }

        $validator = Validator::make([$attribute => $items], [
            $attribute.'.*' => $this->itemRules,
        ], $this->validator->customMessages, $this->validator->customAttributes);


        if ($validator->fails()) {
            foreach ($validator->errors()->messages()[$attribute] as $message) {
                $fail($message)->translate();
            }
        }
    }

    /**
     * Validate the given data or the array of data from the validator againts the array rules.
     *
     * @param  string  $attribute
     * @param  Closure  $fail
     * @param  null|array  $data
     * @param  null|array  $rules
     * @return void
     */
    protected function validateArrayData($attribute, $fail, $data = null, $rules = null)
    {
        $data = $data ?? $this->data;
        $rules = $rules ?? $this->arrayRules;
       
        $validator = Validator::make($data, [
            $attribute => $rules,
        ], $this->validator->customMessages, $this->validator->customAttributes);


        if ($validator->fails()) {
            foreach ($validator->errors()->messages()[$attribute] as $message) {
                $fail($message)->translate();
            }
        }
    }

    /**
     * When developer provides named rules for the items, for example: 'repeatable' => [ValidArray::make()->ruleName('required')]
     *
     * @param stromg $attribute
filter:
    dependency_paths: ["lib/*"]
     * @param array $items
     * @param Closure $fail
     * @return void
     */
    private function validateNamedItemRules($attribute, $items, $fail)
    {
        $this->namedItemRules = array_combine(array_map(function($ruleKey) use ($attribute) {
            return $attribute.'.*.'.$ruleKey;
        }, array_keys($this->namedItemRules)), $this->namedItemRules);
        
        array_walk($this->namedItemRules, function(&$value, $key) {
            if(is_array($value)) {
                $rules = [];
                foreach($value as $rule) {
                    if (is_a($rule, get_class($this), true)) {
                        $validArrayRules =  $rule->itemRules;
                        if(is_array($validArrayRules)) {
                            $rules = array_merge($rules, $validArrayRules);
                            continue;
                        }
                        $rules[] = $validArrayRules;
                        continue;
                    }
                    $rules[] = $rule;
                }
                $value = $rules;
            }
        });

        $this->validateArrayData($attribute, $fail, $items, $this->namedItemRules);
    }

    public function __call($method, $arguments)
    {
        // if method starts with `rule` eg: ruleName, extract the input name and add it to the array of rules
        if(Str::startsWith($method, 'rule')) {
            $argument = Str::snake(Str::replaceFirst('rule', '', $method));
            $this->namedItemRules[$argument] = $arguments[0];
            return $this;
        }

        return $this->{$method}(...$arguments);
    }
}

Laravel-Backpack / CRUD

Scrutinizer GitHub App not installed

Push — upload-validation ( 131a8f...ac355e )

ValidArray::__call() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
