Nip\Controllers\Traits\ActionCallTrait

Complexity

Total Complexity

10

Size/Duplication

Total Lines	89
Duplicated Lines	0 %

Test Coverage

Coverage

75%

Importance

Changes	3
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	callAction()	0	15	3
A	dispatchAction()	0	5	1
A	runAction()	0	18	3
A	validAction()	0	3	1
A	getAction()	0	3	1
A	setAction()	0	5	1

<?php

namespace Nip\Controllers\Traits;

use Nip\Dispatcher\Resolver\ClassResolver\NameFormatter;
use Nip\Http\Response\Response;
use Psr\Http\Message\ResponseInterface;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;

/**
 * Trait ActionCallTrait
 * @package Nip\Controllers\Traits
 */
trait ActionCallTrait
{
    protected $action = null;

    /**
     * @param bool $action
     *
     * @return Response|ResponseInterface
     */
    public function dispatchAction($action = false)
    {
        $action = NameFormatter::formatActionName($action);

        return $this->callAction($action);
    }

    /**
     * @param bool $method
     * @param array $parameters
     * @return ResponseInterface
     */
    public function callAction($method = false, $parameters = [])
    {
        if ($method) {
            if ($this->validAction($method)) {
                $this->setAction($method);

$method of type true is incompatible with the type string expected by parameter $action of Nip\Controllers\Traits\ActionCallTrait::setAction().

                return $this->runAction($method, $parameters);
            } else {
                throw new NotFoundHttpException(
                    'Controller method ['.$method.'] not found for '.get_class($this)

Are you sure $method of type true can be used in concatenation?

                );
            }
        }

        throw new NotFoundHttpException('No action specified for '.get_class($this));
    }

    /**
     * @param $method
     * @param array $parameters
     * @return ResponseInterface
     */
    protected function runAction($method, $parameters = [])
    {
        $this->invokeStage('parseRequest');

It seems like invokeStage() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $this->invokeStage('beforeAction');

        $response = call_user_func_array([$this, $method], $parameters);

        if ($response instanceof ResponseInterface) {
            $this->setResponse($response);

It seems like setResponse() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        }

        $this->invokeStage('afterAction');

        if ($this->hasResponse()) {

It seems like hasResponse() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            return $this->getResponse();

It seems like getResponse() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        }

        return $this->getResponse(true);
    }

    /**
     * @param $action
     * @return bool
     */
    protected function validAction($action)
    {
        return in_array($action, get_class_methods(get_class($this)));
    }

    /**
     * @return string
     */
    public function getAction()
    {
        return $this->action;
    }

    /**
     * @param string $action
     * @return self
     */
    public function setAction($action)
    {
        $this->action = $action;

        return $this;
    }
}