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

  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, TwigTest> */
  40.     private $tests;
  41.     /** @var array<string, TwigFunction> */
  42.     private $functions;
  43.     /** @var array<string, array{precedence: int, class: class-string<AbstractExpression>}> */
  44.     private $unaryOperators;
  45.     /** @var array<string, array{precedence: int, class?: class-string<AbstractExpression>, associativity: ExpressionParser::OPERATOR_*}> */
  46.     private $binaryOperators;
  47.     /** @var array<string, mixed> */
  48.     private $globals;
  49.     private $functionCallbacks = [];
  50.     private $filterCallbacks = [];
  51.     private $parserCallbacks = [];
  52.     private $lastModified = 0;
  54.     public function __construct()
  55.     {
  56.         $this->staging = new StagingExtension();
  57.     }
  59.     public function initRuntime()
  60.     {
  61.         $this->runtimeInitialized = true;
  62.     }
  64.     public function hasExtension(string $class): bool
  65.     {
  66.         return isset($this->extensions[ltrim($class, '\\')]);
  67.     }
  69.     public function getExtension(string $class): ExtensionInterface
  70.     {
  71.         $class = ltrim($class, '\\');
  73.         if (!isset($this->extensions[$class])) {
  74.             throw new RuntimeError(\sprintf('The "%s" extension is not enabled.', $class));
  75.         }
  77.         return $this->extensions[$class];
  78.     }
  80.     /**
  81.      * @param ExtensionInterface[] $extensions
  82.      */
  83.     public function setExtensions(array $extensions): void
  84.     {
  85.         foreach ($extensions as $extension) {
  86.             $this->addExtension($extension);
  87.         }
  88.     }
  90.     /**
  91.      * @return ExtensionInterface[]
  92.      */
  93.     public function getExtensions(): array
  94.     {
  95.         return $this->extensions;
  96.     }
  98.     public function getSignature(): string
  99.     {
  100.         return json_encode(array_keys($this->extensions));
  101.     }
  103.     public function isInitialized(): bool
  104.     {
  105.         return $this->initialized || $this->runtimeInitialized;
  106.     }
  108.     public function getLastModified(): int
  109.     {
  110.         if (0 !== $this->lastModified) {
  111.             return $this->lastModified;
  112.         }
  114.         foreach ($this->extensions as $extension) {
  115.             $r = new \ReflectionObject($extension);
  116.             if (is_file($r->getFileName()) && ($extensionTime = filemtime($r->getFileName())) > $this->lastModified) {
  117.                 $this->lastModified = $extensionTime;
  118.             }
  119.         }
  121.         return $this->lastModified;
  122.     }
  124.     public function addExtension(ExtensionInterface $extension): void
  125.     {
  126.         $class = \get_class($extension);
  128.         if ($this->initialized) {
  129.             throw new \LogicException(\sprintf('Unable to register extension "%s" as extensions have already been initialized.', $class));
  130.         }
  132.         if (isset($this->extensions[$class])) {
  133.             throw new \LogicException(\sprintf('Unable to register extension "%s" as it is already registered.', $class));
  134.         }
  136.         $this->extensions[$class] = $extension;
  137.     }
  139.     public function addFunction(TwigFunction $function): void
  140.     {
  141.         if ($this->initialized) {
  142.             throw new \LogicException(\sprintf('Unable to add function "%s" as extensions have already been initialized.', $function->getName()));
  143.         }
  145.         $this->staging->addFunction($function);
  146.     }
  148.     /**
  149.      * @return TwigFunction[]
  150.      */
  151.     public function getFunctions(): array
  152.     {
  153.         if (!$this->initialized) {
  154.             $this->initExtensions();
  155.         }
  157.         return $this->functions;
  158.     }
  160.     public function getFunction(string $name): ?TwigFunction
  161.     {
  162.         if (!$this->initialized) {
  163.             $this->initExtensions();
  164.         }
  166.         if (isset($this->functions[$name])) {
  167.             return $this->functions[$name];
  168.         }
  170.         foreach ($this->functions as $pattern => $function) {
  171.             $pattern = str_replace('\\*', '(.*?)', preg_quote($pattern, '#'), $count);
  173.             if ($count && preg_match('#^'.$pattern.'$#', $name, $matches)) {
  174.                 array_shift($matches);
  175.                 $function->setArguments($matches);
  177.                 return $function;
  178.             }
  179.         }
  181.         foreach ($this->functionCallbacks as $callback) {
  182.             if (false !== $function = $callback($name)) {
  183.                 return $function;
  184.             }
  185.         }
  187.         return null;
  188.     }
  190.     public function registerUndefinedFunctionCallback(callable $callable): void
  191.     {
  192.         $this->functionCallbacks[] = $callable;
  193.     }
  195.     public function addFilter(TwigFilter $filter): void
  196.     {
  197.         if ($this->initialized) {
  198.             throw new \LogicException(\sprintf('Unable to add filter "%s" as extensions have already been initialized.', $filter->getName()));
  199.         }
  201.         $this->staging->addFilter($filter);
  202.     }
  204.     /**
  205.      * @return TwigFilter[]
  206.      */
  207.     public function getFilters(): array
  208.     {
  209.         if (!$this->initialized) {
  210.             $this->initExtensions();
  211.         }
  213.         return $this->filters;
  214.     }
  216.     public function getFilter(string $name): ?TwigFilter
  217.     {
  218.         if (!$this->initialized) {
  219.             $this->initExtensions();
  220.         }
  222.         if (isset($this->filters[$name])) {
  223.             return $this->filters[$name];
  224.         }
  226.         foreach ($this->filters as $pattern => $filter) {
  227.             $pattern = str_replace('\\*', '(.*?)', preg_quote($pattern, '#'), $count);
  229.             if ($count && preg_match('#^'.$pattern.'$#', $name, $matches)) {
  230.                 array_shift($matches);
  231.                 $filter->setArguments($matches);
  233.                 return $filter;
  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.             $extGlobals = $extension->getGlobals();
  333.             if (!\is_array($extGlobals)) {
  334.                 throw new \UnexpectedValueException(\sprintf('"%s::getGlobals()" must return an array of globals.', \get_class($extension)));
  335.             }
  337.             $globals = array_merge($globals, $extGlobals);
  338.         }
  340.         if ($this->initialized) {
  341.             $this->globals = $globals;
  342.         }
  344.         return $globals;
  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->tests as $pattern => $test) {
  379.             $pattern = str_replace('\\*', '(.*?)', preg_quote($pattern, '#'), $count);
  381.             if ($count) {
  382.                 if (preg_match('#^'.$pattern.'$#', $name, $matches)) {
  383.                     array_shift($matches);
  384.                     $test->setArguments($matches);
  386.                     return $test;
  387.                 }
  388.             }
  389.         }
  391.         return null;
  392.     }
  394.     /**
  395.      * @return array<string, array{precedence: int, class: class-string<AbstractExpression>}>
  396.      */
  397.     public function getUnaryOperators(): array
  398.     {
  399.         if (!$this->initialized) {
  400.             $this->initExtensions();
  401.         }
  403.         return $this->unaryOperators;
  404.     }
  406.     /**
  407.      * @return array<string, array{precedence: int, class?: class-string<AbstractExpression>, associativity: ExpressionParser::OPERATOR_*}>
  408.      */
  409.     public function getBinaryOperators(): array
  410.     {
  411.         if (!$this->initialized) {
  412.             $this->initExtensions();
  413.         }
  415.         return $this->binaryOperators;
  416.     }
  418.     private function initExtensions(): void
  419.     {
  420.         $this->parsers = [];
  421.         $this->filters = [];
  422.         $this->functions = [];
  423.         $this->tests = [];
  424.         $this->visitors = [];
  425.         $this->unaryOperators = [];
  426.         $this->binaryOperators = [];
  428.         foreach ($this->extensions as $extension) {
  429.             $this->initExtension($extension);
  430.         }
  431.         $this->initExtension($this->staging);
  432.         // Done at the end only, so that an exception during initialization does not mark the environment as initialized when catching the exception
  433.         $this->initialized = true;
  434.     }
  436.     private function initExtension(ExtensionInterface $extension): void
  437.     {
  438.         // filters
  439.         foreach ($extension->getFilters() as $filter) {
  440.             $this->filters[$filter->getName()] = $filter;
  441.         }
  443.         // functions
  444.         foreach ($extension->getFunctions() as $function) {
  445.             $this->functions[$function->getName()] = $function;
  446.         }
  448.         // tests
  449.         foreach ($extension->getTests() as $test) {
  450.             $this->tests[$test->getName()] = $test;
  451.         }
  453.         // token parsers
  454.         foreach ($extension->getTokenParsers() as $parser) {
  455.             if (!$parser instanceof TokenParserInterface) {
  456.                 throw new \LogicException('getTokenParsers() must return an array of \Twig\TokenParser\TokenParserInterface.');
  457.             }
  459.             $this->parsers[$parser->getTag()] = $parser;
  460.         }
  462.         // node visitors
  463.         foreach ($extension->getNodeVisitors() as $visitor) {
  464.             $this->visitors[] = $visitor;
  465.         }
  467.         // operators
  468.         if ($operators = $extension->getOperators()) {
  469.             if (!\is_array($operators)) {
  470.                 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)));
  471.             }
  473.             if (2 !== \count($operators)) {
  474.                 throw new \InvalidArgumentException(\sprintf('"%s::getOperators()" must return an array of 2 elements, got %d.', \get_class($extension), \count($operators)));
  475.             }
  477.             $this->unaryOperators = array_merge($this->unaryOperators, $operators[0]);
  478.             $this->binaryOperators = array_merge($this->binaryOperators, $operators[1]);
  479.         }
  480.     }
  481. }