/**
* Parse name to determine template folder and filename.
*/
protected function parse()
{
$parts = explode('::', $this->name);
if (count($parts) === 1) {
if (is_null($this->engine->getDirectory())) {
$this->throwParseException('The default directory has not been defined.');
}
if ($parts[0] === '') {
$this->throwParseException('The template name cannot be empty.');
}
$this->file = $parts[0];
} elseif (count($parts) === 2) {
if ($parts[0] === '') {
$this->throwParseException('The folder name cannot be empty.');
}
if ($parts[1] === '') {
$this->throwParseException('The template name cannot be empty.');
}
if (!$this->engine->getFolders()->exists($parts[0])) {
$this->throwParseException('The folder "' . $parts[0] . '" does not exist.');
}
$this->folder = $this->engine->getFolders()->get($parts[0]);
$this->file = $parts[1];
} else {
$this->throwParseException('Do not use the folder namespace seperator "::" more than once.');
}
}
public function __invoke(array $input)
{
$name = 'index';
if (!empty($input['name'])) {
$name = $input['name'];
}
// $filename = APPPATH . 'templates/static/' . $name;
// if (file_exists($filename)) {
// echo "The file $filename does not exist";
// die('the file does not exist');
// }
// Create new Plates instance
$plates = new Engine(APPPATH . 'templates');
// Register extension
$plates->loadExtension(new Utils());
// Check static page or partial exists
if ($plates->exists('static/' . $name)) {
// Render a template
$template = $plates->render('static/' . $name);
} else {
header("HTTP/1.0 404 Not Found");
echo "PHP continues.\n";
echo "Not after a die, however.\n";
die;
}
// return
return (new Payload())->withStatus(Payload::OK)->withOutput(['hello' => $template]);
}
protected function setUp()
{
$plates = new Engine(__DIR__ . '/Resources/views');
$plates->setFileExtension(null);
$plates->addData(['foo' => 'bar']);
$this->engine = new PlatesEngineAdapter($plates);
}
/**
* {@inheritDoc}
*/
public function register()
{
$container = $this->getContainer();
// route map which contains routes for lookup
$container->singleton(Router\RouteMap::class, function () {
return new Router\RouteMap();
});
// handles errors in the life-cycle
$container->singleton(Handler\ErrorInterface::class, function () {
return new Handler\Error();
});
// handles not found errors in the life-cycle
$container->singleton(Handler\NotFoundInterface::class, function () {
return new Handler\NotFound();
});
// plates engine
$container->singleton(Engine::class, function () use($container) {
$engine = new Engine(__DIR__ . '/../view');
$engine->registerFunction('url', new View\Plates\UrlFunction($container->get(Router\RouteMap::class)));
return $engine;
});
// view manager
$container->singleton(View\Manager::class, function () use($container) {
return new View\Manager(new View\PlatesStrategy($container->get(Engine::class)));
});
// router
$container->add(Router\Router::class, function () use($container) {
return new Router\Router($container->get(Router\RouteMap::class));
});
}
/**
* Register extension functions.
* @return null
*/
public function register(Engine $engine)
{
$engine->registerFunction('fh_default_val', array($this, 'fhDefaultVal'));
$engine->registerFunction('fh_input_select', array($this, 'fhInputSelect'));
$engine->registerFunction('fh_error_css_class', array($this, 'fhErrorCssClass'));
$engine->registerFunction('fh_show_errors', array($this, 'fhShowErrors'));
}
/**
* PlatesProvider constructor.
* @param Engine $plates
* @param string $root_path
* @param string $namespace
*/
public function __construct(Engine $plates, $root_path, $namespace)
{
$this->plates = $plates;
$this->namespace = $namespace;
if (!$plates->getFolders()->exists($namespace)) {
$plates->addFolder($namespace, $root_path);
}
}
/**
* @param Engine $engine
*/
public function register(Engine $engine)
{
// Load the built in URI extension
$engine->loadExtension(new URI($this->request->getPathInfo()));
// Custom methods
$engine->registerFunction('route', [$this, 'route']);
$engine->registerFunction('asset', [$this, 'asset']);
}
private function plates()
{
$league = new Plates\Engine(APP . 'views');
$league->setFileExtension('tpl');
$league->loadExtension(new Plates\Extension\URI(trim(strtok(str_replace($_SERVER['SCRIPT_NAME'], '', $_SERVER['REQUEST_URI']), '?'), '/')));
$league->loadExtension(new MY\Plates\Extension());
return $league;
}
/**
* Handler.
*
* @param ServerRequestInterface $request
* @param ResponseInterface $response
*
* @return ResponseInterface
*/
public function __invoke(ServerRequestInterface $request, ResponseInterface $response)
{
$page = $request->getAttribute('page', '/index');
$content = $this->contentLoader->getContent($page);
$template = $content->getMetadataEntry('template');
$params = array_merge($content->getMetadata(), ['html' => $content->getHtml()]);
$response->getBody()->write($this->plates->render($template, $params));
return $response->withHeader('Content-Type', 'text/html');
}
public function prepareEngine(Engine $engine)
{
// set file extension
// $engine->setFileExtension('php');
// Add folders
$engine->addFolder('templates', APPPATH . 'templates');
$engine->addFolder('partials', APPPATH . 'templates/partials');
$engine->addFolder('staticpages', APPPATH . 'templates/staticpages');
}
/**
* @param $template
* @return bool
*/
public function __invoke($template)
{
//
$template = $this->getPlatesPath($template);
// get the HTML for whatever is going on
echo $this->engine->render($template);
// because we echo'd already, we return false so it's not double-echo'd by wordpress'
// default `include $template` statement
return false;
}
public function __invoke(array $config)
{
$theme = $config['theme'];
$templateEngine = new Engine();
$templateEngine->addFolder('app', 'templates');
$templateEngine->addFolder('theme', 'public/themes/' . $theme . '/templates');
$templateEngine->setFileExtension('phtml');
$templateEngine->loadExtensions([new AssetExt('public', true), new ThemeAssetExt('themes/' . $theme . '/assets')]);
return new Application($config, new PlatesTemplateRenderer($templateEngine));
}
public function register()
{
$this->container->add('service.http.request', function () {
return Request::createFromGlobals();
});
$this->container->add('service.http.route', function () {
$route = new Route($this->container);
foreach ($this->container->get('config')['http']['routes'] as $item) {
$route->addRoute(strtoupper($item['method']), $item['path'], $item['target']);
}
return $route;
});
$this->container->add('Symfony\\Component\\HttpFoundation\\Request', function () {
return $this->container->get('service.http.request');
});
$this->container->add('service.view.view', function () {
$view = new View();
foreach ($this->container->get('config')['http']['views_path'] as $name => $path) {
$view->addFolder($name, $path);
}
$request = $this->container->get('service.http.request');
$view->loadExtension(new RequestExtension($request));
$view->loadExtension(new FlashBagExtension($request->getSession()->getFlashBag()));
$view->loadExtension(new BaseUrlExtension($request->getBasePath()));
$assetBaseUrl = $this->container->get('config')['asset_base_url'];
$view->loadExtension(new AssetUrlExtension($assetBaseUrl));
if ($this->container->get('service.account.auth')->hasAuthenticatedUser()) {
$authenticatedUser = $this->container->get('service.account.auth')->getAuthenticatedUser();
$view->loadExtension(new AuthenticatedUserExtension($authenticatedUser));
}
$view->addData(['applicationName' => $this->container->get('config')['application_name']]);
return $view;
});
}
public function getInstance()
{
if (!$this->_engineInstance) {
// Create new Plates engine
$this->_engineInstance = new PlatesEngine($this->getTemplatesDirectory());
if ($this->fileExtension) {
$this->_engineInstance->setFileExtension($this->fileExtension);
}
}
return $this->_engineInstance;
}
public function __construct()
{
$this->setUrl(env('APP_URL'));
$this->pipe(Middleware::formatNegotiator());
$this->pipe(Middleware::whoops());
$this->source(new StaticFiles('build/**/*'))->build(false);
$this->source(new StaticFiles('source/img/**/*', '/img/**/*'));
$plates = new Engine('source/templates');
$plates->addData(['app' => $this]);
$this->source(new YamlFiles('source/data/*.yml'))->templates($plates);
}
/**
* @param string $type
* @return string
*/
public function render($type = null)
{
$templates = new Engine($this->viewPath);
if ($type === null) {
if ($this->media === false) {
$type = 'media';
} else {
$type = 'thumbnail';
}
}
return $templates->render($type, $this->toArray());
}
/**
* Create instance
*
* @return Engine
*/
public function create(Request $request)
{
$engine = new Engine($this->options['view_path'], null);
// Add folder shortcut (assets::file.js)
$engine->addFolder('assets', $this->options['assets_path']);
$engine->addFolder('view', $this->options['view_path']);
$session = $request->getAttribute(SessionMiddleware::ATTRIBUTE);
$baseUrl = $request->getAttribute('base_url');
// Register Asset extension
$cacheOptions = array('cachepath' => $this->options['cache_path'], 'cachekey' => $session->get('user.locale'), 'baseurl' => $baseUrl, 'minify' => $this->options['minify']);
$engine->loadExtension(new \Odan\Plates\Extension\AssetCache($cacheOptions));
return $engine;
}
public function register(Fol $app)
{
$app['templates'] = function ($app) {
$root = dirname(dirname(__DIR__));
$templates = new Engine($root . '/templates');
$icons = new Collection(new MaterialDesignIcons($root . '/assets/icons'));
$templates->addData(['app' => $app]);
$templates->registerFunction('icon', function ($name) use($icons) {
return $icons->get($name);
});
return $templates;
};
}
protected function getTemplates()
{
if (!self::$templates) {
// Create new Plates engine
self::$templates = new Engine(__DIR__ . '/../../views', 'tpl');
self::$templates->registerFunction('substr', function ($string, $start, $length) {
return substr($string, $start, $length);
});
self::$templates->registerFunction('cleanWikiSyntax', function ($string) {
return preg_replace("/\\[(wiki|url)\\=(?P<url>https?:\\/\\/[^\\]]*)\\](?P<text>[^\\[]*)\\[\\/(wiki|url)\\]/i", "\$3", $string);
});
}
return self::$templates;
}
public function register(App $glue)
{
$glue->singleton('League\\Plates\\Engine', function ($glue) {
if (!$glue->config->exists('plates.path')) {
// We need a default template folder
throw new \Exception("You must configure the plates.path");
}
$engine = new Engine($glue->config->get('plates.path'));
// Register some extensions
$engine->loadExtension($glue->make('Glue\\Plates\\Extensions\\UrlHelpers'));
return $engine;
});
$glue->alias('League\\Plates\\Engine', 'plates');
}
/**
* @param BatchManager $batches
* @param ServerRequestInterface $request
* @param string $task
*
* @return View
*/
public function index(BatchManager $batches, ServerRequestInterface $request, $task = 'custom')
{
// Interactive mode
$query = $request->getQueryParams();
if (array_key_exists('interactive', $query)) {
$this->configuration['tasks'] = $query['interactive'];
}
$task = $this->getTask($task);
$sync = array_get($query, 'sync');
$method = $sync ? 'runTask' : 'getCommandsFrom';
$commands = $this->runner->{$method}($task);
// Store commands for retrieval
$hash = $batches->set($commands);
return $this->views->render('index', ['tasks' => $commands, 'hash' => $hash, 'url' => $this->configuration->get('url')]);
}
/**
* Render the template.
*
* @param string $name
* @param string[] $data
*
* @throws \LogicException
*
* @return \Psr\Http\Message\ResponseInterface
*/
public function render($name, array $data = [])
{
if (!isset($this->response)) {
throw new \LogicException(sprintf('Invalid %s object instance', ResponseInterface::class));
}
return $this->response->write($this->plates->render($name, $data));
}
/**
* Get a Plates engine
*
* @return \League\Plates\Engine
*/
public function getInstance()
{
if (!$this->engineInstance) {
// Create new Plates engine
$this->engineInstance = new \League\Plates\Engine($this->templatesPath ?: $this->getTemplatesDirectory());
if ($this->fileExtension) {
$this->engineInstance->setFileExtension($this->fileExtension);
}
if (count($this->templatesFolders)) {
foreach ($this->templatesFolders as $name => $path) {
$this->engineInstance->addFolder($name, $path);
}
}
}
return $this->engineInstance;
}
/**
* Return the internal array of plates folders.
*
* @return \League\Plates\Template\Folder[]
*/
private function getPlatesFolders()
{
$folders = $this->template->getFolders();
$r = new ReflectionProperty($folders, 'folders');
$r->setAccessible(true);
return $r->getValue($folders);
}
/**
* Get the default templates directory.
* @return string
*/
protected function getDefaultDirectory()
{
$directory = $this->engine->getDirectory();
if (is_null($directory)) {
throw new LogicException('The template name "' . $this->name . '" is not valid. ' . 'The default directory has not been defined.');
}
return $directory;
}
public function render($name, $data = [], $echo = false)
{
$data["layoutName"] = $this->getLayoutName();
$data["crud"] = $this;
$html = $this->template->render($name, $data);
if ($echo) {
echo $html;
}
return $html;
}
/**
* Get an instance of the Plates Engine
*
* @return \League\Plates\Engine
*/
public function getInstance()
{
if (!$this->engineInstance) {
$this->engineInstance = new Engine($this->templatesPath ?: $this->getTemplatesDirectory());
if ($this->fileExtension) {
$this->engineInstance->setFileExtension($this->fileExtension);
}
if (count($this->templatesFolders) > 0) {
foreach ($this->templatesFolders as $name => $path) {
$this->engineInstance->addFolder($name, $path);
}
}
if (count($this->parserExtensions) > 0) {
foreach ($this->parserExtensions as $extension) {
$this->engineInstance->loadExtension($extension);
}
}
}
return $this->engineInstance;
}
/**
* Apply multiple functions to variable.
* @param mixed $var
* @param string $functions
* @return mixed
*/
protected function batch($var, $functions)
{
foreach (explode('|', $functions) as $function) {
if ($this->engine->doesFunctionExist($function)) {
$var = call_user_func(array($this, $function), $var);
} elseif (is_callable($function)) {
$var = call_user_func($function, $var);
} else {
throw new LogicException('The batch function could not find the "' . $function . '" function.');
}
}
return $var;
}
/**
* Plates paths loader.
*/
protected function getLoader() : LeagueEngine
{
if (!$this->engine) {
$config = $this->config;
$this->engine = new LeagueEngine($config['template']['default'] ?? null, $config['engine']['plates']['file_extension'] ?? null);
if (($paths = $config['template']['paths'] ?? null) !== null) {
foreach ($paths as $name => $addPaths) {
$this->engine->addFolder($name, $addPaths);
}
}
}
return $this->engine;
}
protected function setUp()
{
$engine = new Engine(dirname(__DIR__) . '/Fixtures');
$this->plates = new Template($engine->setFileExtension(null));
$this->engine = new PlatesEngine($this->plates);
$this->template = 'foobar.plates.php';
}
