FuzeWorks/Core
FuzeWorks/Core
1
0
Fork 0
Code Issues 9 Pull Requests Packages Releases Activity

Merge branch 'master' into 'master'

Browse Source 
GF Merge

Better router, logger, removal of several useless files, a lot of pragmatic rewrites.

See merge request !20
This commit is contained in:
Abel Hoogeveen 2015-05-03 22:54:30 +02:00
commit 1171e67223
27 changed files with 907 additions and 287 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
Application/Config/config.mailer.php
View File

@ -1,12 +0,0 @@
<?php return array (
'sendmail_enabled' => true,
'smtp_enabled' => false,
'smtp_host' => '',
'smtp_port' => 25,
'smtp_auth' => false,
'smtp_username' => '',
'smtp_password' => '',
'smtp_debug_level' => 0,
'sender_name' => '',
'sender_mail' => '',
) ;

8
Application/Config/config.routes.php Normal file
View File

@ -0,0 +1,8 @@
<?php
return array(
// '/^alias(|\-(?P<function>.*?))$/' => array(
// 'controller' => 'home'
// ),
'/^(?P<controller>.*?)(|\/(?P<function>.*?)(|\/(?P<parameters>.*?)))$/',
);

4
Application/Config/config.sessions.php
View File

@ -1,4 +0,0 @@
<?php return array (
'cookie_name' => '',
'urlSelector' => '',
) ;

7
Application/Controller/controller.standard.php
View File

@ -11,13 +11,6 @@ class Standard extends Controller {
public function index($path = null) {
$this->layout->view('maintenance');
}
public function not_found($path = null) {
$this->logger->http_error(404);
$this->layout->assign('page', $_SERVER['REQUEST_URI']);
$this->layout->assign('mail', $this->config->main->administrator_mail);
$this->layout->view('404');
}
}

0
Application/Events/put_events_here
View File

52
Application/Views/view.default.tpl
View File

@ -1,52 +0,0 @@
<html>
<head>
<title>{$title}</title>
<link href="//netdna.bootstrapcdn.com/bootstrap/3.1.1/css/bootstrap.min.css" rel="stylesheet">
<style>
body {
background: #ecf0f1;
border-bottom: 1px solid #DDD;
padding: 100px 0 100px;
font-size: 16px;
}
#setupcontainer {
max-width: 950px;
margin-left: auto;
margin-right: auto;
}
</style>
</head>
<body>
<div id='setupcontainer'>
<div class='row'>
<div class='col-lg-12 col-md-4 col-sm-12'>
<div id='contentPanel' class="panel panel-default" style='display:none'>
<div id='1' class="panel-body" style='display:none'>
<p class="lead">{$topTitle}</p>
<p>{$content}</p>
</div>
</div>
</div>
</div>
</div>
<footer>
<script src="http://code.jquery.com/jquery-1.11.0.min.js"></script>
<script src="//netdna.bootstrapcdn.com/bootstrap/3.1.1/js/bootstrap.min.js"></script>
<script>
var currentPage = 0;
var currentProgress = 0;
start();
function start() {
$("#contentPanel").fadeIn(500);
$("#1").fadeIn(700);
}
</script>
</footer>
</body>
</html>

29
Application/Views/view.email_verify.tpl
View File

@ -1,29 +0,0 @@
<html>
<body style='background-color:#eeeeee;color:#505050;font-size:11pt;padding-top:20px;'>
<div style='width:300px;height:95px;margin:0 auto 20px auto;'><img src='http://myfuze.net/Fuze2tra.png' alt='Fuze Netwerk Logo' style='width:300px;height:95px;' /></div>
<div id='header' style='padding:25px 20px;width:75%;background-color:#3498db;border-width:1px 1px 0 1px;font-size:20pt;font-weight:bold;border-color:#dddddd;border-style:solid;margin:0 auto;color:#fdfdfd;border-radius:8px 8px 0 0;'>
Verify your mail address
</div>
<div id='body' style='padding:20px;border-width:0 1px 0 1px;width:75%;background-color:#fdfdfd;border-color:#dddddd;border-style:solid;margin:0 auto;'>
<h1>Welcome to {$siteName}! </h1>
<p>Please verify your account by clicking the button below:</p>
<a href='{$verifyURL}?code={$code}'><button>Verify!</button></a>
<p>If the button does not work, please copy the following link into your browser:</p>
<a href='{$verifyURL}?code={$code}'>{$verifyURL}?code={$code}</a>
<p>Thank you for registering to {$siteName}, have a nice day!</p>
</div>
<div id='footer' style='padding:20px;color:#3498db;text-align:center;border-width:0 1px 1px 1px;border-radius:0 0 8px 8px;width:75%;background-color:#fdfdfd;border-color:#dddddd;border-style:solid;margin:0 auto;'>
<a href='http://fuzenetwerk.nl'>FuzeNetwerk.nl</a><br />
<span style='line-height:125%;'>Leguaanstraat 3 1338HB Almere<br />
KvK 00000000<br />
BTW NL.0000.00000.000</span>
</div>
<br style='margin-top:20px;' />
</body>
</html>

