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

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\ExpressionParser\ExpressionParsers;
  16. use Twig\ExpressionParser\Infix\BinaryOperatorExpressionParser;
  17. use Twig\ExpressionParser\InfixAssociativity;
  18. use Twig\ExpressionParser\InfixExpressionParserInterface;
  19. use Twig\ExpressionParser\PrecedenceChange;
  20. use Twig\ExpressionParser\Prefix\UnaryOperatorExpressionParser;
  21. use Twig\Extension\AttributeExtension;
  22. use Twig\Extension\ExtensionInterface;
  23. use Twig\Extension\GlobalsInterface;
  24. use Twig\Extension\LastModifiedExtensionInterface;
  25. use Twig\Extension\StagingExtension;
  26. use Twig\Node\Expression\AbstractExpression;
  27. use Twig\NodeVisitor\NodeVisitorInterface;
  28. use Twig\TokenParser\TokenParserInterface;
  30. /**
  31. * @author Fabien Potencier <fabien@symfony.com>
  32. *
  33. * @internal
  34. */
  35. final class ExtensionSet
  36. {
  37. private $extensions;
  38. private $initialized = false;
  39. private $runtimeInitialized = false;
  40. private $staging;
  41. private $parsers;
  42. private $visitors;
  43. /** @var array<string, TwigFilter> */
  44. private $filters;
  45. /** @var array<string, TwigFilter> */
  46. private $dynamicFilters;
  47. /** @var array<string, TwigTest> */
  48. private $tests;
  49. /** @var array<string, TwigTest> */
  50. private $dynamicTests;
  51. /** @var array<string, TwigFunction> */
  52. private $functions;
  53. /** @var array<string, TwigFunction> */
  54. private $dynamicFunctions;
  55. private ExpressionParsers $expressionParsers;
  56. /** @var array<string, mixed>|null */
  57. private $globals;
  58. /** @var array<callable(string): (TwigFunction|false)> */
  59. private $functionCallbacks = [];
  60. /** @var array<callable(string): (TwigFilter|false)> */
  61. private $filterCallbacks = [];
  62. /** @var array<callable(string): (TokenParserInterface|false)> */
  63. private $parserCallbacks = [];
  64. private $lastModified = 0;
  66. public function __construct()
  67. {
  68. $this->staging = new StagingExtension();
  69. }
  71. /**
  72. * @return void
  73. */
  74. public function initRuntime()
  75. {
  76. $this->runtimeInitialized = true;
  77. }
  79. public function hasExtension(string $class): bool
  80. {
  81. return isset($this->extensions[ltrim($class, '\\')]);
  82. }
  84. public function getExtension(string $class): ExtensionInterface
  85. {
  86. $class = ltrim($class, '\\');
  88. if (!isset($this->extensions[$class])) {
  89. throw new RuntimeError(\sprintf('The "%s" extension is not enabled.', $class));
  90. }
  92. return $this->extensions[$class];
  93. }
  95. /**
  96. * @param ExtensionInterface[] $extensions
  97. */
  98. public function setExtensions(array $extensions): void
  99. {
  100. foreach ($extensions as $extension) {
  101. $this->addExtension($extension);
  102. }
  103. }
  105. /**
  106. * @return ExtensionInterface[]
  107. */
  108. public function getExtensions(): array
  109. {
  110. return $this->extensions;
  111. }
  113. public function getSignature(): string
  114. {
  115. return json_encode(array_keys($this->extensions));
  116. }
  118. public function isInitialized(): bool
  119. {
  120. return $this->initialized || $this->runtimeInitialized;
  121. }
  123. public function getLastModified(): int
  124. {
  125. if (0 !== $this->lastModified) {
  126. return $this->lastModified;
  127. }
  129. $lastModified = 0;
  130. foreach ($this->extensions as $extension) {
  131. if ($extension instanceof LastModifiedExtensionInterface) {
  132. $lastModified = max($extension->getLastModified(), $lastModified);
  133. } else {
  134. $r = new \ReflectionObject($extension);
  135. if (is_file($r->getFileName())) {
  136. $lastModified = max(filemtime($r->getFileName()), $lastModified);
  137. }
  138. }
  139. }
  141. return $this->lastModified = $lastModified;
  142. }
  144. public function addExtension(ExtensionInterface $extension): void
  145. {
  146. if ($extension instanceof AttributeExtension) {
  147. $class = $extension->getClass();
  148. } else {
  149. $class = $extension::class;
  150. }
  152. if ($this->initialized) {
  153. throw new \LogicException(\sprintf('Unable to register extension "%s" as extensions have already been initialized.', $class));
  154. }
  156. if (isset($this->extensions[$class])) {
  157. throw new \LogicException(\sprintf('Unable to register extension "%s" as it is already registered.', $class));
  158. }
  160. $this->extensions[$class] = $extension;
  161. }
  163. public function addFunction(TwigFunction $function): void
  164. {
  165. if ($this->initialized) {
  166. throw new \LogicException(\sprintf('Unable to add function "%s" as extensions have already been initialized.', $function->getName()));
  167. }
  169. $this->staging->addFunction($function);
  170. }
  172. /**
  173. * @return TwigFunction[]
  174. */
  175. public function getFunctions(): array
  176. {
  177. if (!$this->initialized) {
  178. $this->initExtensions();
  179. }
  181. return $this->functions;
  182. }
  184. public function getFunction(string $name): ?TwigFunction
  185. {
  186. if (!$this->initialized) {
  187. $this->initExtensions();
  188. }
  190. if (isset($this->functions[$name])) {
  191. return $this->functions[$name];
  192. }
  194. foreach ($this->dynamicFunctions as $pattern => $function) {
  195. if (preg_match($pattern, $name, $matches)) {
  196. array_shift($matches);
  198. return $function->withDynamicArguments($name, $function->getName(), $matches);
  199. }
  200. }
  202. foreach ($this->functionCallbacks as $callback) {
  203. if (false !== $function = $callback($name)) {
  204. return $function;
  205. }
  206. }
  208. return null;
  209. }
  211. /**
  212. * @param callable(string): (TwigFunction|false) $callable
  213. */
  214. public function registerUndefinedFunctionCallback(callable $callable): void
  215. {
  216. $this->functionCallbacks[] = $callable;
  217. }
  219. public function addFilter(TwigFilter $filter): void
  220. {
  221. if ($this->initialized) {
  222. throw new \LogicException(\sprintf('Unable to add filter "%s" as extensions have already been initialized.', $filter->getName()));
  223. }
  225. $this->staging->addFilter($filter);
  226. }
  228. /**
  229. * @return TwigFilter[]
  230. */
  231. public function getFilters(): array
  232. {
  233. if (!$this->initialized) {
  234. $this->initExtensions();
  235. }
  237. return $this->filters;
  238. }
  240. public function getFilter(string $name): ?TwigFilter
  241. {
  242. if (!$this->initialized) {
  243. $this->initExtensions();
  244. }
  246. if (isset($this->filters[$name])) {
  247. return $this->filters[$name];
  248. }
  250. foreach ($this->dynamicFilters as $pattern => $filter) {
  251. if (preg_match($pattern, $name, $matches)) {
  252. array_shift($matches);
  254. return $filter->withDynamicArguments($name, $filter->getName(), $matches);
  255. }
  256. }
  258. foreach ($this->filterCallbacks as $callback) {
  259. if (false !== $filter = $callback($name)) {
  260. return $filter;
  261. }
  262. }
  264. return null;
  265. }
  267. /**
  268. * @param callable(string): (TwigFilter|false) $callable
  269. */
  270. public function registerUndefinedFilterCallback(callable $callable): void
  271. {
  272. $this->filterCallbacks[] = $callable;
  273. }
  275. public function addNodeVisitor(NodeVisitorInterface $visitor): void
  276. {
  277. if ($this->initialized) {
  278. throw new \LogicException('Unable to add a node visitor as extensions have already been initialized.');
  279. }
  281. $this->staging->addNodeVisitor($visitor);
  282. }
  284. /**
  285. * @return NodeVisitorInterface[]
  286. */
  287. public function getNodeVisitors(): array
  288. {
  289. if (!$this->initialized) {
  290. $this->initExtensions();
  291. }
  293. return $this->visitors;
  294. }
  296. public function addTokenParser(TokenParserInterface $parser): void
  297. {
  298. if ($this->initialized) {
  299. throw new \LogicException('Unable to add a token parser as extensions have already been initialized.');
  300. }
  302. $this->staging->addTokenParser($parser);
  303. }
  305. /**
  306. * @return TokenParserInterface[]
  307. */
  308. public function getTokenParsers(): array
  309. {
  310. if (!$this->initialized) {
  311. $this->initExtensions();
  312. }
  314. return $this->parsers;
  315. }
  317. public function getTokenParser(string $name): ?TokenParserInterface
  318. {
  319. if (!$this->initialized) {
  320. $this->initExtensions();
  321. }
  323. if (isset($this->parsers[$name])) {
  324. return $this->parsers[$name];
  325. }
  327. foreach ($this->parserCallbacks as $callback) {
  328. if (false !== $parser = $callback($name)) {
  329. return $parser;
  330. }
  331. }
  333. return null;
  334. }
  336. /**
  337. * @param callable(string): (TokenParserInterface|false) $callable
  338. */
  339. public function registerUndefinedTokenParserCallback(callable $callable): void
  340. {
  341. $this->parserCallbacks[] = $callable;
  342. }
  344. /**
  345. * @return array<string, mixed>
  346. */
  347. public function getGlobals(): array
  348. {
  349. if (null !== $this->globals) {
  350. return $this->globals;
  351. }
  353. $globals = [];
  354. foreach ($this->extensions as $extension) {
  355. if (!$extension instanceof GlobalsInterface) {
  356. continue;
  357. }
  359. $globals = array_merge($globals, $extension->getGlobals());
  360. }
  362. if ($this->initialized) {
  363. $this->globals = $globals;
  364. }
  366. return $globals;
  367. }
  369. public function resetGlobals(): void
  370. {
  371. $this->globals = null;
  372. }
  374. public function addTest(TwigTest $test): void
  375. {
  376. if ($this->initialized) {
  377. throw new \LogicException(\sprintf('Unable to add test "%s" as extensions have already been initialized.', $test->getName()));
  378. }
  380. $this->staging->addTest($test);
  381. }
  383. /**
  384. * @return TwigTest[]
  385. */
  386. public function getTests(): array
  387. {
  388. if (!$this->initialized) {
  389. $this->initExtensions();
  390. }
  392. return $this->tests;
  393. }
  395. public function getTest(string $name): ?TwigTest
  396. {
  397. if (!$this->initialized) {
  398. $this->initExtensions();
  399. }
  401. if (isset($this->tests[$name])) {
  402. return $this->tests[$name];
  403. }
  405. foreach ($this->dynamicTests as $pattern => $test) {
  406. if (preg_match($pattern, $name, $matches)) {
  407. array_shift($matches);
  409. return $test->withDynamicArguments($name, $test->getName(), $matches);
  410. }
  411. }
  413. return null;
  414. }
  416. public function getExpressionParsers(): ExpressionParsers
  417. {
  418. if (!$this->initialized) {
  419. $this->initExtensions();
  420. }
  422. return $this->expressionParsers;
  423. }
  425. private function initExtensions(): void
  426. {
  427. $this->parsers = [];
  428. $this->filters = [];
  429. $this->functions = [];
  430. $this->tests = [];
  431. $this->dynamicFilters = [];
  432. $this->dynamicFunctions = [];
  433. $this->dynamicTests = [];
  434. $this->visitors = [];
  435. $this->expressionParsers = new ExpressionParsers();
  437. foreach ($this->extensions as $extension) {
  438. $this->initExtension($extension);
  439. }
  440. $this->initExtension($this->staging);
  441. // Done at the end only, so that an exception during initialization does not mark the environment as initialized when catching the exception
  442. $this->initialized = true;
  443. }
  445. private function initExtension(ExtensionInterface $extension): void
  446. {
  447. // filters
  448. foreach ($extension->getFilters() as $filter) {
  449. $this->filters[$name = $filter->getName()] = $filter;
  450. if (str_contains($name, '*')) {
  451. $this->dynamicFilters['#^'.str_replace('\\*', '(.*?)', preg_quote($name, '#')).'$#'] = $filter;
  452. }
  453. }
  455. // functions
  456. foreach ($extension->getFunctions() as $function) {
  457. $this->functions[$name = $function->getName()] = $function;
  458. if (str_contains($name, '*')) {
  459. $this->dynamicFunctions['#^'.str_replace('\\*', '(.*?)', preg_quote($name, '#')).'$#'] = $function;
  460. }
  461. }
  463. // tests
  464. foreach ($extension->getTests() as $test) {
  465. $this->tests[$name = $test->getName()] = $test;
  466. if (str_contains($name, '*')) {
  467. $this->dynamicTests['#^'.str_replace('\\*', '(.*?)', preg_quote($name, '#')).'$#'] = $test;
  468. }
  469. }
  471. // token parsers
  472. foreach ($extension->getTokenParsers() as $parser) {
  473. if (!$parser instanceof TokenParserInterface) {
  474. throw new \LogicException('getTokenParsers() must return an array of \Twig\TokenParser\TokenParserInterface.');
  475. }
  477. $this->parsers[$parser->getTag()] = $parser;
  478. }
  480. // node visitors
  481. foreach ($extension->getNodeVisitors() as $visitor) {
  482. $this->visitors[] = $visitor;
  483. }
  485. // expression parsers
  486. if (method_exists($extension, 'getExpressionParsers')) {
  487. $this->expressionParsers->add($extension->getExpressionParsers());
  488. }
  490. $operators = $extension->getOperators();
  491. if (!\is_array($operators)) {
  492. throw new \InvalidArgumentException(\sprintf('"%s::getOperators()" must return an array with operators, got "%s".', $extension::class, get_debug_type($operators).(\is_resource($operators) ? '' : '#'.$operators)));
  493. }
  495. if (2 !== \count($operators)) {
  496. throw new \InvalidArgumentException(\sprintf('"%s::getOperators()" must return an array of 2 elements, got %d.', $extension::class, \count($operators)));
  497. }
  499. $expressionParsers = [];
  500. foreach ($operators[0] as $operator => $op) {
  501. $expressionParsers[] = new UnaryOperatorExpressionParser($op['class'], $operator, $op['precedence'], $op['precedence_change'] ?? null, '', $op['aliases'] ?? []);
  502. }
  503. foreach ($operators[1] as $operator => $op) {
  504. $op['associativity'] = match ($op['associativity']) {
  505. 1 => InfixAssociativity::Left,
  506. 2 => InfixAssociativity::Right,
  507. default => throw new \InvalidArgumentException(\sprintf('Invalid associativity "%s" for operator "%s".', $op['associativity'], $operator)),
  508. };
  510. if (isset($op['callable'])) {
  511. $expressionParsers[] = $this->convertInfixExpressionParser($op['class'], $operator, $op['precedence'], $op['associativity'], $op['precedence_change'] ?? null, $op['aliases'] ?? [], $op['callable']);
  512. } else {
  513. $expressionParsers[] = new BinaryOperatorExpressionParser($op['class'], $operator, $op['precedence'], $op['associativity'], $op['precedence_change'] ?? null, '', $op['aliases'] ?? []);
  514. }
  515. }
  517. if (\count($expressionParsers)) {
  518. trigger_deprecation('twig/twig', '3.21', \sprintf('Extension "%s" uses the old signature for "getOperators()", please implement "getExpressionParsers()" instead.', $extension::class));
  520. $this->expressionParsers->add($expressionParsers);
  521. }
  522. }
  524. private function convertInfixExpressionParser(string $nodeClass, string $operator, int $precedence, InfixAssociativity $associativity, ?PrecedenceChange $precedenceChange, array $aliases, callable $callable): InfixExpressionParserInterface
  525. {
  526. trigger_deprecation('twig/twig', '3.21', \sprintf('Using a non-ExpressionParserInterface object to define the "%s" binary operator is deprecated.', $operator));
  528. return new class($nodeClass, $operator, $precedence, $associativity, $precedenceChange, $aliases, $callable) extends BinaryOperatorExpressionParser {
  529. public function __construct(
  530. string $nodeClass,
  531. string $operator,
  532. int $precedence,
  533. InfixAssociativity $associativity = InfixAssociativity::Left,
  534. ?PrecedenceChange $precedenceChange = null,
  535. array $aliases = [],
  536. private $callable = null,
  537. ) {
  538. parent::__construct($nodeClass, $operator, $precedence, $associativity, $precedenceChange, $aliases);
  539. }
  541. public function parse(Parser $parser, AbstractExpression $expr, Token $token): AbstractExpression
  542. {
  543. return ($this->callable)($parser, $expr);
  544. }
  545. };
  546. }
  547. }