Bone\Mvc\Dispatcher

Complexity

Total Complexity

33

Size/Duplication

Total Lines	263
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

98.55%

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	19	1
A	checkControllerExists()	0	4	1
A	checkActionExists()	0	4	1
A	prepareResponse()	0	6	1
A	sendResponse()	0	5	1
A	checkNavigator()	0	18	4
A	setHeaders()	0	6	2
A	sinkingShip()	0	15	2
A	getTemplateName()	0	9	3
A	setNotFound()	0	9	2
A	distributeBooty()	0	27	5
A	fireCannons()	0	15	2
A	setStatusCode()	0	12	3
A	plunderEnemyShip()	0	22	3
A	templateCheck()	0	11	2

<?php

namespace Bone\Mvc;

use Bone\Filter;
use Exception;

This use statement conflicts with another class in this namespace, Bone\Mvc\Exception.

use ReflectionClass;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\ResponseInterface;
use Zend\Diactoros\Response\SapiEmitter;

/**
 * Class Dispatcher
 * @package Bone\Mvc
 */
class Dispatcher
{
    // Garrrr! An arrrray!
    private $config = array();

    /** @var ServerRequestInterface $request */
    private $request;

    /** @var Controller */
    private $controller;

    /** @var ResponseInterface $response */
    private $response;

    /**
     * Dispatcher constructor.
     * @param ServerRequestInterface $request
     * @param ResponseInterface $response
     * @throws Filter\Exception
     */
    public function __construct(ServerRequestInterface $request, ResponseInterface $response)
    {
        $this->request = $request;
        $this->response = $response;

        $router = new Router($request);
        $router->parseRoute();

        // what controller be we talkin' about?
        $filtered = Filter::filterString($router->getController(), 'DashToCamelCase');
        $this->config['controller_name'] = '\App\Controller\\' . ucwords($filtered) . 'Controller';

        // whit be yer action ?
        $filtered = Filter::filterString($router->getAction(), 'DashToCamelCase');
        $this->config['action_name'] = $filtered . 'Action';
        $this->config['controller'] = $router->getController();
        $this->config['action'] = $router->getAction();
        $this->config['params'] = $router->getParams();
    }


    /**
     *  Gaaarrr! Check the Navigator be readin' the map!
     * @return null|void
     */
    public function checkNavigator()
    {
        // can we find th' darned controller?
        if (!$this->checkControllerExists()) {
            $this->setNotFound();
            return;
        }

        // gaaarr! there be the controller!
        $this->controller = new $this->config['controller_name']($this->request);
        $this->controller->params = isset($this->config['params']) ? $this->config['params'] : null;

        // where's the bloody action?
        if (!$this->checkActionExists()) {
            $this->setNotFound();
        }
        return null;
    }


    /**
     * @return bool
     */
    private function checkControllerExists()
    {
        return class_exists($this->config['controller_name']);
    }


    /**
     * @return bool
     */
    private function checkActionExists()
    {
        return method_exists($this->controller, $this->config['action_name']);
    }


    /**
     * @return string
     * @throws \Exception
     */
    private function distributeBooty()
    {
        /** @var \stdClass $viewVars */
        $viewVars = $this->controller->view;

        if ($viewVars instanceof ResponseInterface) {
            $this->response = $viewVars;
            return $this->sendResponse();
        }

        $responseBody = $this->controller->getBody();

        if ($this->controller->hasViewEnabled()) {
            $view = $this->config['controller'] . '/' . $this->config['action'];
            try {
                $responseBody = $this->controller->getViewEngine()->render($view, (array) $viewVars);
            } catch (Exception $e) {
                throw $e;
            }
        }

        if ($this->controller->hasLayoutEnabled()) {
            $responseBody = $this->templateCheck($this->controller, $responseBody);
        }
        $this->prepareResponse($responseBody);
        $this->sendResponse();
    }


