mirror of
https://github.com/vichan-devel/vichan.git
synced 2024-12-04 20:08:02 +01:00
518 lines
17 KiB
PHP
518 lines
17 KiB
PHP
<?php
|
|
|
|
/*
|
|
* This file is part of Twig.
|
|
*
|
|
* (c) 2009 Fabien Potencier
|
|
* (c) 2009 Armin Ronacher
|
|
*
|
|
* For the full copyright and license information, please view the LICENSE
|
|
* file that was distributed with this source code.
|
|
*/
|
|
|
|
/**
|
|
* Default base class for compiled templates.
|
|
*
|
|
* @author Fabien Potencier <fabien@symfony.com>
|
|
*/
|
|
abstract class Twig_Template implements Twig_TemplateInterface
|
|
{
|
|
protected static $cache = array();
|
|
|
|
protected $parent;
|
|
protected $parents;
|
|
protected $env;
|
|
protected $blocks;
|
|
protected $traits;
|
|
protected $macros;
|
|
|
|
/**
|
|
* Constructor.
|
|
*
|
|
* @param Twig_Environment $env A Twig_Environment instance
|
|
*/
|
|
public function __construct(Twig_Environment $env)
|
|
{
|
|
$this->env = $env;
|
|
$this->blocks = array();
|
|
$this->traits = array();
|
|
$this->macros = array();
|
|
}
|
|
|
|
/**
|
|
* Returns the template name.
|
|
*
|
|
* @return string The template name
|
|
*/
|
|
abstract public function getTemplateName();
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function getEnvironment()
|
|
{
|
|
return $this->env;
|
|
}
|
|
|
|
/**
|
|
* Returns the parent template.
|
|
*
|
|
* This method is for internal use only and should never be called
|
|
* directly.
|
|
*
|
|
* @return Twig_TemplateInterface|false The parent template or false if there is no parent
|
|
*/
|
|
public function getParent(array $context)
|
|
{
|
|
if (null !== $this->parent) {
|
|
return $this->parent;
|
|
}
|
|
|
|
$parent = $this->doGetParent($context);
|
|
if (false === $parent) {
|
|
return false;
|
|
} elseif ($parent instanceof Twig_Template) {
|
|
$name = $parent->getTemplateName();
|
|
$this->parents[$name] = $parent;
|
|
$parent = $name;
|
|
} elseif (!isset($this->parents[$parent])) {
|
|
$this->parents[$parent] = $this->env->loadTemplate($parent);
|
|
}
|
|
|
|
return $this->parents[$parent];
|
|
}
|
|
|
|
protected function doGetParent(array $context)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
public function isTraitable()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Displays a parent block.
|
|
*
|
|
* This method is for internal use only and should never be called
|
|
* directly.
|
|
*
|
|
* @param string $name The block name to display from the parent
|
|
* @param array $context The context
|
|
* @param array $blocks The current set of blocks
|
|
*/
|
|
public function displayParentBlock($name, array $context, array $blocks = array())
|
|
{
|
|
$name = (string) $name;
|
|
|
|
if (isset($this->traits[$name])) {
|
|
$this->traits[$name][0]->displayBlock($name, $context, $blocks);
|
|
} elseif (false !== $parent = $this->getParent($context)) {
|
|
$parent->displayBlock($name, $context, $blocks);
|
|
} else {
|
|
throw new Twig_Error_Runtime(sprintf('The template has no parent and no traits defining the "%s" block', $name), -1, $this->getTemplateName());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Displays a block.
|
|
*
|
|
* This method is for internal use only and should never be called
|
|
* directly.
|
|
*
|
|
* @param string $name The block name to display
|
|
* @param array $context The context
|
|
* @param array $blocks The current set of blocks
|
|
*/
|
|
public function displayBlock($name, array $context, array $blocks = array())
|
|
{
|
|
$name = (string) $name;
|
|
|
|
if (isset($blocks[$name])) {
|
|
$b = $blocks;
|
|
unset($b[$name]);
|
|
call_user_func($blocks[$name], $context, $b);
|
|
} elseif (isset($this->blocks[$name])) {
|
|
call_user_func($this->blocks[$name], $context, $blocks);
|
|
} elseif (false !== $parent = $this->getParent($context)) {
|
|
$parent->displayBlock($name, $context, array_merge($this->blocks, $blocks));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Renders a parent block.
|
|
*
|
|
* This method is for internal use only and should never be called
|
|
* directly.
|
|
*
|
|
* @param string $name The block name to render from the parent
|
|
* @param array $context The context
|
|
* @param array $blocks The current set of blocks
|
|
*
|
|
* @return string The rendered block
|
|
*/
|
|
public function renderParentBlock($name, array $context, array $blocks = array())
|
|
{
|
|
ob_start();
|
|
$this->displayParentBlock($name, $context, $blocks);
|
|
|
|
return ob_get_clean();
|
|
}
|
|
|
|
/**
|
|
* Renders a block.
|
|
*
|
|
* This method is for internal use only and should never be called
|
|
* directly.
|
|
*
|
|
* @param string $name The block name to render
|
|
* @param array $context The context
|
|
* @param array $blocks The current set of blocks
|
|
*
|
|
* @return string The rendered block
|
|
*/
|
|
public function renderBlock($name, array $context, array $blocks = array())
|
|
{
|
|
ob_start();
|
|
$this->displayBlock($name, $context, $blocks);
|
|
|
|
return ob_get_clean();
|
|
}
|
|
|
|
/**
|
|
* Returns whether a block exists or not.
|
|
*
|
|
* This method is for internal use only and should never be called
|
|
* directly.
|
|
*
|
|
* This method does only return blocks defined in the current template
|
|
* or defined in "used" traits.
|
|
*
|
|
* It does not return blocks from parent templates as the parent
|
|
* template name can be dynamic, which is only known based on the
|
|
* current context.
|
|
*
|
|
* @param string $name The block name
|
|
*
|
|
* @return Boolean true if the block exists, false otherwise
|
|
*/
|
|
public function hasBlock($name)
|
|
{
|
|
return isset($this->blocks[(string) $name]);
|
|
}
|
|
|
|
/**
|
|
* Returns all block names.
|
|
*
|
|
* This method is for internal use only and should never be called
|
|
* directly.
|
|
*
|
|
* @return array An array of block names
|
|
*
|
|
* @see hasBlock
|
|
*/
|
|
public function getBlockNames()
|
|
{
|
|
return array_keys($this->blocks);
|
|
}
|
|
|
|
/**
|
|
* Returns all blocks.
|
|
*
|
|
* This method is for internal use only and should never be called
|
|
* directly.
|
|
*
|
|
* @return array An array of blocks
|
|
*
|
|
* @see hasBlock
|
|
*/
|
|
public function getBlocks()
|
|
{
|
|
return $this->blocks;
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function display(array $context, array $blocks = array())
|
|
{
|
|
$this->displayWithErrorHandling($this->env->mergeGlobals($context), $blocks);
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function render(array $context)
|
|
{
|
|
$level = ob_get_level();
|
|
ob_start();
|
|
try {
|
|
$this->display($context);
|
|
} catch (Exception $e) {
|
|
while (ob_get_level() > $level) {
|
|
ob_end_clean();
|
|
}
|
|
|
|
throw $e;
|
|
}
|
|
|
|
return ob_get_clean();
|
|
}
|
|
|
|
protected function displayWithErrorHandling(array $context, array $blocks = array())
|
|
{
|
|
try {
|
|
$this->doDisplay($context, $blocks);
|
|
} catch (Twig_Error $e) {
|
|
if (!$e->getTemplateFile()) {
|
|
$e->setTemplateFile($this->getTemplateName());
|
|
}
|
|
|
|
// this is mostly useful for Twig_Error_Loader exceptions
|
|
// see Twig_Error_Loader
|
|
if (false === $e->getTemplateLine()) {
|
|
$e->setTemplateLine(-1);
|
|
$e->guess();
|
|
}
|
|
|
|
throw $e;
|
|
} catch (Exception $e) {
|
|
throw new Twig_Error_Runtime(sprintf('An exception has been thrown during the rendering of a template ("%s").', $e->getMessage()), -1, null, $e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Auto-generated method to display the template with the given context.
|
|
*
|
|
* @param array $context An array of parameters to pass to the template
|
|
* @param array $blocks An array of blocks to pass to the template
|
|
*/
|
|
abstract protected function doDisplay(array $context, array $blocks = array());
|
|
|
|
/**
|
|
* Returns a variable from the context.
|
|
*
|
|
* This method is for internal use only and should never be called
|
|
* directly.
|
|
*
|
|
* This method should not be overridden in a sub-class as this is an
|
|
* implementation detail that has been introduced to optimize variable
|
|
* access for versions of PHP before 5.4. This is not a way to override
|
|
* the way to get a variable value.
|
|
*
|
|
* @param array $context The context
|
|
* @param string $item The variable to return from the context
|
|
* @param Boolean $ignoreStrictCheck Whether to ignore the strict variable check or not
|
|
*
|
|
* @return The content of the context variable
|
|
*
|
|
* @throws Twig_Error_Runtime if the variable does not exist and Twig is running in strict mode
|
|
*/
|
|
final protected function getContext($context, $item, $ignoreStrictCheck = false)
|
|
{
|
|
if (!array_key_exists($item, $context)) {
|
|
if ($ignoreStrictCheck || !$this->env->isStrictVariables()) {
|
|
return null;
|
|
}
|
|
|
|
throw new Twig_Error_Runtime(sprintf('Variable "%s" does not exist', $item), -1, $this->getTemplateName());
|
|
}
|
|
|
|
return $context[$item];
|
|
}
|
|
|
|
/**
|
|
* Returns the attribute value for a given array/object.
|
|
*
|
|
* @param mixed $object The object or array from where to get the item
|
|
* @param mixed $item The item to get from the array or object
|
|
* @param array $arguments An array of arguments to pass if the item is an object method
|
|
* @param string $type The type of attribute (@see Twig_Template constants)
|
|
* @param Boolean $isDefinedTest Whether this is only a defined check
|
|
* @param Boolean $ignoreStrictCheck Whether to ignore the strict attribute check or not
|
|
*
|
|
* @return mixed The attribute value, or a Boolean when $isDefinedTest is true, or null when the attribute is not set and $ignoreStrictCheck is true
|
|
*
|
|
* @throws Twig_Error_Runtime if the attribute does not exist and Twig is running in strict mode and $isDefinedTest is false
|
|
*/
|
|
protected function getAttribute($object, $item, array $arguments = array(), $type = Twig_Template::ANY_CALL, $isDefinedTest = false, $ignoreStrictCheck = false)
|
|
{
|
|
// array
|
|
if (Twig_Template::METHOD_CALL !== $type) {
|
|
$arrayItem = is_bool($item) || is_float($item) ? (int) $item : $item;
|
|
|
|
if ((is_array($object) && array_key_exists($arrayItem, $object))
|
|
|| ($object instanceof ArrayAccess && isset($object[$arrayItem]))
|
|
) {
|
|
if ($isDefinedTest) {
|
|
return true;
|
|
}
|
|
|
|
return $object[$arrayItem];
|
|
}
|
|
|
|
if (Twig_Template::ARRAY_CALL === $type || !is_object($object)) {
|
|
if ($isDefinedTest) {
|
|
return false;
|
|
}
|
|
|
|
if ($ignoreStrictCheck || !$this->env->isStrictVariables()) {
|
|
return null;
|
|
}
|
|
|
|
if (is_object($object)) {
|
|
throw new Twig_Error_Runtime(sprintf('Key "%s" in object (with ArrayAccess) of type "%s" does not exist', $arrayItem, get_class($object)), -1, $this->getTemplateName());
|
|
} elseif (is_array($object)) {
|
|
throw new Twig_Error_Runtime(sprintf('Key "%s" for array with keys "%s" does not exist', $arrayItem, implode(', ', array_keys($object))), -1, $this->getTemplateName());
|
|
} elseif (Twig_Template::ARRAY_CALL === $type) {
|
|
throw new Twig_Error_Runtime(sprintf('Impossible to access a key ("%s") on a %s variable ("%s")', $item, gettype($object), $object), -1, $this->getTemplateName());
|
|
} else {
|
|
throw new Twig_Error_Runtime(sprintf('Impossible to access an attribute ("%s") on a %s variable ("%s")', $item, gettype($object), $object), -1, $this->getTemplateName());
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!is_object($object)) {
|
|
if ($isDefinedTest) {
|
|
return false;
|
|
}
|
|
|
|
if ($ignoreStrictCheck || !$this->env->isStrictVariables()) {
|
|
return null;
|
|
}
|
|
|
|
throw new Twig_Error_Runtime(sprintf('Impossible to invoke a method ("%s") on a %s variable ("%s")', $item, gettype($object), $object), -1, $this->getTemplateName());
|
|
}
|
|
|
|
$class = get_class($object);
|
|
|
|
// object property
|
|
if (Twig_Template::METHOD_CALL !== $type) {
|
|
if (isset($object->$item) || array_key_exists((string) $item, $object)) {
|
|
if ($isDefinedTest) {
|
|
return true;
|
|
}
|
|
|
|
if ($this->env->hasExtension('sandbox')) {
|
|
$this->env->getExtension('sandbox')->checkPropertyAllowed($object, $item);
|
|
}
|
|
|
|
return $object->$item;
|
|
}
|
|
}
|
|
|
|
// object method
|
|
if (!isset(self::$cache[$class]['methods'])) {
|
|
self::$cache[$class]['methods'] = array_change_key_case(array_flip(get_class_methods($object)));
|
|
}
|
|
|
|
$lcItem = strtolower($item);
|
|
if (isset(self::$cache[$class]['methods'][$lcItem])) {
|
|
$method = (string) $item;
|
|
} elseif (isset(self::$cache[$class]['methods']['get'.$lcItem])) {
|
|
$method = 'get'.$item;
|
|
} elseif (isset(self::$cache[$class]['methods']['is'.$lcItem])) {
|
|
$method = 'is'.$item;
|
|
} elseif (isset(self::$cache[$class]['methods']['__call'])) {
|
|
$method = (string) $item;
|
|
} else {
|
|
if ($isDefinedTest) {
|
|
return false;
|
|
}
|
|
|
|
if ($ignoreStrictCheck || !$this->env->isStrictVariables()) {
|
|
return null;
|
|
}
|
|
|
|
throw new Twig_Error_Runtime(sprintf('Method "%s" for object "%s" does not exist', $item, get_class($object)), -1, $this->getTemplateName());
|
|
}
|
|
|
|
if ($isDefinedTest) {
|
|
return true;
|
|
}
|
|
|
|
if ($this->env->hasExtension('sandbox')) {
|
|
$this->env->getExtension('sandbox')->checkMethodAllowed($object, $method);
|
|
}
|
|
|
|
$ret = call_user_func_array(array($object, $method), $arguments);
|
|
|
|
// useful when calling a template method from a template
|
|
// this is not supported but unfortunately heavily used in the Symfony profiler
|
|
if ($object instanceof Twig_TemplateInterface) {
|
|
return $ret === '' ? '' : new Twig_Markup($ret, $this->env->getCharset());
|
|
}
|
|
|
|
return $ret;
|
|
}
|
|
|
|
/**
|
|
* Calls macro in a template.
|
|
*
|
|
* @param Twig_Template $template The template
|
|
* @param string $macro The name of macro
|
|
* @param array $arguments The arguments of macro
|
|
* @param array $namedNames An array of names of arguments as keys
|
|
* @param integer $namedCount The count of named arguments
|
|
* @param integer $positionalCount The count of positional arguments
|
|
*
|
|
* @return string The content of a macro
|
|
*
|
|
* @throws Twig_Error_Runtime if the macro is not defined
|
|
* @throws Twig_Error_Runtime if the argument is defined twice
|
|
* @throws Twig_Error_Runtime if the argument is unknown
|
|
*/
|
|
protected function callMacro(Twig_Template $template, $macro, array $arguments, array $namedNames = array(), $namedCount = 0, $positionalCount = -1)
|
|
{
|
|
if (!isset($template->macros[$macro]['reflection'])) {
|
|
if (!isset($template->macros[$macro])) {
|
|
throw new Twig_Error_Runtime(sprintf('Macro "%s" is not defined in the template "%s".', $macro, $template->getTemplateName()));
|
|
}
|
|
|
|
$template->macros[$macro]['reflection'] = new ReflectionMethod($template, $template->macros[$macro]['method']);
|
|
}
|
|
|
|
if ($namedCount < 1) {
|
|
return $template->macros[$macro]['reflection']->invokeArgs($template, $arguments);
|
|
}
|
|
|
|
$i = 0;
|
|
$args = array();
|
|
foreach ($template->macros[$macro]['arguments'] as $name => $value) {
|
|
if (isset($namedNames[$name])) {
|
|
if ($i < $positionalCount) {
|
|
throw new Twig_Error_Runtime(sprintf('Argument "%s" is defined twice for macro "%s" defined in the template "%s".', $name, $macro, $template->getTemplateName()));
|
|
}
|
|
|
|
$args[] = $arguments[$name];
|
|
if (--$namedCount < 1) {
|
|
break;
|
|
}
|
|
} elseif ($i < $positionalCount) {
|
|
$args[] = $arguments[$i];
|
|
} else {
|
|
$args[] = $value;
|
|
}
|
|
|
|
$i++;
|
|
}
|
|
|
|
if ($namedCount > 0) {
|
|
$parameters = array_keys(array_diff_key($namedNames, $template->macros[$macro]['arguments']));
|
|
|
|
throw new Twig_Error_Runtime(sprintf('Unknown argument%s "%s" for macro "%s" defined in the template "%s".', count($parameters) > 1 ? 's' : '' , implode('", "', $parameters), $macro, $template->getTemplateName()));
|
|
}
|
|
|
|
return $template->macros[$macro]['reflection']->invokeArgs($template, $args);
|
|
}
|
|
|
|
/**
|
|
* This method is only useful when testing Twig. Do not use it.
|
|
*/
|
|
public static function clearCache()
|
|
{
|
|
self::$cache = array();
|
|
}
|
|
}
|