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

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): (TwigTest|false)> */
  63.     private $testCallbacks = [];
  64.     /** @var array<callable(string): (TokenParserInterface|false)> */
  65.     private $parserCallbacks = [];
  66.     private $lastModified = 0;
  68.     public function __construct()
  69.     {
  70.         $this->staging = new StagingExtension();
  71.     }
  73.     /**
  74.      * @return void
  75.      */
  76.     public function initRuntime()
  77.     {
  78.         $this->runtimeInitialized = true;
  79.     }
  81.     public function hasExtension(string $class): bool
  82.     {
  83.         return isset($this->extensions[ltrim($class, '\\')]);
  84.     }
  86.     public function getExtension(string $class): ExtensionInterface
  87.     {
  88.         $class = ltrim($class, '\\');
  90.         if (!isset($this->extensions[$class])) {
  91.             throw new RuntimeError(\sprintf('The "%s" extension is not enabled.', $class));
  92.         }
  94.         return $this->extensions[$class];
  95.     }
  97.     /**
  98.      * @param ExtensionInterface[] $extensions
  99.      */
  100.     public function setExtensions(array $extensions): void
  101.     {
  102.         foreach ($extensions as $extension) {
  103.             $this->addExtension($extension);
  104.         }
  105.     }
  107.     /**
  108.      * @return ExtensionInterface[]
  109.      */
  110.     public function getExtensions(): array
  111.     {
  112.         return $this->extensions;
  113.     }
  115.     public function getSignature(): string
  116.     {
  117.         return json_encode(array_keys($this->extensions));
  118.     }
  120.     public function isInitialized(): bool
  121.     {
  122.         return $this->initialized || $this->runtimeInitialized;
  123.     }
  125.     public function getLastModified(): int
  126.     {
  127.         if (0 !== $this->lastModified) {
  128.             return $this->lastModified;
  129.         }
  131.         $lastModified = 0;
  132.         foreach ($this->extensions as $extension) {
  133.             if ($extension instanceof LastModifiedExtensionInterface) {
  134.                 $lastModified = max($extension->getLastModified(), $lastModified);
  135.             } else {
  136.                 $r = new \ReflectionObject($extension);
  137.                 if (is_file($r->getFileName())) {
  138.                     $lastModified = max(filemtime($r->getFileName()), $lastModified);
  139.                 }
  140.             }
  141.         }
  143.         return $this->lastModified = $lastModified;
  144.     }
  146.     public function addExtension(ExtensionInterface $extension): void
  147.     {
  148.         if ($extension instanceof AttributeExtension) {
  149.             $class = $extension->getClass();
  150.         } else {
  151.             $class = $extension::class;
  152.         }
  154.         if ($this->initialized) {
  155.             throw new \LogicException(\sprintf('Unable to register extension "%s" as extensions have already been initialized.', $class));
  156.         }
  158.         if (isset($this->extensions[$class])) {
  159.             throw new \LogicException(\sprintf('Unable to register extension "%s" as it is already registered.', $class));
  160.         }
  162.         $this->extensions[$class] = $extension;
  163.     }
  165.     public function addFunction(TwigFunction $function): void
  166.     {
  167.         if ($this->initialized) {
  168.             throw new \LogicException(\sprintf('Unable to add function "%s" as extensions have already been initialized.', $function->getName()));
  169.         }
  171.         $this->staging->addFunction($function);
  172.     }
  174.     /**
  175.      * @return TwigFunction[]
  176.      */
  177.     public function getFunctions(): array
  178.     {
  179.         if (!$this->initialized) {
  180.             $this->initExtensions();
  181.         }
  183.         return $this->functions;
  184.     }
  186.     public function getFunction(string $name): ?TwigFunction
  187.     {
  188.         if (!$this->initialized) {
  189.             $this->initExtensions();
  190.         }
  192.         if (isset($this->functions[$name])) {
  193.             return $this->functions[$name];
  194.         }
  196.         foreach ($this->dynamicFunctions as $pattern => $function) {
  197.             if (preg_match($pattern, $name, $matches)) {
  198.                 array_shift($matches);
  200.                 return $function->withDynamicArguments($name, $function->getName(), $matches);
  201.             }
  202.         }
  204.         foreach ($this->functionCallbacks as $callback) {
  205.             if (false !== $function = $callback($name)) {
  206.                 return $function;
  207.             }
  208.         }
  210.         return null;
  211.     }
  213.     /**
  214.      * @param callable(string): (TwigFunction|false) $callable
  215.      */
  216.     public function registerUndefinedFunctionCallback(callable $callable): void
  217.     {
  218.         $this->functionCallbacks[] = $callable;
  219.     }
  221.     public function addFilter(TwigFilter $filter): void
  222.     {
  223.         if ($this->initialized) {
  224.             throw new \LogicException(\sprintf('Unable to add filter "%s" as extensions have already been initialized.', $filter->getName()));
  225.         }
  227.         $this->staging->addFilter($filter);
  228.     }
  230.     /**
  231.      * @return TwigFilter[]
  232.      */
  233.     public function getFilters(): array
  234.     {
  235.         if (!$this->initialized) {
  236.             $this->initExtensions();
  237.         }
  239.         return $this->filters;
  240.     }
  242.     public function getFilter(string $name): ?TwigFilter
  243.     {
  244.         if (!$this->initialized) {
  245.             $this->initExtensions();
  246.         }
  248.         if (isset($this->filters[$name])) {
  249.             return $this->filters[$name];
  250.         }
  252.         foreach ($this->dynamicFilters as $pattern => $filter) {
  253.             if (preg_match($pattern, $name, $matches)) {
  254.                 array_shift($matches);
  256.                 return $filter->withDynamicArguments($name, $filter->getName(), $matches);
  257.             }
  258.         }
  260.         foreach ($this->filterCallbacks as $callback) {
  261.             if (false !== $filter = $callback($name)) {
  262.                 return $filter;
  263.             }
  264.         }
  266.         return null;
  267.     }
  269.     /**
  270.      * @param callable(string): (TwigFilter|false) $callable
  271.      */
  272.     public function registerUndefinedFilterCallback(callable $callable): void
  273.     {
  274.         $this->filterCallbacks[] = $callable;
  275.     }
  277.     public function addNodeVisitor(NodeVisitorInterface $visitor): void
  278.     {
  279.         if ($this->initialized) {
  280.             throw new \LogicException('Unable to add a node visitor as extensions have already been initialized.');
  281.         }
  283.         $this->staging->addNodeVisitor($visitor);
  284.     }
  286.     /**
  287.      * @return NodeVisitorInterface[]
  288.      */
  289.     public function getNodeVisitors(): array
  290.     {
  291.         if (!$this->initialized) {
  292.             $this->initExtensions();
  293.         }
  295.         return $this->visitors;
  296.     }
  298.     public function addTokenParser(TokenParserInterface $parser): void
  299.     {
  300.         if ($this->initialized) {
  301.             throw new \LogicException('Unable to add a token parser as extensions have already been initialized.');
  302.         }
  304.         $this->staging->addTokenParser($parser);
  305.     }
  307.     /**
  308.      * @return TokenParserInterface[]
  309.      */
  310.     public function getTokenParsers(): array
  311.     {
  312.         if (!$this->initialized) {
  313.             $this->initExtensions();
  314.         }
  316.         return $this->parsers;
  317.     }
  319.     public function getTokenParser(string $name): ?TokenParserInterface
  320.     {
  321.         if (!$this->initialized) {
  322.             $this->initExtensions();
  323.         }
  325.         if (isset($this->parsers[$name])) {
  326.             return $this->parsers[$name];
  327.         }
  329.         foreach ($this->parserCallbacks as $callback) {
  330.             if (false !== $parser = $callback($name)) {
  331.                 return $parser;
  332.             }
  333.         }
  335.         return null;
  336.     }
  338.     /**
  339.      * @param callable(string): (TokenParserInterface|false) $callable
  340.      */
  341.     public function registerUndefinedTokenParserCallback(callable $callable): void
  342.     {
  343.         $this->parserCallbacks[] = $callable;
  344.     }
  346.     /**
  347.      * @return array<string, mixed>
  348.      */
  349.     public function getGlobals(): array
  350.     {
  351.         if (null !== $this->globals) {
  352.             return $this->globals;
  353.         }
  355.         $globals = [];
  356.         foreach ($this->extensions as $extension) {
  357.             if (!$extension instanceof GlobalsInterface) {
  358.                 continue;
  359.             }
  361.             $globals = array_merge($globals, $extension->getGlobals());
  362.         }
  364.         if ($this->initialized) {
  365.             $this->globals = $globals;
  366.         }
  368.         return $globals;
  369.     }
  371.     public function resetGlobals(): void
  372.     {
  373.         $this->globals = null;
  374.     }
  376.     public function addTest(TwigTest $test): void
  377.     {
  378.         if ($this->initialized) {
  379.             throw new \LogicException(\sprintf('Unable to add test "%s" as extensions have already been initialized.', $test->getName()));
  380.         }
  382.         $this->staging->addTest($test);
  383.     }
  385.     /**
  386.      * @return TwigTest[]
  387.      */
  388.     public function getTests(): array
  389.     {
  390.         if (!$this->initialized) {
  391.             $this->initExtensions();
  392.         }
  394.         return $this->tests;
  395.     }
  397.     public function getTest(string $name): ?TwigTest
  398.     {
  399.         if (!$this->initialized) {
  400.             $this->initExtensions();
  401.         }
  403.         if (isset($this->tests[$name])) {
  404.             return $this->tests[$name];
  405.         }
  407.         foreach ($this->dynamicTests as $pattern => $test) {
  408.             if (preg_match($pattern, $name, $matches)) {
  409.                 array_shift($matches);
  411.                 return $test->withDynamicArguments($name, $test->getName(), $matches);
  412.             }
  413.         }
  415.         foreach ($this->testCallbacks as $callback) {
  416.             if (false !== $test = $callback($name)) {
  417.                 return $test;
  418.             }
  419.         }
  421.         return null;
  422.     }
  424.     /**
  425.      * @param callable(string): (TwigTest|false) $callable
  426.      */
  427.     public function registerUndefinedTestCallback(callable $callable): void
  428.     {
  429.         $this->testCallbacks[] = $callable;
  430.     }
  432.     public function getExpressionParsers(): ExpressionParsers
  433.     {
  434.         if (!$this->initialized) {
  435.             $this->initExtensions();
  436.         }
  438.         return $this->expressionParsers;
  439.     }
  441.     private function initExtensions(): void
  442.     {
  443.         $this->parsers = [];
  444.         $this->filters = [];
  445.         $this->functions = [];
  446.         $this->tests = [];
  447.         $this->dynamicFilters = [];
  448.         $this->dynamicFunctions = [];
  449.         $this->dynamicTests = [];
  450.         $this->visitors = [];
  451.         $this->expressionParsers = new ExpressionParsers();
  453.         foreach ($this->extensions as $extension) {
  454.             $this->initExtension($extension);
  455.         }
  456.         $this->initExtension($this->staging);
  457.         // Done at the end only, so that an exception during initialization does not mark the environment as initialized when catching the exception
  458.         $this->initialized = true;
  459.     }
  461.     private function initExtension(ExtensionInterface $extension): void
  462.     {
  463.         // filters
  464.         foreach ($extension->getFilters() as $filter) {
  465.             $this->filters[$name = $filter->getName()] = $filter;
  466.             if (str_contains($name, '*')) {
  467.                 $this->dynamicFilters['#^'.str_replace('\\*', '(.*?)', preg_quote($name, '#')).'$#'] = $filter;
  468.             }
  469.         }
  471.         // functions
  472.         foreach ($extension->getFunctions() as $function) {
  473.             $this->functions[$name = $function->getName()] = $function;
  474.             if (str_contains($name, '*')) {
  475.                 $this->dynamicFunctions['#^'.str_replace('\\*', '(.*?)', preg_quote($name, '#')).'$#'] = $function;
  476.             }
  477.         }
  479.         // tests
  480.         foreach ($extension->getTests() as $test) {
  481.             $this->tests[$name = $test->getName()] = $test;
  482.             if (str_contains($name, '*')) {
  483.                 $this->dynamicTests['#^'.str_replace('\\*', '(.*?)', preg_quote($name, '#')).'$#'] = $test;
  484.             }
  485.         }
  487.         // token parsers
  488.         foreach ($extension->getTokenParsers() as $parser) {
  489.             if (!$parser instanceof TokenParserInterface) {
  490.                 throw new \LogicException('getTokenParsers() must return an array of \Twig\TokenParser\TokenParserInterface.');
  491.             }
  493.             $this->parsers[$parser->getTag()] = $parser;
  494.         }
  496.         // node visitors
  497.         foreach ($extension->getNodeVisitors() as $visitor) {
  498.             $this->visitors[] = $visitor;
  499.         }
  501.         // expression parsers
  502.         if (method_exists($extension, 'getExpressionParsers')) {
  503.             $this->expressionParsers->add($extension->getExpressionParsers());
  504.         }
  506.         $operators = $extension->getOperators();
  507.         if (!\is_array($operators)) {
  508.             throw new \InvalidArgumentException(\sprintf('"%s::getOperators()" must return an array with operators, got "%s".', $extension::class, get_debug_type($operators).(\is_resource($operators) ? '' : '#'.$operators)));
  509.         }
  511.         if (2 !== \count($operators)) {
  512.             throw new \InvalidArgumentException(\sprintf('"%s::getOperators()" must return an array of 2 elements, got %d.', $extension::class, \count($operators)));
  513.         }
  515.         $expressionParsers = [];
  516.         foreach ($operators[0] as $operator => $op) {
  517.             $expressionParsers[] = new UnaryOperatorExpressionParser($op['class'], $operator, $op['precedence'], $op['precedence_change'] ?? null, '', $op['aliases'] ?? []);
  518.         }
  519.         foreach ($operators[1] as $operator => $op) {
  520.             $op['associativity'] = match ($op['associativity']) {
  521.                 1 => InfixAssociativity::Left,
  522.                 2 => InfixAssociativity::Right,
  523.                 default => throw new \InvalidArgumentException(\sprintf('Invalid associativity "%s" for operator "%s".', $op['associativity'], $operator)),
  524.             };
  526.             if (isset($op['callable'])) {
  527.                 $expressionParsers[] = $this->convertInfixExpressionParser($op['class'], $operator, $op['precedence'], $op['associativity'], $op['precedence_change'] ?? null, $op['aliases'] ?? [], $op['callable']);
  528.             } else {
  529.                 $expressionParsers[] = new BinaryOperatorExpressionParser($op['class'], $operator, $op['precedence'], $op['associativity'], $op['precedence_change'] ?? null, '', $op['aliases'] ?? []);
  530.             }
  531.         }
  533.         if (\count($expressionParsers)) {
  534.             trigger_deprecation('twig/twig', '3.21', \sprintf('Extension "%s" uses the old signature for "getOperators()", please implement "getExpressionParsers()" instead.', $extension::class));
  536.             $this->expressionParsers->add($expressionParsers);
  537.         }
  538.     }
  540.     private function convertInfixExpressionParser(string $nodeClass, string $operator, int $precedence, InfixAssociativity $associativity, ?PrecedenceChange $precedenceChange, array $aliases, callable $callable): InfixExpressionParserInterface
  541.     {
  542.         trigger_deprecation('twig/twig', '3.21', \sprintf('Using a non-ExpressionParserInterface object to define the "%s" binary operator is deprecated.', $operator));
  544.         return new class($nodeClass, $operator, $precedence, $associativity, $precedenceChange, $aliases, $callable) extends BinaryOperatorExpressionParser {
  545.             public function __construct(
  546.                 string $nodeClass,
  547.                 string $operator,
  548.                 int $precedence,
  549.                 InfixAssociativity $associativity = InfixAssociativity::Left,
  550.                 ?PrecedenceChange $precedenceChange = null,
  551.                 array $aliases = [],
  552.                 private $callable = null,
  553.             ) {
  554.                 parent::__construct($nodeClass, $operator, $precedence, $associativity, $precedenceChange, $aliases);
  555.             }
  557.             public function parse(Parser $parser, AbstractExpression $expr, Token $token): AbstractExpression
  558.             {
  559.                 return ($this->callable)($parser, $expr);
  560.             }
  561.         };
  562.     }
  563. }