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

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.     /** @var array<callable(string): (TwigFunction|false)> */
  56.     private $functionCallbacks = [];
  57.     /** @var array<callable(string): (TwigFilter|false)> */
  58.     private $filterCallbacks = [];
  59.     /** @var array<callable(string): (TokenParserInterface|false)> */
  60.     private $parserCallbacks = [];
  61.     private $lastModified = 0;
  63.     public function __construct()
  64.     {
  65.         $this->staging = new StagingExtension();
  66.     }
  68.     /**
  69.      * @return void
  70.      */
  71.     public function initRuntime()
  72.     {
  73.         $this->runtimeInitialized = true;
  74.     }
  76.     public function hasExtension(string $class): bool
  77.     {
  78.         return isset($this->extensions[ltrim($class, '\\')]);
  79.     }
  81.     public function getExtension(string $class): ExtensionInterface
  82.     {
  83.         $class = ltrim($class, '\\');
  85.         if (!isset($this->extensions[$class])) {
  86.             throw new RuntimeError(\sprintf('The "%s" extension is not enabled.', $class));
  87.         }
  89.         return $this->extensions[$class];
  90.     }
  92.     /**
  93.      * @param ExtensionInterface[] $extensions
  94.      */
  95.     public function setExtensions(array $extensions): void
  96.     {
  97.         foreach ($extensions as $extension) {
  98.             $this->addExtension($extension);
  99.         }
  100.     }
  102.     /**
  103.      * @return ExtensionInterface[]
  104.      */
  105.     public function getExtensions(): array
  106.     {
  107.         return $this->extensions;
  108.     }
  110.     public function getSignature(): string
  111.     {
  112.         return json_encode(array_keys($this->extensions));
  113.     }
  115.     public function isInitialized(): bool
  116.     {
  117.         return $this->initialized || $this->runtimeInitialized;
  118.     }
  120.     public function getLastModified(): int
  121.     {
  122.         if (0 !== $this->lastModified) {
  123.             return $this->lastModified;
  124.         }
  126.         $lastModified = 0;
  127.         foreach ($this->extensions as $extension) {
  128.             if ($extension instanceof LastModifiedExtensionInterface) {
  129.                 $lastModified = max($extension->getLastModified(), $lastModified);
  130.             } else {
  131.                 $r = new \ReflectionObject($extension);
  132.                 if (is_file($r->getFileName())) {
  133.                     $lastModified = max(filemtime($r->getFileName()), $lastModified);
  134.                 }
  135.             }
  136.         }
  138.         return $this->lastModified = $lastModified;
  139.     }
  141.     public function addExtension(ExtensionInterface $extension): void
  142.     {
  143.         $class = \get_class($extension);
  145.         if ($this->initialized) {
  146.             throw new \LogicException(\sprintf('Unable to register extension "%s" as extensions have already been initialized.', $class));
  147.         }
  149.         if (isset($this->extensions[$class])) {
  150.             throw new \LogicException(\sprintf('Unable to register extension "%s" as it is already registered.', $class));
  151.         }
  153.         $this->extensions[$class] = $extension;
  154.     }
  156.     public function addFunction(TwigFunction $function): void
  157.     {
  158.         if ($this->initialized) {
  159.             throw new \LogicException(\sprintf('Unable to add function "%s" as extensions have already been initialized.', $function->getName()));
  160.         }
  162.         $this->staging->addFunction($function);
  163.     }
  165.     /**
  166.      * @return TwigFunction[]
  167.      */
  168.     public function getFunctions(): array
  169.     {
  170.         if (!$this->initialized) {
  171.             $this->initExtensions();
  172.         }
  174.         return $this->functions;
  175.     }
  177.     public function getFunction(string $name): ?TwigFunction
  178.     {
  179.         if (!$this->initialized) {
  180.             $this->initExtensions();
  181.         }
  183.         if (isset($this->functions[$name])) {
  184.             return $this->functions[$name];
  185.         }
  187.         foreach ($this->dynamicFunctions as $pattern => $function) {
  188.             if (preg_match($pattern, $name, $matches)) {
  189.                 array_shift($matches);
  191.                 return $function->withDynamicArguments($name, $function->getName(), $matches);
  192.             }
  193.         }
  195.         foreach ($this->functionCallbacks as $callback) {
  196.             if (false !== $function = $callback($name)) {
  197.                 return $function;
  198.             }
  199.         }
  201.         return null;
  202.     }
  204.     /**
  205.      * @param callable(string): (TwigFunction|false) $callable
  206.      */
  207.     public function registerUndefinedFunctionCallback(callable $callable): void
  208.     {
  209.         $this->functionCallbacks[] = $callable;
  210.     }
  212.     public function addFilter(TwigFilter $filter): void
  213.     {
  214.         if ($this->initialized) {
  215.             throw new \LogicException(\sprintf('Unable to add filter "%s" as extensions have already been initialized.', $filter->getName()));
  216.         }
  218.         $this->staging->addFilter($filter);
  219.     }
  221.     /**
  222.      * @return TwigFilter[]
  223.      */
  224.     public function getFilters(): array
  225.     {
  226.         if (!$this->initialized) {
  227.             $this->initExtensions();
  228.         }
  230.         return $this->filters;
  231.     }
  233.     public function getFilter(string $name): ?TwigFilter
  234.     {
  235.         if (!$this->initialized) {
  236.             $this->initExtensions();
  237.         }
  239.         if (isset($this->filters[$name])) {
  240.             return $this->filters[$name];
  241.         }
  243.         foreach ($this->dynamicFilters as $pattern => $filter) {
  244.             if (preg_match($pattern, $name, $matches)) {
  245.                 array_shift($matches);
  247.                 return $filter->withDynamicArguments($name, $filter->getName(), $matches);
  248.             }
  249.         }
  251.         foreach ($this->filterCallbacks as $callback) {
  252.             if (false !== $filter = $callback($name)) {
  253.                 return $filter;
  254.             }
  255.         }
  257.         return null;
  258.     }
  260.     /**
  261.      * @param callable(string): (TwigFilter|false) $callable
  262.      */
  263.     public function registerUndefinedFilterCallback(callable $callable): void
  264.     {
  265.         $this->filterCallbacks[] = $callable;
  266.     }
  268.     public function addNodeVisitor(NodeVisitorInterface $visitor): void
  269.     {
  270.         if ($this->initialized) {
  271.             throw new \LogicException('Unable to add a node visitor as extensions have already been initialized.');
  272.         }
  274.         $this->staging->addNodeVisitor($visitor);
  275.     }
  277.     /**
  278.      * @return NodeVisitorInterface[]
  279.      */
  280.     public function getNodeVisitors(): array
  281.     {
  282.         if (!$this->initialized) {
  283.             $this->initExtensions();
  284.         }
  286.         return $this->visitors;
  287.     }
  289.     public function addTokenParser(TokenParserInterface $parser): void
  290.     {
  291.         if ($this->initialized) {
  292.             throw new \LogicException('Unable to add a token parser as extensions have already been initialized.');
  293.         }
  295.         $this->staging->addTokenParser($parser);
  296.     }
  298.     /**
  299.      * @return TokenParserInterface[]
  300.      */
  301.     public function getTokenParsers(): array
  302.     {
  303.         if (!$this->initialized) {
  304.             $this->initExtensions();
  305.         }
  307.         return $this->parsers;
  308.     }
  310.     public function getTokenParser(string $name): ?TokenParserInterface
  311.     {
  312.         if (!$this->initialized) {
  313.             $this->initExtensions();
  314.         }
  316.         if (isset($this->parsers[$name])) {
  317.             return $this->parsers[$name];
  318.         }
  320.         foreach ($this->parserCallbacks as $callback) {
  321.             if (false !== $parser = $callback($name)) {
  322.                 return $parser;
  323.             }
  324.         }
  326.         return null;
  327.     }
  329.     /**
  330.      * @param callable(string): (TokenParserInterface|false) $callable
  331.      */
  332.     public function registerUndefinedTokenParserCallback(callable $callable): void
  333.     {
  334.         $this->parserCallbacks[] = $callable;
  335.     }
  337.     /**
  338.      * @return array<string, mixed>
  339.      */
  340.     public function getGlobals(): array
  341.     {
  342.         if (null !== $this->globals) {
  343.             return $this->globals;
  344.         }
  346.         $globals = [];
  347.         foreach ($this->extensions as $extension) {
  348.             if (!$extension instanceof GlobalsInterface) {
  349.                 continue;
  350.             }
  352.             $globals = array_merge($globals, $extension->getGlobals());
  353.         }
  355.         if ($this->initialized) {
  356.             $this->globals = $globals;
  357.         }
  359.         return $globals;
  360.     }
  362.     public function resetGlobals(): void
  363.     {
  364.         $this->globals = null;
  365.     }
  367.     public function addTest(TwigTest $test): void
  368.     {
  369.         if ($this->initialized) {
  370.             throw new \LogicException(\sprintf('Unable to add test "%s" as extensions have already been initialized.', $test->getName()));
  371.         }
  373.         $this->staging->addTest($test);
  374.     }
  376.     /**
  377.      * @return TwigTest[]
  378.      */
  379.     public function getTests(): array
  380.     {
  381.         if (!$this->initialized) {
  382.             $this->initExtensions();
  383.         }
  385.         return $this->tests;
  386.     }
  388.     public function getTest(string $name): ?TwigTest
  389.     {
  390.         if (!$this->initialized) {
  391.             $this->initExtensions();
  392.         }
  394.         if (isset($this->tests[$name])) {
  395.             return $this->tests[$name];
  396.         }
  398.         foreach ($this->dynamicTests as $pattern => $test) {
  399.             if (preg_match($pattern, $name, $matches)) {
  400.                 array_shift($matches);
  402.                 return $test->withDynamicArguments($name, $test->getName(), $matches);
  403.             }
  404.         }
  406.         return null;
  407.     }
  409.     /**
  410.      * @return array<string, array{precedence: int, precedence_change?: OperatorPrecedenceChange, class: class-string<AbstractUnary>}>
  411.      */
  412.     public function getUnaryOperators(): array
  413.     {
  414.         if (!$this->initialized) {
  415.             $this->initExtensions();
  416.         }
  418.         return $this->unaryOperators;
  419.     }
  421.     /**
  422.      * @return array<string, array{precedence: int, precedence_change?: OperatorPrecedenceChange, class?: class-string<AbstractBinary>, associativity: ExpressionParser::OPERATOR_*}>
  423.      */
  424.     public function getBinaryOperators(): array
  425.     {
  426.         if (!$this->initialized) {
  427.             $this->initExtensions();
  428.         }
  430.         return $this->binaryOperators;
  431.     }
  433.     private function initExtensions(): void
  434.     {
  435.         $this->parsers = [];
  436.         $this->filters = [];
  437.         $this->functions = [];
  438.         $this->tests = [];
  439.         $this->dynamicFilters = [];
  440.         $this->dynamicFunctions = [];
  441.         $this->dynamicTests = [];
  442.         $this->visitors = [];
  443.         $this->unaryOperators = [];
  444.         $this->binaryOperators = [];
  446.         foreach ($this->extensions as $extension) {
  447.             $this->initExtension($extension);
  448.         }
  449.         $this->initExtension($this->staging);
  450.         // Done at the end only, so that an exception during initialization does not mark the environment as initialized when catching the exception
  451.         $this->initialized = true;
  452.     }
  454.     private function initExtension(ExtensionInterface $extension): void
  455.     {
  456.         // filters
  457.         foreach ($extension->getFilters() as $filter) {
  458.             $this->filters[$name = $filter->getName()] = $filter;
  459.             if (str_contains($name, '*')) {
  460.                 $this->dynamicFilters['#^'.str_replace('\\*', '(.*?)', preg_quote($name, '#')).'$#'] = $filter;
  461.             }
  462.         }
  464.         // functions
  465.         foreach ($extension->getFunctions() as $function) {
  466.             $this->functions[$name = $function->getName()] = $function;
  467.             if (str_contains($name, '*')) {
  468.                 $this->dynamicFunctions['#^'.str_replace('\\*', '(.*?)', preg_quote($name, '#')).'$#'] = $function;
  469.             }
  470.         }
  472.         // tests
  473.         foreach ($extension->getTests() as $test) {
  474.             $this->tests[$name = $test->getName()] = $test;
  475.             if (str_contains($name, '*')) {
  476.                 $this->dynamicTests['#^'.str_replace('\\*', '(.*?)', preg_quote($name, '#')).'$#'] = $test;
  477.             }
  478.         }
  480.         // token parsers
  481.         foreach ($extension->getTokenParsers() as $parser) {
  482.             if (!$parser instanceof TokenParserInterface) {
  483.                 throw new \LogicException('getTokenParsers() must return an array of \Twig\TokenParser\TokenParserInterface.');
  484.             }
  486.             $this->parsers[$parser->getTag()] = $parser;
  487.         }
  489.         // node visitors
  490.         foreach ($extension->getNodeVisitors() as $visitor) {
  491.             $this->visitors[] = $visitor;
  492.         }
  494.         // operators
  495.         if ($operators = $extension->getOperators()) {
  496.             if (!\is_array($operators)) {
  497.                 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)));
  498.             }
  500.             if (2 !== \count($operators)) {
  501.                 throw new \InvalidArgumentException(\sprintf('"%s::getOperators()" must return an array of 2 elements, got %d.', \get_class($extension), \count($operators)));
  502.             }
  504.             $this->unaryOperators = array_merge($this->unaryOperators, $operators[0]);
  505.             $this->binaryOperators = array_merge($this->binaryOperators, $operators[1]);
  506.         }
  507.     }
  508. }