41
Core/Events/event.routerLoadCallableEvent.php Normal file
View File

@ -0,0 +1,41 @@
<?php
use \FuzeWorks\Event;
/**
* Class routerLoadCallableEvent
*
* Called when a callable is about to be loaded
*
* @package System\Events
*/
class routerLoadCallableEvent extends Event{
/**
* @var callable The callable
*/
public $callable;
/**
* @var null|string The controller-part of the route
*/
public $controller = null;
/**
* @var null|string The function-part of the route
*/
public $function = null;
/**
* @var null|string The parameter-part of the route
*/
public $parameters = null;
public function init($callable, $controller, $function, $parameters){
$this->callable = $callable;
$this->controller = $controller;
$this->function = $function;
$this->parameters = $parameters;
}
}

36
Core/Events/event.routerRouteEvent.php
View File

@ -2,18 +2,28 @@
use \FuzeWorks\Event;
class RouterRouteEvent extends Event {
public $controller;
public $function;
public $parameters;
public $directory;
/**
* Class routerRouteEvent
*
* Fired after the router has extracted the path
*
* @package System\Events
*/
class routerRouteEvent extends Event{
public function init($controller, $function, $parameters){
$this->controller = $controller;
$this->function = $function;
$this->parameters = $parameters;
/**
* @var array The routing table
*/
public $routes;
/**
* @var boolean Whether the callable will be loaded directly after or not
*/
public $loadCallable;
public function init($routes, $loadCallable){
$this->routes = $routes;
$this->loadCallable = $loadCallable;
}
}
?>
}

25
Core/Events/event.routerSetPathEvent.php Normal file
View File

@ -0,0 +1,25 @@
<?php
use \FuzeWorks\Event;
/**
* Class routerSetPathEvent
*
* Fired when the router's path is changing
*
* @package System\Events
*/
class routerSetPathEvent extends Event{
/**
* @var string The new path
*/
public $path;
public function init($path){
$this->path = $path;
}
}
?>

3
Core/System/class.abstract.bus.php
View File

@ -6,7 +6,7 @@ abstract class Bus {
protected $core;
protected $mods;
protected $library;
protected $router;
protected $config;
protected $logger;
protected $models;
@ -22,6 +22,7 @@ abstract class Bus {
$this->models = &$core->mods->models;
$this->layout = &$core->mods->layout;
$this->events = &$core->mods->events;
$this->router = &$core->mods->router;
}
}

1
Core/System/class.config.php
View File

@ -1,7 +1,6 @@
<?php
namespace FuzeWorks;
use \Exception;
/**
* Config Class

7
Core/System/class.core.php
View File

@ -2,7 +2,6 @@
namespace FuzeWorks;
use \stdClass;
use \Exception;
/**
* FuzeWorks Core
@ -38,6 +37,9 @@ class Core {
$this->buildRegister();
$this->mods->events->buildEventRegister();
// And initialize the router paths
$this->mods->router->init();
$event = $this->mods->events->fireEvent('coreStartEvent');
if ($event->isCancelled()) {
return true;
@ -55,6 +57,7 @@ class Core {
require_once("Core/System/class.abstract.model.php");
require_once("Core/System/class.abstract.controller.php");
require_once("Core/System/class.abstract.eventPriority.php");
require_once("Core/System/class.exceptions.php");
// Load the core classes
require_once("Core/System/class.config.php");
@ -62,6 +65,7 @@ class Core {
require_once("Core/System/class.models.php");
require_once("Core/System/class.layout.php");
require_once("Core/System/class.events.php");
require_once("Core/System/class.router.php");
// Load them
$this->mods->events = new Events ($this);
@ -69,6 +73,7 @@ class Core {
$this->mods->logger = new Logger ($this);
$this->mods->models = new Models ($this);
$this->mods->layout = new Layout ($this);
$this->mods->router = new Router ($this);
$this->loaded = true;
}

1
Core/System/class.events.php
View File

@ -5,7 +5,6 @@
*/
namespace FuzeWorks;
use \Exception;
/**
* Event Class

45
Core/System/class.exceptions.php Normal file
View File

@ -0,0 +1,45 @@
<?php
namespace FuzeWorks;
/**
* Class Exception
* @package System\Core
*/
class Exception extends \Exception{}
/**
* Class LayoutException
* @package System\Core
*/
class LayoutException extends Exception{}
/**
* Class RouterException
* @package System\Core
*/
class RouterException extends Exception{}
/**
* Class CoreException
* @package System\Core
*/
class CoreException extends Exception{}
/**
* Class EventException
* @package System\Core
*/
class EventException extends Exception{}
/**
* Class DatabaseException
* @package System\Core
*/
class DatabaseException extends Exception{}
/**
* Class ModuleException
* @package System\Core
*/
class ModuleException extends Exception{}

5
Core/System/class.layout.php
View File

@ -1,7 +1,6 @@
<?php
namespace FuzeWorks;
use \Exception;
/**
* Layout Class
@ -131,7 +130,7 @@ class Layout extends Bus {
// Throw error on failure
$this->logger->logError('Could not load view '.$directory.'/'.$vw.' :: ' . $e->getMessage(), 'Layout', __FILE__, __LINE__);
throw new Exception\Layout('Could not load view '.$directory.'/'.$vw);
throw new LayoutException('Could not load view '.$directory.'/'.$vw);
}
}
@ -160,7 +159,7 @@ class Layout extends Bus {
// Throw error on failure
$this->logger->logError('Could not load view '.$directory.'/view.'.$view.'.tpl :: ' . $e->getMessage(), 'Layout', __FILE__, __LINE__);
throw new Exception\Layout('Could not load view '.$directory.'/view.'.$view.'.tpl');
throw new LayoutException('Could not load view '.$directory.'/view.'.$view.'.tpl');
}
}
}

23
Core/System/class.logger.php
View File

@ -1,7 +1,6 @@
<?php
namespace FuzeWorks;
use \Exception;
/**
* Logger Class
@ -16,6 +15,7 @@ class Logger extends Bus{
public $warningErrors = array();
public $Logs = array();
private $print_to_screen = false;
public $debug = false;
public function __construct(&$core) {
parent::__construct($core);
@ -27,6 +27,7 @@ class Logger extends Bus{
error_reporting(false);
}
$this->events->addListener(array($this, 'shutdown'), 'coreShutdownEvent', EventPriority::LOWEST);
$this->debug = $this->config->error->debug;
$this->newLevel("Logger Initiated");
}
@ -49,7 +50,7 @@ class Logger extends Bus{
$this->logInfo($this->backtrace());
}
if ($this->mods->config->error->debug == true || $this->print_to_screen) {
if ($this->debug == true || $this->print_to_screen) {
$this->log("Parsing debug log", "Logger");
$this->logToScreen();
}
@ -263,7 +264,7 @@ class Logger extends Bus{
return $type = 'Unknown error: '.$type;
}
public function http_error($errno){
public function http_error($errno = 500, $view = true){
$http_codes = array(
@ -305,6 +306,22 @@ class Logger extends Bus{
$this->logError('HTTP-error '.$errno.' called', 'Logger');
$this->logInfo('Sending header HTTP/1.1 '.$errno.' '.$http_codes[$errno], 'Logger', __FILE__, __LINE__);
header('HTTP/1.1 '.$errno.' '.$http_codes[$errno]);
// Do we want the error-view with it?
if($view == false)
return;
$view = 'errors/'.$errno;
$this->logger->log('Loading view '.$view);
try{
$this->layout->view($view);
}catch(LayoutException $exception){
// No error page could be found, just echo the result
echo "<h1>$errno</h1><h3>".$http_codes[$errno]."</h3>";
}
}
/**

397
Core/System/class.router.php Normal file
View File

@ -0,0 +1,397 @@
<?php
namespace FuzeWorks;
class Router extends Bus{
/**
* @var null|string The provided path
*/
private $path = null;
/**
* @var array Routes
*/
private $routes = array();
/**
* @var null|mixed The callable
*/
private $callable = null;
/**
* @var null|string The controller object
*/
private $controller= null;
/**
* @var null|string The extracted controller's function name
*/
private $function = null;
/**
* @var array The extracted parameters
*/
private $parameters = array();
/**
* The constructor adds the default route to the routing table
*
* @param Core $core Reference to the core object
*/
public function __construct(&$core){
parent::__construct($core);
}
/**
* Add the default routes to the routing table
*/
public function init() {
foreach($this->config->routes as $route => $callable){
if(is_int($route)) {
$route = $callable;
$callable = array($this, 'defaultCallable');
}
$this->addRoute($route, $callable, false);
}
}
/**
* Returns the current routing path
*
* @return bool|string
*/
public function getPath(){
return $this->path;
}
/**
* Returns an array with all the routes
* @return array
*/
public function getRoutes(){
return $this->routes;
}
/**
* Returns the currently loaded callable
* @return null|callable
*/
public function getCallable(){
return $this->callable;
}
/**
* Returns the active controller
*
* @return null|Controller The controller object
*/
public function getController() {
return $this->controller;
}
/**
* Returns the name of the function
*
* @return null|string The name of the function
*/
public function getFunction() {
return $this->function;
}
/**
* Returns the routing parameters
*
* @return array
*/
public function getParameters(){
return $this->parameters;
}
/**
* Returns the routing parameter at given index
*
* @param int $index
* @return array
*/
public function getParameter($index = 0){
$parameters = $this->parameters;
$index = ($index >= 0 ? $index : count($parameters)+$index);
if(isset($parameters[$index]))
return $parameters[$index];
return null;
}
/**
* Set the current routing path
*
* @param string $path The routing path (e.g. a/b/c/d/e)
* @return bool|string
*/
public function setPath($path){
// Fire the event to notify our modules
$event = $this->events->fireEvent('routerSetPathEvent', $path);
// The event has been cancelled
if($event->isCancelled()){
return false;
}
// Remove double slashes
$event->path = preg_replace('@[/]+@', '/', $event->path);
// Remove first slash
if(substr($event->path, 0, 1) == '/')
$event->path = substr($event->path, 1);
// Remove trailing slash
if(substr($event->path, -1, 1) == '/')
$event->path = substr($event->path, 0, strlen($event->path)-1);
return $this->path = $event->path;
}
/**
* Add a route
*
* The path will be checked before custom routes before the default route(/controller/function/param1/param2/etc)
* When the given RegEx matches the current routing-path, the callable will be called.
*
* The callable will be called with three arguments:
*
* Callable($controller, $function, $parameters)
*
* These three variables will be extracted from the named groups of your RegEx. When one or more named groups are
* not matched, they will be set to NULL. The default RegEx is:
*
* /^(?P<controller>.*?)(|\/(?P<function>.*?)(|\/(?P<parameters>.*?)))$/
*
* ^ Named group 1 ^ Named group 2 ^ Named group 3
*
* Named group 1 is named 'controller' and thus will become $controller
* Named group 2 is named 'function' and thus will become $function
* Named group 3 is named 'parameters' and thus will become $parameters
*
* You can also add aliases with the following:
*
* '/^this-is-an-alias$/' => array(
* 'controller' => 'home',
* 'function' => 'index',
* 'parameters' => array()
* ),
*
* This will link '/this-is-an-alias/ to /home/index. It is also possible to use the three named capture groups
* for the function, parameters or controllers. Like this:
*
* '/^alias(|\-(?P<function>.*?))$/' => array(
* 'controller' => 'home'
* ),
*
* This will mask '/alias' to '/home' and '/alias-test' to 'home/test'.
*
* You do not *have* to use named groups, but when you don't the arguments will be left NULL; and you will need to
* extract the information from the routing-path yourself.
*
* @param string $route This is a RegEx of the route, Every capture group will be a parameter
* @param callable $callable The callable to execute
* @param bool $prepend Whether or not to insert at the beginning of the routing table
*/
public function addRoute($route, $callable, $prepend = true){
if($prepend)
$this->routes = array($route => $callable) + $this->routes;
else
$this->routes[$route] = $callable;
$this->logger->log('Route added at '.($prepend ? 'top' : 'bottom').': "'.$route.'"');
}
/**
* Removes a route from the array based on the given route
*
* @param $route string The route to remove
*/
public function removeRoute($route){
unset($this->routes[$route]);
$this->logger->log('Route removed: '.$route);
}
/**
* Extracts the routing path to controller, function and parameters
*
* @param boolean $loadCallable Immediate load the callable after routing
*/
public function route($loadCallable = true)
{
// Default values
$callable = null;
$args = array();
$controller = null;
$function = null;
$parameters = null;
// Fire the event to notify our modules
$event = $this->events->fireEvent('routerRouteEvent', $this->routes, $loadCallable);
// The event has been cancelled
if($event->isCancelled()){
return;
}
// Assign everything to the object to make it accessible, but let modules check it first
$this->routes = $event->routes;
$loadCallable = $event->loadCallable;
//Check the custom routes
foreach ($this->routes as $r => $c) {
//A custom route is found
if(preg_match($r, $this->path, $matches)) {
$controller = !empty($matches['controller']) ? $matches['controller'] : null;
$function = !empty($matches['function']) ? $matches['function'] : null;
$parameters = !empty($matches['parameters']) ? explode('/', $matches['parameters']) : null;
$this->logger->log('Route matched: '.$r);
$callable = $c;
break;
}
}
$this->callable = $callable;
$this->controller = $controller;
$this->function = $function;
$this->parameters = $parameters;
// Check if we found a callable anyway
if($this->callable === null){
$this->logger->logWarning('No routes found for given path: "'.$this->path.'"', 'Router');
$this->logger->http_error(404);
return;
}
if($loadCallable)
$this->loadCallable();
}
/**
* Load and execute the callable
*/
public function loadCallable(){
$this->logger->newLevel('Loading callable');
// Fire the event to notify our modules
$event = $this->events->fireEvent('routerLoadCallableEvent', $this->callable, $this->controller, $this->function, $this->parameters);
// The event has been cancelled
if($event->isCancelled()){
return;
}
// Assign everything to the object to make it accessible, but let modules check it first
$this->callable = $event->callable;
$this->controller = $event->controller;
$this->function = $event->function;
$this->parameters = $event->parameters;
if(!is_callable($this->callable))
if(isset($this->callable['controller'])) {
$this->controller = isset($this->callable['controller']) ? $this->callable['controller'] : $this->controller;
$this->function = isset($this->callable['function']) ? $this->callable['function'] : $this->function;
$this->parameters = isset($this->callable['parameters']) ? $this->callable['parameters'] : $this->parameters;
$this->callable = array($this, 'defaultCallable');
}else{
$this->logger->log('The given callable is not callable!', E_ERROR);
$this->error->http_error(500);
$this->logger->stopLevel();
return;
}
$args = array(
$this->controller,
$this->function,
$this->parameters,
);
$this->logger->newLevel('Calling Callable');
$this->logger->log('Controller: '. ($args[0] === null ? 'null' : $args[0]));
$this->logger->log('Function: '. ($args[1] === null ? 'null' : $args[1]));
$this->logger->log('Parameters: '. (empty($args[2]) ? '[]' : implode(', ',$args[2])));
$this->logger->stopLevel();
call_user_func_array($this->callable, $args);
$this->logger->stopLevel();
}
/**
* The default callable
*
* This callable will do the 'old skool' routing. It will load the controllers from the controller-directory
* in the application-directory.
*/
public function defaultCallable(){
$this->logger->log('Default callable called!');
$this->controller = $this->controller === null ? $this->config->main->default_controller : $this->controller;
$this->function = $this->function === null ? $this->config->main->default_function : $this->function;
// Construct file paths and classes
$class = '\Controller\\'.ucfirst($this->controller);
$file = 'Application/Controller/controller.'.$this->controller.'.php';
$this->logger->log('Loading controller '.$class.' from file: '.$file);
// Check if the file exists
if(file_exists($file)){
if(!class_exists($class))
require $file;
$this->callable = new $class($this->core);
// Check if method exists or if there is a caller function
if(method_exists($this->callable, $this->function) || method_exists($this->callable, '__call')){
// Execute the function on the controller
$this->callable->{$this->function}($this->parameters);
}else{
// Function could not be found
$this->logger->log('Could not find function '.$this->function.' on controller '.$class);
$this->error->http_error(404);
}
}else{
// Controller could not be found
$this->logger->log('Could not find controller '.$class);
$this->logger->http_error(404);
}
}
}
?>

