ResolvesValidation::parentRules() - Code Metrics - Inspection of "parent rules feature" - larapie/actions - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 7b85f5...35d881 )

by Arthur

created 2019-07-14 22:02 UTC

ResolvesValidation::parentRules() A

↳ Parent: ResolvesValidation

Complexity

Conditions	1
Paths	1

Size

Total Lines	2
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	1
c	1
b	0
f	0
dl	0
loc	2
ccs	2
cts	2
cp	1
rs	10
cc	1
nc	1
nop	0
crap	1

<?php

namespace Larapie\Actions\Concerns;

use Illuminate\Contracts\Validation\Factory as ValidationFactory;
use Illuminate\Support\Arr;
use Illuminate\Validation\ValidationException;
use Illuminate\Validation\Validator;
use Larapie\Actions\Attribute;

trait ResolvesValidation
{
    protected $errorBag = 'default';

    /**
     * @var Validator
     */
    protected $validator;

    public function validate($rules = [], $messages = [], $customAttributes = [])
    {
        return app(ValidationFactory::class)
            ->make($this->validationData(), $rules, $messages, $customAttributes)
            ->validate();
    }

    public function parentRules(){
        return [];
    }

    public function buildRules()
    {
        $rules = [];
        foreach (array_merge($this->parentRules(), $this->rules()) as $key => $rule) {
            if ($rule instanceof Attribute) {
                $rule = $rule->getRules();
            }
            $rules[$key] = $rule;
        }

        foreach ($this->includes() as $key => $included) {
        foreach ($this->/** @scrutinizer ignore-call */ includes() as $key => $included) {
            if (! array_key_exists($key, $rules)) {
                $rules[$key] = 'required';
            }
        }

        return $rules;
    }

    public function passesValidation()
    {
        return $this->getValidatorInstance()->passes();
    }

    public function setValidator(Validator $validator)
    {
        $this->validator = $validator;

        return $this;
    }

    public function validated(bool $recursive = true)
    {
        return $recursive ? $this->filterRulesRecursively($this->validator->validated()) : $this->validator->validated();
    }

    protected function filterRulesRecursively(array $data)
    {
        //Dot notation makes it possible to parse nested values without recursion
        $original = Arr::dot($data);

        $filtered = [];
        $rules = collect($this->buildRules());
        $keys = $rules->keys();
        $rules->each(function ($rules, $key) use ($original, $keys, &$filtered) {
            //Allow for array or pipe-delimited rule-sets
            if (is_string($rules)) {
                $rules = explode('|', $rules);
            }
            //In case a rule requires an element to be an array, look for nested rules
            $nestedRules = $keys->filter(function ($otherKey) use ($key) {
                return strpos($otherKey, "$key.") === 0;
            });
            //If the input must be an array, default missing nested rules to a wildcard
            if (in_array('array', $rules) && $nestedRules->isEmpty()) {
                $key .= '.*';
            }

            foreach ($original as $dotIndex => $element) {
                //fnmatch respects wildcard asterisks
                if (fnmatch($key, $dotIndex)) {
                    //array_set respects dot-notation, building out a normal array
                    array_set($filtered, $dotIndex, $element);
                    /** @scrutinizer ignore-deprecated */ array_set($filtered, $dotIndex, $element);
                }
            }
        });

        return $filtered;
    }

    public function rules()
    {
        return [];
    }

    public function messages()
    {
        return [];
    }

    public function attributes()
    {
        return [];
    }

    protected function resolveValidation()
    {
        if (! $this->passesValidation()) {
            $this->failedValidation();
        }

        return $this;
    }

    protected function getValidatorInstance()
    {
        if ($this->validator) {
            return $this->validator;
        }

        $factory = app(ValidationFactory::class);

        $validator = method_exists($this, 'validator')
            ? $this->validator($factory)
            : $this->createDefaultValidator($factory);

        if (method_exists($this, 'withValidator')) {
            $this->resolveAndCall($this, 'withValidator', compact('validator'));
                   resolveAndCall($this, 'withValidator', compact('validator'));
        }

        if (method_exists($this, 'afterValidator')) {
            $validator->after(function ($validator) {
                $this->resolveAndCall($this, 'afterValidator', compact('validator'));
            });
        }

        $this->setValidator($validator);

        return $this->validator;
    }

    protected function createDefaultValidator(ValidationFactory $factory)
    {
        return $factory->make(
            $this->validationData(), $this->buildRules(),
            $this->messages(), $this->attributes()
        );
    }

    protected function failedValidation()
    {
        throw (new ValidationException($this->validator))
            ->errorBag($this->errorBag)
            ->redirectTo($this->getRedirectUrl());
    }

    protected function getRedirectUrl()
    {
        return redirect()->getUrlGenerator()->previous();
    }

    protected function validationData()
    {
        return $this->all();
        return $this->/** @scrutinizer ignore-call */ all();
    }
}


larapie / actions

Push — master ( 7b85f5...35d881 )

ResolvesValidation::parentRules() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like