You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
101 lines
3.6 KiB
101 lines
3.6 KiB
<?php
|
|
/**
|
|
* li₃: the most RAD framework for PHP (http://li3.me)
|
|
*
|
|
* Copyright 2010, Union of RAD. All rights reserved. This source
|
|
* code is distributed under the terms of the BSD 3-Clause License.
|
|
* The full license text can be found in the LICENSE.txt file.
|
|
*/
|
|
|
|
namespace lithium\template\view;
|
|
|
|
use lithium\core\Libraries;
|
|
use lithium\template\TemplateException;
|
|
|
|
/**
|
|
* The template compiler is a simple string replacement engine which allows PHP templates to be
|
|
* overridden with custom syntax. The default process rules allow PHP templates using short-echo
|
|
* syntax (`<?=`) to be rewritten to full PHP tags which automatically escape their output.
|
|
*
|
|
* It is possible to create your own template compiler and have the chosen `View` adapter use that
|
|
* instead. Please see the documentation on the dynamic dependencies of the adapter in question
|
|
* to know more about how this can be achieved.
|
|
*
|
|
* @see lithium\template\View
|
|
* @see lithium\template\view\adapter
|
|
*/
|
|
class Compiler extends \lithium\core\StaticObjectDeprecated {
|
|
|
|
/**
|
|
* The list of syntax replacements to apply to compiled templates.
|
|
*
|
|
* Key/value pairs of regular expressions. The keys are the regexes, and the values are the
|
|
* resulting expressions along with any capture groups that may have been used in the
|
|
* corresponding regexes.
|
|
*
|
|
* @var array
|
|
*/
|
|
protected static $_processors = [
|
|
'/\<\?=\s*\$this->(.+?)\s*;?\s*\?>/msx' => '<?php echo $this->$1; ?>',
|
|
'/\<\?=\s*(\$h\(.+?)\s*;?\s*\?>/msx' => '<?php echo $1; ?>',
|
|
'/\<\?=\s*(.+?)\s*;?\s*\?>/msx' => '<?php echo $h($1); ?>'
|
|
];
|
|
|
|
/**
|
|
* Compiles a template and writes it to a cache file, which is used for inclusion.
|
|
*
|
|
* @param string $file The full path to the template that will be compiled.
|
|
* @param array $options Options for compilation include:
|
|
* - `path`: Path where the compiled template should be written.
|
|
* - `fallback`: Boolean indicating that if the compilation failed for some
|
|
* reason (e.g. `path` is not writable), that the compiled template
|
|
* should still be returned and no exception be thrown.
|
|
* @return string The compiled template.
|
|
*/
|
|
public static function template($file, array $options = []) {
|
|
$cachePath = Libraries::get(true, 'resources') . '/tmp/cache/templates';
|
|
$defaults = ['path' => $cachePath, 'fallback' => false];
|
|
$options += $defaults;
|
|
|
|
$stats = stat($file);
|
|
|
|
$oname = basename(dirname($file)) . '_' . basename($file, '.php');
|
|
$oname .= '_' . ($stats['ino'] ?: hash('md5', $file));
|
|
|
|
$template = "template_{$oname}_{$stats['mtime']}_{$stats['size']}.php";
|
|
$template = "{$options['path']}/{$template}";
|
|
|
|
if (file_exists($template)) {
|
|
return $template;
|
|
}
|
|
$compiled = static::compile(file_get_contents($file));
|
|
|
|
if (is_writable($cachePath) && file_put_contents($template, $compiled) !== false) {
|
|
foreach (glob("{$options['path']}/template_{$oname}_*.php", GLOB_NOSORT) as $expired) {
|
|
if ($expired !== $template) {
|
|
unlink($expired);
|
|
}
|
|
}
|
|
return $template;
|
|
}
|
|
if ($options['fallback']) {
|
|
return $file;
|
|
}
|
|
throw new TemplateException("Could not write compiled template `{$template}` to cache.");
|
|
}
|
|
|
|
/**
|
|
* Preprocess the passed `$string` (usually a PHP template) for syntax replacements
|
|
* using sets of regular expressions.
|
|
*
|
|
* @see lithium\template\view\Compiler::$_processors
|
|
* @param string $string The string to be preprocessed.
|
|
* @return string Processed string.
|
|
*/
|
|
public static function compile($string) {
|
|
$patterns = static::$_processors;
|
|
return preg_replace(array_keys($patterns), array_values($patterns), $string);
|
|
}
|
|
}
|
|
|
|
?>
|