Faulancer\Controller\Dispatcher

Complexity

Total Complexity

41

Size/Duplication

Total Lines	289
Duplicated Lines	5.88 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
C	dispatch()	0	45	8
A	detectLanguageSwitch()	0	4	1
B	resolveAssetsPath()	0	24	5
A	sendCssFileHeader()	0	6	1
A	sendJsFileHeader()	0	6	1
B	getRoute()	0	20	5
B	getDirectMatch()	8	26	6
C	getVariableMatch()	9	35	7
B	getRestfulAction()	0	26	6

<?php
/**
 * Class Dispatcher | Dispatcher.php
 * @package Faulancer\AbstractController
 * @author Florian Knapp <office@florianknapp.de>
 */
namespace Faulancer\Controller;

use Faulancer\Exception\ClassNotFoundException;
use Faulancer\Exception\DispatchFailureException;
use Faulancer\Exception\IncompatibleResponseException;
use Faulancer\Form\AbstractFormHandler;
use Faulancer\Http\JsonResponse;
use Faulancer\Http\Request;
use Faulancer\Http\Response;
use Faulancer\Exception\MethodNotFoundException;
use Faulancer\Service\Config;
use Faulancer\Service\SessionManagerService;
use Faulancer\ServiceLocator\ServiceLocator;
use Faulancer\Session\SessionManager;

/**
 * Class Dispatcher
 */
class Dispatcher
{

    /**
     * The current request object
     *
     * @var Request
     */
    protected $request;

    /**
     * The configuration object
     *
     * @var Config
     */
    protected $config;

    /**
     * user, api
     *
     * @var string
     */
    protected $requestType = 'default';

    /**
     * Dispatcher constructor.
     *
     * @param Request $request
     * @param Config  $config
     */
    public function __construct(Request $request, Config $config)
    {
        $this->request = $request;
        $this->config  = $config;
    }

    /**
     * Bootstrap for every route call
     *
     * @return Response|JsonResponse|mixed
     * @throws MethodNotFoundException
     * @throws ClassNotFoundException
     * @throws DispatchFailureException
     * @throws IncompatibleResponseException
     */
    public function dispatch()
    {
        // Check for core assets path
        if ($assets = $this->resolveAssetsPath()) {
            return $assets;
        }

        /** @var Response $response */
        $response = null;

$response is not used, you could remove the assignment.

        if ($this->detectLanguageSwitch()) {
            $serviceLocator = ServiceLocator::instance();
            $sessionManager = $serviceLocator->get(SessionManagerService::class);
            $sessionManager->set('language', $this->request->getParam('lang'));
        }

        if (strpos($this->request->getUri(), '/api') === 0) {
            $this->requestType = 'api';
        }

        $target  = $this->getRoute($this->request->getUri());
        $class   = $target['class'];
        $action  = $this->requestType === 'api' ? $this->getRestfulAction() : $target['action'];
        $payload = !empty($target['var']) ? $target['var'] : [];

        $payload = array_map('stripslashes', $payload);
        $payload = array_map('htmlentities', $payload);
        $payload = array_map('strip_tags', $payload);

        /** @var Response $class */
        $class = new $class($this->request);

        if (!method_exists($class, $action)) {
            throw new MethodNotFoundException('Class "' . get_class($class) . '" doesn\'t have the method ' . $action);
        }

        $response = call_user_func_array([$class, $action], $payload);

        if (!$response instanceof Response) {
            throw new IncompatibleResponseException('No valid response returned.');
        }

        return $response;

    }

    private function detectLanguageSwitch()
    {
        return $this->request->getParam('lang') !== null;
    }

    /**
     * @return bool|string
     */
    private function resolveAssetsPath()
    {
        $matches = [];

        if (preg_match('/(?<style>css)|(?<script>js)/', $this->request->getUri(), $matches)) {

            $file = $this->request->getUri();

            if (strpos($file, 'core') !== false) {

                $path = str_replace('/core', '', $file);

                if ($matches['style'] === 'css') {
                    return $this->sendCssFileHeader($path);
                } else if ($matches['script'] === 'js') {
                    return $this->sendJsFileHeader($path);
                }

            }

        }

        return false;
    }

    /**
     * @param $file
     * @return string
     * @codeCoverageIgnore
     */
    public function sendCssFileHeader($file)
    {
        header('Content-Type: text/css');
        echo file_get_contents(__DIR__ . '/../../public/assets' . $file);
        exit(0);
    }

    /**
     * @param $file
     * @return string
     * @codeCoverageIgnore
     */
    public function sendJsFileHeader($file)
    {
        header('Content-Type: text/javascript');
        echo file_get_contents(__DIR__ . '/../../public/assets' . $file);
        exit(0);
    }

    /**
     * Get data for specific route path
     *
     * @param string $path
     *
     * @return array
     * @throws MethodNotFoundException
     */
    private function getRoute($path)
    {
        if (strpos($this->request->getUri(), '/api') === 0) {
            $routes = $this->config->get('routes:rest');
        } else {
            $routes = $this->config->get('routes');
        }

        foreach ($routes as $name => $data) {

            if ($target = $this->getDirectMatch($path, $data)) {
                return $target;
            } else if ($target = $this->getVariableMatch($path, $data)) {
                return $target;
            }

        }

        throw new MethodNotFoundException('No matching route for path "' . $path . '" found');
    }

    /**
     * Determines if we have a direct/static route match
     *
     * @param string $uri  The request uri
     * @param array  $data The result from ClassParser
     *
     * @return array
     * @throws MethodNotFoundException
     */
    private function getDirectMatch($uri, array $data) :array
    {
        if (!empty($data['path']) && $uri === $data['path']) {

            if ($this->requestType === 'default' && in_array($this->request->getMethod(), $data['method'])) {

                return [
                    'class'  => $data['controller'],
                    'action' => $data['action'] . 'Action'
                ];

            } else if ($this->requestType === 'api') {

This code seems to be duplicated across your project.

                return [
                    'class'  => $data['controller'],
                    'action' => $this->getRestfulAction()
                ];

            }

            throw new MethodNotFoundException('Non valid request method available.');

        }

        return [];
    }

    /**
     * Determines if we have a variable route match
     *
     * @param string $uri
     * @param array  $data
     *
     * @return array
     * @throws MethodNotFoundException
     */
    private function getVariableMatch($uri, array $data) :array
    {
        if (empty($data['path']) || $data['path'] === '/') {
            return [];
        }

        $var   = [];
        $regex = str_replace(['/', '___'], ['\/', '+'], $data['path']);

        if (preg_match('|^' . $regex . '$|', $uri, $var)) {

            array_splice($var, 0, 1);

            if ($this->requestType === 'default'  && in_array($this->request->getMethod(), $data['method'])) {

                return [
                    'class'  => $data['controller'],
                    'action' => $data['action'] . 'Action',
                    'var'    => $var
                ];

            } else if ($this->requestType === 'api') {

This code seems to be duplicated across your project.

                return [
                    'class'  => $data['controller'],
                    'action' => $this->getRestfulAction(),
                    'var'    => $var
                ];

            }

        }

        return [];
    }

    /**
     * @return string
     */
    private function getRestfulAction()
    {
        $method = strtoupper($this->request->getMethod());

        switch ($method) {

            case 'GET':
                return 'get';

            case 'POST':
                return 'create';

            case 'PUT':
                return 'update';

            case 'DELETE':
                return 'delete';

            case 'PATCH':
                return 'update';

            default:
                return 'get';

        }
    }

}