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

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\LastModifiedExtensionInterface;
  18. use Twig\Extension\StagingExtension;
  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, precedence_change?: OperatorPrecedenceChange, class: class-string<AbstractUnary>}> */
  50.     private $unaryOperators;
  51.     /** @var array<string, array{precedence: int, precedence_change?: OperatorPrecedenceChange, class?: class-string<AbstractBinary>, associativity: ExpressionParser::OPERATOR_*}> */
  52.     private $binaryOperators;
  53.     /** @var array<string, mixed>|null */
  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.     /**
  66.      * @return void
  67.      */
  68.     public function initRuntime()
  69.     {
  70.         $this->runtimeInitialized = true;
  71.     }
  73.     public function hasExtension(string $class): bool
  74.     {
  75.         return isset($this->extensions[ltrim($class, '\\')]);
  76.     }
  78.     public function getExtension(string $class): ExtensionInterface
  79.     {
  80.         $class = ltrim($class, '\\');
  82.         if (!isset($this->extensions[$class])) {
  83.             throw new RuntimeError(\sprintf('The "%s" extension is not enabled.', $class));
  84.         }
  86.         return $this->extensions[$class];
  87.     }
  89.     /**
  90.      * @param ExtensionInterface[] $extensions
  91.      */
  92.     public function setExtensions(array $extensions): void
  93.     {
  94.         foreach ($extensions as $extension) {
  95.             $this->addExtension($extension);
  96.         }
  97.     }
  99.     /**
  100.      * @return ExtensionInterface[]
  101.      */
  102.     public function getExtensions(): array
  103.     {
  104.         return $this->extensions;
  105.     }
  107.     public function getSignature(): string
  108.     {
  109.         return json_encode(array_keys($this->extensions));
  110.     }
  112.     public function isInitialized(): bool
  113.     {
  114.         return $this->initialized || $this->runtimeInitialized;
  115.     }
  117.     public function getLastModified(): int
  118.     {
  119.         if (0 !== $this->lastModified) {
  120.             return $this->lastModified;
  121.         }
  123.         $lastModified = 0;
  124.         foreach ($this->extensions as $extension) {
  125.             if ($extension instanceof LastModifiedExtensionInterface) {
  126.                 $lastModified = max($extension->getLastModified(), $lastModified);
  127.             } else {
  128.                 $r = new \ReflectionObject($extension);
  129.                 if (is_file($r->getFileName())) {
  130.                     $lastModified = max(filemtime($r->getFileName()), $lastModified);
  131.                 }
  132.             }
  133.         }
  135.         return $this->lastModified = $lastModified;
  136.     }
  138.     public function addExtension(ExtensionInterface $extension): void
  139.     {
  140.         $class = \get_class($extension);
  142.         if ($this->initialized) {
  143.             throw new \LogicException(\sprintf('Unable to register extension "%s" as extensions have already been initialized.', $class));
  144.         }
  146.         if (isset($this->extensions[$class])) {
  147.             throw new \LogicException(\sprintf('Unable to register extension "%s" as it is already registered.', $class));
  148.         }
  150.         $this->extensions[$class] = $extension;
  151.     }
  153.     public function addFunction(TwigFunction $function): void
  154.     {
  155.         if ($this->initialized) {
  156.             throw new \LogicException(\sprintf('Unable to add function "%s" as extensions have already been initialized.', $function->getName()));
  157.         }
  159.         $this->staging->addFunction($function);
  160.     }
  162.     /**
  163.      * @return TwigFunction[]
  164.      */
  165.     public function getFunctions(): array
  166.     {
  167.         if (!$this->initialized) {
  168.             $this->initExtensions();
  169.         }
  171.         return $this->functions;
  172.     }
  174.     public function getFunction(string $name): ?TwigFunction
  175.     {
  176.         if (!$this->initialized) {
  177.             $this->initExtensions();
  178.         }
  180.         if (isset($this->functions[$name])) {
  181.             return $this->functions[$name];
  182.         }
  184.         foreach ($this->dynamicFunctions as $pattern => $function) {
  185.             if (preg_match($pattern, $name, $matches)) {
  186.                 array_shift($matches);
  188.                 return $function->withDynamicArguments($name, $function->getName(), $matches);
  189.             }
  190.         }
  192.         foreach ($this->functionCallbacks as $callback) {
  193.             if (false !== $function = $callback($name)) {
  194.                 return $function;
  195.             }
  196.         }
  198.         return null;
  199.     }
  201.     public function registerUndefinedFunctionCallback(callable $callable): void
  202.     {
  203.         $this->functionCallbacks[] = $callable;
  204.     }
  206.     public function addFilter(TwigFilter $filter): void
  207.     {
  208.         if ($this->initialized) {
  209.             throw new \LogicException(\sprintf('Unable to add filter "%s" as extensions have already been initialized.', $filter->getName()));
  210.         }
  212.         $this->staging->addFilter($filter);
  213.     }
  215.     /**
  216.      * @return TwigFilter[]
  217.      */
  218.     public function getFilters(): array
  219.     {
  220.         if (!$this->initialized) {
  221.             $this->initExtensions();
  222.         }
  224.         return $this->filters;
  225.     }
  227.     public function getFilter(string $name): ?TwigFilter
  228.     {
  229.         if (!$this->initialized) {
  230.             $this->initExtensions();
  231.         }
  233.         if (isset($this->filters[$name])) {
  234.             return $this->filters[$name];
  235.         }
  237.         foreach ($this->dynamicFilters as $pattern => $filter) {
  238.             if (preg_match($pattern, $name, $matches)) {
  239.                 array_shift($matches);
  241.                 return $filter->withDynamicArguments($name, $filter->getName(), $matches);
  242.             }
  243.         }
  245.         foreach ($this->filterCallbacks as $callback) {
  246.             if (false !== $filter = $callback($name)) {
  247.                 return $filter;
  248.             }
  249.         }
  251.         return null;
  252.     }
  254.     public function registerUndefinedFilterCallback(callable $callable): void
  255.     {
  256.         $this->filterCallbacks[] = $callable;
  257.     }
  259.     public function addNodeVisitor(NodeVisitorInterface $visitor): void
  260.     {
  261.         if ($this->initialized) {
  262.             throw new \LogicException('Unable to add a node visitor as extensions have already been initialized.');
  263.         }
  265.         $this->staging->addNodeVisitor($visitor);
  266.     }
  268.     /**
  269.      * @return NodeVisitorInterface[]
  270.      */
  271.     public function getNodeVisitors(): array
  272.     {
  273.         if (!$this->initialized) {
  274.             $this->initExtensions();
  275.         }
  277.         return $this->visitors;
  278.     }
  280.     public function addTokenParser(TokenParserInterface $parser): void
  281.     {
  282.         if ($this->initialized) {
  283.             throw new \LogicException('Unable to add a token parser as extensions have already been initialized.');
  284.         }
  286.         $this->staging->addTokenParser($parser);
  287.     }
  289.     /**
  290.      * @return TokenParserInterface[]
  291.      */
  292.     public function getTokenParsers(): array
  293.     {
  294.         if (!$this->initialized) {
  295.             $this->initExtensions();
  296.         }
  298.         return $this->parsers;
  299.     }
  301.     public function getTokenParser(string $name): ?TokenParserInterface
  302.     {
  303.         if (!$this->initialized) {
  304.             $this->initExtensions();
  305.         }
  307.         if (isset($this->parsers[$name])) {
  308.             return $this->parsers[$name];
  309.         }
  311.         foreach ($this->parserCallbacks as $callback) {
  312.             if (false !== $parser = $callback($name)) {
  313.                 return $parser;
  314.             }
  315.         }
  317.         return null;
  318.     }
  320.     public function registerUndefinedTokenParserCallback(callable $callable): void
  321.     {
  322.         $this->parserCallbacks[] = $callable;
  323.     }
  325.     /**
  326.      * @return array<string, mixed>
  327.      */
  328.     public function getGlobals(): array
  329.     {
  330.         if (null !== $this->globals) {
  331.             return $this->globals;
  332.         }
  334.         $globals = [];
  335.         foreach ($this->extensions as $extension) {
  336.             if (!$extension instanceof GlobalsInterface) {
  337.                 continue;
  338.             }
  340.             $globals = array_merge($globals, $extension->getGlobals());
  341.         }
  343.         if ($this->initialized) {
  344.             $this->globals = $globals;
  345.         }
  347.         return $globals;
  348.     }
  350.     public function resetGlobals(): void
  351.     {
  352.         $this->globals = null;
  353.     }
  355.     public function addTest(TwigTest $test): void
  356.     {
  357.         if ($this->initialized) {
  358.             throw new \LogicException(\sprintf('Unable to add test "%s" as extensions have already been initialized.', $test->getName()));
  359.         }
  361.         $this->staging->addTest($test);
  362.     }
  364.     /**
  365.      * @return TwigTest[]
  366.      */
  367.     public function getTests(): array
  368.     {
  369.         if (!$this->initialized) {
  370.             $this->initExtensions();
  371.         }
  373.         return $this->tests;
  374.     }
  376.     public function getTest(string $name): ?TwigTest
  377.     {
  378.         if (!$this->initialized) {
  379.             $this->initExtensions();
  380.         }
  382.         if (isset($this->tests[$name])) {
  383.             return $this->tests[$name];
  384.         }
  386.         foreach ($this->dynamicTests as $pattern => $test) {
  387.             if (preg_match($pattern, $name, $matches)) {
  388.                 array_shift($matches);
  390.                 return $test->withDynamicArguments($name, $test->getName(), $matches);
  391.             }
  392.         }
  394.         return null;
  395.     }
  397.     /**
  398.      * @return array<string, array{precedence: int, precedence_change?: OperatorPrecedenceChange, class: class-string<AbstractUnary>}>
  399.      */
  400.     public function getUnaryOperators(): array
  401.     {
  402.         if (!$this->initialized) {
  403.             $this->initExtensions();
  404.         }
  406.         return $this->unaryOperators;
  407.     }
  409.     /**
  410.      * @return array<string, array{precedence: int, precedence_change?: OperatorPrecedenceChange, class?: class-string<AbstractBinary>, associativity: ExpressionParser::OPERATOR_*}>
  411.      */
  412.     public function getBinaryOperators(): array
  413.     {
  414.         if (!$this->initialized) {
  415.             $this->initExtensions();
  416.         }
  418.         return $this->binaryOperators;
  419.     }
  421.     private function initExtensions(): void
  422.     {
  423.         $this->parsers = [];
  424.         $this->filters = [];
  425.         $this->functions = [];
  426.         $this->tests = [];
  427.         $this->dynamicFilters = [];
  428.         $this->dynamicFunctions = [];
  429.         $this->dynamicTests = [];
  430.         $this->visitors = [];
  431.         $this->unaryOperators = [];
  432.         $this->binaryOperators = [];
  434.         foreach ($this->extensions as $extension) {
  435.             $this->initExtension($extension);
  436.         }
  437.         $this->initExtension($this->staging);
  438.         // Done at the end only, so that an exception during initialization does not mark the environment as initialized when catching the exception
  439.         $this->initialized = true;
  440.     }
  442.     private function initExtension(ExtensionInterface $extension): void
  443.     {
  444.         // filters
  445.         foreach ($extension->getFilters() as $filter) {
  446.             $this->filters[$name = $filter->getName()] = $filter;
  447.             if (str_contains($name, '*')) {
  448.                 $this->dynamicFilters['#^'.str_replace('\\*', '(.*?)', preg_quote($name, '#')).'$#'] = $filter;
  449.             }
  450.         }
  452.         // functions
  453.         foreach ($extension->getFunctions() as $function) {
  454.             $this->functions[$name = $function->getName()] = $function;
  455.             if (str_contains($name, '*')) {
  456.                 $this->dynamicFunctions['#^'.str_replace('\\*', '(.*?)', preg_quote($name, '#')).'$#'] = $function;
  457.             }
  458.         }
  460.         // tests
  461.         foreach ($extension->getTests() as $test) {
  462.             $this->tests[$name = $test->getName()] = $test;
  463.             if (str_contains($name, '*')) {
  464.                 $this->dynamicTests['#^'.str_replace('\\*', '(.*?)', preg_quote($name, '#')).'$#'] = $test;
  465.             }
  466.         }
  468.         // token parsers
  469.         foreach ($extension->getTokenParsers() as $parser) {
  470.             if (!$parser instanceof TokenParserInterface) {
  471.                 throw new \LogicException('getTokenParsers() must return an array of \Twig\TokenParser\TokenParserInterface.');
  472.             }
  474.             $this->parsers[$parser->getTag()] = $parser;
  475.         }
  477.         // node visitors
  478.         foreach ($extension->getNodeVisitors() as $visitor) {
  479.             $this->visitors[] = $visitor;
  480.         }
  482.         // operators
  483.         if ($operators = $extension->getOperators()) {
  484.             if (!\is_array($operators)) {
  485.                 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)));
  486.             }
  488.             if (2 !== \count($operators)) {
  489.                 throw new \InvalidArgumentException(\sprintf('"%s::getOperators()" must return an array of 2 elements, got %d.', \get_class($extension), \count($operators)));
  490.             }
  492.             $this->unaryOperators = array_merge($this->unaryOperators, $operators[0]);
  493.             $this->binaryOperators = array_merge($this->binaryOperators, $operators[1]);
  494.         }
  495.     }
  496. }