Ubiquity\controllers\Startup

Complexity

Total Complexity

61

Size/Duplication

Total Lines	338
Duplicated Lines	0 %

Test Coverage

Coverage

82.98%

Importance

Changes	1
Bugs	0	Features	0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	getTemplateEngineInstance()	0	7	2
A	getApplicationName()	0	2	1
A	injectDependencies()	0	17	6
A	run()	0	3	1
A	getControllerSimpleName()	0	2	1
A	startDefaultTemplateEngine()	0	7	3
A	getFrameworkDir()	0	2	1
A	parseUrl()	0	5	2
A	onError()	0	14	3
A	getController()	0	2	1
A	runAsString()	0	4	1
A	logError()	0	7	3
A	startTemplateEngine()	0	10	3
B	runAction()	0	44	11
A	getViewNameFileExtension()	0	2	1
A	getAction()	0	2	1
A	runCallable()	0	10	3
A	init()	0	9	3
A	_getControllerInstance()	0	10	4
A	setMainParams()	0	6	3
A	forward()	0	15	5
A	getApplicationDir()	0	2	1
A	getActionParams()	0	2	1

<?php

namespace Ubiquity\controllers;

use Ubiquity\controllers\di\DiManager;
use Ubiquity\controllers\traits\StartupConfigTrait;
use Ubiquity\log\Logger;
use Ubiquity\utils\http\USession;
use Ubiquity\views\engine\TemplateEngine;

/**
 * Starts the framework.
 * This class is part of Ubiquity
 *
 * @author jcheron <myaddressmail@gmail.com>
 * @version 1.2.0
 *
 */
class Startup {
	use StartupConfigTrait;

	public static $urlParts;
	public static $templateEngine;
	protected static $controller;
	protected static $action;
	protected static $actionParams;

	protected static function parseUrl(&$url): array {
		if (!$url) {
			return self::$urlParts = [$url = '_default'];
		}
		return self::$urlParts = \explode('/', \rtrim($url, '/'));
	}

	protected static function _getControllerInstance(string $controllerName): ?object {
		if (\class_exists($controllerName, true)) {
			$controller = new $controllerName ();
			// Dependency injection
			if (isset (self::$config ['di']) && \is_array(self::$config ['di'])) {
				self::injectDependencies($controller);
			}
			return $controller;
		}
		return null;
	}

	protected static function startTemplateEngine(array &$config): void {
		try {
			$templateEngine = $config ['templateEngine'];
			$engineOptions = $config ['templateEngineOptions'] ?? ['cache' => false];
			$engine = new $templateEngine ($engineOptions);
			if ($engine instanceof TemplateEngine) {
				self::$templateEngine = $engine;
			}
		} catch (\Exception $e) {
			echo $e->getTraceAsString();
		}
	}

	protected static function setMainParams($controller, $mainParams) {
		foreach ($mainParams as $k => $v) {
			if (\method_exists($controller, $k)) {
				$controller->$k($v);
			} else {
				$controller->$k = $v;
			}
		}
	}

	/**
	 * Handles the request
	 *
	 * @param array $config The loaded config array
	 */
	public static function run(array &$config): void {
		self::init($config);
		self::forward($_GET ['c']);
	}

	/**
	 * Initialize the app with $config array
	 *
	 * @param array $config
	 */
	public static function init(array &$config): void {
		self::$config = $config;
		if (isset ($config ['templateEngine'])) {
			self::startTemplateEngine($config);
		}
		if (isset ($config ['sessionName'])) {
			USession::start($config ['sessionName']);
		}
		self::$ctrlNS = self::getNS();
	}

	/**
	 * Forwards to url
	 *
	 * @param string $url The url to forward to
	 * @param boolean $initialize If true, the **initialize** method of the controller is called
	 * @param boolean $finalize If true, the **finalize** method of the controller is called
	 */
	public static function forward(string $url, bool $initialize = true, bool $finalize = true): void {
		$u = self::parseUrl($url);
		if (\is_array(Router::getRoutes()) && ($ru = Router::getRoute($url, true, self::$config ['debug'] ?? false)) !== false) {
			if (\is_array($ru)) {
				if (isset ($ru ['controller'])) {
					static::runAction($ru, $initialize, $finalize);
				} else {
					self::runCallable($ru);
				}
			} else {
				echo $ru; // Displays route response from cache
			}
		} else {
			$ru = ['controller' => self::$ctrlNS . $u [0], 'action' => $u [1] ?? 'index', 'params' => \array_slice($u, 2)];
			static::runAction($ru, $initialize, $finalize);
		}
	}

	/**
	 * Returns the template engine instance
	 *
	 * @return TemplateEngine
	 */
	public static function getTemplateEngineInstance(): ?TemplateEngine {
		$config = self::$config;
		if (isset ($config ['templateEngine'])) {
			$templateEngine = $config ['templateEngine'];
			return new $templateEngine ([]);
		}
		return null;
	}

	/**
	 * Starts the default Template engine (Twig for Webtools).
	 *
	 * @return TemplateEngine
	 */
	public static function startDefaultTemplateEngine(): TemplateEngine {
		if (self::$templateEngine === null || !self::$templateEngine instanceof \Ubiquity\views\engine\twig\Twig) {
			$config = self::$config;
			$config['templateEngine'] = \Ubiquity\views\engine\twig\Twig::class;
			self::startTemplateEngine($config);
		}
		return self::$templateEngine;
	}

