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

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\Extension\ExtensionInterface;
  16. use Twig\Extension\GlobalsInterface;
  17. use Twig\Extension\StagingExtension;
  18. use Twig\Node\Expression\Binary\AbstractBinary;
  19. use Twig\Node\Expression\Unary\AbstractUnary;
  20. use Twig\NodeVisitor\NodeVisitorInterface;
  21. use Twig\TokenParser\TokenParserInterface;
  23. /**
  24.  * @author Fabien Potencier <fabien@symfony.com>
  25.  *
  26.  * @internal
  27.  */
  28. final class ExtensionSet
  29. {
  30.     private $extensions;
  31.     private $initialized = false;
  32.     private $runtimeInitialized = false;
  33.     private $staging;
  34.     private $parsers;
  35.     private $visitors;
  36.     /** @var array<string, TwigFilter> */
  37.     private $filters;
  38.     /** @var array<string, TwigFilter> */
  39.     private $dynamicFilters;
  40.     /** @var array<string, TwigTest> */
  41.     private $tests;
  42.     /** @var array<string, TwigTest> */
  43.     private $dynamicTests;
  44.     /** @var array<string, TwigFunction> */
  45.     private $functions;
  46.     /** @var array<string, TwigFunction> */
  47.     private $dynamicFunctions;
  48.     /** @var array<string, array{precedence: int, precedence_change?: OperatorPrecedenceChange, class: class-string<AbstractUnary>}> */
  49.     private $unaryOperators;
  50.     /** @var array<string, array{precedence: int, precedence_change?: OperatorPrecedenceChange, class?: class-string<AbstractBinary>, associativity: ExpressionParser::OPERATOR_*}> */
  51.     private $binaryOperators;
  52.     /** @var array<string, mixed>|null */
  53.     private $globals;
  54.     private $functionCallbacks = [];
  55.     private $filterCallbacks = [];
  56.     private $parserCallbacks = [];
  57.     private $lastModified = 0;
  59.     public function __construct()
  60.     {
  61.         $this->staging = new StagingExtension();
  62.     }
  64.     public function initRuntime()
  65.     {
  66.         $this->runtimeInitialized = true;
  67.     }
  69.     public function hasExtension(string $class): bool
  70.     {
  71.         return isset($this->extensions[ltrim($class, '\\')]);
  72.     }
  74.     public function getExtension(string $class): ExtensionInterface
  75.     {
  76.         $class = ltrim($class, '\\');
  78.         if (!isset($this->extensions[$class])) {
  79.             throw new RuntimeError(\sprintf('The "%s" extension is not enabled.', $class));
  80.         }
  82.         return $this->extensions[$class];
  83.     }
  85.     /**
  86.      * @param ExtensionInterface[] $extensions
  87.      */
  88.     public function setExtensions(array $extensions): void
  89.     {
  90.         foreach ($extensions as $extension) {
  91.             $this->addExtension($extension);
  92.         }
  93.     }
  95.     /**
  96.      * @return ExtensionInterface[]
  97.      */
  98.     public function getExtensions(): array
  99.     {
  100.         return $this->extensions;
  101.     }
  103.     public function getSignature(): string
  104.     {
  105.         return json_encode(array_keys($this->extensions));
  106.     }
  108.     public function isInitialized(): bool
  109.     {
  110.         return $this->initialized || $this->runtimeInitialized;
  111.     }
  113.     public function getLastModified(): int
  114.     {
  115.         if (0 !== $this->lastModified) {
  116.             return $this->lastModified;
  117.         }
  119.         foreach ($this->extensions as $extension) {
  120.             $r = new \ReflectionObject($extension);
  121.             if (is_file($r->getFileName()) && ($extensionTime = filemtime($r->getFileName())) > $this->lastModified) {
  122.                 $this->lastModified = $extensionTime;
  123.             }
  124.         }
  126.         return $this->lastModified;
  127.     }
  129.     public function addExtension(ExtensionInterface $extension): void
  130.     {
  131.         $class = \get_class($extension);
  133.         if ($this->initialized) {
  134.             throw new \LogicException(\sprintf('Unable to register extension "%s" as extensions have already been initialized.', $class));
  135.         }
  137.         if (isset($this->extensions[$class])) {
  138.             throw new \LogicException(\sprintf('Unable to register extension "%s" as it is already registered.', $class));
  139.         }
  141.         $this->extensions[$class] = $extension;
  142.     }
  144.     public function addFunction(TwigFunction $function): void
  145.     {
  146.         if ($this->initialized) {
  147.             throw new \LogicException(\sprintf('Unable to add function "%s" as extensions have already been initialized.', $function->getName()));
  148.         }
  150.         $this->staging->addFunction($function);
  151.     }
  153.     /**
  154.      * @return TwigFunction[]
  155.      */
  156.     public function getFunctions(): array
  157.     {
  158.         if (!$this->initialized) {
  159.             $this->initExtensions();
  160.         }
  162.         return $this->functions;
  163.     }
  165.     public function getFunction(string $name): ?TwigFunction
  166.     {
  167.         if (!$this->initialized) {
  168.             $this->initExtensions();
  169.         }
  171.         if (isset($this->functions[$name])) {
  172.             return $this->functions[$name];
  173.         }
  175.         foreach ($this->dynamicFunctions as $pattern => $function) {
  176.             if (preg_match($pattern, $name, $matches)) {
  177.                 array_shift($matches);
  179.                 return $function->withDynamicArguments($name, $function->getName(), $matches);
  180.             }
  181.         }
  183.         foreach ($this->functionCallbacks as $callback) {
  184.             if (false !== $function = $callback($name)) {
  185.                 return $function;
  186.             }
  187.         }
  189.         return null;
  190.     }
  192.     public function registerUndefinedFunctionCallback(callable $callable): void
  193.     {
  194.         $this->functionCallbacks[] = $callable;
  195.     }
  197.     public function addFilter(TwigFilter $filter): void
  198.     {
  199.         if ($this->initialized) {
  200.             throw new \LogicException(\sprintf('Unable to add filter "%s" as extensions have already been initialized.', $filter->getName()));
  201.         }
  203.         $this->staging->addFilter($filter);
  204.     }
  206.     /**
  207.      * @return TwigFilter[]
  208.      */
  209.     public function getFilters(): array
  210.     {
  211.         if (!$this->initialized) {
  212.             $this->initExtensions();
  213.         }
  215.         return $this->filters;
  216.     }
  218.     public function getFilter(string $name): ?TwigFilter
  219.     {
  220.         if (!$this->initialized) {
  221.             $this->initExtensions();
  222.         }
  224.         if (isset($this->filters[$name])) {
  225.             return $this->filters[$name];
  226.         }
  228.         foreach ($this->dynamicFilters as $pattern => $filter) {
  229.             if (preg_match($pattern, $name, $matches)) {
  230.                 array_shift($matches);
  232.                 return $filter->withDynamicArguments($name, $filter->getName(), $matches);
  233.             }
  234.         }
  236.         foreach ($this->filterCallbacks as $callback) {
  237.             if (false !== $filter = $callback($name)) {
  238.                 return $filter;
  239.             }
  240.         }
  242.         return null;
  243.     }
  245.     public function registerUndefinedFilterCallback(callable $callable): void
  246.     {
  247.         $this->filterCallbacks[] = $callable;
  248.     }
  250.     public function addNodeVisitor(NodeVisitorInterface $visitor): void
  251.     {
  252.         if ($this->initialized) {
  253.             throw new \LogicException('Unable to add a node visitor as extensions have already been initialized.');
  254.         }
  256.         $this->staging->addNodeVisitor($visitor);
  257.     }
  259.     /**
  260.      * @return NodeVisitorInterface[]
  261.      */
  262.     public function getNodeVisitors(): array
  263.     {
  264.         if (!$this->initialized) {
  265.             $this->initExtensions();
  266.         }
  268.         return $this->visitors;
  269.     }
  271.     public function addTokenParser(TokenParserInterface $parser): void
  272.     {
  273.         if ($this->initialized) {
  274.             throw new \LogicException('Unable to add a token parser as extensions have already been initialized.');
  275.         }
  277.         $this->staging->addTokenParser($parser);
  278.     }
  280.     /**
  281.      * @return TokenParserInterface[]
  282.      */
  283.     public function getTokenParsers(): array
  284.     {
  285.         if (!$this->initialized) {
  286.             $this->initExtensions();
  287.         }
  289.         return $this->parsers;
  290.     }
  292.     public function getTokenParser(string $name): ?TokenParserInterface
  293.     {
  294.         if (!$this->initialized) {
  295.             $this->initExtensions();
  296.         }
  298.         if (isset($this->parsers[$name])) {
  299.             return $this->parsers[$name];
  300.         }
  302.         foreach ($this->parserCallbacks as $callback) {
  303.             if (false !== $parser = $callback($name)) {
  304.                 return $parser;
  305.             }
  306.         }
  308.         return null;
  309.     }
  311.     public function registerUndefinedTokenParserCallback(callable $callable): void
  312.     {
  313.         $this->parserCallbacks[] = $callable;
  314.     }
  316.     /**
  317.      * @return array<string, mixed>
  318.      */
  319.     public function getGlobals(): array
  320.     {
  321.         if (null !== $this->globals) {
  322.             return $this->globals;
  323.         }
  325.         $globals = [];
  326.         foreach ($this->extensions as $extension) {
  327.             if (!$extension instanceof GlobalsInterface) {
  328.                 continue;
  329.             }
  331.             $globals = array_merge($globals, $extension->getGlobals());
  332.         }
  334.         if ($this->initialized) {
  335.             $this->globals = $globals;
  336.         }
  338.         return $globals;
  339.     }
  341.     public function resetGlobals(): void
  342.     {
  343.         $this->globals = null;
  344.     }
  346.     public function addTest(TwigTest $test): void
  347.     {
  348.         if ($this->initialized) {
  349.             throw new \LogicException(\sprintf('Unable to add test "%s" as extensions have already been initialized.', $test->getName()));
  350.         }
  352.         $this->staging->addTest($test);
  353.     }
  355.     /**
  356.      * @return TwigTest[]
  357.      */
  358.     public function getTests(): array
  359.     {
  360.         if (!$this->initialized) {
  361.             $this->initExtensions();
  362.         }
  364.         return $this->tests;
  365.     }
  367.     public function getTest(string $name): ?TwigTest
  368.     {
  369.         if (!$this->initialized) {
  370.             $this->initExtensions();
  371.         }
  373.         if (isset($this->tests[$name])) {
  374.             return $this->tests[$name];
  375.         }
  377.         foreach ($this->dynamicTests as $pattern => $test) {
  378.             if (preg_match($pattern, $name, $matches)) {
  379.                 array_shift($matches);
  381.                 return $test->withDynamicArguments($name, $test->getName(), $matches);
  382.             }
  383.         }
  385.         return null;
  386.     }
  388.     /**
  389.      * @return array<string, array{precedence: int, precedence_change?: OperatorPrecedenceChange, class: class-string<AbstractUnary>}>
  390.      */
  391.     public function getUnaryOperators(): array
  392.     {
  393.         if (!$this->initialized) {
  394.             $this->initExtensions();
  395.         }
  397.         return $this->unaryOperators;
  398.     }
  400.     /**
  401.      * @return array<string, array{precedence: int, precedence_change?: OperatorPrecedenceChange, class?: class-string<AbstractBinary>, associativity: ExpressionParser::OPERATOR_*}>
  402.      */
  403.     public function getBinaryOperators(): array
  404.     {
  405.         if (!$this->initialized) {
  406.             $this->initExtensions();
  407.         }
  409.         return $this->binaryOperators;
  410.     }
  412.     private function initExtensions(): void
  413.     {
  414.         $this->parsers = [];
  415.         $this->filters = [];
  416.         $this->functions = [];
  417.         $this->tests = [];
  418.         $this->dynamicFilters = [];
  419.         $this->dynamicFunctions = [];
  420.         $this->dynamicTests = [];
  421.         $this->visitors = [];
  422.         $this->unaryOperators = [];
  423.         $this->binaryOperators = [];
  425.         foreach ($this->extensions as $extension) {
  426.             $this->initExtension($extension);
  427.         }
  428.         $this->initExtension($this->staging);
  429.         // Done at the end only, so that an exception during initialization does not mark the environment as initialized when catching the exception
  430.         $this->initialized = true;
  431.     }
  433.     private function initExtension(ExtensionInterface $extension): void
  434.     {
  435.         // filters
  436.         foreach ($extension->getFilters() as $filter) {
  437.             $this->filters[$name = $filter->getName()] = $filter;
  438.             if (str_contains($name, '*')) {
  439.                 $this->dynamicFilters['#^'.str_replace('\\*', '(.*?)', preg_quote($name, '#')).'$#'] = $filter;
  440.             }
  441.         }
  443.         // functions
  444.         foreach ($extension->getFunctions() as $function) {
  445.             $this->functions[$name = $function->getName()] = $function;
  446.             if (str_contains($name, '*')) {
  447.                 $this->dynamicFunctions['#^'.str_replace('\\*', '(.*?)', preg_quote($name, '#')).'$#'] = $function;
  448.             }
  449.         }
  451.         // tests
  452.         foreach ($extension->getTests() as $test) {
  453.             $this->tests[$name = $test->getName()] = $test;
  454.             if (str_contains($name, '*')) {
  455.                 $this->dynamicTests['#^'.str_replace('\\*', '(.*?)', preg_quote($name, '#')).'$#'] = $test;
  456.             }
  457.         }
  459.         // token parsers
  460.         foreach ($extension->getTokenParsers() as $parser) {
  461.             if (!$parser instanceof TokenParserInterface) {
  462.                 throw new \LogicException('getTokenParsers() must return an array of \Twig\TokenParser\TokenParserInterface.');
  463.             }
  465.             $this->parsers[$parser->getTag()] = $parser;
  466.         }
  468.         // node visitors
  469.         foreach ($extension->getNodeVisitors() as $visitor) {
  470.             $this->visitors[] = $visitor;
  471.         }
  473.         // operators
  474.         if ($operators = $extension->getOperators()) {
  475.             if (!\is_array($operators)) {
  476.                 throw new \InvalidArgumentException(\sprintf('"%s::getOperators()" must return an array with operators, got "%s".', \get_class($extension), get_debug_type($operators).(\is_resource($operators) ? '' : '#'.$operators)));
  477.             }
  479.             if (2 !== \count($operators)) {
  480.                 throw new \InvalidArgumentException(\sprintf('"%s::getOperators()" must return an array of 2 elements, got %d.', \get_class($extension), \count($operators)));
  481.             }
  483.             $this->unaryOperators = array_merge($this->unaryOperators, $operators[0]);
  484.             $this->binaryOperators = array_merge($this->binaryOperators, $operators[1]);
  485.         }
  486.     }
  487. }