PSFS\Dispatcher

Complexity

Total Complexity

22

Size/Duplication

Total Lines	183
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

87.18%

Importance

Changes	2
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	init()	0	10	1
A	setLocale()	0	17	1
C	run()	0	23	8
A	dumpException()	0	14	2
A	getMem()	0	16	4
A	getTs()	0	4	1
A	bindWarningAsExceptions()	0	11	2
A	initiateStats()	0	10	3

<?php

For compatibility and reusability of your code, PSR1 recommends that a file should introduce either new symbols (like classes, functions, etc.) or have side-effects (like outputting something, or including other files), but not both at the same time. The first symbol is defined on line 25 and the first side effect is on line 19.

/**
 * @author Fran López <fran.lopez84@hotmail.es>
 * @version 1.0
 */

namespace PSFS;

use PSFS\base\config\Config;
use PSFS\base\exception\ConfigException;
use PSFS\base\exception\RouterException;
use PSFS\base\exception\SecurityException;
use PSFS\base\exception\UserAuthException;
use PSFS\base\Logger;
use PSFS\base\Request;
use PSFS\base\Singleton;
use PSFS\controller\ConfigController;

require_once __DIR__ . DIRECTORY_SEPARATOR . "bootstrap.php";

/**
 * Class Dispatcher
 * @package PSFS
 */
class Dispatcher extends Singleton
{
    /**
     * @Inyectable
     * @var \PSFS\base\Security $security
     */
    protected $security;
    /**
     * @Inyectable
     * @var \PSFS\base\Router $router
     */
    protected $router;
    /**
     * @Inyectable
     * @var \PSFS\base\Request $parser
     */
    protected $parser;
    /**
     * @Inyectable
     * @var \PSFS\base\Logger $log
     */
    protected $log;
    /**
     * @Inyectable
     * @var \PSFS\base\config\Config $config
     */
    protected $config;

    protected $ts;

Avoid variables with short names like $ts. Configured minimum length is 3.

    protected $mem;
    protected $locale = "es_ES";

    private $actualUri;

    /**
     * Initializer method
     */
    public function init()
    {
        Logger::log('Dispatcher init');
        parent::init();
        $this->initiateStats();
        $this->setLocale();
        $this->bindWarningAsExceptions();
        $this->actualUri = $this->parser->getServer("REQUEST_URI");
        Logger::log('End dispatcher init');
    }

    /**
     * Method that assign the locale to the request
     * @return $this
     */
    private function setLocale()
    {
        $this->locale = $this->config->get("default_language");
        Logger::log('Set locale to project [' . $this->locale . ']');
        // Load translations
        putenv("LC_ALL=" . $this->locale);
        setlocale(LC_ALL, $this->locale);
        // Load the locale path
        $locale_path = BASE_DIR . DIRECTORY_SEPARATOR . 'locale';
        Logger::log('Set locale dir ' . $locale_path);
        Config::createDir($locale_path);
        bindtextdomain('translations', $locale_path);
        textdomain('translations');
        bind_textdomain_codeset('translations', 'UTF-8');

        return $this;
    }

    /**
     * Run method
     * @return string HTML

Should the return type not be string|null?

     */
    public function run()
    {
        Logger::log('Begin runner');
        try {
            if ($this->config->isConfigured()) {
                if (!$this->parser->isFile()) {
                    return $this->router->execute($this->actualUri);
                }
            } else {
                return ConfigController::getInstance()->config();
            }
        } catch (ConfigException $c) {
            return $this->dumpException($c);
        } catch (SecurityException $s) {
            return $this->security->notAuthorized($this->actualUri);
        } catch (UserAuthException $u) {
            Request::getInstance()->redirect($this->router->getRoute($this->config->get('home_action')));
        } catch (RouterException $r) {
            return $this->router->httpNotFound($r);
        } catch (\Exception $e) {
            return $this->dumpException($e);
        }
    }

    /**
     * Method that convert an exception to html
     *
     * @param \Exception $e
     *
     * @return string HTML
     */
    protected function dumpException(\Exception $e)

Avoid variables with short names like $e. Configured minimum length is 3.

    {
        Logger::log('Starting dump exception');
        $ex = (NULL !== $e->getPrevious()) ? $e->getPrevious() : $e;

Avoid variables with short names like $ex. Configured minimum length is 3.

        $error = array(
            "error" => $ex->getMessage(),
            "file" => $ex->getFile(),
            "line" => $ex->getLine(),
        );
        Logger::log('Throwing exception', LOG_ERR, $error);
        unset($error);

        return $this->router->httpNotFound($ex);
    }

    /**
     * Method that returns the memory used at this specific moment
     *
     * @param $unit string
     *
     * @return int
     */
    public function getMem($unit = "Bytes")
    {
        $use = memory_get_usage() - $this->mem;
        switch ($unit) {
            case "KBytes":
                $use /= 1024;
                break;
            case "MBytes":
                $use /= (1024 * 1024);
                break;
            case "Bytes":
            default:
        }

        return $use;
    }

    /**
     * Method that returns the seconds spent with the script
     * @return double
     */
    public function getTs()
    {
        return microtime(TRUE) - $this->ts;
    }

    /**
     * Debug function to catch warnings as exceptions
     */
    protected function bindWarningAsExceptions()
    {
        if ($this->config->getDebugMode()) {
            Logger::log('Added handlers for errors');
            //Warning & Notice handler
            set_error_handler(function ($errno, $errstr, $errfile, $errline) {
                Logger::log($errstr, LOG_CRIT, ['file' => $errfile, 'line' => $errline]);
                throw new \Exception($errstr, 500);
            });
        }
    }

    /**
     * Stats initializer
     */
    private function initiateStats()

initiateStats uses the super-global variable $_SERVER which is generally not recommended.

    {
        Logger::log('Initialicing stats (mem + ts)');
        if (null !== $_SERVER && array_key_exists('REQUEST_TIME_FLOAT', $_SERVER)) {
            $this->ts = (float)$_SERVER['REQUEST_TIME_FLOAT'];
        } else {
            $this->ts = $this->parser->getTs();
        }
        $this->mem = memory_get_usage();
    }

}