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

  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\Extension\ExtensionInterface;
  16. use Twig\Extension\GlobalsInterface;
  17. use Twig\Extension\StagingExtension;
  18. use Twig\Node\Expression\AbstractExpression;
  19. use Twig\Node\Expression\Binary\AbstractBinary;
  20. use Twig\Node\Expression\Unary\AbstractUnary;
  21. use Twig\NodeVisitor\NodeVisitorInterface;
  22. use Twig\TokenParser\TokenParserInterface;
  24. /**
  25.  * @author Fabien Potencier <fabien@symfony.com>
  26.  *
  27.  * @internal
  28.  */
  29. final class ExtensionSet
  30. {
  31.     private $extensions;
  32.     private $initialized = false;
  33.     private $runtimeInitialized = false;
  34.     private $staging;
  35.     private $parsers;
  36.     private $visitors;
  37.     /** @var array<string, TwigFilter> */
  38.     private $filters;
  39.     /** @var array<string, TwigFilter> */
  40.     private $dynamicFilters;
  41.     /** @var array<string, TwigTest> */
  42.     private $tests;
  43.     /** @var array<string, TwigTest> */
  44.     private $dynamicTests;
  45.     /** @var array<string, TwigFunction> */
  46.     private $functions;
  47.     /** @var array<string, TwigFunction> */
  48.     private $dynamicFunctions;
  49.     /** @var array<string, array{precedence: int, class: class-string<AbstractExpression>}> */
  50.     private $unaryOperators;
  51.     /** @var array<string, array{precedence: int, class?: class-string<AbstractExpression>, associativity: ExpressionParser::OPERATOR_*}> */
  52.     private $binaryOperators;
  53.     /** @var array<string, mixed> */
  54.     private $globals;
  55.     private $functionCallbacks = [];
  56.     private $filterCallbacks = [];
  57.     private $parserCallbacks = [];
  58.     private $lastModified = 0;
  60.     public function __construct()
  61.     {
  62.         $this->staging = new StagingExtension();
  63.     }
  65.     public function initRuntime()
  66.     {
  67.         $this->runtimeInitialized = true;
  68.     }
  70.     public function hasExtension(string $class): bool
  71.     {
  72.         return isset($this->extensions[ltrim($class, '\\')]);
  73.     }
  75.     public function getExtension(string $class): ExtensionInterface
  76.     {
  77.         $class = ltrim($class, '\\');
  79.         if (!isset($this->extensions[$class])) {
  80.             throw new RuntimeError(\sprintf('The "%s" extension is not enabled.', $class));
  81.         }
  83.         return $this->extensions[$class];
  84.     }
  86.     /**
  87.      * @param ExtensionInterface[] $extensions
  88.      */
  89.     public function setExtensions(array $extensions): void
  90.     {
  91.         foreach ($extensions as $extension) {
  92.             $this->addExtension($extension);
  93.         }
  94.     }
  96.     /**
  97.      * @return ExtensionInterface[]
  98.      */
  99.     public function getExtensions(): array
  100.     {
  101.         return $this->extensions;
  102.     }
  104.     public function getSignature(): string
  105.     {
  106.         return json_encode(array_keys($this->extensions));
  107.     }
  109.     public function isInitialized(): bool
  110.     {
  111.         return $this->initialized || $this->runtimeInitialized;
  112.     }
  114.     public function getLastModified(): int
  115.     {
  116.         if (0 !== $this->lastModified) {
  117.             return $this->lastModified;
  118.         }
  120.         foreach ($this->extensions as $extension) {
  121.             $r = new \ReflectionObject($extension);
  122.             if (is_file($r->getFileName()) && ($extensionTime = filemtime($r->getFileName())) > $this->lastModified) {
  123.                 $this->lastModified = $extensionTime;
  124.             }
  125.         }
  127.         return $this->lastModified;
  128.     }
  130.     public function addExtension(ExtensionInterface $extension): void
  131.     {
  132.         $class = \get_class($extension);
  134.         if ($this->initialized) {
  135.             throw new \LogicException(\sprintf('Unable to register extension "%s" as extensions have already been initialized.', $class));
  136.         }
  138.         if (isset($this->extensions[$class])) {
  139.             throw new \LogicException(\sprintf('Unable to register extension "%s" as it is already registered.', $class));
  140.         }
  142.         $this->extensions[$class] = $extension;
  143.     }
  145.     public function addFunction(TwigFunction $function): void
  146.     {
  147.         if ($this->initialized) {
  148.             throw new \LogicException(\sprintf('Unable to add function "%s" as extensions have already been initialized.', $function->getName()));
  149.         }
  151.         $this->staging->addFunction($function);
  152.     }
  154.     /**
  155.      * @return TwigFunction[]
  156.      */
  157.     public function getFunctions(): array
  158.     {
  159.         if (!$this->initialized) {
  160.             $this->initExtensions();
  161.         }
  163.         return $this->functions;
  164.     }
  166.     public function getFunction(string $name): ?TwigFunction
  167.     {
  168.         if (!$this->initialized) {
  169.             $this->initExtensions();
  170.         }
  172.         if (isset($this->functions[$name])) {
  173.             return $this->functions[$name];
  174.         }
  176.         foreach ($this->dynamicFunctions as $pattern => $function) {
  177.             if (preg_match($pattern, $name, $matches)) {
  178.                 array_shift($matches);
  180.                 return $function->withDynamicArguments($name, $function->getName(), $matches);
  181.             }
  182.         }
  184.         foreach ($this->functionCallbacks as $callback) {
  185.             if (false !== $function = $callback($name)) {
  186.                 return $function;
  187.             }
  188.         }
  190.         return null;
  191.     }
  193.     public function registerUndefinedFunctionCallback(callable $callable): void
  194.     {
  195.         $this->functionCallbacks[] = $callable;
  196.     }
  198.     public function addFilter(TwigFilter $filter): void
  199.     {
  200.         if ($this->initialized) {
  201.             throw new \LogicException(\sprintf('Unable to add filter "%s" as extensions have already been initialized.', $filter->getName()));
  202.         }
  204.         $this->staging->addFilter($filter);
  205.     }
  207.     /**
  208.      * @return TwigFilter[]
  209.      */
  210.     public function getFilters(): array
  211.     {
  212.         if (!$this->initialized) {
  213.             $this->initExtensions();
  214.         }
  216.         return $this->filters;
  217.     }
  219.     public function getFilter(string $name): ?TwigFilter
  220.     {
  221.         if (!$this->initialized) {
  222.             $this->initExtensions();
  223.         }
  225.         if (isset($this->filters[$name])) {
  226.             return $this->filters[$name];
  227.         }
  229.         foreach ($this->dynamicFilters as $pattern => $filter) {
  230.             if (preg_match($pattern, $name, $matches)) {
  231.                 array_shift($matches);
  233.                 return $filter->withDynamicArguments($name, $filter->getName(), $matches);
  234.             }
  235.         }
  237.         foreach ($this->filterCallbacks as $callback) {
  238.             if (false !== $filter = $callback($name)) {
  239.                 return $filter;
  240.             }
  241.         }
  243.         return null;
  244.     }
  246.     public function registerUndefinedFilterCallback(callable $callable): void
  247.     {
  248.         $this->filterCallbacks[] = $callable;
  249.     }
  251.     public function addNodeVisitor(NodeVisitorInterface $visitor): void
  252.     {
  253.         if ($this->initialized) {
  254.             throw new \LogicException('Unable to add a node visitor as extensions have already been initialized.');
  255.         }
  257.         $this->staging->addNodeVisitor($visitor);
  258.     }
  260.     /**
  261.      * @return NodeVisitorInterface[]
  262.      */
  263.     public function getNodeVisitors(): array
  264.     {
  265.         if (!$this->initialized) {
  266.             $this->initExtensions();
  267.         }
  269.         return $this->visitors;
  270.     }
  272.     public function addTokenParser(TokenParserInterface $parser): void
  273.     {
  274.         if ($this->initialized) {
  275.             throw new \LogicException('Unable to add a token parser as extensions have already been initialized.');
  276.         }
  278.         $this->staging->addTokenParser($parser);
  279.     }
  281.     /**
  282.      * @return TokenParserInterface[]
  283.      */
  284.     public function getTokenParsers(): array
  285.     {
  286.         if (!$this->initialized) {
  287.             $this->initExtensions();
  288.         }
  290.         return $this->parsers;
  291.     }
  293.     public function getTokenParser(string $name): ?TokenParserInterface
  294.     {
  295.         if (!$this->initialized) {
  296.             $this->initExtensions();
  297.         }
  299.         if (isset($this->parsers[$name])) {
  300.             return $this->parsers[$name];
  301.         }
  303.         foreach ($this->parserCallbacks as $callback) {
  304.             if (false !== $parser = $callback($name)) {
  305.                 return $parser;
  306.             }
  307.         }
  309.         return null;
  310.     }
  312.     public function registerUndefinedTokenParserCallback(callable $callable): void
  313.     {
  314.         $this->parserCallbacks[] = $callable;
  315.     }
  317.     /**
  318.      * @return array<string, mixed>
  319.      */
  320.     public function getGlobals(): array
  321.     {
  322.         if (null !== $this->globals) {
  323.             return $this->globals;
  324.         }
  326.         $globals = [];
  327.         foreach ($this->extensions as $extension) {
  328.             if (!$extension instanceof GlobalsInterface) {
  329.                 continue;
  330.             }
  332.             $globals = array_merge($globals, $extension->getGlobals());
  333.         }
  335.         if ($this->initialized) {
  336.             $this->globals = $globals;
  337.         }
  339.         return $globals;
  340.     }
  342.     public function resetGlobals(): void
  343.     {
  344.         $this->globals = null;
  345.     }
  347.     public function addTest(TwigTest $test): void
  348.     {
  349.         if ($this->initialized) {
  350.             throw new \LogicException(\sprintf('Unable to add test "%s" as extensions have already been initialized.', $test->getName()));
  351.         }
  353.         $this->staging->addTest($test);
  354.     }
  356.     /**
  357.      * @return TwigTest[]
  358.      */
  359.     public function getTests(): array
  360.     {
  361.         if (!$this->initialized) {
  362.             $this->initExtensions();
  363.         }
  365.         return $this->tests;
  366.     }
  368.     public function getTest(string $name): ?TwigTest
  369.     {
  370.         if (!$this->initialized) {
  371.             $this->initExtensions();
  372.         }
  374.         if (isset($this->tests[$name])) {
  375.             return $this->tests[$name];
  376.         }
  378.         foreach ($this->dynamicTests as $pattern => $test) {
  379.             if (preg_match($pattern, $name, $matches)) {
  380.                 array_shift($matches);
  382.                 return $test->withDynamicArguments($name, $test->getName(), $matches);
  383.             }
  384.         }
  386.         return null;
  387.     }
  389.     /**
  390.      * @return array<string, array{precedence: int, class: class-string<AbstractExpression>}>
  391.      */
  392.     public function getUnaryOperators(): array
  393.     {
  394.         if (!$this->initialized) {
  395.             $this->initExtensions();
  396.         }
  398.         return $this->unaryOperators;
  399.     }
  401.     /**
  402.      * @return array<string, array{precedence: int, class?: class-string<AbstractExpression>, associativity: ExpressionParser::OPERATOR_*}>
  403.      */
  404.     public function getBinaryOperators(): array
  405.     {
  406.         if (!$this->initialized) {
  407.             $this->initExtensions();
  408.         }
  410.         return $this->binaryOperators;
  411.     }
  413.     private function initExtensions(): void
  414.     {
  415.         $this->parsers = [];
  416.         $this->filters = [];
  417.         $this->functions = [];
  418.         $this->tests = [];
  419.         $this->dynamicFilters = [];
  420.         $this->dynamicFunctions = [];
  421.         $this->dynamicTests = [];
  422.         $this->visitors = [];
  423.         $this->unaryOperators = [];
  424.         $this->binaryOperators = [];
  426.         foreach ($this->extensions as $extension) {
  427.             $this->initExtension($extension);
  428.         }
  429.         $this->initExtension($this->staging);
  430.         // Done at the end only, so that an exception during initialization does not mark the environment as initialized when catching the exception
  431.         $this->initialized = true;
  432.     }
  434.     private function initExtension(ExtensionInterface $extension): void
  435.     {
  436.         // filters
  437.         foreach ($extension->getFilters() as $filter) {
  438.             $this->filters[$name = $filter->getName()] = $filter;
  439.             if (str_contains($name, '*')) {
  440.                 $this->dynamicFilters['#^'.str_replace('\\*', '(.*?)', preg_quote($name, '#')).'$#'] = $filter;
  441.             }
  442.         }
  444.         // functions
  445.         foreach ($extension->getFunctions() as $function) {
  446.             $this->functions[$name = $function->getName()] = $function;
  447.             if (str_contains($name, '*')) {
  448.                 $this->dynamicFunctions['#^'.str_replace('\\*', '(.*?)', preg_quote($name, '#')).'$#'] = $function;
  449.             }
  450.         }
  452.         // tests
  453.         foreach ($extension->getTests() as $test) {
  454.             $this->tests[$name = $test->getName()] = $test;
  455.             if (str_contains($name, '*')) {
  456.                 $this->dynamicTests['#^'.str_replace('\\*', '(.*?)', preg_quote($name, '#')).'$#'] = $test;
  457.             }
  458.         }
  460.         // token parsers
  461.         foreach ($extension->getTokenParsers() as $parser) {
  462.             if (!$parser instanceof TokenParserInterface) {
  463.                 throw new \LogicException('getTokenParsers() must return an array of \Twig\TokenParser\TokenParserInterface.');
  464.             }
  466.             $this->parsers[$parser->getTag()] = $parser;
  467.         }
  469.         // node visitors
  470.         foreach ($extension->getNodeVisitors() as $visitor) {
  471.             $this->visitors[] = $visitor;
  472.         }
  474.         // operators
  475.         if ($operators = $extension->getOperators()) {
  476.             if (!\is_array($operators)) {
  477.                 throw new \InvalidArgumentException(\sprintf('"%s::getOperators()" must return an array with operators, got "%s".', \get_class($extension), \is_object($operators) ? \get_class($operators) : \gettype($operators).(\is_resource($operators) ? '' : '#'.$operators)));
  478.             }
  480.             if (2 !== \count($operators)) {
  481.                 throw new \InvalidArgumentException(\sprintf('"%s::getOperators()" must return an array of 2 elements, got %d.', \get_class($extension), \count($operators)));
  482.             }
  484.             $this->unaryOperators = array_merge($this->unaryOperators, $operators[0]);
  485.             $this->binaryOperators = array_merge($this->binaryOperators, $operators[1]);
  486.         }
  487.     }
  488. }