Imanghafoori\HeyMan\Reactions\Validator

Complexity

Total Complexity

13

Size/Duplication

Total Lines	89
Duplicated Lines	0 %

Test Coverage

Coverage

97.62%

Importance

Changes	4
Bugs	1	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	wrapForIgnore()	0	3	1
A	otherwise()	0	12	2
A	validationPassesCallback()	0	7	1
A	validatorCallback()	0	7	1
A	__construct()	0	3	1
A	makeValidator()	0	9	2
A	__destruct()	0	18	4
A	beforeValidationModifyData()	0	3	1

<?php

namespace Imanghafoori\HeyMan\Reactions;

use Imanghafoori\HeyMan\Core\Reaction;
use Illuminate\Contracts\Validation\Factory;
use Imanghafoori\HeyMan\Switching\HeyManSwitcher;

final class Validator
{
    private $validationData;

    private $modifier;

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

    public function otherwise()
    {
        $rules = $this->validationData;
        $modifier = $this->modifier ?: function ($args) {
            return $args;
        };

        $result = $this->validationPassesCallback($modifier, $rules);

        resolve('heyman.chain')->set('condition', $result);

The method set() does not exist on Illuminate\Foundation\Application.

        return resolve(Reaction::class);
    }

    public function beforeValidationModifyData($callable)
    {
        $this->modifier = $callable;
    }

    public function validatorCallback($modifier, $rules)
    {
        $validator = function () use ($modifier, $rules) {
            $this->makeValidator($modifier, $rules)->validate();
        };

        return $this->wrapForIgnore($validator);
    }

    public function validationPassesCallback($modifier, $rules)
    {
        $validator = function () use ($modifier, $rules) {
            return ! $this->makeValidator($modifier, $rules)->fails();
        };

        return $this->wrapForIgnore($validator);
    }

    public function makeValidator($modifier, $rules)
    {
        if (is_callable($rules[0])) {
            $rules[0] = call_user_func($rules[0]);
        }

        $newData = app()->call($modifier, [request()->all()]);

        return resolve(Factory::class)->make($newData, ...$rules);

$rules is expanded, but the parameter $rules of Illuminate\Validation\Factory::make() does not expect variable arguments.

It seems like $newData can also be of type callable; however, parameter $data of Illuminate\Validation\Factory::make() does only seem to accept array, maybe add an additional type check?

    }

    public function __destruct()
    {
        try {
            $chain = app('heyman.chain');
            $condition = $chain->get('condition');

            if (! $condition) {
                $data = $this->validationData;
                $modifier = $this->modifier ?: function ($args) {
                    return $args;
                };

                $condition = $this->validatorCallback($modifier, $data);
                $chain->set('condition', $condition);
            }

            resolve('heyman.chains')->commitChain();

The method commitChain() does not exist on Illuminate\Foundation\Application.

        } catch (\Throwable $throwable) {
            //
        }
    }

    /**
     * @param \Closure $validator
     *
     * @return mixed
     */
    private function wrapForIgnore(\Closure $validator)
    {
        return resolve(HeyManSwitcher::class)->wrapForIgnorance($validator, 'validation');
}
}