vendor/twig/twig/src/Node/Node.php line 206

  1. <?php
  3. /*
  4.  * This file is part of Twig.
  5.  *
  6.  * (c) Fabien Potencier
  7.  * (c) Armin Ronacher
  8.  *
  9.  * For the full copyright and license information, please view the LICENSE
  10.  * file that was distributed with this source code.
  11.  */
  13. namespace Twig\Node;
  15. use Twig\Attribute\YieldReady;
  16. use Twig\Compiler;
  17. use Twig\Source;
  19. /**
  20.  * Represents a node in the AST.
  21.  *
  22.  * @author Fabien Potencier <fabien@symfony.com>
  23.  */
  24. #[YieldReady]
  25. class Node implements \Countable, \IteratorAggregate
  26. {
  27.     /**
  28.      * @var array<string|int, Node>
  29.      */
  30.     protected $nodes;
  31.     protected $attributes;
  32.     protected $lineno;
  33.     protected $tag;
  35.     private $sourceContext;
  36.     /** @var array<string, NameDeprecation> */
  37.     private $nodeNameDeprecations = [];
  38.     /** @var array<string, NameDeprecation> */
  39.     private $attributeNameDeprecations = [];
  41.     /**
  42.      * @param array<string|int, Node> $nodes      An array of named nodes
  43.      * @param array                   $attributes An array of attributes (should not be nodes)
  44.      * @param int                     $lineno     The line number
  45.      */
  46.     public function __construct(array $nodes = [], array $attributes = [], int $lineno = 0)
  47.     {
  48.         foreach ($nodes as $name => $node) {
  49.             if (!$node instanceof self) {
  50.                 throw new \InvalidArgumentException(\sprintf('Using "%s" for the value of node "%s" of "%s" is not supported. You must pass a \Twig\Node\Node instance.', \is_object($node) ? $node::class : (null === $node ? 'null' : \gettype($node)), $name, static::class));
  51.             }
  52.         }
  53.         $this->nodes = $nodes;
  54.         $this->attributes = $attributes;
  55.         $this->lineno = $lineno;
  57.         if (\func_num_args() > 3) {
  58.             trigger_deprecation('twig/twig', '3.12', \sprintf('The "tag" constructor argument of the "%s" class is deprecated and ignored (check which TokenParser class set it to "%s"), the tag is now automatically set by the Parser when needed.', static::class, func_get_arg(3) ?: 'null'));
  59.         }
  60.     }
  62.     public function __toString()
  63.     {
  64.         $repr = static::class;
  66.         if ($this->tag) {
  67.             $repr .= \sprintf("\n  tag: %s", $this->tag);
  68.         }
  70.         $attributes = [];
  71.         foreach ($this->attributes as $name => $value) {
  72.             if (\is_callable($value)) {
  73.                 $v = '\Closure';
  74.             } elseif ($value instanceof \Stringable) {
  75.                 $v = (string) $value;
  76.             } else {
  77.                 $v = str_replace("\n", '', var_export($value, true));
  78.             }
  79.             $attributes[] = \sprintf('%s: %s', $name, $v);
  80.         }
  82.         if ($attributes) {
  83.             $repr .= \sprintf("\n  attributes:\n    %s", implode("\n    ", $attributes));
  84.         }
  86.         if (\count($this->nodes)) {
  87.             $repr .= "\n  nodes:";
  88.             foreach ($this->nodes as $name => $node) {
  89.                 $len = \strlen($name) + 6;
  90.                 $noderepr = [];
  91.                 foreach (explode("\n", (string) $node) as $line) {
  92.                     $noderepr[] = str_repeat(' ', $len).$line;
  93.                 }
  95.                 $repr .= \sprintf("\n    %s: %s", $name, ltrim(implode("\n", $noderepr)));
  96.             }
  97.         }
  99.         return $repr;
  100.     }
  102.     /**
  103.      * @return void
  104.      */
  105.     public function compile(Compiler $compiler)
  106.     {
  107.         foreach ($this->nodes as $node) {
  108.             $compiler->subcompile($node);
  109.         }
  110.     }
  112.     public function getTemplateLine(): int
  113.     {
  114.         return $this->lineno;
  115.     }
  117.     public function getNodeTag(): ?string
  118.     {
  119.         return $this->tag;
  120.     }
  122.     /**
  123.      * @internal
  124.      */
  125.     public function setNodeTag(string $tag): void
  126.     {
  127.         if ($this->tag) {
  128.             throw new \LogicException('The tag of a node can only be set once.');
  129.         }
  131.         $this->tag = $tag;
  132.     }
  134.     public function hasAttribute(string $name): bool
  135.     {
  136.         return \array_key_exists($name, $this->attributes);
  137.     }
  139.     public function getAttribute(string $name)
  140.     {
  141.         if (!\array_key_exists($name, $this->attributes)) {
  142.             throw new \LogicException(\sprintf('Attribute "%s" does not exist for Node "%s".', $name, static::class));
  143.         }
  145.         $triggerDeprecation = \func_num_args() > 1 ? func_get_arg(1) : true;
  146.         if ($triggerDeprecation && isset($this->attributeNameDeprecations[$name])) {
  147.             $dep = $this->attributeNameDeprecations[$name];
  148.             if ($dep->getNewName()) {
  149.                 trigger_deprecation($dep->getPackage(), $dep->getVersion(), 'Getting attribute "%s" on a "%s" class is deprecated, get the "%s" attribute instead.', $name, static::class, $dep->getNewName());
  150.             } else {
  151.                 trigger_deprecation($dep->getPackage(), $dep->getVersion(), 'Getting attribute "%s" on a "%s" class is deprecated.', $name, static::class);
  152.             }
  153.         }
  155.         return $this->attributes[$name];
  156.     }
  158.     public function setAttribute(string $name, $value): void
  159.     {
  160.         $triggerDeprecation = \func_num_args() > 2 ? func_get_arg(2) : true;
  161.         if ($triggerDeprecation && isset($this->attributeNameDeprecations[$name])) {
  162.             $dep = $this->attributeNameDeprecations[$name];
  163.             if ($dep->getNewName()) {
  164.                 trigger_deprecation($dep->getPackage(), $dep->getVersion(), 'Setting attribute "%s" on a "%s" class is deprecated, set the "%s" attribute instead.', $name, static::class, $dep->getNewName());
  165.             } else {
  166.                 trigger_deprecation($dep->getPackage(), $dep->getVersion(), 'Setting attribute "%s" on a "%s" class is deprecated.', $name, static::class);
  167.             }
  168.         }
  170.         $this->attributes[$name] = $value;
  171.     }
  173.     public function deprecateAttribute(string $name, NameDeprecation $dep): void
  174.     {
  175.         $this->attributeNameDeprecations[$name] = $dep;
  176.     }
  178.     public function removeAttribute(string $name): void
  179.     {
  180.         unset($this->attributes[$name]);
  181.     }
  183.     /**
  184.      * @param string|int $name
  185.      */
  186.     public function hasNode(string $name): bool
  187.     {
  188.         return isset($this->nodes[$name]);
  189.     }
  191.     /**
  192.      * @param string|int $name
  193.      */
  194.     public function getNode(string $name): self
  195.     {
  196.         if (!isset($this->nodes[$name])) {
  197.             throw new \LogicException(\sprintf('Node "%s" does not exist for Node "%s".', $name, static::class));
  198.         }
  200.         $triggerDeprecation = \func_num_args() > 1 ? func_get_arg(1) : true;
  201.         if ($triggerDeprecation && isset($this->nodeNameDeprecations[$name])) {
  202.             $dep = $this->nodeNameDeprecations[$name];
  203.             if ($dep->getNewName()) {
  204.                 trigger_deprecation($dep->getPackage(), $dep->getVersion(), 'Getting node "%s" on a "%s" class is deprecated, get the "%s" node instead.', $name, static::class, $dep->getNewName());
  205.             } else {
  206.                 trigger_deprecation($dep->getPackage(), $dep->getVersion(), 'Getting node "%s" on a "%s" class is deprecated.', $name, static::class);
  207.             }
  208.         }
  210.         return $this->nodes[$name];
  211.     }
  213.     /**
  214.      * @param string|int $name
  215.      */
  216.     public function setNode(string $name, self $node): void
  217.     {
  218.         $triggerDeprecation = \func_num_args() > 2 ? func_get_arg(2) : true;
  219.         if ($triggerDeprecation && isset($this->nodeNameDeprecations[$name])) {
  220.             $dep = $this->nodeNameDeprecations[$name];
  221.             if ($dep->getNewName()) {
  222.                 trigger_deprecation($dep->getPackage(), $dep->getVersion(), 'Setting node "%s" on a "%s" class is deprecated, set the "%s" node instead.', $name, static::class, $dep->getNewName());
  223.             } else {
  224.                 trigger_deprecation($dep->getPackage(), $dep->getVersion(), 'Setting node "%s" on a "%s" class is deprecated.', $name, static::class);
  225.             }
  226.         }
  228.         if (null !== $this->sourceContext) {
  229.             $node->setSourceContext($this->sourceContext);
  230.         }
  231.         $this->nodes[$name] = $node;
  232.     }
  234.     /**
  235.      * @param string|int $name
  236.      */
  237.     public function removeNode(string $name): void
  238.     {
  239.         unset($this->nodes[$name]);
  240.     }
  242.     /**
  243.      * @param string|int $name
  244.      */
  245.     public function deprecateNode(string $name, NameDeprecation $dep): void
  246.     {
  247.         $this->nodeNameDeprecations[$name] = $dep;
  248.     }
  250.     /**
  251.      * @return int
  252.      */
  253.     #[\ReturnTypeWillChange]
  254.     public function count()
  255.     {
  256.         return \count($this->nodes);
  257.     }
  259.     public function getIterator(): \Traversable
  260.     {
  261.         return new \ArrayIterator($this->nodes);
  262.     }
  264.     public function getTemplateName(): ?string
  265.     {
  266.         return $this->sourceContext ? $this->sourceContext->getName() : null;
  267.     }
  269.     public function setSourceContext(Source $source): void
  270.     {
  271.         $this->sourceContext = $source;
  272.         foreach ($this->nodes as $node) {
  273.             $node->setSourceContext($source);
  274.         }
  275.     }
  277.     public function getSourceContext(): ?Source
  278.     {
  279.         return $this->sourceContext;
  280.     }
  281. }