juju-php/Data/template.class.php

<?php
	namespace Juju\Data;
	require_once(realpath(dirname(__DIR__).'/events.trait.php'));
	require_once('earray.class.php');
	use Juju\{Events, Data\EArray};
	use \Exception;

	class Template {
		use Events;
		private static $templates = [];
		public static $cachedir;
		public static $basedir = __DIR__;
		private static $tidy;
		private static $tidyConfig = [
			'indent'=>true,
			'tab-size'=>4,
			'wrap'=>0,
			'wrap-asp'=>false,
			'wrap-attributes'=>false,
			'wrap-jste'=>false,
			'wrap-php'=>false,
			'wrap-script-literals'=>false,
			'wrap-sections'=>false,
			'char-encoding'=>'utf8',
			'newline'=>'LF',
			'tidy-mark'=>true,
			'merge-divs'=>false,
			'merge-spans'=>false,
			'logical-emphasis'=>false,
			'literal-attributes'=>true
		];
		private static $regex = [
			'match'=>'/\{([^#\/?_][^}\n]*?)\}/i',
			'parentmatch'=>'/\{\.\.\/([^#\/?_][^}\n]*?)\}/i',
			'each'=>'/\{#each ([^}]*)\}([\S\s]*)\{\/each \1\}/i',
			'exist'=>'/\{#exist ([^}]*)\}([\S\s]*)\{\/exist \1\}/i',
			'existelse'=>'/\{#exist ([^}]*)\}([\S\s]*)\{#else \1\}([\S\s]*)\{\/exist \1\}/i',
			'ignore'=>'/\{#ignore\}([\S\s]*)\{\/ignore\}/i',
			'ignored'=>'/\{#ignored (\d+?)\}/i',
			'gettext'=>"/{_([^,}]+)(?:, ?([^},]+))*\}/i",
			'gettext_string'=>'/^([\'"])(.+)\1$/i',
			'echo'=>'/\{=([^}]+)\}/i',
			'eval'=>'/\{\?([\W\w\S\s]+)\?\}/i',
			'include'=>'/{#include ([^}]+)}/i'
		];
		protected static $parsers;
		private $template;
		private $name;
		private $path;
		public function __construct(string $name, string $template, bool $is_file = false){
			if(is_null(static::$parsers)){
				static::$parsers = [
					'ignore'=>function(&$output, &$ignored){
						$output = preg_replace_callback(static::$regex['ignore'], function($matches) use(&$ignored){
							$ignored[] = $matches[1];
							return '{#ignored '.(count($ignored) - 1).'}';
						}, $output);
					},
					'include'=>function(&$output, &$ignored = null){
						while(preg_match(static::$regex['include'], $output)){
							$output = preg_replace_callback(static::$regex['include'], function($matches) use(&$ignored){
								$path = static::$basedir.'/'.$matches[1];
								if(file_exists($path)){
									$output = file_get_contents($path);
									if(!is_null($ignored)){
										static::$parsers['ignore']($output, $ignored);
									}
									return $output;
								}
								return '';
							}, $output);
						}
					},
					'each'=>[
						function(&$output, $data){
							$output = preg_replace_callback(static::$regex['each'], function($matches) use($data){
								$output = '';
								if(isset($data[$matches[1]])){
									foreach($data[$matches[1]] as $item){
										$output = static::parse($matches[2], $item);
									}
								}
								return $output;
							}, $output);
						},
						function(&$output){
							$output = preg_replace_callback(static::$regex['each'], function($matches){
							$output = "<?php if(isset(\$data[".var_export($matches[1], true)."])): ";
							$output .= "foreach(\$data[".var_export($matches[1], true)."] as \$item): ";
							$output .= "\$parent[] = \$data; \$data = \$item; ?>";
							$output .= static::compile($matches[2]);
							$output .= "<?php \$data = array_pop(\$parent);";
							$output .= "endforeach;endif; ?>";
							return $output;
						}, $output);
						}
					],
					'existelse'=>[
						function(&$output, $data){
							$output = preg_replace_callback(static::$regex['existelse'], function($matches) use($data){
								if(isset($data[$matches[1]])){
									$output = static::parse($matches[2], $data);
								}else{
									$output = static::parse($matches[3], $data);
								}
								return $output;
							}, $output);
						},
						function(&$output){
							$output = preg_replace_callback(static::$regex['existelse'], function($matches){
								$output = "<?php if(isset(\$data[".var_export($matches[1], true)."])): ?>";
								$output .= static::compile($matches[2]);
								$output .= "<?php else: ?>";
								$output .= static::compile($matches[3]);
								$output .= "<?php endif; ?>";
								return $output;
							}, $output);
						}
					],
					'exist'=>[
						function(&$output, $data){
							$output = preg_replace_callback(static::$regex['exist'], function($matches) use($data){
								if(isset($data[$matches[1]])){
									return static::parse($data[$matches[2]], $data);
								}
								return '';
							}, $output);
						},
						function(&$output){
							$output = preg_replace_callback(static::$regex['exist'], function($matches){
								$output = "<?php if(isset(\$data[".var_export($matches[1], true)."])): ?>";
								$output .= static::compile($matches[2]);
								$output .= "<?php endif; ?>";
								return $output;
							}, $output);
						}
					],
					'gettext'=>[
						function(&$output, $data){
							$output = preg_replace_callback(static::$regex['gettext'], function($matches) use($data){
								$args = array_map(function($item) use($data){
									if(preg_match(static::$regex['gettext_string'], $item)){
										return preg_replace(static::$regex['gettext_string'], '\2', $item);
									}else{
										return $data[$item] ?? '';
									}
								}, array_slice($matches, 1));
								return htmlentities(_(sprintf(...$args)));
							}, $output);
						},
						function(&$output){
							$output = preg_replace_callback(static::$regex['gettext'], function($matches){
								if(count($matches) > 2){
									$output = "<?=htmlentities(sprintf(_({$matches[1]})";
									foreach(array_slice($matches, 2) as $item){
										if(preg_match(static::$regex['gettext_string'], $item)){
											$output .= ", $item";
										}else{
											$output .= ", (\$data['{$item}'] ?? '')";
										}
									}
								}else{
									$output = "<?=htmlentities(_({$matches[1]}";
								}
								return "{$output})); ?>";
							}, $output);
						}
					],
					'echo'=>[
						function(&$output){
							$output = preg_replace_callback(static::$regex['echo'], function($matches){
								return eval("return {$matches[1]};");
							}, $output);
						},
						function(&$output){
							$output = preg_replace_callback(static::$regex['echo'], function($matches){
								return "<?= {$matches[1]}; ?>";
							}, $output);
						}
					],
					'eval'=>[
						function(&$output){
							$output = preg_replace_callback(static::$regex['eval'], function($matches){
								ob_start();
								eval($matches[1]);
								$output = ob_get_contents();
								ob_end_clean();
								return $output;
							}, $output);
						},
						function(&$output){
							$output = preg_replace_callback(static::$regex['eval'], function($matches){
								return "<?php {$matches[1]}; ?>";
							}, $output);
						}
					],
					'match'=>[
						function(&$output, $data){
							$output = preg_replace_callback(static::$regex['match'], function($matches) use($data){
								return htmlentities($data[$matches[1]] ?? '');
							}, $output);
						},
						function(&$output){
							$output = preg_replace_callback(static::$regex['match'], function($matches){
								return "<?=htmlentities(\$data[".var_export($matches[1], true)."] ?? ''); ?>";
							}, $output);
						}
					],
					'parentmatch'=>[
						function(&$output, $data){
							throw new \Exception("Not supported in non-compiled templates");
						},
						function(&$output){
							$output = preg_replace_callback(static::$regex['parentmatch'], function($matches){
								return "<?=htmlentities(\$parent[count(\$parent)-1][".var_export($matches[1], true)."] ?? ''); ?>";
							}, $output);
						}
					],
					'ignored'=>function(&$output, $ignored){
						$output = preg_replace_callback(static::$regex['ignored'], function($matches) use($ignored){
							return htmlentities($ignored[(int)$matches[1]] ?? '');
						}, $output);
					}
				];
			}
			if(isset(static::$templates[$name])){
				throw new Exception("Template {$name} already exists");
			}
			if($is_file){
				$path = realpath($template);
				if(!file_exists($path)){
					throw new Exception("Template file {$template} doesn't exist");
				}
				$template = file_get_contents($path);
			}
			static::$parsers['include']($template);
			$this->template = $template;
			$this->name = $name;
			$this->path = static::$cachedir."/{$this->name}.".md5($this->template).'.php';
			static::$templates[$name] = $this;
		}
		public function run(array $data) : string{
			$data = EArray::from($data);
			if($this->fire('before', $data) === false){
				throw new Exception("Render on template {$this->name} cancelled. Before.");
			}
			if(!file_exists($this->path)){
				file_put_contents($this->path, static::compile($this->template));
			}
			try{
				$output = static::execute($this->path, $data);
			}catch(Exception $e){
				file_put_contents($this->path, static::compile($this->template));
				$output = static::execute($this->path, $data);
			}
			if(class_exists('tidy')){
				if(is_null(static::$tidy)){
					static::$tidy = new \tidy();
				}
				$tidy = static::$tidy;
				$tidy->parseString($output, static::$tidyConfig);
				if(!$tidy->cleanRepair()){
					throw new \Exception($tidy->errorBuffer);
				}
				$output = "{$tidy}";
			}
			if($this->fire('after', $output) === false){
				throw new Exception("Render on template {$this->name} cancelled. After");
			}
			return (string)$output;
		}
		public static function from(string $name, array $data = []) : string{
			$template = static::$templates[$name] ?? null;
			if(is_null($template)){
				throw new Exception("Template {$name} does not exist");
			}
			return $template->run($data);
		}
		public static function compile(string $template) : string{
			$ignored = [];
			$output = $template;
			// Handle {#ignore code}
			static::$parsers['ignore']($output, $ignored);
			// Handle {#include path/to/file}
			static::$parsers['include']($output, $ignored);
			// Handle {#each name}{/each}
			static::$parsers['each'][1]($output);
			// Handle {#exist name}{#else}{/exist}
			static::$parsers['existelse'][1]($output);
			// Handle {#exist name}{/exist}
			static::$parsers['exist'][1]($output);
			// Handle {gettext}
			static::$parsers['gettext'][1]($output);
			// Handle {=expression}
			static::$parsers['echo'][1]($output);
			// Handle {? expression ?}
			static::$parsers['eval'][1]($output);
			// Handle {../name}
			static::$parsers['parentmatch'][1]($output);
			// Handle {name}
			static::$parsers['match'][1]($output);
			// Handle {#ignored i}
			static::$parsers['ignored']($output, $ignored);
			return $output;
		}
		public static function parse(string $template, $data) : string{
			if(is_null(static::$parsers)){
				// Force parsers to be added
				new Template(uuid(), $template);
			}
			$ignored = [];
			$output = $template;
			// Handle {#ignore code}
			static::$parsers['ignore']($output, $ignored);
			// Handle {#include path/to/file}
			static::$parsers['include']($output, $ignored);
			// Handle {#each name}{/each}
			static::$parsers['each'][0]($output, $data);
			// Handle {#exist name}{#else}{/exist}
			static::$parsers['existelse'][0]($output, $data);
			// Handle {#exist name}{/exist}
			static::$parsers['exist'][0]($output, $data);
			// Handle {gettext}
			static::$parsers['gettext'][0]($output, $data);
			// Handle {=expression}
			static::$parsers['echo'][0]($output);
			// Handle {? expression ?}
			static::$parsers['eval'][0]($output);
			// Handle {../name}
			static::$parsers['parentmatch'][1]($output, $data);
			// Handle {name}
			static::$parsers['match'][0]($output, $data);
			// Handle {#ignored i}
			static::$parsers['ignored']($output, $ignored);
			return $output;
		}
		public static function execute(string $path, $data) : string{
			ob_start();
			include($path);
			$output = ob_get_contents();
			ob_end_clean();
			return $output;
		}
	}
?>