Equip\Handler\ActionHandler

Complexity

Total Complexity

6

Size/Duplication

Total Lines	107
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	__invoke()	0	12	1
A	handle()	0	14	1
A	resolve()	0	4	1
A	payload()	0	7	1
A	response()	0	8	1

<?php

namespace Equip\Handler;

use Arbiter\Action;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\ResponseInterface;
use Relay\ResolverInterface;
use Equip\Adr\PayloadInterface;
use Equip\Adr\DomainInterface;
use Equip\Adr\InputInterface;
use Equip\Adr\ResponderInterface;

class ActionHandler
{
    const ACTION_ATTRIBUTE = 'equip/adr:action';

    /**
     * @var ResolverInterface
     */
    private $resolver;

    /**
     * @param ResolverInterface $resolver
     */
    public function __construct(ResolverInterface $resolver)
    {
        $this->resolver = $resolver;
    }

    /**
     * @param ServerRequestInterface $request
     * @param ResponseInterface $response
     * @param callable $next
     */
    public function __invoke(
        ServerRequestInterface $request,
        ResponseInterface $response,
        callable $next
    ) {
        $action = $request->getAttribute(self::ACTION_ATTRIBUTE);

Equals sign not aligned with surrounding assignments; expected 2 spaces but found 1 space

        $request = $request->withoutAttribute(self::ACTION_ATTRIBUTE);

        $response = $this->handle($action, $request, $response);

        return $next($request, $response);
    }

    /**
     * Use the action collaborators to get a response.
     *
     * @param Action $action
     * @param ServerRequestInterface $request
     * @param ResponseInterface $response
     *
     * @return ResponseInterface
     */
    private function handle(
        Action $action,
        ServerRequestInterface $request,
        ResponseInterface $response
    ) {
        $domain = $this->resolve($action->getDomain());

Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space

        $input = $this->resolve($action->getInput());

Equals sign not aligned with surrounding assignments; expected 5 spaces but found 1 space

        $responder = $this->resolve($action->getResponder());

        $payload = $this->payload($domain, $input, $request);

Equals sign not aligned with surrounding assignments; expected 2 spaces but found 1 space

        $response = $this->response($responder, $request, $response, $payload);

        return $response;
    }

    /**
     * Resolve the class spec into an object.
     *
     * @param string $spec
     *
     * @return object
     */
    private function resolve($spec)
    {
        return call_user_func($this->resolver, $spec);
    }

    /**
     * Execute the domain to get a payload using input from the request.
     *
     * @param DomainInterface $domain
     * @param InputInterface $input
     * @param ServerRequestInterface $request
     *
     * @return PayloadInterface
     */
    private function payload(
        DomainInterface $domain,
        InputInterface $input,
        ServerRequestInterface $request
    ) {
        return $domain($input($request));
    }

    /**
     * Execute the responder to marshall the payload into the response.
     *
     * @param ResponderInterface $responder
     * @param ServerRequestInterface $request
     * @param ResponseInterface $response
     * @param PayloadInterface $payload
     *
     * @return ResponseInterface
     */
    private function response(
        ResponderInterface $responder,
        ServerRequestInterface $request,
        ResponseInterface $response,
        PayloadInterface $payload
    ) {
        return $responder($request, $response, $payload);
    }
}