	/**
	 * Runs an action on a controller
	 *
	 * @param array $u An array containing controller, action and parameters
	 * @param boolean $initialize If true, the **initialize** method of the controller is called
	 * @param boolean $finalize If true, the **finalize** method of the controller is called
	 */
	public static function runAction(array &$u, bool $initialize = true, bool $finalize = true): void {
		self::$controller = $ctrl = $u ['controller'];
		self::$action = $action = $u ['action'] ?? 'index';
		self::$actionParams = $u['params'] ?? [];

		try {
			if (null !== $controller = self::_getControllerInstance($ctrl)) {
				if ($mainParams = $u['mainParams'] ?? false) {
					static::setMainParams($controller, $mainParams);
				}
				if (!$controller->isValid($action)) {
					$controller->onInvalidControl();
				} else {
					if ($initialize) {
						$controller->initialize();
					}
					try {
						$controller->$action (...(self::$actionParams));
					} catch (\Error $e) {
						if (!\method_exists($controller, $action)) {
							static::onError(404, "This action does not exist on the controller " . $ctrl, $controller);
						} else {
							static::logError($e->getCode(), $e->getMessage());
							if (self::$config ['debug']) {
								throw $e;
							} else {
								static::onError(500, $e->getMessage(), $controller);
							}
						}
					}
					if ($finalize) {
						$controller->finalize();
					}
				}
			} else {
				Logger::warn('Startup', "The controller `$ctrl` doesn't exist! <br/>", 'runAction');
				static::onError(404, "The controller `$ctrl` doesn't exist! <br/>");
			}
		} catch (\Error $eC) {
			static::logError($eC->getCode(), $eC->getMessage());
			if (self::$config ['debug']) {
				throw $eC;
			} else {
				static::onError(500, $eC->getMessage());
			}
		}
	}

	/**
	 * Runs a callback
	 *
	 * @param array $u An array containing a callback, and some parameters
	 */
	public static function runCallable(array &$u): void {
		self::$actionParams = $u['params'] ?? [];
		if (isset (self::$config ['di'])) {
			$di = self::$config ['di'];
			if (\is_array($di)) {
				self::$actionParams += \array_values($di);
			}
		}
		$func = $u ['callback'];
		$func (...(self::$actionParams));
	}

	/**
	 * Injects the dependencies from the **di** config key in a controller
	 *
	 * @param Controller $controller The controller
	 */
	public static function injectDependencies($controller): void {
		$di = DiManager::fetch($controller);
		if ($di !== false) {
			foreach ($di as $k => $v) {
				$setter = 'set' . \ucfirst($k);
				if (\method_exists($controller, $setter)) {
					$controller->$setter ($v ($controller));
				} else {
					$controller->$k = $v ($controller);
				}
			}
		}

		$di = self::$config ['di'] ?? [];
		if (isset ($di ['@exec'])) {
			foreach ($di ['@exec'] as $k => $v) {
				$controller->$k = $v ($controller);
			}
		}
	}

	/**
	 * Runs an action on a controller and returns a string
	 *
	 * @param array $u
	 * @param boolean $initialize If true, the **initialize** method of the controller is called
	 * @param boolean $finalize If true, the **finalize** method of the controller is called
	 * @return string
	 */
	public static function runAsString(array &$u, bool $initialize = true, bool $finalize = true): string {
		\ob_start();
		self::runAction($u, $initialize, $finalize);
		return \ob_get_clean();
	}

	public static function onError(int $code, ?string $message = null, $controllerInstance = null) {
		$onError = self::$config ['onError'] ?? (function ($code, $message = null, $controllerInstance = null) {
			switch ($code) {
				case 404 :
					self::getHttpInstance()->header('HTTP/1.0 404 Not Found', '', true, 404);
					echo $message ?? "The page you are looking for doesn't exist!";
					break;

				case 500 :
					echo $message ?? "A server error occurred!";
					break;
			}
		});
		$onError ($code, $message, $controllerInstance);
	}

	public static function logError(int $code, string $message) {
		if ($code <= E_ERROR) {
			Logger::critical('Startup', $message, 'runAction');
		} elseif ($code <= E_WARNING) {
			Logger::error('Startup', $message, 'runAction');
		} else {
			Logger::warn('Startup', $message, 'runAction');
		}
	}

	/**
	 * Returns the active controller name
	 *
	 * @return ?string
	 */
	public static function getController(): ?string {
		return self::$controller;
	}

	/**
	 * Returns the class simple name of the active controller
	 *
	 * @return string
	 */
	public static function getControllerSimpleName(): string {
		return (new \ReflectionClass (self::$controller))->getShortName();
	}

	/**
	 * Returns the extension for view files
	 *
	 * @return string
	 */
	public static function getViewNameFileExtension(): string {
		return self::$config ['templateEngineOptions']['fileExt'] ?? 'html';
	}

	/**
	 * Returns tha active action
	 *
	 * @return string
	 */
	public static function getAction(): ?string {
		return self::$action;
	}

	/**
	 * Returns the active parameters
	 *
	 * @return array
	 */
	public static function getActionParams(): array {
		return self::$actionParams;
	}

	/**
	 * Returns the framework directory
	 *
	 * @return string
	 */
	public static function getFrameworkDir(): string {
		return \dirname(__FILE__);
	}

	/**
	 * Returns the application directory (app directory)
	 *
	 * @return string
	 */
	public static function getApplicationDir(): string {
		return \dirname(\ROOT);
	}

	/**
	 * Returns the application name
	 *
	 * @return string
	 */
	public static function getApplicationName(): string {
		return \basename(\dirname(\ROOT));
	}
}