Imanghafoori\HeyMan\Reactions\ResponderFactory

Complexity

Total Complexity

12

Size/Duplication

Total Lines	111
Duplicated Lines	0 %

Test Coverage

Coverage

97.37%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	exception()	0	6	1
A	abort()	0	4	1
A	nothing()	0	3	1
A	__construct()	0	3	1
A	sendResponse()	0	7	2
A	validatorCallback()	0	13	2
A	respondFrom()	0	4	1
A	make()	0	5	1
A	response()	0	4	1
A	redirect()	0	4	1

<?php

namespace Imanghafoori\HeyMan\Reactions;

use Illuminate\Contracts\Validation\Factory;
use Imanghafoori\HeyMan\Chain;
use Imanghafoori\HeyMan\HeyManSwitcher;

class ResponderFactory
{
    private $chain;

    /**
     * ResponderFactory constructor.
     *
     * @param Chain $chain
     */
    public function __construct(Chain $chain)
    {
        $this->chain = $chain;
    }

    public function make()
    {
        $m = $this->chain->responseType;

        return $this->$m($this->chain->data);
    }

    protected function abort($abort): \Closure
    {
        return function () use ($abort) {
            abort(...$abort);

$abort is expanded, but the parameter $code of abort() does not expect variable arguments.

        };
    }

    protected function nothing(): \Closure
    {
        return function () {
        };
    }

    /**
     * @param $e
     *
     * @return \Closure
     */
    protected function exception(array $e): \Closure
    {
        return function () use ($e) {
            $exClass = $e['class'];

            throw new $exClass($e['message']);
        };
    }

    /**
     * @param $resp
     *
     * @return \Closure
     */
    protected function response(array $resp): \Closure
    {
        return function () use ($resp) {
            $this->sendResponse($resp, response());
        };
    }

    protected function redirect(array $resp): \Closure
    {
        return function () use ($resp) {
            $this->sendResponse($resp, redirect());
        };
    }

    protected function respondFrom($method): \Closure
    {
        return function () use ($method) {
            respondWith(app()->call(...$method));

It seems like app()->call($method) can also be of type callable; however, parameter $response of respondWith() does only seem to accept string, maybe add an additional type check?

$method is expanded, but the parameter $callback of Illuminate\Container\Container::call() does not expect variable arguments.

        };
    }

    /**
     * @param array $resp
     * @param $respObj
     * @throws \ImanGhafoori\Terminator\TerminateException
     */
    private function sendResponse(array $resp, $respObj)
    {
        foreach ($resp as $call) {
            list($method, $args) = $call;
            $respObj = $respObj->{$method}(...$args);
        }
        respondWith($respObj);
    }

    /**
     * Validate the given request with the given rules.
     *
     * @param string|\Closure $modifier
     * @param array|\Closure  $rules
     * @param array           $messages
     * @param array           $customAttributes
     *
     * @return \Closure
     */
    public function validatorCallback($modifier, $rules, array $messages = [], array $customAttributes = []): \Closure
    {
        $validator = function () use ($modifier, $rules, $messages, $customAttributes) {
            if (is_callable($rules)) {
                $rules = $rules();
            }

            $data = app()->call($modifier, [request()->all()]);
            $validator = app(Factory::class)->make($data, $rules, $messages, $customAttributes);

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

            $validator->validate();
        };

        return app(HeyManSwitcher::class)->wrapForIgnorance($validator, 'validation');
    }
}