539 lines
18 KiB
PHP
539 lines
18 KiB
PHP
<?php
|
|
/**
|
|
* FuzeWorks Framework Layout Template System.
|
|
*
|
|
* The FuzeWorks PHP FrameWork
|
|
*
|
|
* Copyright (C) 2013-2018 TechFuze
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*
|
|
* @author TechFuze
|
|
* @copyright Copyright (c) 2013 - 2018, TechFuze. (http://techfuze.net)
|
|
* @license https://opensource.org/licenses/MIT MIT License
|
|
*
|
|
* @link http://techfuze.net/fuzeworks
|
|
* @since Version 0.0.1
|
|
*
|
|
* @version Version 1.2.0
|
|
*/
|
|
|
|
|
|
namespace FuzeWorks;
|
|
|
|
use FuzeWorks\Event\LayoutLoadEvent;
|
|
use FuzeWorks\TemplateEngine\{JsonEngine,PHPEngine,SmartyEngine,LatteEngine,TemplateEngine};
|
|
use FuzeWorks\Exception\LayoutException;
|
|
use FuzeWorks\Exception\EventException;
|
|
|
|
/**
|
|
* Layout and Template Manager for FuzeWorks.
|
|
*
|
|
* @author Abel Hoogeveen <abel@techfuze.net>
|
|
* @copyright Copyright (c) 2013 - 2018, TechFuze. (http://techfuze.net)
|
|
*/
|
|
class Layout
|
|
{
|
|
|
|
/**
|
|
* @var Factory
|
|
*/
|
|
protected $factory;
|
|
|
|
/**
|
|
* The file to be loaded by the layout manager.
|
|
*
|
|
* @var null|string
|
|
*/
|
|
public $file = null;
|
|
|
|
/**
|
|
* The directory of the file to be loaded by the layout manager.
|
|
*
|
|
* @var string
|
|
*/
|
|
public $directory;
|
|
|
|
/**
|
|
* All assigned currently assigned to the template.
|
|
*
|
|
* @var array Associative Assigned Variable Array
|
|
*/
|
|
protected $assigned_variables = array();
|
|
|
|
/**
|
|
* All engines that can be used for templates.
|
|
*
|
|
* @var array of engines
|
|
*/
|
|
protected $engines = array();
|
|
|
|
/**
|
|
* All file extensions that can be used and are bound to a template engine.
|
|
*
|
|
* @var array of names of engines
|
|
*/
|
|
protected $file_extensions = array();
|
|
|
|
/**
|
|
* whether the template engines are already called.
|
|
*
|
|
* @var bool True if loaded
|
|
*/
|
|
protected $engines_loaded = false;
|
|
|
|
/**
|
|
* The currently selected template engine.
|
|
*
|
|
* @var string name of engine
|
|
*/
|
|
protected $current_engine;
|
|
|
|
/**
|
|
* Standard Component method for initializing components after adding extensions
|
|
*/
|
|
public function init()
|
|
{
|
|
$this->factory = Factory::getInstance();
|
|
$this->directory = Core::$appDirs[0] . DS .'Layout';
|
|
}
|
|
|
|
/**
|
|
* Retrieve a template file using a string and a directory and immediatly parse it to the output class.
|
|
*
|
|
* What template file gets loaded depends on the template engine that is being used.
|
|
* PHP for example uses .php files. Providing this function with 'home/dashboard' will load the home/layout.dashboard.php file.
|
|
* You can also provide no particular engine, and the manager will decide what template to load.
|
|
* Remember that doing so will result in a LayoutException when multiple compatible files are found.
|
|
*
|
|
* @param string $file File to load
|
|
* @param string $directory Directory to load it from
|
|
*
|
|
* @return mixed
|
|
* @throws LayoutException On error
|
|
* @throws EventException
|
|
*/
|
|
public function display($file, $directory = null)
|
|
{
|
|
$directory = (is_null($directory) ? $this->directory : $directory);
|
|
$contents = $this->get($file, $directory);
|
|
|
|
$event = Events::fireEvent('layoutDisplayEvent', $contents, $file, $directory);
|
|
if (!$event->isCancelled())
|
|
echo $event->contents;
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Retrieve a template file using a string and a directory.
|
|
*
|
|
* What template file gets loaded depends on the template engine that is being used.
|
|
* PHP for example uses .php files. Providing this function with 'home/dashboard' will load the home/layout.dashboard.php file.
|
|
* You can also provide no particular engine, and the manager will decide what template to load.
|
|
* Remember that doing so will result in a LayoutException when multiple compatible files are found.
|
|
*
|
|
* @param string $file File to load
|
|
* @param string $directory Directory to load it from
|
|
*
|
|
* @return string The output of the template
|
|
* @throws LayoutException On error
|
|
*/
|
|
public function get($file, $directory = null): string
|
|
{
|
|
$directory = (is_null($directory) ? $this->directory : $directory);
|
|
Logger::newLevel("Loading template file '".$file."' in '".$directory."'");
|
|
|
|
// First load the template engines
|
|
$this->loadTemplateEngines();
|
|
|
|
// First retrieve the filePath
|
|
if (is_null($this->current_engine)) {
|
|
$this->setFileFromString($file, $directory, array_keys($this->file_extensions));
|
|
} else {
|
|
$this->setFileFromString($file, $directory, $this->current_engine->getFileExtensions());
|
|
}
|
|
|
|
// Then assign some basic variables for the template
|
|
$main_config = $this->factory->config->get('main');
|
|
$this->assigned_variables['wwwDir'] = $main_config->base_url;
|
|
$this->assigned_variables['siteURL'] = $main_config->base_url;
|
|
$this->assigned_variables['serverName'] = $main_config->server_name;
|
|
$this->assigned_variables['adminMail'] = $main_config->administrator_mail;
|
|
// @TODO: Implement csrfTokenName and csrfHash from security under layoutLoadEvent
|
|
|
|
// Select an engine if one is not already selected
|
|
if (is_null($this->current_engine)) {
|
|
$this->current_engine = $this->getEngineFromExtension($this->getExtensionFromFile($this->file));
|
|
}
|
|
|
|
$this->current_engine->setDirectory($this->directory);
|
|
|
|
// And run an Event to see what other parts have to say about it
|
|
try {
|
|
/** @var LayoutLoadEvent $event */
|
|
$event = Events::fireEvent('layoutLoadEvent', $this->file, $this->directory, $this->current_engine, $this->assigned_variables);
|
|
// @codeCoverageIgnoreStart
|
|
} catch (EventException $e) {
|
|
throw new LayoutException("layoutEvent threw exception: '".$e->getMessage()."''", 1);
|
|
// @codeCoverageIgnoreEnd
|
|
}
|
|
|
|
// The event has been cancelled
|
|
if ($event->isCancelled()) {
|
|
return 'cancelled';
|
|
}
|
|
|
|
// And refetch the data from the event
|
|
$this->current_engine = $event->engine;
|
|
$this->assigned_variables = $event->assigned_variables;
|
|
|
|
Logger::stopLevel();
|
|
|
|
// And finally run it
|
|
if (file_exists($event->file)) {
|
|
return $this->current_engine->get($event->file, $this->assigned_variables);
|
|
}
|
|
|
|
throw new LayoutException('The requested file was not found', 1);
|
|
}
|
|
|
|
/**
|
|
* Retrieve a Template Engine from a File Extension.
|
|
*
|
|
* @param string $extension File extention to look for
|
|
*
|
|
* @return TemplateEngine
|
|
* @throws LayoutException
|
|
*/
|
|
public function getEngineFromExtension($extension): TemplateEngine
|
|
{
|
|
if (isset($this->file_extensions[strtolower($extension)])) {
|
|
return $this->engines[ $this->file_extensions[strtolower($extension)]];
|
|
}
|
|
|
|
throw new LayoutException('Could not get Template Engine. No engine has corresponding file extension', 1);
|
|
}
|
|
|
|
/**
|
|
* Retrieve the extension from a file string.
|
|
*
|
|
* @param string $fileString The path to the file
|
|
*
|
|
* @return string Extension of the file
|
|
*/
|
|
public function getExtensionFromFile($fileString): string
|
|
{
|
|
return substr($fileString, strrpos($fileString, '.') + 1);
|
|
}
|
|
|
|
/**
|
|
* Converts a layout string to a file using the directory and the used extensions.
|
|
*
|
|
* It will detect whether the file exists and choose a file according to the provided extensions
|
|
*
|
|
* @param string $string The string used by a controller. eg: 'dashboard/home'
|
|
* @param string $directory The directory to search in for the template
|
|
* @param array $extensions Extensions to use for this template. Eg array('php', 'tpl') etc.
|
|
*
|
|
* @return string Filepath of the template
|
|
* @throws LayoutException On error
|
|
*/
|
|
public function getFileFromString($string, $directory, $extensions = array()): string
|
|
{
|
|
$directory = preg_replace('#/+#', '/', (!is_null($directory) ? $directory : $this->directory).DS);
|
|
|
|
// @TODO Malformed strings pass. Write better function
|
|
if (strpbrk($directory, "\\/?%*:|\"<>") === TRUE || strpbrk($string, "\\/?%*:|\"<>") === TRUE)
|
|
{
|
|
// @codeCoverageIgnoreStart
|
|
throw new LayoutException('Could not get file. Invalid file string', 1);
|
|
// @codeCoverageIgnoreEnd
|
|
}
|
|
|
|
if (!file_exists($directory)) {
|
|
throw new LayoutException('Could not get file. Directory does not exist', 1);
|
|
}
|
|
|
|
// Set the file name and location
|
|
$layoutSelector = explode('/', $string);
|
|
if (count($layoutSelector) == 1) {
|
|
$layoutSelector = 'layout.'.$layoutSelector[0];
|
|
} else {
|
|
// Get last file
|
|
$file = end($layoutSelector);
|
|
|
|
// Reset to start
|
|
reset($layoutSelector);
|
|
|
|
// Remove last value
|
|
array_pop($layoutSelector);
|
|
|
|
$layoutSelector[] = 'layout.'.$file;
|
|
|
|
// And create the final value
|
|
$layoutSelector = implode(DS, $layoutSelector);
|
|
}
|
|
|
|
// Then try and select a file
|
|
$fileSelected = false;
|
|
$selectedFile = null;
|
|
foreach ($extensions as $extension) {
|
|
$file = $directory.$layoutSelector.'.'.strtolower($extension);
|
|
$file = preg_replace('#/+#', '/', $file);
|
|
if (file_exists($file) && !$fileSelected) {
|
|
$selectedFile = $file;
|
|
$fileSelected = true;
|
|
Logger::log("Found matching file: '".$file."'");
|
|
} elseif (file_exists($file) && $fileSelected) {
|
|
throw new LayoutException('Could not select template. Multiple valid extensions detected. Can not choose.', 1);
|
|
}
|
|
}
|
|
|
|
// And choose what to output
|
|
if (!$fileSelected) {
|
|
throw new LayoutException('Could not select template. No matching file found.');
|
|
}
|
|
|
|
return $selectedFile;
|
|
}
|
|
|
|
/**
|
|
* Converts a layout string to a file using the directory and the used extensions.
|
|
* It also sets the file variable of this class.
|
|
*
|
|
* It will detect whether the file exists and choose a file according to the provided extensions
|
|
*
|
|
* @param string $string The string used by a controller. eg: 'dashboard/home'
|
|
* @param string $directory The directory to search in for the template
|
|
* @param array $extensions Extensions to use for this template. Eg array('php', 'tpl') etc.
|
|
*
|
|
* @throws LayoutException On error
|
|
*/
|
|
public function setFileFromString($string, $directory, $extensions = array())
|
|
{
|
|
$this->file = $this->getFileFromString($string, $directory, $extensions);
|
|
$this->directory = preg_replace('#/+#', '/', (!is_null($directory) ? $directory : $this->directory).DS);
|
|
}
|
|
|
|
/**
|
|
* Get the current file to be loaded.
|
|
*
|
|
* @return null|string Path to the file
|
|
*/
|
|
public function getFile()
|
|
{
|
|
return $this->file;
|
|
}
|
|
|
|
/**
|
|
* Set the file to be loaded.
|
|
*
|
|
* @param string $file Path to the file
|
|
*/
|
|
public function setFile($file)
|
|
{
|
|
$this->file = $file;
|
|
}
|
|
|
|
/**
|
|
* Get the directory of the file to be loaded.
|
|
*
|
|
* @return null|string Path to the directory
|
|
*/
|
|
public function getDirectory()
|
|
{
|
|
return $this->directory;
|
|
}
|
|
|
|
/**
|
|
* Set the directory of the file to be loaded.
|
|
*
|
|
* @param string $directory Path to the directory
|
|
*/
|
|
public function setDirectory($directory)
|
|
{
|
|
$this->directory = $directory;
|
|
}
|
|
|
|
/**
|
|
* Assign a variable for the template.
|
|
*
|
|
* @param string $key Key of the variable
|
|
* @param mixed $value Value of the variable
|
|
*/
|
|
public function assign($key, $value)
|
|
{
|
|
$this->assigned_variables[$key] = $value;
|
|
}
|
|
|
|
/**
|
|
* Set the title of the template.
|
|
*
|
|
* @param string $title title of the template
|
|
*/
|
|
public function setTitle($title)
|
|
{
|
|
$this->assigned_variables['title'] = $title;
|
|
}
|
|
|
|
/**
|
|
* Get the title of the template.
|
|
*
|
|
* @return string|bool title of the template
|
|
*/
|
|
public function getTitle()
|
|
{
|
|
if (!isset($this->assigned_variables['title']))
|
|
{
|
|
return false;
|
|
}
|
|
return $this->assigned_variables['title'];
|
|
}
|
|
|
|
/**
|
|
* Set the engine for the next layout.
|
|
*
|
|
* @param string $name Name of the template engine
|
|
*
|
|
* @return bool true on success
|
|
* @throws LayoutException on error
|
|
*/
|
|
public function setEngine($name): bool
|
|
{
|
|
$this->loadTemplateEngines();
|
|
if (isset($this->engines[$name])) {
|
|
$this->current_engine = $this->engines[$name];
|
|
Logger::log('Set the Template Engine to '.$name);
|
|
|
|
return true;
|
|
}
|
|
throw new LayoutException('Could not set engine. Engine does not exist', 1);
|
|
}
|
|
|
|
/**
|
|
* Get a loaded template engine.
|
|
*
|
|
* @param string $name Name of the template engine
|
|
*
|
|
* @return TemplateEngine
|
|
* @throws LayoutException
|
|
*/
|
|
public function getEngine(string $name): TemplateEngine
|
|
{
|
|
$this->loadTemplateEngines();
|
|
if (isset($this->engines[$name])) {
|
|
return $this->engines[$name];
|
|
}
|
|
throw new LayoutException('Could not return engine. Engine does not exist', 1);
|
|
}
|
|
|
|
/**
|
|
* Register a new template engine.
|
|
*
|
|
* @param TemplateEngine $engineClass Object that implements the \FuzeWorks\TemplateEngine
|
|
* @param string $engineName Name of the template engine
|
|
* @param array $engineFileExtensions File extensions this template engine should be used for
|
|
*
|
|
* @return bool true on success
|
|
* @throws LayoutException
|
|
*/
|
|
public function registerEngine(TemplateEngine $engineClass, string $engineName, array $engineFileExtensions = array()): bool
|
|
{
|
|
// First check if the engine already exists
|
|
if (isset($this->engines[$engineName]))
|
|
throw new LayoutException("Could not register engine. Engine '".$engineName."' already registered", 1);
|
|
|
|
// Install it
|
|
$this->engines[$engineName] = $engineClass;
|
|
|
|
// Then install them
|
|
foreach ($engineFileExtensions as $extension) {
|
|
if (isset($this->file_extensions[strtolower($extension)])) {
|
|
throw new LayoutException('Could not register engine. File extension already bound to engine', 1);
|
|
}
|
|
|
|
// And add it
|
|
$this->file_extensions[strtolower($extension)] = $engineName;
|
|
}
|
|
|
|
// And log it
|
|
Logger::log('Registered Template Engine: '.$engineName);
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Load the template engines by sending a layoutLoadEngineEvent.
|
|
* @throws LayoutException
|
|
* @returns bool True on loading. False when already loaded
|
|
*/
|
|
public function loadTemplateEngines(): bool
|
|
{
|
|
if (!$this->engines_loaded) {
|
|
// Fire Engine Event
|
|
try {
|
|
Events::fireEvent('layoutLoadEngineEvent');
|
|
} catch (Exception\EventException $e) {
|
|
throw new LayoutException("Could not loadTemplateEngines. layoutLoadEngineEvent threw exception: '".$e->getMessage()."''", 1);
|
|
}
|
|
|
|
// Load the engines provided in this file
|
|
// PHP Engine
|
|
$this->registerEngine(new PHPEngine(), 'PHP', array('php'));
|
|
|
|
// JSON Engine
|
|
if (extension_loaded('json'))
|
|
$this->registerEngine(new JsonEngine(), 'JSON', array('json'));
|
|
|
|
// Latte Engine
|
|
if (class_exists('\Latte\Engine', true))
|
|
$this->registerEngine(new LatteEngine(), 'Latte', array('latte'));
|
|
|
|
// Smarty Engine
|
|
if (class_exists('\Smarty', true))
|
|
$this->registerEngine(new SmartyEngine(), 'Smarty', array('tpl'));
|
|
|
|
$this->engines_loaded = true;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Resets the layout manager to its default state.
|
|
*/
|
|
public function reset()
|
|
{
|
|
if (!is_null($this->current_engine)) {
|
|
$this->current_engine->reset();
|
|
}
|
|
|
|
// Unload the engines
|
|
$this->engines = array();
|
|
$this->engines_loaded = false;
|
|
$this->file_extensions = array();
|
|
|
|
$this->current_engine = null;
|
|
$this->assigned_variables = array();
|
|
$this->directory = Core::$appDirs[0]. DS . 'Layout';
|
|
Logger::log('Reset the layout manager to its default state');
|
|
}
|
|
} |