vendor/twig/twig/src/ExtensionSet.php line 425

Open in your IDE?
  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;
  14. use Twig\Error\RuntimeError;
  15. use Twig\ExpressionParser\ExpressionParsers;
  16. use Twig\ExpressionParser\Infix\BinaryOperatorExpressionParser;
  17. use Twig\ExpressionParser\InfixAssociativity;
  18. use Twig\ExpressionParser\InfixExpressionParserInterface;
  19. use Twig\ExpressionParser\PrecedenceChange;
  20. use Twig\ExpressionParser\Prefix\UnaryOperatorExpressionParser;
  21. use Twig\Extension\AttributeExtension;
  22. use Twig\Extension\ExtensionInterface;
  23. use Twig\Extension\GlobalsInterface;
  24. use Twig\Extension\LastModifiedExtensionInterface;
  25. use Twig\Extension\StagingExtension;
  26. use Twig\Node\Expression\AbstractExpression;
  27. use Twig\NodeVisitor\NodeVisitorInterface;
  28. use Twig\TokenParser\TokenParserInterface;
  30. /**
  31.  * @author Fabien Potencier <fabien@symfony.com>
  32.  *
  33.  * @internal
  34.  */
  35. final class ExtensionSet
  36. {
  37.     private $extensions;
  38.     private $initialized = false;
  39.     private $runtimeInitialized = false;
  40.     private $staging;
  41.     private $parsers;
  42.     private $visitors;
  43.     /** @var array<string, TwigFilter> */
  44.     private $filters;
  45.     /** @var array<string, TwigFilter> */
  46.     private $dynamicFilters;
  47.     /** @var array<string, TwigTest> */
  48.     private $tests;
  49.     /** @var array<string, TwigTest> */
  50.     private $dynamicTests;
  51.     /** @var array<string, TwigFunction> */
  52.     private $functions;
  53.     /** @var array<string, TwigFunction> */
  54.     private $dynamicFunctions;
  55.     private ExpressionParsers $expressionParsers;
  56.     /** @var array<string, mixed>|null */
  57.     private $globals;
  58.     /** @var array<callable(string): (TwigFunction|false)> */
  59.     private $functionCallbacks = [];
  60.     /** @var array<callable(string): (TwigFilter|false)> */
  61.     private $filterCallbacks = [];
  62.     /** @var array<callable(string): (TokenParserInterface|false)> */
  63.     private $parserCallbacks = [];
  64.     private $lastModified = 0;
  66.     public function __construct()
  67.     {
  68.         $this->staging = new StagingExtension();
  69.     }
  71.     /**
  72.      * @return void
  73.      */
  74.     public function initRuntime()
  75.     {
  76.         $this->runtimeInitialized = true;
  77.     }
  79.     public function hasExtension(string $class): bool
  80.     {
  81.         return isset($this->extensions[ltrim($class, '\\')]);
  82.     }
  84.     public function getExtension(string $class): ExtensionInterface
  85.     {
  86.         $class = ltrim($class, '\\');
  88.         if (!isset($this->extensions[$class])) {
  89.             throw new RuntimeError(\sprintf('The "%s" extension is not enabled.', $class));
  90.         }
  92.         return $this->extensions[$class];
  93.     }
  95.     /**
  96.      * @param ExtensionInterface[] $extensions
  97.      */
  98.     public function setExtensions(array $extensions): void
  99.     {
  100.         foreach ($extensions as $extension) {
  101.             $this->addExtension($extension);
  102.         }
  103.     }
  105.     /**
  106.      * @return ExtensionInterface[]
  107.      */
  108.     public function getExtensions(): array
  109.     {
  110.         return $this->extensions;
  111.     }
  113.     public function getSignature(): string
  114.     {
  115.         return json_encode(array_keys($this->extensions));
  116.     }
  118.     public function isInitialized(): bool
  119.     {
  120.         return $this->initialized || $this->runtimeInitialized;
  121.     }
  123.     public function getLastModified(): int
  124.     {
  125.         if (0 !== $this->lastModified) {
  126.             return $this->lastModified;
  127.         }
  129.         $lastModified = 0;
  130.         foreach ($this->extensions as $extension) {
  131.             if ($extension instanceof LastModifiedExtensionInterface) {
  132.                 $lastModified = max($extension->getLastModified(), $lastModified);
  133.             } else {
  134.                 $r = new \ReflectionObject($extension);
  135.                 if (is_file($r->getFileName())) {
  136.                     $lastModified = max(filemtime($r->getFileName()), $lastModified);
  137.                 }
  138.             }
  139.         }
  141.         return $this->lastModified = $lastModified;
  142.     }
  144.     public function addExtension(ExtensionInterface $extension): void
  145.     {
  146.         if ($extension instanceof AttributeExtension) {
  147.             $class = $extension->getClass();
  148.         } else {
  149.             $class = $extension::class;
  150.         }
  152.         if ($this->initialized) {
  153.             throw new \LogicException(\sprintf('Unable to register extension "%s" as extensions have already been initialized.', $class));
  154.         }
  156.         if (isset($this->extensions[$class])) {
  157.             throw new \LogicException(\sprintf('Unable to register extension "%s" as it is already registered.', $class));
  158.         }
  160.         $this->extensions[$class] = $extension;
  161.     }
  163.     public function addFunction(TwigFunction $function): void
  164.     {
  165.         if ($this->initialized) {
  166.             throw new \LogicException(\sprintf('Unable to add function "%s" as extensions have already been initialized.', $function->getName()));
  167.         }
  169.         $this->staging->addFunction($function);
  170.     }
  172.     /**
  173.      * @return TwigFunction[]
  174.      */
  175.     public function getFunctions(): array
  176.     {
  177.         if (!$this->initialized) {
  178.             $this->initExtensions();
  179.         }
  181.         return $this->functions;
  182.     }
  184.     public function getFunction(string $name): ?TwigFunction
  185.     {
  186.         if (!$this->initialized) {
  187.             $this->initExtensions();
  188.         }
  190.         if (isset($this->functions[$name])) {
  191.             return $this->functions[$name];
  192.         }
  194.         foreach ($this->dynamicFunctions as $pattern => $function) {
  195.             if (preg_match($pattern, $name, $matches)) {
  196.                 array_shift($matches);
  198.                 return $function->withDynamicArguments($name, $function->getName(), $matches);
  199.             }
  200.         }
  202.         foreach ($this->functionCallbacks as $callback) {
  203.             if (false !== $function = $callback($name)) {
  204.                 return $function;
  205.             }
  206.         }
  208.         return null;
  209.     }
  211.     /**
  212.      * @param callable(string): (TwigFunction|false) $callable
  213.      */
  214.     public function registerUndefinedFunctionCallback(callable $callable): void
  215.     {
  216.         $this->functionCallbacks[] = $callable;
  217.     }
  219.     public function addFilter(TwigFilter $filter): void
  220.     {
  221.         if ($this->initialized) {
  222.             throw new \LogicException(\sprintf('Unable to add filter "%s" as extensions have already been initialized.', $filter->getName()));
  223.         }
  225.         $this->staging->addFilter($filter);
  226.     }
  228.     /**
  229.      * @return TwigFilter[]
  230.      */
  231.     public function getFilters(): array
  232.     {
  233.         if (!$this->initialized) {
  234.             $this->initExtensions();
  235.         }
  237.         return $this->filters;
  238.     }
  240.     public function getFilter(string $name): ?TwigFilter
  241.     {
  242.         if (!$this->initialized) {
  243.             $this->initExtensions();
  244.         }
  246.         if (isset($this->filters[$name])) {
  247.             return $this->filters[$name];
  248.         }
  250.         foreach ($this->dynamicFilters as $pattern => $filter) {
  251.             if (preg_match($pattern, $name, $matches)) {
  252.                 array_shift($matches);
  254.                 return $filter->withDynamicArguments($name, $filter->getName(), $matches);
  255.             }
  256.         }
  258.         foreach ($this->filterCallbacks as $callback) {
  259.             if (false !== $filter = $callback($name)) {
  260.                 return $filter;
  261.             }
  262.         }
  264.         return null;
  265.     }
  267.     /**
  268.      * @param callable(string): (TwigFilter|false) $callable
  269.      */
  270.     public function registerUndefinedFilterCallback(callable $callable): void
  271.     {
  272.         $this->filterCallbacks[] = $callable;
  273.     }
  275.     public function addNodeVisitor(NodeVisitorInterface $visitor): void
  276.     {
  277.         if ($this->initialized) {
  278.             throw new \LogicException('Unable to add a node visitor as extensions have already been initialized.');
  279.         }
  281.         $this->staging->addNodeVisitor($visitor);
  282.     }
  284.     /**
  285.      * @return NodeVisitorInterface[]
  286.      */
  287.     public function getNodeVisitors(): array
  288.     {
  289.         if (!$this->initialized) {
  290.             $this->initExtensions();
  291.         }
  293.         return $this->visitors;
  294.     }
  296.     public function addTokenParser(TokenParserInterface $parser): void
  297.     {
  298.         if ($this->initialized) {
  299.             throw new \LogicException('Unable to add a token parser as extensions have already been initialized.');
  300.         }
  302.         $this->staging->addTokenParser($parser);
  303.     }
  305.     /**
  306.      * @return TokenParserInterface[]
  307.      */
  308.     public function getTokenParsers(): array
  309.     {
  310.         if (!$this->initialized) {
  311.             $this->initExtensions();
  312.         }
  314.         return $this->parsers;
  315.     }
  317.     public function getTokenParser(string $name): ?TokenParserInterface
  318.     {
  319.         if (!$this->initialized) {
  320.             $this->initExtensions();
  321.         }
  323.         if (isset($this->parsers[$name])) {
  324.             return $this->parsers[$name];
  325.         }
  327.         foreach ($this->parserCallbacks as $callback) {
  328.             if (false !== $parser = $callback($name)) {
  329.                 return $parser;
  330.             }
  331.         }
  333.         return null;
  334.     }
  336.     /**
  337.      * @param callable(string): (TokenParserInterface|false) $callable
  338.      */
  339.     public function registerUndefinedTokenParserCallback(callable $callable): void
  340.     {
  341.         $this->parserCallbacks[] = $callable;
  342.     }
  344.     /**
  345.      * @return array<string, mixed>
  346.      */
  347.     public function getGlobals(): array
  348.     {
  349.         if (null !== $this->globals) {
  350.             return $this->globals;
  351.         }
  353.         $globals = [];
  354.         foreach ($this->extensions as $extension) {
  355.             if (!$extension instanceof GlobalsInterface) {
  356.                 continue;
  357.             }
  359.             $globals = array_merge($globals, $extension->getGlobals());
  360.         }
  362.         if ($this->initialized) {
  363.             $this->globals = $globals;
  364.         }
  366.         return $globals;
  367.     }
  369.     public function resetGlobals(): void
  370.     {
  371.         $this->globals = null;
  372.     }
  374.     public function addTest(TwigTest $test): void
  375.     {
  376.         if ($this->initialized) {
  377.             throw new \LogicException(\sprintf('Unable to add test "%s" as extensions have already been initialized.', $test->getName()));
  378.         }
  380.         $this->staging->addTest($test);
  381.     }
  383.     /**
  384.      * @return TwigTest[]
  385.      */
  386.     public function getTests(): array
  387.     {
  388.         if (!$this->initialized) {
  389.             $this->initExtensions();
  390.         }
  392.         return $this->tests;
  393.     }
  395.     public function getTest(string $name): ?TwigTest
  396.     {
  397.         if (!$this->initialized) {
  398.             $this->initExtensions();
  399.         }
  401.         if (isset($this->tests[$name])) {
  402.             return $this->tests[$name];
  403.         }
  405.         foreach ($this->dynamicTests as $pattern => $test) {
  406.             if (preg_match($pattern, $name, $matches)) {
  407.                 array_shift($matches);
  409.                 return $test->withDynamicArguments($name, $test->getName(), $matches);
  410.             }
  411.         }
  413.         return null;
  414.     }
  416.     public function getExpressionParsers(): ExpressionParsers
  417.     {
  418.         if (!$this->initialized) {
  419.             $this->initExtensions();
  420.         }
  422.         return $this->expressionParsers;
  423.     }
  425.     private function initExtensions(): void
  426.     {
  427.         $this->parsers = [];
  428.         $this->filters = [];
  429.         $this->functions = [];
  430.         $this->tests = [];
  431.         $this->dynamicFilters = [];
  432.         $this->dynamicFunctions = [];
  433.         $this->dynamicTests = [];
  434.         $this->visitors = [];
  435.         $this->expressionParsers = new ExpressionParsers();
  437.         foreach ($this->extensions as $extension) {
  438.             $this->initExtension($extension);
  439.         }
  440.         $this->initExtension($this->staging);
  441.         // Done at the end only, so that an exception during initialization does not mark the environment as initialized when catching the exception
  442.         $this->initialized = true;
  443.     }
  445.     private function initExtension(ExtensionInterface $extension): void
  446.     {
  447.         // filters
  448.         foreach ($extension->getFilters() as $filter) {
  449.             $this->filters[$name = $filter->getName()] = $filter;
  450.             if (str_contains($name, '*')) {
  451.                 $this->dynamicFilters['#^'.str_replace('\\*', '(.*?)', preg_quote($name, '#')).'$#'] = $filter;
  452.             }
  453.         }
  455.         // functions
  456.         foreach ($extension->getFunctions() as $function) {
  457.             $this->functions[$name = $function->getName()] = $function;
  458.             if (str_contains($name, '*')) {
  459.                 $this->dynamicFunctions['#^'.str_replace('\\*', '(.*?)', preg_quote($name, '#')).'$#'] = $function;
  460.             }
  461.         }
  463.         // tests
  464.         foreach ($extension->getTests() as $test) {
  465.             $this->tests[$name = $test->getName()] = $test;
  466.             if (str_contains($name, '*')) {
  467.                 $this->dynamicTests['#^'.str_replace('\\*', '(.*?)', preg_quote($name, '#')).'$#'] = $test;
  468.             }
  469.         }
  471.         // token parsers
  472.         foreach ($extension->getTokenParsers() as $parser) {
  473.             if (!$parser instanceof TokenParserInterface) {
  474.                 throw new \LogicException('getTokenParsers() must return an array of \Twig\TokenParser\TokenParserInterface.');
  475.             }
  477.             $this->parsers[$parser->getTag()] = $parser;
  478.         }
  480.         // node visitors
  481.         foreach ($extension->getNodeVisitors() as $visitor) {
  482.             $this->visitors[] = $visitor;
  483.         }
  485.         // expression parsers
  486.         if (method_exists($extension, 'getExpressionParsers')) {
  487.             $this->expressionParsers->add($extension->getExpressionParsers());
  488.         }
  490.         $operators = $extension->getOperators();
  491.         if (!\is_array($operators)) {
  492.             throw new \InvalidArgumentException(\sprintf('"%s::getOperators()" must return an array with operators, got "%s".', $extension::class, get_debug_type($operators).(\is_resource($operators) ? '' : '#'.$operators)));
  493.         }
  495.         if (2 !== \count($operators)) {
  496.             throw new \InvalidArgumentException(\sprintf('"%s::getOperators()" must return an array of 2 elements, got %d.', $extension::class, \count($operators)));
  497.         }
  499.         $expressionParsers = [];
  500.         foreach ($operators[0] as $operator => $op) {
  501.             $expressionParsers[] = new UnaryOperatorExpressionParser($op['class'], $operator, $op['precedence'], $op['precedence_change'] ?? null, '', $op['aliases'] ?? []);
  502.         }
  503.         foreach ($operators[1] as $operator => $op) {
  504.             $op['associativity'] = match ($op['associativity']) {
  505.                 1 => InfixAssociativity::Left,
  506.                 2 => InfixAssociativity::Right,
  507.                 default => throw new \InvalidArgumentException(\sprintf('Invalid associativity "%s" for operator "%s".', $op['associativity'], $operator)),
  508.             };
  510.             if (isset($op['callable'])) {
  511.                 $expressionParsers[] = $this->convertInfixExpressionParser($op['class'], $operator, $op['precedence'], $op['associativity'], $op['precedence_change'] ?? null, $op['aliases'] ?? [], $op['callable']);
  512.             } else {
  513.                 $expressionParsers[] = new BinaryOperatorExpressionParser($op['class'], $operator, $op['precedence'], $op['associativity'], $op['precedence_change'] ?? null, '', $op['aliases'] ?? []);
  514.             }
  515.         }
  517.         if (\count($expressionParsers)) {
  518.             trigger_deprecation('twig/twig', '3.21', \sprintf('Extension "%s" uses the old signature for "getOperators()", please implement "getExpressionParsers()" instead.', $extension::class));
  520.             $this->expressionParsers->add($expressionParsers);
  521.         }
  522.     }
  524.     private function convertInfixExpressionParser(string $nodeClass, string $operator, int $precedence, InfixAssociativity $associativity, ?PrecedenceChange $precedenceChange, array $aliases, callable $callable): InfixExpressionParserInterface
  525.     {
  526.         trigger_deprecation('twig/twig', '3.21', \sprintf('Using a non-ExpressionParserInterface object to define the "%s" binary operator is deprecated.', $operator));
  528.         return new class($nodeClass, $operator, $precedence, $associativity, $precedenceChange, $aliases, $callable) extends BinaryOperatorExpressionParser {
  529.             public function __construct(
  530.                 string $nodeClass,
  531.                 string $operator,
  532.                 int $precedence,
  533.                 InfixAssociativity $associativity = InfixAssociativity::Left,
  534.                 ?PrecedenceChange $precedenceChange = null,
  535.                 array $aliases = [],
  536.                 private $callable = null,
  537.             ) {
  538.                 parent::__construct($nodeClass, $operator, $precedence, $associativity, $precedenceChange, $aliases);
  539.             }
  541.             public function parse(Parser $parser, AbstractExpression $expr, Token $token): AbstractExpression
  542.             {
  543.                 return ($this->callable)($parser, $expr);
  544.             }
  545.         };
  546.     }
  547. }