    /**
     * @throws Exception
     */
    public function fireCannons()
    {
        try {
            // Garr! Check the route with th' navigator
            $this->checkNavigator();

            // Fire cannons t' th' controller action
            $this->plunderEnemyShip();

            // Share the loot! send out th' response
            $this->distributeBooty();
        } catch (Exception $e) {
            $this->sinkingShip($e);
        }
    }

    /**
     * @param $booty
     */
    private function prepareResponse($booty)
    {
        $this->response->getBody()->write($booty);
        $this->setHeaders();
        $this->setStatusCode();
    }


    private function sendResponse()
    {
        $emitter = new SapiEmitter();

The class Zend\Diactoros\Response\SapiEmitter has been deprecated with message: since 1.8.0. The package zendframework/zend-httphandlerrunner now provides this functionality.

        $emitter->emit($this->response);
    }

    private function setHeaders()
    {
        foreach ($this->controller->getHeaders() as $key => $value) {
            $this->response = $this->response->withHeader($key, $value);
        }
    }

    private function setStatusCode()
    {
        $status = $this->controller->getStatusCode();
        if ($status != 200) {
            try {
                $this->response = $this->response->withStatus($status);
            } catch (Exception $e) {
                $this->response = $this->response->withStatus(500);
            }

        }
    }


    private function plunderEnemyShip()
    {
        // run th' controller action
        $action = $this->config['action_name'];

        $this->controller->init();
        $vars = $this->controller->$action();

        if (is_array($vars)) {

            $viewVars = (array) $this->controller->view;
            $view = (object) array_merge($vars, $viewVars);
            $this->controller->view = $view;

        } elseif ($vars instanceof ResponseInterface) {

            $this->controller->view = $vars;

It seems like $vars of type object<Psr\Http\Message\ResponseInterface> is incompatible with the declared type object<stdClass> of property $view.

        }

        $this->controller->postDispatch();
    }

    /**
     * @param Exception $e
     * @return string
     * @throws Exception
     */
    public function sinkingShip(Exception $e)
    {
        $controllerName = class_exists('\App\Controller\ErrorController') ? 'App\Controller\ErrorController' : 'Bone\Mvc\Controller';
        $this->controller = new $controllerName($this->request);
        $this->controller->setParam('error', $e);
        $reflection = new ReflectionClass(get_class($this->controller));
        $method = $reflection->getMethod('errorAction');
        $method->setAccessible(true);
        $method->invokeArgs($this->controller, []);
        $this->controller->error = $e;
        $this->config['controller'] = 'error';
        $this->config['action'] = 'error';
        $this->response = $this->response->withStatus(500);
        $this->distributeBooty();
    }


    /**
     * @param Controller $controller
     * @param string $content
     * @return string
     */
    private function templateCheck($controller, $content)
    {
        $responseBody = '';
        //check we be usin' th' templates in th' config
        $templates = Registry::ahoy()->get('templates');
        $template = $this->getTemplateName($templates);
        if ($template !== null) {
            $responseBody = $controller->getViewEngine()->render('layouts/' . $template, array('content' => $content));
        }
        return $responseBody;
    }

    /**
     * @param mixed $templates
     * @return string|null
     */
    private function getTemplateName($templates)
    {
        if (is_null($templates)) {
            return null;
        } elseif (is_array($templates)) {
            return (string) $templates[0];
        }
        return (string) $templates;
    }

    /**
     * Sets controller to error and action to not found
     * @return void
     */
    private function setNotFound()
    {
        $this->config['controller_name'] = class_exists('\App\Controller\ErrorController') ? '\App\Controller\ErrorController' : '\Bone\Mvc\Controller';
        $this->config['action_name'] = 'notFoundAction';
        $this->config['controller'] = 'error';
        $this->config['action'] = 'not-found';
        $this->controller = new $this->config['controller_name']($this->request);
        $this->response = $this->response->withStatus(404);
    }
}