Imanghafoori\HeyMan\Reactions\ResponderFactory

Complexity

Total Complexity

11

Size/Duplication

Total Lines	110
Duplicated Lines	0 %

Test Coverage

Coverage

97.37%

Importance

Changes

0

9 Methods

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

<?php

namespace Imanghafoori\HeyMan\Reactions;

use Illuminate\Contracts\Validation\Factory;
use Illuminate\Http\Exceptions\HttpResponseException;
use Imanghafoori\HeyMan\ChainManager;
use Imanghafoori\HeyMan\Switching\HeyManSwitcher;

final class ResponderFactory
{
    public function make()
    {
        $chain = resolve(ChainManager::class);
        $m = $chain->get('responseType');
        $data = $chain->get('data');
        return $this->$m(...$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[0];
            $message = $e[1];

            throw new $exClass($message);
        };
    }

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

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

    /**
     * @param $method
     *
     * @throws \Illuminate\Http\Exceptions\HttpResponseException
     *
     * @return \Closure
     */
    protected function respondFrom($method): \Closure
    {
        return function () use ($method) {
            throw new HttpResponseException(app()->call(...$method));

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

It seems like app()->call($method) can also be of type callable; however, parameter $response of Illuminate\Http\Exceptions\HttpResponseException::__construct() does only seem to accept Symfony\Component\HttpFoundation\Response, maybe add an additional type check?

        };
    }

    /**
     * @param array $methodCalls
     * @param $respObj
     *
     * @throws \Illuminate\Http\Exceptions\HttpResponseException
     */
    private function sendResponse(array $methodCalls, $respObj)
    {
        foreach ($methodCalls as $call) {
            list($method, $args) = $call;
            $respObj = $respObj->{$method}(...$args);
        }

        throw new HttpResponseException($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 = resolve(Factory::class)->make($data, $rules, $messages, $customAttributes);

It seems like $data 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?

            $validator->validate();
        };

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