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

Open in your IDE?
  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.  * @implements \IteratorAggregate<int|string, Node>
  25.  */
  26. #[YieldReady]
  27. class Node implements \Countable, \IteratorAggregate
  28. {
  29.     /**
  30.      * @var array<string|int, Node>
  31.      */
  32.     protected $nodes;
  33.     protected $attributes;
  34.     protected $lineno;
  35.     protected $tag;
  37.     private $sourceContext;
  38.     private ?string $documentation = null;
  39.     /** @var array<string, NameDeprecation> */
  40.     private $nodeNameDeprecations = [];
  41.     /** @var array<string, NameDeprecation> */
  42.     private $attributeNameDeprecations = [];
  44.     /**
  45.      * @param array<string|int, Node> $nodes      An array of named nodes
  46.      * @param array                   $attributes An array of attributes (should not be nodes)
  47.      * @param int                     $lineno     The line number
  48.      */
  49.     public function __construct(array $nodes = [], array $attributes = [], int $lineno = 0)
  50.     {
  51.         if (self::class === static::class) {
  52.             trigger_deprecation('twig/twig', '3.15', \sprintf('Instantiating "%s" directly is deprecated; the class will become abstract in 4.0.', self::class));
  53.         }
  55.         foreach ($nodes as $name => $node) {
  56.             if (!$node instanceof self) {
  57.                 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.', get_debug_type($node), $name, static::class));
  58.             }
  59.         }
  60.         $this->nodes = $nodes;
  61.         $this->attributes = $attributes;
  62.         $this->lineno = $lineno;
  64.         if (\func_num_args() > 3) {
  65.             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'));
  66.         }
  67.     }
  69.     public function __toString(): string
  70.     {
  71.         $repr = static::class;
  73.         if ($this->tag) {
  74.             $repr .= \sprintf("\n  tag: %s", $this->tag);
  75.         }
  77.         if (null !== $this->documentation) {
  78.             $repr .= \sprintf("\n  documentation: %s", str_replace("\n", '\\n', $this->documentation));
  79.         }
  81.         $attributes = [];
  82.         foreach ($this->attributes as $name => $value) {
  83.             if (\is_callable($value)) {
  84.                 $v = '\Closure';
  85.             } elseif ($value instanceof \Stringable) {
  86.                 $v = (string) $value;
  87.             } else {
  88.                 $v = str_replace("\n", '', var_export($value, true));
  89.             }
  90.             $attributes[] = \sprintf('%s: %s', $name, $v);
  91.         }
  93.         if ($attributes) {
  94.             $repr .= \sprintf("\n  attributes:\n    %s", implode("\n    ", $attributes));
  95.         }
  97.         if (\count($this->nodes)) {
  98.             $repr .= "\n  nodes:";
  99.             foreach ($this->nodes as $name => $node) {
  100.                 $len = \strlen($name) + 6;
  101.                 $noderepr = [];
  102.                 foreach (explode("\n", (string) $node) as $line) {
  103.                     $noderepr[] = str_repeat(' ', $len).$line;
  104.                 }
  106.                 $repr .= \sprintf("\n    %s: %s", $name, ltrim(implode("\n", $noderepr)));
  107.             }
  108.         }
  110.         return $repr;
  111.     }
  113.     public function __clone()
  114.     {
  115.         foreach ($this->nodes as $name => $node) {
  116.             $this->nodes[$name] = clone $node;
  117.         }
  118.     }
  120.     /**
  121.      * @return void
  122.      */
  123.     public function compile(Compiler $compiler)
  124.     {
  125.         foreach ($this->nodes as $node) {
  126.             $compiler->subcompile($node);
  127.         }
  128.     }
  130.     public function getTemplateLine(): int
  131.     {
  132.         return $this->lineno;
  133.     }
  135.     public function getNodeTag(): ?string
  136.     {
  137.         return $this->tag;
  138.     }
  140.     public function getDocumentation(): ?string
  141.     {
  142.         return $this->documentation;
  143.     }
  145.     /**
  146.      * @internal
  147.      */
  148.     public function setDocumentation(?string $documentation): void
  149.     {
  150.         $this->documentation = $documentation;
  151.     }
  153.     /**
  154.      * @internal
  155.      */
  156.     public function setNodeTag(string $tag): void
  157.     {
  158.         if ($this->tag) {
  159.             throw new \LogicException('The tag of a node can only be set once.');
  160.         }
  162.         $this->tag = $tag;
  163.     }
  165.     public function hasAttribute(string $name): bool
  166.     {
  167.         return \array_key_exists($name, $this->attributes);
  168.     }
  170.     public function getAttribute(string $name)
  171.     {
  172.         if (!\array_key_exists($name, $this->attributes)) {
  173.             throw new \LogicException(\sprintf('Attribute "%s" does not exist for Node "%s".', $name, static::class));
  174.         }
  176.         $triggerDeprecation = \func_num_args() > 1 ? func_get_arg(1) : true;
  177.         if ($triggerDeprecation && isset($this->attributeNameDeprecations[$name])) {
  178.             $dep = $this->attributeNameDeprecations[$name];
  179.             if ($dep->getNewName()) {
  180.                 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());
  181.             } else {
  182.                 trigger_deprecation($dep->getPackage(), $dep->getVersion(), 'Getting attribute "%s" on a "%s" class is deprecated.', $name, static::class);
  183.             }
  184.         }
  186.         return $this->attributes[$name];
  187.     }
  189.     public function setAttribute(string $name, $value): void
  190.     {
  191.         $triggerDeprecation = \func_num_args() > 2 ? func_get_arg(2) : true;
  192.         if ($triggerDeprecation && isset($this->attributeNameDeprecations[$name])) {
  193.             $dep = $this->attributeNameDeprecations[$name];
  194.             if ($dep->getNewName()) {
  195.                 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());
  196.             } else {
  197.                 trigger_deprecation($dep->getPackage(), $dep->getVersion(), 'Setting attribute "%s" on a "%s" class is deprecated.', $name, static::class);
  198.             }
  199.         }
  201.         $this->attributes[$name] = $value;
  202.     }
  204.     public function deprecateAttribute(string $name, NameDeprecation $dep): void
  205.     {
  206.         $this->attributeNameDeprecations[$name] = $dep;
  207.     }
  209.     public function removeAttribute(string $name): void
  210.     {
  211.         unset($this->attributes[$name]);
  212.     }
  214.     /**
  215.      * @param string|int $name
  216.      */
  217.     public function hasNode(string $name): bool
  218.     {
  219.         return isset($this->nodes[$name]);
  220.     }
  222.     /**
  223.      * @param string|int $name
  224.      */
  225.     public function getNode(string $name): self
  226.     {
  227.         if (!isset($this->nodes[$name])) {
  228.             throw new \LogicException(\sprintf('Node "%s" does not exist for Node "%s".', $name, static::class));
  229.         }
  231.         $triggerDeprecation = \func_num_args() > 1 ? func_get_arg(1) : true;
  232.         if ($triggerDeprecation && isset($this->nodeNameDeprecations[$name])) {
  233.             $dep = $this->nodeNameDeprecations[$name];
  234.             if ($dep->getNewName()) {
  235.                 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());
  236.             } else {
  237.                 trigger_deprecation($dep->getPackage(), $dep->getVersion(), 'Getting node "%s" on a "%s" class is deprecated.', $name, static::class);
  238.             }
  239.         }
  241.         return $this->nodes[$name];
  242.     }
  244.     /**
  245.      * @param string|int $name
  246.      */
  247.     public function setNode(string $name, self $node): void
  248.     {
  249.         $triggerDeprecation = \func_num_args() > 2 ? func_get_arg(2) : true;
  250.         if ($triggerDeprecation && isset($this->nodeNameDeprecations[$name])) {
  251.             $dep = $this->nodeNameDeprecations[$name];
  252.             if ($dep->getNewName()) {
  253.                 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());
  254.             } else {
  255.                 trigger_deprecation($dep->getPackage(), $dep->getVersion(), 'Setting node "%s" on a "%s" class is deprecated.', $name, static::class);
  256.             }
  257.         }
  259.         if (null !== $this->sourceContext) {
  260.             $node->setSourceContext($this->sourceContext);
  261.         }
  262.         $this->nodes[$name] = $node;
  263.     }
  265.     /**
  266.      * @param string|int $name
  267.      */
  268.     public function removeNode(string $name): void
  269.     {
  270.         unset($this->nodes[$name]);
  271.     }
  273.     /**
  274.      * @param string|int $name
  275.      */
  276.     public function deprecateNode(string $name, NameDeprecation $dep): void
  277.     {
  278.         $this->nodeNameDeprecations[$name] = $dep;
  279.     }
  281.     /**
  282.      * @return int
  283.      */
  284.     #[\ReturnTypeWillChange]
  285.     public function count()
  286.     {
  287.         return \count($this->nodes);
  288.     }
  290.     public function getIterator(): \Traversable
  291.     {
  292.         return new \ArrayIterator($this->nodes);
  293.     }
  295.     public function getTemplateName(): ?string
  296.     {
  297.         return $this->sourceContext ? $this->sourceContext->getName() : null;
  298.     }
  300.     public function setSourceContext(Source $source): void
  301.     {
  302.         $this->sourceContext = $source;
  303.         foreach ($this->nodes as $node) {
  304.             $node->setSourceContext($source);
  305.         }
  306.     }
  308.     public function getSourceContext(): ?Source
  309.     {
  310.         return $this->sourceContext;
  311.     }
  312. }