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

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\AbstractExpression;
  19. use Twig\NodeVisitor\NodeVisitorInterface;
  20. use Twig\TokenParser\TokenParserInterface;
  22. /**
  23. * @author Fabien Potencier <fabien@symfony.com>
  24. *
  25. * @internal
  26. */
  27. final class ExtensionSet
  28. {
  29. private $extensions;
  30. private $initialized = false;
  31. private $runtimeInitialized = false;
  32. private $staging;
  33. private $parsers;
  34. private $visitors;
  35. /** @var array<string, TwigFilter> */
  36. private $filters;
  37. /** @var array<string, TwigFilter> */
  38. private $dynamicFilters;
  39. /** @var array<string, TwigTest> */
  40. private $tests;
  41. /** @var array<string, TwigTest> */
  42. private $dynamicTests;
  43. /** @var array<string, TwigFunction> */
  44. private $functions;
  45. /** @var array<string, TwigFunction> */
  46. private $dynamicFunctions;
  47. /** @var array<string, array{precedence: int, class: class-string<AbstractExpression>}> */
  48. private $unaryOperators;
  49. /** @var array<string, array{precedence: int, class?: class-string<AbstractExpression>, associativity: ExpressionParser::OPERATOR_*}> */
  50. private $binaryOperators;
  51. /** @var array<string, mixed>|null */
  52. private $globals;
  53. private $functionCallbacks = [];
  54. private $filterCallbacks = [];
  55. private $parserCallbacks = [];
  56. private $lastModified = 0;
  58. public function __construct()
  59. {
  60. $this->staging = new StagingExtension();
  61. }
  63. public function initRuntime()
  64. {
  65. $this->runtimeInitialized = true;
  66. }
  68. public function hasExtension(string $class): bool
  69. {
  70. return isset($this->extensions[ltrim($class, '\\')]);
  71. }
  73. public function getExtension(string $class): ExtensionInterface
  74. {
  75. $class = ltrim($class, '\\');
  77. if (!isset($this->extensions[$class])) {
  78. throw new RuntimeError(\sprintf('The "%s" extension is not enabled.', $class));
  79. }
  81. return $this->extensions[$class];
  82. }
  84. /**
  85. * @param ExtensionInterface[] $extensions
  86. */
  87. public function setExtensions(array $extensions): void
  88. {
  89. foreach ($extensions as $extension) {
  90. $this->addExtension($extension);
  91. }
  92. }
  94. /**
  95. * @return ExtensionInterface[]
  96. */
  97. public function getExtensions(): array
  98. {
  99. return $this->extensions;
  100. }
  102. public function getSignature(): string
  103. {
  104. return json_encode(array_keys($this->extensions));
  105. }
  107. public function isInitialized(): bool
  108. {
  109. return $this->initialized || $this->runtimeInitialized;
  110. }
  112. public function getLastModified(): int
  113. {
  114. if (0 !== $this->lastModified) {
  115. return $this->lastModified;
  116. }
  118. foreach ($this->extensions as $extension) {
  119. $r = new \ReflectionObject($extension);
  120. if (is_file($r->getFileName()) && ($extensionTime = filemtime($r->getFileName())) > $this->lastModified) {
  121. $this->lastModified = $extensionTime;
  122. }
  123. }
  125. return $this->lastModified;
  126. }
  128. public function addExtension(ExtensionInterface $extension): void
  129. {
  130. $class = \get_class($extension);
  132. if ($this->initialized) {
  133. throw new \LogicException(\sprintf('Unable to register extension "%s" as extensions have already been initialized.', $class));
  134. }
  136. if (isset($this->extensions[$class])) {
  137. throw new \LogicException(\sprintf('Unable to register extension "%s" as it is already registered.', $class));
  138. }
  140. $this->extensions[$class] = $extension;
  141. }
  143. public function addFunction(TwigFunction $function): void
  144. {
  145. if ($this->initialized) {
  146. throw new \LogicException(\sprintf('Unable to add function "%s" as extensions have already been initialized.', $function->getName()));
  147. }
  149. $this->staging->addFunction($function);
  150. }
  152. /**
  153. * @return TwigFunction[]
  154. */
  155. public function getFunctions(): array
  156. {
  157. if (!$this->initialized) {
  158. $this->initExtensions();
  159. }
  161. return $this->functions;
  162. }
  164. public function getFunction(string $name): ?TwigFunction
  165. {
  166. if (!$this->initialized) {
  167. $this->initExtensions();
  168. }
  170. if (isset($this->functions[$name])) {
  171. return $this->functions[$name];
  172. }
  174. foreach ($this->dynamicFunctions as $pattern => $function) {
  175. if (preg_match($pattern, $name, $matches)) {
  176. array_shift($matches);
  178. return $function->withDynamicArguments($name, $function->getName(), $matches);
  179. }
  180. }
  182. foreach ($this->functionCallbacks as $callback) {
  183. if (false !== $function = $callback($name)) {
  184. return $function;
  185. }
  186. }
  188. return null;
  189. }
  191. public function registerUndefinedFunctionCallback(callable $callable): void
  192. {
  193. $this->functionCallbacks[] = $callable;
  194. }
  196. public function addFilter(TwigFilter $filter): void
  197. {
  198. if ($this->initialized) {
  199. throw new \LogicException(\sprintf('Unable to add filter "%s" as extensions have already been initialized.', $filter->getName()));
  200. }
  202. $this->staging->addFilter($filter);
  203. }
  205. /**
  206. * @return TwigFilter[]
  207. */
  208. public function getFilters(): array
  209. {
  210. if (!$this->initialized) {
  211. $this->initExtensions();
  212. }
  214. return $this->filters;
  215. }
  217. public function getFilter(string $name): ?TwigFilter
  218. {
  219. if (!$this->initialized) {
  220. $this->initExtensions();
  221. }
  223. if (isset($this->filters[$name])) {
  224. return $this->filters[$name];
  225. }
  227. foreach ($this->dynamicFilters as $pattern => $filter) {
  228. if (preg_match($pattern, $name, $matches)) {
  229. array_shift($matches);
  231. return $filter->withDynamicArguments($name, $filter->getName(), $matches);
  232. }
  233. }
  235. foreach ($this->filterCallbacks as $callback) {
  236. if (false !== $filter = $callback($name)) {
  237. return $filter;
  238. }
  239. }
  241. return null;
  242. }
  244. public function registerUndefinedFilterCallback(callable $callable): void
  245. {
  246. $this->filterCallbacks[] = $callable;
  247. }
  249. public function addNodeVisitor(NodeVisitorInterface $visitor): void
  250. {
  251. if ($this->initialized) {
  252. throw new \LogicException('Unable to add a node visitor as extensions have already been initialized.');
  253. }
  255. $this->staging->addNodeVisitor($visitor);
  256. }
  258. /**
  259. * @return NodeVisitorInterface[]
  260. */
  261. public function getNodeVisitors(): array
  262. {
  263. if (!$this->initialized) {
  264. $this->initExtensions();
  265. }
  267. return $this->visitors;
  268. }
  270. public function addTokenParser(TokenParserInterface $parser): void
  271. {
  272. if ($this->initialized) {
  273. throw new \LogicException('Unable to add a token parser as extensions have already been initialized.');
  274. }
  276. $this->staging->addTokenParser($parser);
  277. }
  279. /**
  280. * @return TokenParserInterface[]
  281. */
  282. public function getTokenParsers(): array
  283. {
  284. if (!$this->initialized) {
  285. $this->initExtensions();
  286. }
  288. return $this->parsers;
  289. }
  291. public function getTokenParser(string $name): ?TokenParserInterface
  292. {
  293. if (!$this->initialized) {
  294. $this->initExtensions();
  295. }
  297. if (isset($this->parsers[$name])) {
  298. return $this->parsers[$name];
  299. }
  301. foreach ($this->parserCallbacks as $callback) {
  302. if (false !== $parser = $callback($name)) {
  303. return $parser;
  304. }
  305. }
  307. return null;
  308. }
  310. public function registerUndefinedTokenParserCallback(callable $callable): void
  311. {
  312. $this->parserCallbacks[] = $callable;
  313. }
  315. /**
  316. * @return array<string, mixed>
  317. */
  318. public function getGlobals(): array
  319. {
  320. if (null !== $this->globals) {
  321. return $this->globals;
  322. }
  324. $globals = [];
  325. foreach ($this->extensions as $extension) {
  326. if (!$extension instanceof GlobalsInterface) {
  327. continue;
  328. }
  330. $globals = array_merge($globals, $extension->getGlobals());
  331. }
  333. if ($this->initialized) {
  334. $this->globals = $globals;
  335. }
  337. return $globals;
  338. }
  340. public function resetGlobals(): void
  341. {
  342. $this->globals = null;
  343. }
  345. public function addTest(TwigTest $test): void
  346. {
  347. if ($this->initialized) {
  348. throw new \LogicException(\sprintf('Unable to add test "%s" as extensions have already been initialized.', $test->getName()));
  349. }
  351. $this->staging->addTest($test);
  352. }
  354. /**
  355. * @return TwigTest[]
  356. */
  357. public function getTests(): array
  358. {
  359. if (!$this->initialized) {
  360. $this->initExtensions();
  361. }
  363. return $this->tests;
  364. }
  366. public function getTest(string $name): ?TwigTest
  367. {
  368. if (!$this->initialized) {
  369. $this->initExtensions();
  370. }
  372. if (isset($this->tests[$name])) {
  373. return $this->tests[$name];
  374. }
  376. foreach ($this->dynamicTests as $pattern => $test) {
  377. if (preg_match($pattern, $name, $matches)) {
  378. array_shift($matches);
  380. return $test->withDynamicArguments($name, $test->getName(), $matches);
  381. }
  382. }
  384. return null;
  385. }
  387. /**
  388. * @return array<string, array{precedence: int, class: class-string<AbstractExpression>}>
  389. */
  390. public function getUnaryOperators(): array
  391. {
  392. if (!$this->initialized) {
  393. $this->initExtensions();
  394. }
  396. return $this->unaryOperators;
  397. }
  399. /**
  400. * @return array<string, array{precedence: int, class?: class-string<AbstractExpression>, associativity: ExpressionParser::OPERATOR_*}>
  401. */
  402. public function getBinaryOperators(): array
  403. {
  404. if (!$this->initialized) {
  405. $this->initExtensions();
  406. }
  408. return $this->binaryOperators;
  409. }
  411. private function initExtensions(): void
  412. {
  413. $this->parsers = [];
  414. $this->filters = [];
  415. $this->functions = [];
  416. $this->tests = [];
  417. $this->dynamicFilters = [];
  418. $this->dynamicFunctions = [];
  419. $this->dynamicTests = [];
  420. $this->visitors = [];
  421. $this->unaryOperators = [];
  422. $this->binaryOperators = [];
  424. foreach ($this->extensions as $extension) {
  425. $this->initExtension($extension);
  426. }
  427. $this->initExtension($this->staging);
  428. // Done at the end only, so that an exception during initialization does not mark the environment as initialized when catching the exception
  429. $this->initialized = true;
  430. }
  432. private function initExtension(ExtensionInterface $extension): void
  433. {
  434. // filters
  435. foreach ($extension->getFilters() as $filter) {
  436. $this->filters[$name = $filter->getName()] = $filter;
  437. if (str_contains($name, '*')) {
  438. $this->dynamicFilters['#^'.str_replace('\\*', '(.*?)', preg_quote($name, '#')).'$#'] = $filter;
  439. }
  440. }
  442. // functions
  443. foreach ($extension->getFunctions() as $function) {
  444. $this->functions[$name = $function->getName()] = $function;
  445. if (str_contains($name, '*')) {
  446. $this->dynamicFunctions['#^'.str_replace('\\*', '(.*?)', preg_quote($name, '#')).'$#'] = $function;
  447. }
  448. }
  450. // tests
  451. foreach ($extension->getTests() as $test) {
  452. $this->tests[$name = $test->getName()] = $test;
  453. if (str_contains($name, '*')) {
  454. $this->dynamicTests['#^'.str_replace('\\*', '(.*?)', preg_quote($name, '#')).'$#'] = $test;
  455. }
  456. }
  458. // token parsers
  459. foreach ($extension->getTokenParsers() as $parser) {
  460. if (!$parser instanceof TokenParserInterface) {
  461. throw new \LogicException('getTokenParsers() must return an array of \Twig\TokenParser\TokenParserInterface.');
  462. }
  464. $this->parsers[$parser->getTag()] = $parser;
  465. }
  467. // node visitors
  468. foreach ($extension->getNodeVisitors() as $visitor) {
  469. $this->visitors[] = $visitor;
  470. }
  472. // operators
  473. if ($operators = $extension->getOperators()) {
  474. if (!\is_array($operators)) {
  475. 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)));
  476. }
  478. if (2 !== \count($operators)) {
  479. throw new \InvalidArgumentException(\sprintf('"%s::getOperators()" must return an array of 2 elements, got %d.', \get_class($extension), \count($operators)));
  480. }
  482. $this->unaryOperators = array_merge($this->unaryOperators, $operators[0]);
  483. $this->binaryOperators = array_merge($this->binaryOperators, $operators[1]);
  484. }
  485. }
  486. }