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

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. }