vendor/twig/twig/src/NodeVisitor/EscaperNodeVisitor.php line 46

  1. <?php
  3. /*
  4.  * This file is part of Twig.
  5.  *
  6.  * (c) Fabien Potencier
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Twig\NodeVisitor;
  14. use Twig\Environment;
  15. use Twig\Extension\EscaperExtension;
  16. use Twig\Node\AutoEscapeNode;
  17. use Twig\Node\BlockNode;
  18. use Twig\Node\BlockReferenceNode;
  19. use Twig\Node\DoNode;
  20. use Twig\Node\Expression\ConditionalExpression;
  21. use Twig\Node\Expression\ConstantExpression;
  22. use Twig\Node\Expression\FilterExpression;
  23. use Twig\Node\Expression\InlinePrint;
  24. use Twig\Node\ImportNode;
  25. use Twig\Node\ModuleNode;
  26. use Twig\Node\Node;
  27. use Twig\Node\PrintNode;
  28. use Twig\NodeTraverser;
  30. /**
  31.  * @author Fabien Potencier <fabien@symfony.com>
  32.  *
  33.  * @internal
  34.  */
  35. final class EscaperNodeVisitor implements NodeVisitorInterface
  36. {
  37.     private $statusStack = [];
  38.     private $blocks = [];
  39.     private $safeAnalysis;
  40.     private $traverser;
  41.     private $defaultStrategy = false;
  42.     private $safeVars = [];
  44.     public function __construct()
  45.     {
  46.         $this->safeAnalysis = new SafeAnalysisNodeVisitor();
  47.     }
  49.     public function enterNode(Node $node, Environment $env): Node
  50.     {
  51.         if ($node instanceof ModuleNode) {
  52.             if ($env->hasExtension(EscaperExtension::class) && $defaultStrategy = $env->getExtension(EscaperExtension::class)->getDefaultStrategy($node->getTemplateName())) {
  53.                 $this->defaultStrategy = $defaultStrategy;
  54.             }
  55.             $this->safeVars = [];
  56.             $this->blocks = [];
  57.         } elseif ($node instanceof AutoEscapeNode) {
  58.             $this->statusStack[] = $node->getAttribute('value');
  59.         } elseif ($node instanceof BlockNode) {
  60.             $this->statusStack[] = isset($this->blocks[$node->getAttribute('name')]) ? $this->blocks[$node->getAttribute('name')] : $this->needEscaping($env);
  61.         } elseif ($node instanceof ImportNode) {
  62.             $this->safeVars[] = $node->getNode('var')->getAttribute('name');
  63.         }
  65.         return $node;
  66.     }
  68.     public function leaveNode(Node $node, Environment $env): ?Node
  69.     {
  70.         if ($node instanceof ModuleNode) {
  71.             $this->defaultStrategy = false;
  72.             $this->safeVars = [];
  73.             $this->blocks = [];
  74.         } elseif ($node instanceof FilterExpression) {
  75.             return $this->preEscapeFilterNode($node, $env);
  76.         } elseif ($node instanceof PrintNode && false !== $type = $this->needEscaping($env)) {
  77.             $expression = $node->getNode('expr');
  78.             if ($expression instanceof ConditionalExpression && $this->shouldUnwrapConditional($expression, $env, $type)) {
  79.                 return new DoNode($this->unwrapConditional($expression, $env, $type), $expression->getTemplateLine());
  80.             }
  82.             return $this->escapePrintNode($node, $env, $type);
  83.         }
  85.         if ($node instanceof AutoEscapeNode || $node instanceof BlockNode) {
  86.             array_pop($this->statusStack);
  87.         } elseif ($node instanceof BlockReferenceNode) {
  88.             $this->blocks[$node->getAttribute('name')] = $this->needEscaping($env);
  89.         }
  91.         return $node;
  92.     }
  94.     private function shouldUnwrapConditional(ConditionalExpression $expression, Environment $env, string $type): bool
  95.     {
  96.         $expr2Safe = $this->isSafeFor($type, $expression->getNode('expr2'), $env);
  97.         $expr3Safe = $this->isSafeFor($type, $expression->getNode('expr3'), $env);
  99.         return $expr2Safe !== $expr3Safe;
  100.     }
  102.     private function unwrapConditional(ConditionalExpression $expression, Environment $env, string $type): ConditionalExpression
  103.     {
  104.         // convert "echo a ? b : c" to "a ? echo b : echo c" recursively
  105.         $expr2 = $expression->getNode('expr2');
  106.         if ($expr2 instanceof ConditionalExpression && $this->shouldUnwrapConditional($expr2, $env, $type)) {
  107.             $expr2 = $this->unwrapConditional($expr2, $env, $type);
  108.         } else {
  109.             $expr2 = $this->escapeInlinePrintNode(new InlinePrint($expr2, $expr2->getTemplateLine()), $env, $type);
  110.         }
  111.         $expr3 = $expression->getNode('expr3');
  112.         if ($expr3 instanceof ConditionalExpression && $this->shouldUnwrapConditional($expr3, $env, $type)) {
  113.             $expr3 = $this->unwrapConditional($expr3, $env, $type);
  114.         } else {
  115.             $expr3 = $this->escapeInlinePrintNode(new InlinePrint($expr3, $expr3->getTemplateLine()), $env, $type);
  116.         }
  118.         return new ConditionalExpression($expression->getNode('expr1'), $expr2, $expr3, $expression->getTemplateLine());
  119.     }
  121.     private function escapeInlinePrintNode(InlinePrint $node, Environment $env, string $type): Node
  122.     {
  123.         $expression = $node->getNode('node');
  125.         if ($this->isSafeFor($type, $expression, $env)) {
  126.             return $node;
  127.         }
  129.         return new InlinePrint($this->getEscaperFilter($type, $expression), $node->getTemplateLine());
  130.     }
  132.     private function escapePrintNode(PrintNode $node, Environment $env, string $type): Node
  133.     {
  134.         if (false === $type) {
  135.             return $node;
  136.         }
  138.         $expression = $node->getNode('expr');
  140.         if ($this->isSafeFor($type, $expression, $env)) {
  141.             return $node;
  142.         }
  144.         $class = \get_class($node);
  146.         return new $class($this->getEscaperFilter($type, $expression), $node->getTemplateLine());
  147.     }
  149.     private function preEscapeFilterNode(FilterExpression $filter, Environment $env): FilterExpression
  150.     {
  151.         $name = $filter->getNode('filter')->getAttribute('value');
  153.         $type = $env->getFilter($name)->getPreEscape();
  154.         if (null === $type) {
  155.             return $filter;
  156.         }
  158.         $node = $filter->getNode('node');
  159.         if ($this->isSafeFor($type, $node, $env)) {
  160.             return $filter;
  161.         }
  163.         $filter->setNode('node', $this->getEscaperFilter($type, $node));
  165.         return $filter;
  166.     }
  168.     private function isSafeFor(string $type, Node $expression, Environment $env): bool
  169.     {
  170.         $safe = $this->safeAnalysis->getSafe($expression);
  172.         if (null === $safe) {
  173.             if (null === $this->traverser) {
  174.                 $this->traverser = new NodeTraverser($env, [$this->safeAnalysis]);
  175.             }
  177.             $this->safeAnalysis->setSafeVars($this->safeVars);
  179.             $this->traverser->traverse($expression);
  180.             $safe = $this->safeAnalysis->getSafe($expression);
  181.         }
  183.         return \in_array($type, $safe) || \in_array('all', $safe);
  184.     }
  186.     private function needEscaping(Environment $env)
  187.     {
  188.         if (\count($this->statusStack)) {
  189.             return $this->statusStack[\count($this->statusStack) - 1];
  190.         }
  192.         return $this->defaultStrategy ? $this->defaultStrategy : false;
  193.     }
  195.     private function getEscaperFilter(string $type, Node $node): FilterExpression
  196.     {
  197.         $line = $node->getTemplateLine();
  198.         $name = new ConstantExpression('escape', $line);
  199.         $args = new Node([new ConstantExpression($type, $line), new ConstantExpression(null, $line), new ConstantExpression(true, $line)]);
  201.         return new FilterExpression($node, $name, $args, $line);
  202.     }
  204.     public function getPriority(): int
  205.     {
  206.         return 0;
  207.     }
  208. }