1
Modules/databasemodel/class.model.php
View File

@ -3,7 +3,6 @@
namespace Module;
use \FuzeWorks\Module;
use \FuzeWorks\ModelServer;
use \Exception;
class DatabaseModel extends Module implements ModelServer {

156
Modules/router/class.router.php
View File

@ -1,156 +0,0 @@
<?php
use \FuzeWorks\Module;
class Router extends Module {
public $controller = null;
public $controllerName = null;
public $function = null;
public $route = array();
public $parameters = array();
public $directory;
public $path;
public function __construct(&$core) {
parent::__construct($core);
}
public function onLoad() {}
public function setPath($path) {
if (substr($path, -1, 1) == '/')
$path = substr($path, 0, strlen($path)-1);
return $this->path = $path;
}
public function getPath() {
return $this->path;
}
public function getRoute($index = null) {
if ($index === null)
return $this->route;
return $this->route[$index];
}
public function getParameters() {
return $this->parameters;
}
public function getParameter($index = 0) {
$parameters = $this->getParameters();
return ($index >= 0 ? $parameters[$index] : $parameters[count($parameters)+$index]);
}
/**
* Extracts the routing path to controller, function and parameters
*
* Path structure: /controller/function/par1/par2...
*/
public function route(){
// Retrieve the path and convert it to a proper format
$path = (!empty($this->getPath()) ? explode('/', preg_replace('#/+#','/',$this->getPath())) : array());
$path_size = count($path);
// If trailing slash was given or the last element was empty: remove it
if(end($path) == ''){
array_pop($path);
}
// Perform a routing check
// Prepare CONTROLLER, FUNCTION and PARAMS variables
$CONTROLLER = "";
$FUNCTION = "";
$PARAMS = array();
// First check if anything is given
if ($path_size >= 1) {
$CONTROLLER = $path[0];
if ($path_size >= 2) {
$FUNCTION = $path[1];
if ($path_size >= 3) {
$PARAMS = array_slice($path, 2);
}
}
} else {
// Default controller, default function, no arguments
$CONTROLLER = 'standard';
}
// Fire the event to notify our modules
$event = $this->events->fireEvent('routerRouteEvent', $CONTROLLER, $FUNCTION, $PARAMS);
// The event has been cancelled
if($event->isCancelled()){
return;
}
// Assign everything to the object to make it accessible, but let modules check it first
$this->route = $path;
$this->controllerName = ($event->controller === null || empty($event->controller) ? $this->config->main->default_controller : $event->controller);
$this->function = ($event->function === null || empty($event->function) ? $this->config->main->default_function : $event->function);
$this->parameters = $event->parameters;
$this->directory = ($event->directory === null || empty($event->directory) ? "Application/Controller/" : $event->directory);
}
/**
* Load a controller
* @access public
*/
public function loadController() {
// Initate the controllerLoadEvent
$event = $this->events->fireEvent('controllerLoadEvent',
$this->route,
$this->controllerName,
$this->function,
$this->parameters,
$this->directory
);
$this->route = ($event->route === null ? $this->route : $event->route);
$this->controllerName = ($event->controllerName === null ? $this->controllerName : $event->controllerName);
$this->function = ($event->function === null ? $this->function : $event->function);
$this->parameters = ($event->parameters === null ? $this->parameters : $event->parameters);
$this->directory = ($event->directory === null ? $this->directory : $event->directory);
$file = $this->directory . "controller.".strtolower($this->controllerName).".php";
$this->logger->log("Loading controller from file: '".$file."'");
if (file_exists($file)) {
if (!class_exists(ucfirst($this->controllerName)))
require_once($file);
$this->controllerClass = "\Controller\\" . ucfirst($this->controllerName);
$this->controller = new $this->controllerClass($this->core);
if (method_exists($this->controller, $this->function) || method_exists($this->controller, '__call')) {
$this->controller->{$this->function}($this->parameters);
} elseif (method_exists($this->controller, 'not_found')) {
// Trying last resort
$this->logger->log("Function was not found, trying Controllers not_found function");
// Add the function to the parameters just because it's usefull
array_unshift($this->parameters, $this->function);
$this->controller->not_found($this->parameters);
} else {
$this->logger->logError("Could not load not_found function. Aborting");
// totally not found
}
} else {
$this->logger->logError("Could not find class. Reverting to default controller not_found");
$file = $this->directory . "controller.".strtolower($this->config->main->default_controller).".php";
if (file_exists($file))
require_once($file);
$this->controllerClass = ucfirst($this->config->main->default_controller);
$this->controller = new $this->controllerClass($this->core);
// Add the function to the parameters just because it's usefull
array_unshift($this->parameters, $this->function);
$this->controller->not_found($this->parameters);
}
}
}
?>

2
Modules/sections/moduleInfo.php
View File

@ -18,5 +18,5 @@ return array(
'date_created' => '29-04-2015',
'date_updated' => '29-04-2015',
'enabled' => true,
'enabled' => false,
);

1
build.xml
View File

@ -15,6 +15,7 @@
<arg line="--configuration phpunit.xml
--log-junit build/logs/phpunit.xml
--coverage-clover build/logs/clover.xml
--coverage-text=coverage.txt
--coverage-html build/clover" />
</exec>
</target>

2
index.php
View File

@ -5,9 +5,7 @@ require_once( dirname(__FILE__) . "/Core/System/class.core.php");
// Load it
$core = new \FuzeWorks\Core();
$core->init();
$core->loadMod('router');
$core->mods->router->setPath( (isset($_GET['path']) ? $_GET['path'] : null) );
$core->mods->router->route();
$core->mods->router->loadController();
?>

126
tests/core_routerTest.php Normal file
View File

@ -0,0 +1,126 @@
<?php
/**
* Class RouterTest
*
* This test will test the router
*/
class RouterTest extends CoreTestAbstract
{
public function testParsePath(){
$core = $this->createCore();
// Act and assert
$core->mods->router->setPath('a/b/c/d/');
$this->assertEquals('a/b/c/d', $core->mods->router->getPath());
$core->mods->router->setPath('//a//b//c');
$this->assertEquals('a/b/c', $core->mods->router->getPath());
$core->mods->router->setPath('/');
$this->assertEquals('', $core->mods->router->getPath());
$core->mods->router->setPath('');
$this->assertEquals('', $core->mods->router->getPath());
$core->mods->router->setPath(false);
$this->assertEquals('', $core->mods->router->getPath());
$core->mods->router->setPath(null);
$this->assertEquals('', $core->mods->router->getPath());
}
/**
* @depends testParsePath
*/
public function testDoRoute(){
$core = $this->createCore();
// Act
$core->mods->router->setPath('a/b/c/d/');
$core->mods->router->route(false);
// Assert
// Whole route
$this->assertEquals(array('a','b',array('c','d')), array($core->mods->router->getController(), $core->mods->router->getFunction(), $core->mods->router->getParameters()));
$this->assertEquals('a', $core->mods->router->getController());
$this->assertEquals('d', $core->mods->router->getParameter(-1));
$this->assertEquals(null, $core->mods->router->getParameter(5));
// Parameters
$this->assertEquals(array('c','d'), $core->mods->router->getParameters());
$this->assertEquals('c', $core->mods->router->getParameter(0));
$this->assertEquals('d', $core->mods->router->getParameter(-1));
// Function and controller
$this->assertEquals('a', $core->mods->router->getController());
$this->assertEquals('b', $core->mods->router->getFunction());
}
/**
* @depends testDoRoute
*/
public function testOddRoutes(){
$core = $this->createCore();
// Empty path
$core->mods->router->setPath(null);
$core->mods->router->route(false);
$this->assertEquals(null, $core->mods->router->getController());
// Double slashes
$core->mods->router->setPath('a///b');
$core->mods->router->route(false);
$this->assertEquals(array('a','b'), array($core->mods->router->getController(), $core->mods->router->getFunction()));
// Escaped path path
$core->mods->router->setPath('/a\/b\/c/');
$core->mods->router->route(false);
$this->assertEquals(array('a\\','b\\','c'), array($core->mods->router->getController(), $core->mods->router->getFunction(), $core->mods->router->getParameter(0)));
$this->assertNotEquals('a', $core->mods->router->getController());
}
public function testCustomRoute(){
$core = $this->createCore();
$core->mods->router->addRoute('/test1/test2/', 'callable');
$this->assertArraySubset(array('/test1/test2/' => 'callable'), $core->mods->router->getRoutes());
$core->mods->router->setPath('test1/test2');
$core->mods->router->route(false);
$this->assertEquals(array('test1', 'test2'), array($core->mods->router->getController(), $core->mods->router->getFunction()));
}
public function testCustomRouteWithParameters(){
$core = $this->createCore();
$core->mods->router->addRoute('/^b\/(?P<controller>[^\/]+)\/?(?P<function>.+?)$/', 'callable');
$core->mods->router->addRoute('/e\/(?P<function>[^\/]+)/', 'callable');
$core->mods->router->addRoute('/b\/b$/', 'callable');
$core->mods->router->setPath('b/controller_a/function_a');
$core->mods->router->route(false);
$this->assertEquals('controller_a', $core->mods->router->getController());
$this->assertEquals('function_a', $core->mods->router->getFunction());
$core->mods->router->setPath('e/function_b/c');
$core->mods->router->route(false);
$this->assertEquals(null, $core->mods->router->getController());
$this->assertEquals('function_b', $core->mods->router->getFunction());
$core->mods->router->setPath('b/b');
$core->mods->router->route(false);
$this->assertEquals(null, $core->mods->router->getController());
$this->assertEquals(null, $core->mods->router->getFunction());
$core->mods->router->setPath('a/b');
$core->mods->router->route(false);
$this->assertEquals('a', $core->mods->router->getController());
$this->assertEquals('b', $core->mods->router->getFunction());
}
}

82
tests/event_routerLoadCallableEventTest.php Normal file
View File

@ -0,0 +1,82 @@
<?php
/**
* Class RouterLoadCallableEventTest
*/
class RouterLoadCallableEventTest extends CoreTestAbstract{
/**
* Check if the event is fired when it should be
*/
public function test_basic(){
$core = $this->createCore();
$mock = $this->getMock('MockEvent', array('mockMethod'));
$mock->expects($this->once())->method('mockMethod')->with(
$this->isInstanceOf('\routerLoadCallableEvent')
);
$core->mods->events->addListener(array($mock, 'mockMethod'), 'routerLoadCallableEvent', \FuzeWorks\EventPriority::NORMAL);
//Prevent ouputting HTML
ob_start();
$core->mods->router->route();
ob_end_clean();
}
/**
* Intercept and change
* @todo Make this test correct
*/
public function test_change(){
$core = $this->createCore();
$core->mods->events->addListener(array($this, 'listener_change'), 'routerLoadCallableEvent', \FuzeWorks\EventPriority::NORMAL);
$core->mods->router->setPath('x/y/z');
ob_start();
$core->mods->router->route(true);
ob_end_clean();
$this->assertNotNull($core->mods->router->getCallable());
$this->assertInstanceOf('\FuzeWorks\Router', $core->mods->router->getCallable()[0]);
}
// Change title from new to other
public function listener_change(\routerLoadCallableEvent $event){
// This controller should not exist
$this->assertEquals('x', $event->controller);
$this->assertEquals('y', $event->function);
// It should exist now
$event->controller = 'home';
$event->function = 'index';
}
/**
* Cancel events
*/
public function test_cancel(){
// When the callable may execute, the callable will change to the controller
// (because '' will trigger the default callable')
$core = $this->createCore();
$core->mods->router->setPath('');
$core->mods->events->addListener(array($this, 'listener_cancel'), 'routerLoadCallableEvent', \FuzeWorks\EventPriority::NORMAL);
$core->mods->router->route();
$this->assertTrue(is_callable($core->mods->router->getCallable()));
// When disabled, the default controller will be loaded and the callable will be overwritten
$core = $this->createCore();
$core->mods->router->setPath('');
$core->mods->router->route();
$this->assertFalse(is_callable($core->mods->router->getCallable()));
}
// Cancel all calls
public function listener_cancel(\routerLoadCallableEvent $event){
$event->setCancelled(true);
}
}

45
tests/event_routerRouteEventTest.php Normal file
View File

@ -0,0 +1,45 @@
<?php
/**
* Class RouterRouteEventTest
*/
class RouterRouteEventTest extends CoreTestAbstract{
/**
* Check if the event is fired when it should be
*/
public function test_basic(){
$core = $this->createCore();
$mock = $this->getMock('MockEvent', array('mockMethod'));
$mock->expects($this->once())->method('mockMethod')->with(
$this->isInstanceOf('\routerRouteEvent')
);
$core->mods->events->addListener(array($mock, 'mockMethod'), 'routerRouteEvent', \FuzeWorks\EventPriority::NORMAL);
$core->mods->router->setPath('a/b/c');
$core->mods->router->route(false);
}
/**
* Cancel events
*/
public function test_cancel(){
$core = $this->createCore();
$core->mods->router->setPath('a/b/c');
$core->mods->events->addListener(array($this, 'listener_cancel'), 'routerRouteEvent', \FuzeWorks\EventPriority::NORMAL);
$core->mods->router->route(false);
$this->assertNotEquals('a', $core->mods->router->getController());
$this->assertNotEquals('b', $core->mods->router->getFunction());
$this->assertNotEquals(array('c'), $core->mods->router->getParameters());
}
// Cancel all calls
public function listener_cancel(\System\Events\routerRouteEvent $event){
$event->setCancelled(true);
}
}

83
tests/event_routerRouterSetPathEventTest.php Normal file
View File

@ -0,0 +1,83 @@
<?php
/**
* Class RouterSetPathEventTest
*/
class RouterSetPathEventTest extends CoreTestAbstract{
/**
* Check if the event is fired when it should be
*/
public function testRouterSetPathEvent(){
$core = $this->createCore();
$mock = $this->getMock('MockEvent', array('mockMethod'));
$mock->expects($this->once())->method('mockMethod')->with(
$this->isInstanceOf('\routerSetPathEvent')
);
$core->mods->events->addListener(array($mock, 'mockMethod'), 'routerSetPathEvent', \FuzeWorks\EventPriority::NORMAL);
$core->mods->router->setPath('a/b/c');
}
/**
* Intercept and change
*/
public function testRouterSetPathEvent_change(){
$core = $this->createCore();
$core->mods->events->addListener(array($this, 'listener_change'), 'routerSetPathEvent', \FuzeWorks\EventPriority::NORMAL);
$core->mods->router->setPath('a/b/c');
$this->assertEquals('x/y/z', $core->mods->router->getPath());
}
// Change title from new to other
public function listener_change(\routerSetPathEvent $event){
$this->assertEquals('a/b/c', $event->path);
$event->path = 'x/y/z';
}
/**
* Cancel events
*/
public function testLayoutFunctionCallEvent_cancel(){
$core = $this->createCore();
$core->mods->router->setPath('a/b/c');
$core->mods->events->addListener(array($this, 'listener_cancel'), 'routerSetPathEvent', \FuzeWorks\EventPriority::NORMAL);
$core->mods->router->setPath('x/y/z');
$this->assertEquals('a/b/c', $core->mods->router->getPath());
}
// Cancel all calls
public function listener_cancel(\routerSetPathEvent $event){
$event->setCancelled(true);
}
/**
* Do not cancel events
*/
public function testLayoutFunctionCallEvent_dontcancel(){
$core = $this->createCore();
$core->mods->router->setPath('a/b/c');
$core->mods->events->addListener(array($this, 'listener_dontcancel'), 'routerSetPathEvent', \FuzeWorks\EventPriority::NORMAL);
$core->mods->router->setPath('x/y/z');
$this->assertEquals('x/y/z', $core->mods->router->getPath());
}
// Cancel all calls
public function listener_dontcancel(\routerSetPathEvent $event){
$event->setCancelled(false);
}
}