private function parseToken(Token $token, Stream $stream, RootNode $root) { $value = $token->getValue(); switch ($token->getType()) { case Token::TEXT: $root->addChild(new PrintNode($value)); break; case Token::TAG_START: try { $node = $this->environment->getTag($value)->parse($this, $stream); if ($node instanceof Node) { $node->addData('line', $token->getLine()); $root->addChild($node); } } catch (\OutOfBoundsException $e) { throw new ParseException("Unknown {$value} tag", $token->getLine(), $e); } break; default: $type = $token->getTypeString(); $line = $token->getLine(); throw new ParseException("Unexpected {$type} ({$value}) token", $line); } return $stream->next(); }
public function __construct(Environment $environment) { if (self::$environment !== $environment) { self::$environment = $environment; self::$operators = array_combine($environment->getOperatorSymbols(), $environment->getOperatorSymbols()); self::$expressionPartsPattern = $this->getExpressionPartsPattern(); } }
public function testThatDefaultErrorTemplateRespectsCustomDelimiters() { $this->loader->addTemplate('template', '{*'); ob_start(); try { $this->env->render('template'); } catch (TemplatingException $e) { $this->fail(); } ob_end_clean(); }
public function __construct(Environment $env, $templateName) { $this->templateName = $templateName; $this->baseClass = $env->getOption('template_base_class'); $className = $env->getTemplateClassName($templateName); $classNameOffset = strrpos($className, '\\'); if ($classNameOffset === false) { $this->namespace = ''; $this->className = $className; } else { $this->namespace = substr($className, 0, $classNameOffset); $this->className = substr($className, $classNameOffset + 1); } }
/** * @param Node $node * @param $for */ private function addFilterNode(Node $node, $for) { if (!$this->environment->hasFunction('filter_' . $for)) { $for = $this->defaultAutofilterStrategy; } $node->addChild(new FunctionNode('filter_' . $for, [$node->getChild('expression')]), 'expression'); }
/** * @test * @dataProvider getTests */ public function runIntegrationTests($file, $description, $templates, $data, $expectation, $exception, $exceptionMessage) { //global counter to provide random namespaces to avoid class name collision $options = $this->optionsProperty->getValue($this->environment); $options['cache_namespace'] = 'test_' . ++self::$counter; $this->optionsProperty->setValue($this->environment, $options); foreach ($templates as $name => $template) { $this->stringLoader->addTemplate($name, $template); } if ($data) { eval('$data = ' . $data . ';'); } else { $data = []; } if ($exception) { $this->setExpectedException($exception, $exceptionMessage); } $obLevel = ob_get_level(); try { ob_start(); $this->environment->render('index', $data); $output = rtrim(ob_get_clean(), "\n"); if ($expectation) { $this->assertEquals($expectation, $output, $description . ' (' . $file . ')'); } } catch (\Exception $e) { if (ob_get_level() !== $obLevel) { ob_end_clean(); } throw $e; } }
private function functionNeedsEnvironment(IdentifierNode $node) { $function = $this->environment->getFunction($node->getData('name')); if ($function->getOption('needs_environment')) { return true; } return !is_string($function->getCallback()); }
/** * @param Template $parent * @param $blockName * @param Context $context * * @throws \RuntimeException */ private function renderParentBlock(Template $parent, $blockName, Context $context) { while ($parent->parentTemplate) { $parent = $this->environment->load($parent->parentTemplate); if (isset($parent->blocks[$blockName])) { $parent->blocks[$blockName]($context); return; } } throw new \RuntimeException("Block {$blockName} was not found."); }
public function getEnvironment(StringLoader $loader) { $env = new Environment($loader, ['fallback_tag' => 'print', 'global_variables' => ['global' => 'global variable']]); $env->addFunction(new TemplateFunction('html_safe', function ($data) { return $data; }, ['is_safe' => ['html', 'xml']])); $env->addFunction(new TemplateFunction('json_safe', function ($data) { return $data; }, ['is_safe' => 'json'])); $env->addFunction(new TemplateFunction('dump', function ($data) { return print_r($data, 1); }, ['is_safe' => true])); $env->addExtension(new Core()); return $env; }
private function processTag($tag) { //Try to find the tag name preg_match('/(\\S*)(?:\\s*(.*|))$/ADs', $tag, $parts); list(, $tagName, $expression) = $parts; //If the tag name is unknown, try to use the fallback if (isset(self::$closingTags[$tagName])) { $tagName = self::$closingTags[$tagName]; } elseif (!self::$environment->hasTag($tagName)) { $tagName = self::$fallbackTagName; $expression = $tag; } $this->pushToken(Token::TAG_START, $tagName); self::$expressionTokenizer->setLine($this->line); $stream = self::$expressionTokenizer->tokenize($expression); while (!$stream->next()->test(Token::EOF)) { $this->tokenBuffer[] = $stream->current(); } $this->line = $stream->current()->getLine(); $this->pushToken(Token::TAG_END, $tagName); }
function template_function_source(Environment $environment, $template) { return $environment->getSource($environment->findFirstExistingTemplate($template)); }
public function getEnvironment(StringLoader $loader) { $env = new Environment($loader, ['fallback_tag' => 'print', 'error_template' => false]); $env->addExtension(new Core()); return $env; }
/** * @dataProvider returnValueProvider */ public function testFunctionReturnValues($function, $arguments, $expected) { $actual = call_user_func_array($this->env->getFunction($function)->getCallback(), $arguments); $this->assertEquals($expected, $actual); }
/** * @inheritdoc */ public function isCacheFresh($template) { $cacheTime = $this->environment->getTemplateCache()->getCreatedTime($this->getCacheKey($template)); return filemtime($this->getPath($template)) < $cacheTime; }
/** * @inheritdoc */ public function isCacheFresh($template) { return $this->environment->getTemplateCache()->exists($this->getCacheKey($template)); }
public function __construct(Environment $environment) { $this->binaryOperators = $environment->getBinaryOperators(); $this->unaryPrefixOperators = $environment->getUnaryPrefixOperators(); $this->unaryPostfixOperators = $environment->getUnaryPostfixOperators(); }