vendor/twig/twig/src/Extension/CoreExtension.php line 1861

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\Extension;
  14. use Twig\DeprecatedCallableInfo;
  15. use Twig\Environment;
  16. use Twig\Error\LoaderError;
  17. use Twig\Error\RuntimeError;
  18. use Twig\Error\SyntaxError;
  19. use Twig\ExpressionParser;
  20. use Twig\Markup;
  21. use Twig\Node\Expression\AbstractExpression;
  22. use Twig\Node\Expression\Binary\AddBinary;
  23. use Twig\Node\Expression\Binary\AndBinary;
  24. use Twig\Node\Expression\Binary\BitwiseAndBinary;
  25. use Twig\Node\Expression\Binary\BitwiseOrBinary;
  26. use Twig\Node\Expression\Binary\BitwiseXorBinary;
  27. use Twig\Node\Expression\Binary\ConcatBinary;
  28. use Twig\Node\Expression\Binary\DivBinary;
  29. use Twig\Node\Expression\Binary\EndsWithBinary;
  30. use Twig\Node\Expression\Binary\EqualBinary;
  31. use Twig\Node\Expression\Binary\FloorDivBinary;
  32. use Twig\Node\Expression\Binary\GreaterBinary;
  33. use Twig\Node\Expression\Binary\GreaterEqualBinary;
  34. use Twig\Node\Expression\Binary\HasEveryBinary;
  35. use Twig\Node\Expression\Binary\HasSomeBinary;
  36. use Twig\Node\Expression\Binary\InBinary;
  37. use Twig\Node\Expression\Binary\LessBinary;
  38. use Twig\Node\Expression\Binary\LessEqualBinary;
  39. use Twig\Node\Expression\Binary\MatchesBinary;
  40. use Twig\Node\Expression\Binary\ModBinary;
  41. use Twig\Node\Expression\Binary\MulBinary;
  42. use Twig\Node\Expression\Binary\NotEqualBinary;
  43. use Twig\Node\Expression\Binary\NotInBinary;
  44. use Twig\Node\Expression\Binary\OrBinary;
  45. use Twig\Node\Expression\Binary\PowerBinary;
  46. use Twig\Node\Expression\Binary\RangeBinary;
  47. use Twig\Node\Expression\Binary\SpaceshipBinary;
  48. use Twig\Node\Expression\Binary\StartsWithBinary;
  49. use Twig\Node\Expression\Binary\SubBinary;
  50. use Twig\Node\Expression\Binary\XorBinary;
  51. use Twig\Node\Expression\BlockReferenceExpression;
  52. use Twig\Node\Expression\Filter\DefaultFilter;
  53. use Twig\Node\Expression\FunctionNode\EnumCasesFunction;
  54. use Twig\Node\Expression\FunctionNode\EnumFunction;
  55. use Twig\Node\Expression\GetAttrExpression;
  56. use Twig\Node\Expression\NullCoalesceExpression;
  57. use Twig\Node\Expression\ParentExpression;
  58. use Twig\Node\Expression\Test\ConstantTest;
  59. use Twig\Node\Expression\Test\DefinedTest;
  60. use Twig\Node\Expression\Test\DivisiblebyTest;
  61. use Twig\Node\Expression\Test\EvenTest;
  62. use Twig\Node\Expression\Test\NullTest;
  63. use Twig\Node\Expression\Test\OddTest;
  64. use Twig\Node\Expression\Test\SameasTest;
  65. use Twig\Node\Expression\Unary\NegUnary;
  66. use Twig\Node\Expression\Unary\NotUnary;
  67. use Twig\Node\Expression\Unary\PosUnary;
  68. use Twig\Node\Node;
  69. use Twig\OperatorPrecedenceChange;
  70. use Twig\Parser;
  71. use Twig\Sandbox\SecurityNotAllowedMethodError;
  72. use Twig\Sandbox\SecurityNotAllowedPropertyError;
  73. use Twig\Source;
  74. use Twig\Template;
  75. use Twig\TemplateWrapper;
  76. use Twig\TokenParser\ApplyTokenParser;
  77. use Twig\TokenParser\BlockTokenParser;
  78. use Twig\TokenParser\DeprecatedTokenParser;
  79. use Twig\TokenParser\DoTokenParser;
  80. use Twig\TokenParser\EmbedTokenParser;
  81. use Twig\TokenParser\ExtendsTokenParser;
  82. use Twig\TokenParser\FlushTokenParser;
  83. use Twig\TokenParser\ForTokenParser;
  84. use Twig\TokenParser\FromTokenParser;
  85. use Twig\TokenParser\GuardTokenParser;
  86. use Twig\TokenParser\IfTokenParser;
  87. use Twig\TokenParser\ImportTokenParser;
  88. use Twig\TokenParser\IncludeTokenParser;
  89. use Twig\TokenParser\MacroTokenParser;
  90. use Twig\TokenParser\SetTokenParser;
  91. use Twig\TokenParser\TypesTokenParser;
  92. use Twig\TokenParser\UseTokenParser;
  93. use Twig\TokenParser\WithTokenParser;
  94. use Twig\TwigFilter;
  95. use Twig\TwigFunction;
  96. use Twig\TwigTest;
  97. use Twig\Util\CallableArgumentsExtractor;
  99. final class CoreExtension extends AbstractExtension
  100. {
  101. public const ARRAY_LIKE_CLASSES = [
  102. 'ArrayIterator',
  103. 'ArrayObject',
  104. 'CachingIterator',
  105. 'RecursiveArrayIterator',
  106. 'RecursiveCachingIterator',
  107. 'SplDoublyLinkedList',
  108. 'SplFixedArray',
  109. 'SplObjectStorage',
  110. 'SplQueue',
  111. 'SplStack',
  112. 'WeakMap',
  113. ];
  115. private const DEFAULT_TRIM_CHARS = " \t\n\r\0\x0B";
  117. private $dateFormats = ['F j, Y H:i', '%d days'];
  118. private $numberFormat = [0, '.', ','];
  119. private $timezone = null;
  121. /**
  122. * Sets the default format to be used by the date filter.
  123. *
  124. * @param string|null $format The default date format string
  125. * @param string|null $dateIntervalFormat The default date interval format string
  126. */
  127. public function setDateFormat($format = null, $dateIntervalFormat = null)
  128. {
  129. if (null !== $format) {
  130. $this->dateFormats[0] = $format;
  131. }
  133. if (null !== $dateIntervalFormat) {
  134. $this->dateFormats[1] = $dateIntervalFormat;
  135. }
  136. }
  138. /**
  139. * Gets the default format to be used by the date filter.
  140. *
  141. * @return array The default date format string and the default date interval format string
  142. */
  143. public function getDateFormat()
  144. {
  145. return $this->dateFormats;
  146. }
  148. /**
  149. * Sets the default timezone to be used by the date filter.
  150. *
  151. * @param \DateTimeZone|string $timezone The default timezone string or a \DateTimeZone object
  152. */
  153. public function setTimezone($timezone)
  154. {
  155. $this->timezone = $timezone instanceof \DateTimeZone ? $timezone : new \DateTimeZone($timezone);
  156. }
  158. /**
  159. * Gets the default timezone to be used by the date filter.
  160. *
  161. * @return \DateTimeZone The default timezone currently in use
  162. */
  163. public function getTimezone()
  164. {
  165. if (null === $this->timezone) {
  166. $this->timezone = new \DateTimeZone(date_default_timezone_get());
  167. }
  169. return $this->timezone;
  170. }
  172. /**
  173. * Sets the default format to be used by the number_format filter.
  174. *
  175. * @param int $decimal the number of decimal places to use
  176. * @param string $decimalPoint the character(s) to use for the decimal point
  177. * @param string $thousandSep the character(s) to use for the thousands separator
  178. */
  179. public function setNumberFormat($decimal, $decimalPoint, $thousandSep)
  180. {
  181. $this->numberFormat = [$decimal, $decimalPoint, $thousandSep];
  182. }
  184. /**
  185. * Get the default format used by the number_format filter.
  186. *
  187. * @return array The arguments for number_format()
  188. */
  189. public function getNumberFormat()
  190. {
  191. return $this->numberFormat;
  192. }
  194. public function getTokenParsers(): array
  195. {
  196. return [
  197. new ApplyTokenParser(),
  198. new ForTokenParser(),
  199. new IfTokenParser(),
  200. new ExtendsTokenParser(),
  201. new IncludeTokenParser(),
  202. new BlockTokenParser(),
  203. new UseTokenParser(),
  204. new MacroTokenParser(),
  205. new ImportTokenParser(),
  206. new FromTokenParser(),
  207. new SetTokenParser(),
  208. new TypesTokenParser(),
  209. new FlushTokenParser(),
  210. new DoTokenParser(),
  211. new EmbedTokenParser(),
  212. new WithTokenParser(),
  213. new DeprecatedTokenParser(),
  214. new GuardTokenParser(),
  215. ];
  216. }
  218. public function getFilters(): array
  219. {
  220. return [
  221. // formatting filters
  222. new TwigFilter('date', [$this, 'formatDate']),
  223. new TwigFilter('date_modify', [$this, 'modifyDate']),
  224. new TwigFilter('format', [self::class, 'sprintf']),
  225. new TwigFilter('replace', [self::class, 'replace']),
  226. new TwigFilter('number_format', [$this, 'formatNumber']),
  227. new TwigFilter('abs', 'abs'),
  228. new TwigFilter('round', [self::class, 'round']),
  230. // encoding
  231. new TwigFilter('url_encode', [self::class, 'urlencode']),
  232. new TwigFilter('json_encode', 'json_encode'),
  233. new TwigFilter('convert_encoding', [self::class, 'convertEncoding']),
  235. // string filters
  236. new TwigFilter('title', [self::class, 'titleCase'], ['needs_charset' => true]),
  237. new TwigFilter('capitalize', [self::class, 'capitalize'], ['needs_charset' => true]),
  238. new TwigFilter('upper', [self::class, 'upper'], ['needs_charset' => true]),
  239. new TwigFilter('lower', [self::class, 'lower'], ['needs_charset' => true]),
  240. new TwigFilter('striptags', [self::class, 'striptags']),
  241. new TwigFilter('trim', [self::class, 'trim']),
  242. new TwigFilter('nl2br', [self::class, 'nl2br'], ['pre_escape' => 'html', 'is_safe' => ['html']]),
  243. new TwigFilter('spaceless', [self::class, 'spaceless'], ['is_safe' => ['html'], 'deprecation_info' => new DeprecatedCallableInfo('twig/twig', '3.12')]),
  245. // array helpers
  246. new TwigFilter('join', [self::class, 'join']),
  247. new TwigFilter('split', [self::class, 'split'], ['needs_charset' => true]),
  248. new TwigFilter('sort', [self::class, 'sort'], ['needs_environment' => true]),
  249. new TwigFilter('merge', [self::class, 'merge']),
  250. new TwigFilter('batch', [self::class, 'batch']),
  251. new TwigFilter('column', [self::class, 'column']),
  252. new TwigFilter('filter', [self::class, 'filter'], ['needs_environment' => true]),
  253. new TwigFilter('map', [self::class, 'map'], ['needs_environment' => true]),
  254. new TwigFilter('reduce', [self::class, 'reduce'], ['needs_environment' => true]),
  255. new TwigFilter('find', [self::class, 'find'], ['needs_environment' => true]),
  257. // string/array filters
  258. new TwigFilter('reverse', [self::class, 'reverse'], ['needs_charset' => true]),
  259. new TwigFilter('shuffle', [self::class, 'shuffle'], ['needs_charset' => true]),
  260. new TwigFilter('length', [self::class, 'length'], ['needs_charset' => true]),
  261. new TwigFilter('slice', [self::class, 'slice'], ['needs_charset' => true]),
  262. new TwigFilter('first', [self::class, 'first'], ['needs_charset' => true]),
  263. new TwigFilter('last', [self::class, 'last'], ['needs_charset' => true]),
  265. // iteration and runtime
  266. new TwigFilter('default', [self::class, 'default'], ['node_class' => DefaultFilter::class]),
  267. new TwigFilter('keys', [self::class, 'keys']),
  268. ];
  269. }
  271. public function getFunctions(): array
  272. {
  273. return [
  274. new TwigFunction('parent', null, ['parser_callable' => [self::class, 'parseParentFunction']]),
  275. new TwigFunction('block', null, ['parser_callable' => [self::class, 'parseBlockFunction']]),
  276. new TwigFunction('attribute', null, ['parser_callable' => [self::class, 'parseAttributeFunction']]),
  277. new TwigFunction('max', 'max'),
  278. new TwigFunction('min', 'min'),
  279. new TwigFunction('range', 'range'),
  280. new TwigFunction('constant', [self::class, 'constant']),
  281. new TwigFunction('cycle', [self::class, 'cycle']),
  282. new TwigFunction('random', [self::class, 'random'], ['needs_charset' => true]),
  283. new TwigFunction('date', [$this, 'convertDate']),
  284. new TwigFunction('include', [self::class, 'include'], ['needs_environment' => true, 'needs_context' => true, 'is_safe' => ['all']]),
  285. new TwigFunction('source', [self::class, 'source'], ['needs_environment' => true, 'is_safe' => ['all']]),
  286. new TwigFunction('enum_cases', [self::class, 'enumCases'], ['node_class' => EnumCasesFunction::class]),
  287. new TwigFunction('enum', [self::class, 'enum'], ['node_class' => EnumFunction::class]),
  288. ];
  289. }
  291. public function getTests(): array
  292. {
  293. return [
  294. new TwigTest('even', null, ['node_class' => EvenTest::class]),
  295. new TwigTest('odd', null, ['node_class' => OddTest::class]),
  296. new TwigTest('defined', null, ['node_class' => DefinedTest::class]),
  297. new TwigTest('same as', null, ['node_class' => SameasTest::class, 'one_mandatory_argument' => true]),
  298. new TwigTest('none', null, ['node_class' => NullTest::class]),
  299. new TwigTest('null', null, ['node_class' => NullTest::class]),
  300. new TwigTest('divisible by', null, ['node_class' => DivisiblebyTest::class, 'one_mandatory_argument' => true]),
  301. new TwigTest('constant', null, ['node_class' => ConstantTest::class]),
  302. new TwigTest('empty', [self::class, 'testEmpty']),
  303. new TwigTest('iterable', 'is_iterable'),
  304. new TwigTest('sequence', [self::class, 'testSequence']),
  305. new TwigTest('mapping', [self::class, 'testMapping']),
  306. ];
  307. }
  309. public function getNodeVisitors(): array
  310. {
  311. return [];
  312. }
  314. public function getOperators(): array
  315. {
  316. return [
  317. [
  318. 'not' => ['precedence' => 50, 'precedence_change' => new OperatorPrecedenceChange('twig/twig', '3.15', 70), 'class' => NotUnary::class],
  319. '-' => ['precedence' => 500, 'class' => NegUnary::class],
  320. '+' => ['precedence' => 500, 'class' => PosUnary::class],
  321. ],
  322. [
  323. 'or' => ['precedence' => 10, 'class' => OrBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  324. 'xor' => ['precedence' => 12, 'class' => XorBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  325. 'and' => ['precedence' => 15, 'class' => AndBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  326. 'b-or' => ['precedence' => 16, 'class' => BitwiseOrBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  327. 'b-xor' => ['precedence' => 17, 'class' => BitwiseXorBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  328. 'b-and' => ['precedence' => 18, 'class' => BitwiseAndBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  329. '==' => ['precedence' => 20, 'class' => EqualBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  330. '!=' => ['precedence' => 20, 'class' => NotEqualBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  331. '<=>' => ['precedence' => 20, 'class' => SpaceshipBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  332. '<' => ['precedence' => 20, 'class' => LessBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  333. '>' => ['precedence' => 20, 'class' => GreaterBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  334. '>=' => ['precedence' => 20, 'class' => GreaterEqualBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  335. '<=' => ['precedence' => 20, 'class' => LessEqualBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  336. 'not in' => ['precedence' => 20, 'class' => NotInBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  337. 'in' => ['precedence' => 20, 'class' => InBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  338. 'matches' => ['precedence' => 20, 'class' => MatchesBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  339. 'starts with' => ['precedence' => 20, 'class' => StartsWithBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  340. 'ends with' => ['precedence' => 20, 'class' => EndsWithBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  341. 'has some' => ['precedence' => 20, 'class' => HasSomeBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  342. 'has every' => ['precedence' => 20, 'class' => HasEveryBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  343. '..' => ['precedence' => 25, 'class' => RangeBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  344. '+' => ['precedence' => 30, 'class' => AddBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  345. '-' => ['precedence' => 30, 'class' => SubBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  346. '~' => ['precedence' => 40, 'precedence_change' => new OperatorPrecedenceChange('twig/twig', '3.15', 27), 'class' => ConcatBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  347. '*' => ['precedence' => 60, 'class' => MulBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  348. '/' => ['precedence' => 60, 'class' => DivBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  349. '//' => ['precedence' => 60, 'class' => FloorDivBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  350. '%' => ['precedence' => 60, 'class' => ModBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  351. 'is' => ['precedence' => 100, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  352. 'is not' => ['precedence' => 100, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  353. '**' => ['precedence' => 200, 'class' => PowerBinary::class, 'associativity' => ExpressionParser::OPERATOR_RIGHT],
  354. '??' => ['precedence' => 300, 'precedence_change' => new OperatorPrecedenceChange('twig/twig', '3.15', 5), 'class' => NullCoalesceExpression::class, 'associativity' => ExpressionParser::OPERATOR_RIGHT],
  355. ],
  356. ];
  357. }
  359. /**
  360. * Cycles over a sequence.
  361. *
  362. * @param array|\ArrayAccess $values A non-empty sequence of values
  363. * @param int<0, max> $position The position of the value to return in the cycle
  364. *
  365. * @return mixed The value at the given position in the sequence, wrapping around as needed
  366. *
  367. * @internal
  368. */
  369. public static function cycle($values, $position): mixed
  370. {
  371. if (!\is_array($values)) {
  372. if (!$values instanceof \ArrayAccess) {
  373. throw new RuntimeError('The "cycle" function expects an array or "ArrayAccess" as first argument.');
  374. }
  376. if (!is_countable($values)) {
  377. // To be uncommented in 4.0
  378. // throw new RuntimeError('The "cycle" function expects a countable sequence as first argument.');
  380. trigger_deprecation('twig/twig', '3.12', 'Passing a non-countable sequence of values to "%s()" is deprecated.', __METHOD__);
  382. return $values;
  383. }
  385. $values = self::toArray($values, false);
  386. }
  388. if (!$count = \count($values)) {
  389. throw new RuntimeError('The "cycle" function expects a non-empty sequence.');
  390. }
  392. return $values[$position % $count];
  393. }
  395. /**
  396. * Returns a random value depending on the supplied parameter type:
  397. * - a random item from a \Traversable or array
  398. * - a random character from a string
  399. * - a random integer between 0 and the integer parameter.
  400. *
  401. * @param \Traversable|array|int|float|string $values The values to pick a random item from
  402. * @param int|null $max Maximum value used when $values is an int
  403. *
  404. * @return mixed A random value from the given sequence
  405. *
  406. * @throws RuntimeError when $values is an empty array (does not apply to an empty string which is returned as is)
  407. *
  408. * @internal
  409. */
  410. public static function random(string $charset, $values = null, $max = null)
  411. {
  412. if (null === $values) {
  413. return null === $max ? mt_rand() : mt_rand(0, (int) $max);
  414. }
  416. if (\is_int($values) || \is_float($values)) {
  417. if (null === $max) {
  418. if ($values < 0) {
  419. $max = 0;
  420. $min = $values;
  421. } else {
  422. $max = $values;
  423. $min = 0;
  424. }
  425. } else {
  426. $min = $values;
  427. }
  429. return mt_rand((int) $min, (int) $max);
  430. }
  432. if (\is_string($values)) {
  433. if ('' === $values) {
  434. return '';
  435. }
  437. if ('UTF-8' !== $charset) {
  438. $values = self::convertEncoding($values, 'UTF-8', $charset);
  439. }
  441. // unicode version of str_split()
  442. // split at all positions, but not after the start and not before the end
  443. $values = preg_split('/(?<!^)(?!$)/u', $values);
  445. if ('UTF-8' !== $charset) {
  446. foreach ($values as $i => $value) {
  447. $values[$i] = self::convertEncoding($value, $charset, 'UTF-8');
  448. }
  449. }
  450. }
  452. if (!is_iterable($values)) {
  453. return $values;
  454. }
  456. $values = self::toArray($values);
  458. if (0 === \count($values)) {
  459. throw new RuntimeError('The "random" function cannot pick from an empty sequence or mapping.');
  460. }
  462. return $values[array_rand($values, 1)];
  463. }
  465. /**
  466. * Formats a date.
  467. *
  468. * {{ post.published_at|date("m/d/Y") }}
  469. *
  470. * @param \DateTimeInterface|\DateInterval|string|int|null $date A date, a timestamp or null to use the current time
  471. * @param string|null $format The target format, null to use the default
  472. * @param \DateTimeZone|string|false|null $timezone The target timezone, null to use the default, false to leave unchanged
  473. */
  474. public function formatDate($date, $format = null, $timezone = null): string
  475. {
  476. if (null === $format) {
  477. $formats = $this->getDateFormat();
  478. $format = $date instanceof \DateInterval ? $formats[1] : $formats[0];
  479. }
  481. if ($date instanceof \DateInterval) {
  482. return $date->format($format);
  483. }
  485. return $this->convertDate($date, $timezone)->format($format);
  486. }
  488. /**
  489. * Returns a new date object modified.
  490. *
  491. * {{ post.published_at|date_modify("-1day")|date("m/d/Y") }}
  492. *
  493. * @param \DateTimeInterface|string|int|null $date A date, a timestamp or null to use the current time
  494. * @param string $modifier A modifier string
  495. *
  496. * @return \DateTime|\DateTimeImmutable
  497. *
  498. * @internal
  499. */
  500. public function modifyDate($date, $modifier)
  501. {
  502. return $this->convertDate($date, false)->modify($modifier);
  503. }
  505. /**
  506. * Returns a formatted string.
  507. *
  508. * @param string|null $format
  509. * @param ...$values
  510. *
  511. * @internal
  512. */
  513. public static function sprintf($format, ...$values): string
  514. {
  515. return \sprintf($format ?? '', ...$values);
  516. }
  518. /**
  519. * @internal
  520. */
  521. public static function dateConverter(Environment $env, $date, $format = null, $timezone = null): string
  522. {
  523. return $env->getExtension(self::class)->formatDate($date, $format, $timezone);
  524. }
  526. /**
  527. * Converts an input to a \DateTime instance.
  528. *
  529. * {% if date(user.created_at) < date('+2days') %}
  530. * {# do something #}
  531. * {% endif %}
  532. *
  533. * @param \DateTimeInterface|string|int|null $date A date, a timestamp or null to use the current time
  534. * @param \DateTimeZone|string|false|null $timezone The target timezone, null to use the default, false to leave unchanged
  535. *
  536. * @return \DateTime|\DateTimeImmutable
  537. */
  538. public function convertDate($date = null, $timezone = null)
  539. {
  540. // determine the timezone
  541. if (false !== $timezone) {
  542. if (null === $timezone) {
  543. $timezone = $this->getTimezone();
  544. } elseif (!$timezone instanceof \DateTimeZone) {
  545. $timezone = new \DateTimeZone($timezone);
  546. }
  547. }
  549. // immutable dates
  550. if ($date instanceof \DateTimeImmutable) {
  551. return false !== $timezone ? $date->setTimezone($timezone) : $date;
  552. }
  554. if ($date instanceof \DateTime) {
  555. $date = clone $date;
  556. if (false !== $timezone) {
  557. $date->setTimezone($timezone);
  558. }
  560. return $date;
  561. }
  563. if (null === $date || 'now' === $date) {
  564. if (null === $date) {
  565. $date = 'now';
  566. }
  568. return new \DateTime($date, false !== $timezone ? $timezone : $this->getTimezone());
  569. }
  571. $asString = (string) $date;
  572. if (ctype_digit($asString) || ('' !== $asString && '-' === $asString[0] && ctype_digit(substr($asString, 1)))) {
  573. $date = new \DateTime('@'.$date);
  574. } else {
  575. $date = new \DateTime($date, $this->getTimezone());
  576. }
  578. if (false !== $timezone) {
  579. $date->setTimezone($timezone);
  580. }
  582. return $date;
  583. }
  585. /**
  586. * Replaces strings within a string.
  587. *
  588. * @param string|null $str String to replace in
  589. * @param array|\Traversable $from Replace values
  590. *
  591. * @internal
  592. */
  593. public static function replace($str, $from): string
  594. {
  595. if (!is_iterable($from)) {
  596. throw new RuntimeError(\sprintf('The "replace" filter expects a sequence or a mapping, got "%s".', get_debug_type($from)));
  597. }
  599. return strtr($str ?? '', self::toArray($from));
  600. }
  602. /**
  603. * Rounds a number.
  604. *
  605. * @param int|float|string|null $value The value to round
  606. * @param int|float $precision The rounding precision
  607. * @param string $method The method to use for rounding
  608. *
  609. * @return int|float The rounded number
  610. *
  611. * @internal
  612. */
  613. public static function round($value, $precision = 0, $method = 'common')
  614. {
  615. $value = (float) $value;
  617. if ('common' === $method) {
  618. return round($value, $precision);
  619. }
  621. if ('ceil' !== $method && 'floor' !== $method) {
  622. throw new RuntimeError('The "round" filter only supports the "common", "ceil", and "floor" methods.');
  623. }
  625. return $method($value * 10 ** $precision) / 10 ** $precision;
  626. }
  628. /**
  629. * Formats a number.
  630. *
  631. * All of the formatting options can be left null, in that case the defaults will
  632. * be used. Supplying any of the parameters will override the defaults set in the
  633. * environment object.
  634. *
  635. * @param mixed $number A float/int/string of the number to format
  636. * @param int|null $decimal the number of decimal points to display
  637. * @param string|null $decimalPoint the character(s) to use for the decimal point
  638. * @param string|null $thousandSep the character(s) to use for the thousands separator
  639. */
  640. public function formatNumber($number, $decimal = null, $decimalPoint = null, $thousandSep = null): string
  641. {
  642. $defaults = $this->getNumberFormat();
  643. if (null === $decimal) {
  644. $decimal = $defaults[0];
  645. }
  647. if (null === $decimalPoint) {
  648. $decimalPoint = $defaults[1];
  649. }
  651. if (null === $thousandSep) {
  652. $thousandSep = $defaults[2];
  653. }
  655. return number_format((float) $number, $decimal, $decimalPoint, $thousandSep);
  656. }
  658. /**
  659. * URL encodes (RFC 3986) a string as a path segment or an array as a query string.
  660. *
  661. * @param string|array|null $url A URL or an array of query parameters
  662. *
  663. * @internal
  664. */
  665. public static function urlencode($url): string
  666. {
  667. if (\is_array($url)) {
  668. return http_build_query($url, '', '&', \PHP_QUERY_RFC3986);
  669. }
  671. return rawurlencode($url ?? '');
  672. }
  674. /**
  675. * Merges any number of arrays or Traversable objects.
  676. *
  677. * {% set items = { 'apple': 'fruit', 'orange': 'fruit' } %}
  678. *
  679. * {% set items = items|merge({ 'peugeot': 'car' }, { 'banana': 'fruit' }) %}
  680. *
  681. * {# items now contains { 'apple': 'fruit', 'orange': 'fruit', 'peugeot': 'car', 'banana': 'fruit' } #}
  682. *
  683. * @param array|\Traversable ...$arrays Any number of arrays or Traversable objects to merge
  684. *
  685. * @internal
  686. */
  687. public static function merge(...$arrays): array
  688. {
  689. $result = [];
  691. foreach ($arrays as $argNumber => $array) {
  692. if (!is_iterable($array)) {
  693. throw new RuntimeError(\sprintf('The "merge" filter expects a sequence or a mapping, got "%s" for argument %d.', get_debug_type($array), $argNumber + 1));
  694. }
  696. $result = array_merge($result, self::toArray($array));
  697. }
  699. return $result;
  700. }
  702. /**
  703. * Slices a variable.
  704. *
  705. * @param mixed $item A variable
  706. * @param int $start Start of the slice
  707. * @param int $length Size of the slice
  708. * @param bool $preserveKeys Whether to preserve key or not (when the input is an array)
  709. *
  710. * @return mixed The sliced variable
  711. *
  712. * @internal
  713. */
  714. public static function slice(string $charset, $item, $start, $length = null, $preserveKeys = false)
  715. {
  716. if ($item instanceof \Traversable) {
  717. while ($item instanceof \IteratorAggregate) {
  718. $item = $item->getIterator();
  719. }
  721. if ($start >= 0 && $length >= 0 && $item instanceof \Iterator) {
  722. try {
  723. return iterator_to_array(new \LimitIterator($item, $start, $length ?? -1), $preserveKeys);
  724. } catch (\OutOfBoundsException $e) {
  725. return [];
  726. }
  727. }
  729. $item = iterator_to_array($item, $preserveKeys);
  730. }
  732. if (\is_array($item)) {
  733. return \array_slice($item, $start, $length, $preserveKeys);
  734. }
  736. return mb_substr((string) $item, $start, $length, $charset);
  737. }
  739. /**
  740. * Returns the first element of the item.
  741. *
  742. * @param mixed $item A variable
  743. *
  744. * @return mixed The first element of the item
  745. *
  746. * @internal
  747. */
  748. public static function first(string $charset, $item)
  749. {
  750. $elements = self::slice($charset, $item, 0, 1, false);
  752. return \is_string($elements) ? $elements : current($elements);
  753. }
  755. /**
  756. * Returns the last element of the item.
  757. *
  758. * @param mixed $item A variable
  759. *
  760. * @return mixed The last element of the item
  761. *
  762. * @internal
  763. */
  764. public static function last(string $charset, $item)
  765. {
  766. $elements = self::slice($charset, $item, -1, 1, false);
  768. return \is_string($elements) ? $elements : current($elements);
  769. }
  771. /**
  772. * Joins the values to a string.
  773. *
  774. * The separators between elements are empty strings per default, you can define them with the optional parameters.
  775. *
  776. * {{ [1, 2, 3]|join(', ', ' and ') }}
  777. * {# returns 1, 2 and 3 #}
  778. *
  779. * {{ [1, 2, 3]|join('|') }}
  780. * {# returns 1|2|3 #}
  781. *
  782. * {{ [1, 2, 3]|join }}
  783. * {# returns 123 #}
  784. *
  785. * @param iterable|array|string|float|int|bool|null $value An array
  786. * @param string $glue The separator
  787. * @param string|null $and The separator for the last pair
  788. *
  789. * @internal
  790. */
  791. public static function join($value, $glue = '', $and = null): string
  792. {
  793. if (!is_iterable($value)) {
  794. $value = (array) $value;
  795. }
  797. $value = self::toArray($value, false);
  799. if (0 === \count($value)) {
  800. return '';
  801. }
  803. if (null === $and || $and === $glue) {
  804. return implode($glue, $value);
  805. }
  807. if (1 === \count($value)) {
  808. return $value[0];
  809. }
  811. return implode($glue, \array_slice($value, 0, -1)).$and.$value[\count($value) - 1];
  812. }
  814. /**
  815. * Splits the string into an array.
  816. *
  817. * {{ "one,two,three"|split(',') }}
  818. * {# returns [one, two, three] #}
  819. *
  820. * {{ "one,two,three,four,five"|split(',', 3) }}
  821. * {# returns [one, two, "three,four,five"] #}
  822. *
  823. * {{ "123"|split('') }}
  824. * {# returns [1, 2, 3] #}
  825. *
  826. * {{ "aabbcc"|split('', 2) }}
  827. * {# returns [aa, bb, cc] #}
  828. *
  829. * @param string|null $value A string
  830. * @param string $delimiter The delimiter
  831. * @param int|null $limit The limit
  832. *
  833. * @internal
  834. */
  835. public static function split(string $charset, $value, $delimiter, $limit = null): array
  836. {
  837. $value = $value ?? '';
  839. if ('' !== $delimiter) {
  840. return null === $limit ? explode($delimiter, $value) : explode($delimiter, $value, $limit);
  841. }
  843. if ($limit <= 1) {
  844. return preg_split('/(?<!^)(?!$)/u', $value);
  845. }
  847. $length = mb_strlen($value, $charset);
  848. if ($length < $limit) {
  849. return [$value];
  850. }
  852. $r = [];
  853. for ($i = 0; $i < $length; $i += $limit) {
  854. $r[] = mb_substr($value, $i, $limit, $charset);
  855. }
  857. return $r;
  858. }
  860. /**
  861. * @internal
  862. */
  863. public static function default($value, $default = '')
  864. {
  865. if (self::testEmpty($value)) {
  866. return $default;
  867. }
  869. return $value;
  870. }
  872. /**
  873. * Returns the keys for the given array.
  874. *
  875. * It is useful when you want to iterate over the keys of an array:
  876. *
  877. * {% for key in array|keys %}
  878. * {# ... #}
  879. * {% endfor %}
  880. *
  881. * @internal
  882. */
  883. public static function keys($array): array
  884. {
  885. if ($array instanceof \Traversable) {
  886. while ($array instanceof \IteratorAggregate) {
  887. $array = $array->getIterator();
  888. }
  890. $keys = [];
  891. if ($array instanceof \Iterator) {
  892. $array->rewind();
  893. while ($array->valid()) {
  894. $keys[] = $array->key();
  895. $array->next();
  896. }
  898. return $keys;
  899. }
  901. foreach ($array as $key => $item) {
  902. $keys[] = $key;
  903. }
  905. return $keys;
  906. }
  908. if (!\is_array($array)) {
  909. return [];
  910. }
  912. return array_keys($array);
  913. }
  915. /**
  916. * Reverses a variable.
  917. *
  918. * @param array|\Traversable|string|null $item An array, a \Traversable instance, or a string
  919. * @param bool $preserveKeys Whether to preserve key or not
  920. *
  921. * @return mixed The reversed input
  922. *
  923. * @internal
  924. */
  925. public static function reverse(string $charset, $item, $preserveKeys = false)
  926. {
  927. if ($item instanceof \Traversable) {
  928. return array_reverse(iterator_to_array($item), $preserveKeys);
  929. }
  931. if (\is_array($item)) {
  932. return array_reverse($item, $preserveKeys);
  933. }
  935. $string = (string) $item;
  937. if ('UTF-8' !== $charset) {
  938. $string = self::convertEncoding($string, 'UTF-8', $charset);
  939. }
  941. preg_match_all('/./us', $string, $matches);
  943. $string = implode('', array_reverse($matches[0]));
  945. if ('UTF-8' !== $charset) {
  946. $string = self::convertEncoding($string, $charset, 'UTF-8');
  947. }
  949. return $string;
  950. }
  952. /**
  953. * Shuffles an array, a \Traversable instance, or a string.
  954. * The function does not preserve keys.
  955. *
  956. * @param array|\Traversable|string|null $item
  957. *
  958. * @return mixed
  959. *
  960. * @internal
  961. */
  962. public static function shuffle(string $charset, $item)
  963. {
  964. if (\is_string($item)) {
  965. if ('UTF-8' !== $charset) {
  966. $item = self::convertEncoding($item, 'UTF-8', $charset);
  967. }
  969. $item = preg_split('/(?<!^)(?!$)/u', $item, -1);
  970. shuffle($item);
  971. $item = implode('', $item);
  973. if ('UTF-8' !== $charset) {
  974. $item = self::convertEncoding($item, $charset, 'UTF-8');
  975. }
  977. return $item;
  978. }
  980. if (is_iterable($item)) {
  981. $item = self::toArray($item, false);
  982. shuffle($item);
  983. }
  985. return $item;
  986. }
  988. /**
  989. * Sorts an array.
  990. *
  991. * @param array|\Traversable $array
  992. * @param ?\Closure $arrow
  993. *
  994. * @internal
  995. */
  996. public static function sort(Environment $env, $array, $arrow = null): array
  997. {
  998. if ($array instanceof \Traversable) {
  999. $array = iterator_to_array($array);
  1000. } elseif (!\is_array($array)) {
  1001. throw new RuntimeError(\sprintf('The "sort" filter expects a sequence or a mapping, got "%s".', get_debug_type($array)));
  1002. }
  1004. if (null !== $arrow) {
  1005. self::checkArrow($env, $arrow, 'sort', 'filter');
  1007. uasort($array, $arrow);
  1008. } else {
  1009. asort($array);
  1010. }
  1012. return $array;
  1013. }
  1015. /**
  1016. * @internal
  1017. */
  1018. public static function inFilter($value, $compare)
  1019. {
  1020. if ($value instanceof Markup) {
  1021. $value = (string) $value;
  1022. }
  1023. if ($compare instanceof Markup) {
  1024. $compare = (string) $compare;
  1025. }
  1027. if (\is_string($compare)) {
  1028. if (\is_string($value) || \is_int($value) || \is_float($value)) {
  1029. return '' === $value || str_contains($compare, (string) $value);
  1030. }
  1032. return false;
  1033. }
  1035. if (!is_iterable($compare)) {
  1036. return false;
  1037. }
  1039. if (\is_object($value) || \is_resource($value)) {
  1040. if (!\is_array($compare)) {
  1041. foreach ($compare as $item) {
  1042. if ($item === $value) {
  1043. return true;
  1044. }
  1045. }
  1047. return false;
  1048. }
  1050. return \in_array($value, $compare, true);
  1051. }
  1053. foreach ($compare as $item) {
  1054. if (0 === self::compare($value, $item)) {
  1055. return true;
  1056. }
  1057. }
  1059. return false;
  1060. }
  1062. /**
  1063. * Compares two values using a more strict version of the PHP non-strict comparison operator.
  1064. *
  1065. * @see https://wiki.php.net/rfc/string_to_number_comparison
  1066. * @see https://wiki.php.net/rfc/trailing_whitespace_numerics
  1067. *
  1068. * @internal
  1069. */
  1070. public static function compare($a, $b)
  1071. {
  1072. // int <=> string
  1073. if (\is_int($a) && \is_string($b)) {
  1074. $bTrim = trim($b, " \t\n\r\v\f");
  1075. if (!is_numeric($bTrim)) {
  1076. return (string) $a <=> $b;
  1077. }
  1078. if ((int) $bTrim == $bTrim) {
  1079. return $a <=> (int) $bTrim;
  1080. } else {
  1081. return (float) $a <=> (float) $bTrim;
  1082. }
  1083. }
  1084. if (\is_string($a) && \is_int($b)) {
  1085. $aTrim = trim($a, " \t\n\r\v\f");
  1086. if (!is_numeric($aTrim)) {
  1087. return $a <=> (string) $b;
  1088. }
  1089. if ((int) $aTrim == $aTrim) {
  1090. return (int) $aTrim <=> $b;
  1091. } else {
  1092. return (float) $aTrim <=> (float) $b;
  1093. }
  1094. }
  1096. // float <=> string
  1097. if (\is_float($a) && \is_string($b)) {
  1098. if (is_nan($a)) {
  1099. return 1;
  1100. }
  1101. $bTrim = trim($b, " \t\n\r\v\f");
  1102. if (!is_numeric($bTrim)) {
  1103. return (string) $a <=> $b;
  1104. }
  1106. return $a <=> (float) $bTrim;
  1107. }
  1108. if (\is_string($a) && \is_float($b)) {
  1109. if (is_nan($b)) {
  1110. return 1;
  1111. }
  1112. $aTrim = trim($a, " \t\n\r\v\f");
  1113. if (!is_numeric($aTrim)) {
  1114. return $a <=> (string) $b;
  1115. }
  1117. return (float) $aTrim <=> $b;
  1118. }
  1120. // fallback to <=>
  1121. return $a <=> $b;
  1122. }
  1124. /**
  1125. * @throws RuntimeError When an invalid pattern is used
  1126. *
  1127. * @internal
  1128. */
  1129. public static function matches(string $regexp, ?string $str): int
  1130. {
  1131. set_error_handler(function ($t, $m) use ($regexp) {
  1132. throw new RuntimeError(\sprintf('Regexp "%s" passed to "matches" is not valid', $regexp).substr($m, 12));
  1133. });
  1134. try {
  1135. return preg_match($regexp, $str ?? '');
  1136. } finally {
  1137. restore_error_handler();
  1138. }
  1139. }
  1141. /**
  1142. * Returns a trimmed string.
  1143. *
  1144. * @param string|\Stringable|null $string
  1145. * @param string|null $characterMask
  1146. * @param string $side left, right, or both
  1147. *
  1148. * @throws RuntimeError When an invalid trimming side is used
  1149. *
  1150. * @internal
  1151. */
  1152. public static function trim($string, $characterMask = null, $side = 'both'): string|\Stringable
  1153. {
  1154. if (null === $characterMask) {
  1155. $characterMask = self::DEFAULT_TRIM_CHARS;
  1156. }
  1158. $trimmed = match ($side) {
  1159. 'both' => trim($string ?? '', $characterMask),
  1160. 'left' => ltrim($string ?? '', $characterMask),
  1161. 'right' => rtrim($string ?? '', $characterMask),
  1162. default => throw new RuntimeError('Trimming side must be "left", "right" or "both".'),
  1163. };
  1165. // trimming a safe string with the default character mask always returns a safe string (independently of the context)
  1166. return $string instanceof Markup && self::DEFAULT_TRIM_CHARS === $characterMask ? new Markup($trimmed, $string->getCharset()) : $trimmed;
  1167. }
  1169. /**
  1170. * Inserts HTML line breaks before all newlines in a string.
  1171. *
  1172. * @param string|null $string
  1173. *
  1174. * @internal
  1175. */
  1176. public static function nl2br($string): string
  1177. {
  1178. return nl2br($string ?? '');
  1179. }
  1181. /**
  1182. * Removes whitespaces between HTML tags.
  1183. *
  1184. * @param string|null $content
  1185. *
  1186. * @internal
  1187. */
  1188. public static function spaceless($content): string
  1189. {
  1190. return trim(preg_replace('/>\s+</', '><', $content ?? ''));
  1191. }
  1193. /**
  1194. * @param string|null $string
  1195. * @param string $to
  1196. * @param string $from
  1197. *
  1198. * @internal
  1199. */
  1200. public static function convertEncoding($string, $to, $from): string
  1201. {
  1202. if (!\function_exists('iconv')) {
  1203. throw new RuntimeError('Unable to convert encoding: required function iconv() does not exist. You should install ext-iconv or symfony/polyfill-iconv.');
  1204. }
  1206. return iconv($from, $to, $string ?? '');
  1207. }
  1209. /**
  1210. * Returns the length of a variable.
  1211. *
  1212. * @param mixed $thing A variable
  1213. *
  1214. * @internal
  1215. */
  1216. public static function length(string $charset, $thing): int
  1217. {
  1218. if (null === $thing) {
  1219. return 0;
  1220. }
  1222. if (\is_scalar($thing)) {
  1223. return mb_strlen($thing, $charset);
  1224. }
  1226. if ($thing instanceof \Countable || \is_array($thing) || $thing instanceof \SimpleXMLElement) {
  1227. return \count($thing);
  1228. }
  1230. if ($thing instanceof \Traversable) {
  1231. return iterator_count($thing);
  1232. }
  1234. if ($thing instanceof \Stringable) {
  1235. return mb_strlen((string) $thing, $charset);
  1236. }
  1238. return 1;
  1239. }
  1241. /**
  1242. * Converts a string to uppercase.
  1243. *
  1244. * @param string|null $string A string
  1245. *
  1246. * @internal
  1247. */
  1248. public static function upper(string $charset, $string): string
  1249. {
  1250. return mb_strtoupper($string ?? '', $charset);
  1251. }
  1253. /**
  1254. * Converts a string to lowercase.
  1255. *
  1256. * @param string|null $string A string
  1257. *
  1258. * @internal
  1259. */
  1260. public static function lower(string $charset, $string): string
  1261. {
  1262. return mb_strtolower($string ?? '', $charset);
  1263. }
  1265. /**
  1266. * Strips HTML and PHP tags from a string.
  1267. *
  1268. * @param string|null $string
  1269. * @param string[]|string|null $allowable_tags
  1270. *
  1271. * @internal
  1272. */
  1273. public static function striptags($string, $allowable_tags = null): string
  1274. {
  1275. return strip_tags($string ?? '', $allowable_tags);
  1276. }
  1278. /**
  1279. * Returns a titlecased string.
  1280. *
  1281. * @param string|null $string A string
  1282. *
  1283. * @internal
  1284. */
  1285. public static function titleCase(string $charset, $string): string
  1286. {
  1287. return mb_convert_case($string ?? '', \MB_CASE_TITLE, $charset);
  1288. }
  1290. /**
  1291. * Returns a capitalized string.
  1292. *
  1293. * @param string|null $string A string
  1294. *
  1295. * @internal
  1296. */
  1297. public static function capitalize(string $charset, $string): string
  1298. {
  1299. return mb_strtoupper(mb_substr($string ?? '', 0, 1, $charset), $charset).mb_strtolower(mb_substr($string ?? '', 1, null, $charset), $charset);
  1300. }
  1302. /**
  1303. * @internal
  1304. *
  1305. * to be removed in 4.0
  1306. */
  1307. public static function callMacro(Template $template, string $method, array $args, int $lineno, array $context, Source $source)
  1308. {
  1309. if (!method_exists($template, $method)) {
  1310. $parent = $template;
  1311. while ($parent = $parent->getParent($context)) {
  1312. if (method_exists($parent, $method)) {
  1313. return $parent->$method(...$args);
  1314. }
  1315. }
  1317. throw new RuntimeError(\sprintf('Macro "%s" is not defined in template "%s".', substr($method, \strlen('macro_')), $template->getTemplateName()), $lineno, $source);
  1318. }
  1320. return $template->$method(...$args);
  1321. }
  1323. /**
  1324. * @template TSequence
  1325. *
  1326. * @param TSequence $seq
  1327. *
  1328. * @return ($seq is iterable ? TSequence : array{})
  1329. *
  1330. * @internal
  1331. */
  1332. public static function ensureTraversable($seq)
  1333. {
  1334. if (is_iterable($seq)) {
  1335. return $seq;
  1336. }
  1338. return [];
  1339. }
  1341. /**
  1342. * @internal
  1343. */
  1344. public static function toArray($seq, $preserveKeys = true)
  1345. {
  1346. if ($seq instanceof \Traversable) {
  1347. return iterator_to_array($seq, $preserveKeys);
  1348. }
  1350. if (!\is_array($seq)) {
  1351. return $seq;
  1352. }
  1354. return $preserveKeys ? $seq : array_values($seq);
  1355. }
  1357. /**
  1358. * Checks if a variable is empty.
  1359. *
  1360. * {# evaluates to true if the foo variable is null, false, or the empty string #}
  1361. * {% if foo is empty %}
  1362. * {# ... #}
  1363. * {% endif %}
  1364. *
  1365. * @param mixed $value A variable
  1366. *
  1367. * @internal
  1368. */
  1369. public static function testEmpty($value): bool
  1370. {
  1371. if ($value instanceof \Countable) {
  1372. return 0 === \count($value);
  1373. }
  1375. if ($value instanceof \Traversable) {
  1376. return !iterator_count($value);
  1377. }
  1379. if ($value instanceof \Stringable) {
  1380. return '' === (string) $value;
  1381. }
  1383. return '' === $value || false === $value || null === $value || [] === $value;
  1384. }
  1386. /**
  1387. * Checks if a variable is a sequence.
  1388. *
  1389. * {# evaluates to true if the foo variable is a sequence #}
  1390. * {% if foo is sequence %}
  1391. * {# ... #}
  1392. * {% endif %}
  1393. *
  1394. * @param mixed $value
  1395. *
  1396. * @internal
  1397. */
  1398. public static function testSequence($value): bool
  1399. {
  1400. if ($value instanceof \ArrayObject) {
  1401. $value = $value->getArrayCopy();
  1402. }
  1404. if ($value instanceof \Traversable) {
  1405. $value = iterator_to_array($value);
  1406. }
  1408. return \is_array($value) && array_is_list($value);
  1409. }
  1411. /**
  1412. * Checks if a variable is a mapping.
  1413. *
  1414. * {# evaluates to true if the foo variable is a mapping #}
  1415. * {% if foo is mapping %}
  1416. * {# ... #}
  1417. * {% endif %}
  1418. *
  1419. * @param mixed $value
  1420. *
  1421. * @internal
  1422. */
  1423. public static function testMapping($value): bool
  1424. {
  1425. if ($value instanceof \ArrayObject) {
  1426. $value = $value->getArrayCopy();
  1427. }
  1429. if ($value instanceof \Traversable) {
  1430. $value = iterator_to_array($value);
  1431. }
  1433. return (\is_array($value) && !array_is_list($value)) || \is_object($value);
  1434. }
  1436. /**
  1437. * Renders a template.
  1438. *
  1439. * @param array $context
  1440. * @param string|array|TemplateWrapper $template The template to render or an array of templates to try consecutively
  1441. * @param array $variables The variables to pass to the template
  1442. * @param bool $withContext
  1443. * @param bool $ignoreMissing Whether to ignore missing templates or not
  1444. * @param bool $sandboxed Whether to sandbox the template or not
  1445. *
  1446. * @internal
  1447. */
  1448. public static function include(Environment $env, $context, $template, $variables = [], $withContext = true, $ignoreMissing = false, $sandboxed = false): string
  1449. {
  1450. $alreadySandboxed = false;
  1451. $sandbox = null;
  1452. if ($withContext) {
  1453. $variables = array_merge($context, $variables);
  1454. }
  1456. if ($isSandboxed = $sandboxed && $env->hasExtension(SandboxExtension::class)) {
  1457. $sandbox = $env->getExtension(SandboxExtension::class);
  1458. if (!$alreadySandboxed = $sandbox->isSandboxed()) {
  1459. $sandbox->enableSandbox();
  1460. }
  1461. }
  1463. try {
  1464. $loaded = null;
  1465. try {
  1466. $loaded = $env->resolveTemplate($template);
  1467. } catch (LoaderError $e) {
  1468. if (!$ignoreMissing) {
  1469. throw $e;
  1470. }
  1472. return '';
  1473. }
  1475. if ($isSandboxed) {
  1476. $loaded->unwrap()->checkSecurity();
  1477. }
  1479. return $loaded->render($variables);
  1480. } finally {
  1481. if ($isSandboxed && !$alreadySandboxed) {
  1482. $sandbox->disableSandbox();
  1483. }
  1484. }
  1485. }
  1487. /**
  1488. * Returns a template content without rendering it.
  1489. *
  1490. * @param string $name The template name
  1491. * @param bool $ignoreMissing Whether to ignore missing templates or not
  1492. *
  1493. * @internal
  1494. */
  1495. public static function source(Environment $env, $name, $ignoreMissing = false): string
  1496. {
  1497. $loader = $env->getLoader();
  1498. try {
  1499. return $loader->getSourceContext($name)->getCode();
  1500. } catch (LoaderError $e) {
  1501. if (!$ignoreMissing) {
  1502. throw $e;
  1503. }
  1505. return '';
  1506. }
  1507. }
  1509. /**
  1510. * Returns the list of cases of the enum.
  1511. *
  1512. * @template T of \UnitEnum
  1513. *
  1514. * @param class-string<T> $enum
  1515. *
  1516. * @return list<T>
  1517. *
  1518. * @internal
  1519. */
  1520. public static function enumCases(string $enum): array
  1521. {
  1522. if (!enum_exists($enum)) {
  1523. throw new RuntimeError(\sprintf('Enum "%s" does not exist.', $enum));
  1524. }
  1526. return $enum::cases();
  1527. }
  1529. /**
  1530. * Provides the ability to access enums by their class names.
  1531. *
  1532. * @template T of \UnitEnum
  1533. *
  1534. * @param class-string<T> $enum
  1535. *
  1536. * @return T
  1537. *
  1538. * @internal
  1539. */
  1540. public static function enum(string $enum): \UnitEnum
  1541. {
  1542. if (!enum_exists($enum)) {
  1543. throw new RuntimeError(sprintf('"%s" is not an enum.', $enum));
  1544. }
  1546. if (!$cases = $enum::cases()) {
  1547. throw new RuntimeError(sprintf('"%s" is an empty enum.', $enum));
  1548. }
  1550. return $cases[0];
  1551. }
  1553. /**
  1554. * Provides the ability to get constants from instances as well as class/global constants.
  1555. *
  1556. * @param string $constant The name of the constant
  1557. * @param object|null $object The object to get the constant from
  1558. * @param bool $checkDefined Whether to check if the constant is defined or not
  1559. *
  1560. * @return mixed Class constants can return many types like scalars, arrays, and
  1561. * objects depending on the PHP version (\BackedEnum, \UnitEnum, etc.)
  1562. * When $checkDefined is true, returns true when the constant is defined, false otherwise
  1563. *
  1564. * @internal
  1565. */
  1566. public static function constant($constant, $object = null, bool $checkDefined = false)
  1567. {
  1568. if (null !== $object) {
  1569. if ('class' === $constant) {
  1570. return $checkDefined ? true : \get_class($object);
  1571. }
  1573. $constant = \get_class($object).'::'.$constant;
  1574. }
  1576. if (!\defined($constant)) {
  1577. if ($checkDefined) {
  1578. return false;
  1579. }
  1581. if ('::class' === strtolower(substr($constant, -7))) {
  1582. throw new RuntimeError(\sprintf('You cannot use the Twig function "constant" to access "%s". You could provide an object and call constant("class", $object) or use the class name directly as a string.', $constant));
  1583. }
  1585. throw new RuntimeError(\sprintf('Constant "%s" is undefined.', $constant));
  1586. }
  1588. return $checkDefined ? true : \constant($constant);
  1589. }
  1591. /**
  1592. * Batches item.
  1593. *
  1594. * @param array $items An array of items
  1595. * @param int $size The size of the batch
  1596. * @param mixed $fill A value used to fill missing items
  1597. *
  1598. * @internal
  1599. */
  1600. public static function batch($items, $size, $fill = null, $preserveKeys = true): array
  1601. {
  1602. if (!is_iterable($items)) {
  1603. throw new RuntimeError(\sprintf('The "batch" filter expects a sequence or a mapping, got "%s".', get_debug_type($items)));
  1604. }
  1606. $size = (int) ceil($size);
  1608. $result = array_chunk(self::toArray($items, $preserveKeys), $size, $preserveKeys);
  1610. if (null !== $fill && $result) {
  1611. $last = \count($result) - 1;
  1612. if ($fillCount = $size - \count($result[$last])) {
  1613. for ($i = 0; $i < $fillCount; ++$i) {
  1614. $result[$last][] = $fill;
  1615. }
  1616. }
  1617. }
  1619. return $result;
  1620. }
  1622. /**
  1623. * Returns the attribute value for a given array/object.
  1624. *
  1625. * @param mixed $object The object or array from where to get the item
  1626. * @param mixed $item The item to get from the array or object
  1627. * @param array $arguments An array of arguments to pass if the item is an object method
  1628. * @param string $type The type of attribute (@see \Twig\Template constants)
  1629. * @param bool $isDefinedTest Whether this is only a defined check
  1630. * @param bool $ignoreStrictCheck Whether to ignore the strict attribute check or not
  1631. * @param int $lineno The template line where the attribute was called
  1632. *
  1633. * @return mixed The attribute value, or a Boolean when $isDefinedTest is true, or null when the attribute is not set and $ignoreStrictCheck is true
  1634. *
  1635. * @throws RuntimeError if the attribute does not exist and Twig is running in strict mode and $isDefinedTest is false
  1636. *
  1637. * @internal
  1638. */
  1639. public static function getAttribute(Environment $env, Source $source, $object, $item, array $arguments = [], $type = Template::ANY_CALL, $isDefinedTest = false, $ignoreStrictCheck = false, $sandboxed = false, int $lineno = -1)
  1640. {
  1641. $propertyNotAllowedError = null;
  1643. // array
  1644. if (Template::METHOD_CALL !== $type) {
  1645. $arrayItem = \is_bool($item) || \is_float($item) ? (int) $item : $item = (string) $item;
  1647. if ($sandboxed && $object instanceof \ArrayAccess && !\in_array($object::class, self::ARRAY_LIKE_CLASSES, true)) {
  1648. try {
  1649. $env->getExtension(SandboxExtension::class)->checkPropertyAllowed($object, $arrayItem, $lineno, $source);
  1650. } catch (SecurityNotAllowedPropertyError $propertyNotAllowedError) {
  1651. goto methodCheck;
  1652. }
  1653. }
  1655. if (match (true) {
  1656. \is_array($object) => \array_key_exists($arrayItem, $object),
  1657. $object instanceof \ArrayAccess => $object->offsetExists($arrayItem),
  1658. default => false,
  1659. }) {
  1660. if ($isDefinedTest) {
  1661. return true;
  1662. }
  1664. return $object[$arrayItem];
  1665. }
  1667. if (Template::ARRAY_CALL === $type || !\is_object($object)) {
  1668. if ($isDefinedTest) {
  1669. return false;
  1670. }
  1672. if ($ignoreStrictCheck || !$env->isStrictVariables()) {
  1673. return;
  1674. }
  1676. if ($object instanceof \ArrayAccess) {
  1677. $message = \sprintf('Key "%s" in object with ArrayAccess of class "%s" does not exist.', $arrayItem, \get_class($object));
  1678. } elseif (\is_object($object)) {
  1679. $message = \sprintf('Impossible to access a key "%s" on an object of class "%s" that does not implement ArrayAccess interface.', $item, \get_class($object));
  1680. } elseif (\is_array($object)) {
  1681. if (!$object) {
  1682. $message = \sprintf('Key "%s" does not exist as the sequence/mapping is empty.', $arrayItem);
  1683. } else {
  1684. $message = \sprintf('Key "%s" for sequence/mapping with keys "%s" does not exist.', $arrayItem, implode(', ', array_keys($object)));
  1685. }
  1686. } elseif (Template::ARRAY_CALL === $type) {
  1687. if (null === $object) {
  1688. $message = \sprintf('Impossible to access a key ("%s") on a null variable.', $item);
  1689. } else {
  1690. $message = \sprintf('Impossible to access a key ("%s") on a %s variable ("%s").', $item, get_debug_type($object), $object);
  1691. }
  1692. } elseif (null === $object) {
  1693. $message = \sprintf('Impossible to access an attribute ("%s") on a null variable.', $item);
  1694. } else {
  1695. $message = \sprintf('Impossible to access an attribute ("%s") on a %s variable ("%s").', $item, get_debug_type($object), $object);
  1696. }
  1698. throw new RuntimeError($message, $lineno, $source);
  1699. }
  1700. }
  1702. $item = (string) $item;
  1704. if (!\is_object($object)) {
  1705. if ($isDefinedTest) {
  1706. return false;
  1707. }
  1709. if ($ignoreStrictCheck || !$env->isStrictVariables()) {
  1710. return;
  1711. }
  1713. if (null === $object) {
  1714. $message = \sprintf('Impossible to invoke a method ("%s") on a null variable.', $item);
  1715. } elseif (\is_array($object)) {
  1716. $message = \sprintf('Impossible to invoke a method ("%s") on a sequence/mapping.', $item);
  1717. } else {
  1718. $message = \sprintf('Impossible to invoke a method ("%s") on a %s variable ("%s").', $item, get_debug_type($object), $object);
  1719. }
  1721. throw new RuntimeError($message, $lineno, $source);
  1722. }
  1724. if ($object instanceof Template) {
  1725. throw new RuntimeError('Accessing \Twig\Template attributes is forbidden.', $lineno, $source);
  1726. }
  1728. // object property
  1729. if (Template::METHOD_CALL !== $type) {
  1730. if ($sandboxed) {
  1731. try {
  1732. $env->getExtension(SandboxExtension::class)->checkPropertyAllowed($object, $item, $lineno, $source);
  1733. } catch (SecurityNotAllowedPropertyError $propertyNotAllowedError) {
  1734. goto methodCheck;
  1735. }
  1736. }
  1738. static $propertyCheckers = [];
  1740. if (isset($object->$item)
  1741. || ($propertyCheckers[$object::class][$item] ??= self::getPropertyChecker($object::class, $item))($object, $item)
  1742. ) {
  1743. if ($isDefinedTest) {
  1744. return true;
  1745. }
  1747. return $object->$item;
  1748. }
  1750. if ($object instanceof \DateTimeInterface && \in_array($item, ['date', 'timezone', 'timezone_type'], true)) {
  1751. if ($isDefinedTest) {
  1752. return true;
  1753. }
  1755. return ((array) $object)[$item];
  1756. }
  1758. if (\defined($object::class.'::'.$item)) {
  1759. if ($isDefinedTest) {
  1760. return true;
  1761. }
  1763. return \constant($object::class.'::'.$item);
  1764. }
  1765. }
  1767. methodCheck:
  1769. static $cache = [];
  1771. $class = \get_class($object);
  1773. // object method
  1774. // precedence: getXxx() > isXxx() > hasXxx()
  1775. if (!isset($cache[$class])) {
  1776. $methods = get_class_methods($object);
  1777. sort($methods);
  1778. $lcMethods = array_map('strtolower', $methods);
  1779. $classCache = [];
  1780. foreach ($methods as $i => $method) {
  1781. $classCache[$method] = $method;
  1782. $classCache[$lcName = $lcMethods[$i]] = $method;
  1784. if ('g' === $lcName[0] && str_starts_with($lcName, 'get')) {
  1785. $name = substr($method, 3);
  1786. $lcName = substr($lcName, 3);
  1787. } elseif ('i' === $lcName[0] && str_starts_with($lcName, 'is')) {
  1788. $name = substr($method, 2);
  1789. $lcName = substr($lcName, 2);
  1790. } elseif ('h' === $lcName[0] && str_starts_with($lcName, 'has')) {
  1791. $name = substr($method, 3);
  1792. $lcName = substr($lcName, 3);
  1793. if (\in_array('is'.$lcName, $lcMethods)) {
  1794. continue;
  1795. }
  1796. } else {
  1797. continue;
  1798. }
  1800. // skip get() and is() methods (in which case, $name is empty)
  1801. if ($name) {
  1802. if (!isset($classCache[$name])) {
  1803. $classCache[$name] = $method;
  1804. }
  1806. if (!isset($classCache[$lcName])) {
  1807. $classCache[$lcName] = $method;
  1808. }
  1809. }
  1810. }
  1811. $cache[$class] = $classCache;
  1812. }
  1814. $call = false;
  1815. if (isset($cache[$class][$item])) {
  1816. $method = $cache[$class][$item];
  1817. } elseif (isset($cache[$class][$lcItem = strtolower($item)])) {
  1818. $method = $cache[$class][$lcItem];
  1819. } elseif (isset($cache[$class]['__call'])) {
  1820. $method = $item;
  1821. $call = true;
  1822. } else {
  1823. if ($isDefinedTest) {
  1824. return false;
  1825. }
  1827. if ($propertyNotAllowedError) {
  1828. throw $propertyNotAllowedError;
  1829. }
  1831. if ($ignoreStrictCheck || !$env->isStrictVariables()) {
  1832. return;
  1833. }
  1835. throw new RuntimeError(\sprintf('Neither the property "%1$s" nor one of the methods "%1$s()", "get%1$s()"/"is%1$s()"/"has%1$s()" or "__call()" exist and have public access in class "%2$s".', $item, $class), $lineno, $source);
  1836. }
  1838. if ($sandboxed) {
  1839. try {
  1840. $env->getExtension(SandboxExtension::class)->checkMethodAllowed($object, $method, $lineno, $source);
  1841. } catch (SecurityNotAllowedMethodError $e) {
  1842. if ($isDefinedTest) {
  1843. return false;
  1844. }
  1846. if ($propertyNotAllowedError) {
  1847. throw $propertyNotAllowedError;
  1848. }
  1850. throw $e;
  1851. }
  1852. }
  1854. if ($isDefinedTest) {
  1855. return true;
  1856. }
  1858. // Some objects throw exceptions when they have __call, and the method we try
  1859. // to call is not supported. If ignoreStrictCheck is true, we should return null.
  1860. try {
  1861. $ret = $object->$method(...$arguments);
  1862. } catch (\BadMethodCallException $e) {
  1863. if ($call && ($ignoreStrictCheck || !$env->isStrictVariables())) {
  1864. return;
  1865. }
  1866. throw $e;
  1867. }
  1869. return $ret;
  1870. }
  1872. /**
  1873. * Returns the values from a single column in the input array.
  1874. *
  1875. * <pre>
  1876. * {% set items = [{ 'fruit' : 'apple'}, {'fruit' : 'orange' }] %}
  1877. *
  1878. * {% set fruits = items|column('fruit') %}
  1879. *
  1880. * {# fruits now contains ['apple', 'orange'] #}
  1881. * </pre>
  1882. *
  1883. * @param array|\Traversable $array An array
  1884. * @param int|string $name The column name
  1885. * @param int|string|null $index The column to use as the index/keys for the returned array
  1886. *
  1887. * @return array The array of values
  1888. *
  1889. * @internal
  1890. */
  1891. public static function column($array, $name, $index = null): array
  1892. {
  1893. if (!is_iterable($array)) {
  1894. throw new RuntimeError(\sprintf('The "column" filter expects a sequence or a mapping, got "%s".', get_debug_type($array)));
  1895. }
  1897. if ($array instanceof \Traversable) {
  1898. $array = iterator_to_array($array);
  1899. }
  1901. return array_column($array, $name, $index);
  1902. }
  1904. /**
  1905. * @param \Closure $arrow
  1906. *
  1907. * @internal
  1908. */
  1909. public static function filter(Environment $env, $array, $arrow)
  1910. {
  1911. if (!is_iterable($array)) {
  1912. throw new RuntimeError(\sprintf('The "filter" filter expects a sequence/mapping or "Traversable", got "%s".', get_debug_type($array)));
  1913. }
  1915. self::checkArrow($env, $arrow, 'filter', 'filter');
  1917. if (\is_array($array)) {
  1918. return array_filter($array, $arrow, \ARRAY_FILTER_USE_BOTH);
  1919. }
  1921. // the IteratorIterator wrapping is needed as some internal PHP classes are \Traversable but do not implement \Iterator
  1922. return new \CallbackFilterIterator(new \IteratorIterator($array), $arrow);
  1923. }
  1925. /**
  1926. * @param \Closure $arrow
  1927. *
  1928. * @internal
  1929. */
  1930. public static function find(Environment $env, $array, $arrow)
  1931. {
  1932. if (!is_iterable($array)) {
  1933. throw new RuntimeError(\sprintf('The "find" filter expects a sequence or a mapping, got "%s".', get_debug_type($array)));
  1934. }
  1936. self::checkArrow($env, $arrow, 'find', 'filter');
  1938. foreach ($array as $k => $v) {
  1939. if ($arrow($v, $k)) {
  1940. return $v;
  1941. }
  1942. }
  1944. return null;
  1945. }
  1947. /**
  1948. * @param \Closure $arrow
  1949. *
  1950. * @internal
  1951. */
  1952. public static function map(Environment $env, $array, $arrow)
  1953. {
  1954. if (!is_iterable($array)) {
  1955. throw new RuntimeError(\sprintf('The "map" filter expects a sequence or a mapping, got "%s".', get_debug_type($array)));
  1956. }
  1958. self::checkArrow($env, $arrow, 'map', 'filter');
  1960. $r = [];
  1961. foreach ($array as $k => $v) {
  1962. $r[$k] = $arrow($v, $k);
  1963. }
  1965. return $r;
  1966. }
  1968. /**
  1969. * @param \Closure $arrow
  1970. *
  1971. * @internal
  1972. */
  1973. public static function reduce(Environment $env, $array, $arrow, $initial = null)
  1974. {
  1975. if (!is_iterable($array)) {
  1976. throw new RuntimeError(\sprintf('The "reduce" filter expects a sequence or a mapping, got "%s".', get_debug_type($array)));
  1977. }
  1979. self::checkArrow($env, $arrow, 'reduce', 'filter');
  1981. $accumulator = $initial;
  1982. foreach ($array as $key => $value) {
  1983. $accumulator = $arrow($accumulator, $value, $key);
  1984. }
  1986. return $accumulator;
  1987. }
  1989. /**
  1990. * @param \Closure $arrow
  1991. *
  1992. * @internal
  1993. */
  1994. public static function arraySome(Environment $env, $array, $arrow)
  1995. {
  1996. if (!is_iterable($array)) {
  1997. throw new RuntimeError(\sprintf('The "has some" test expects a sequence or a mapping, got "%s".', get_debug_type($array)));
  1998. }
  2000. self::checkArrow($env, $arrow, 'has some', 'operator');
  2002. foreach ($array as $k => $v) {
  2003. if ($arrow($v, $k)) {
  2004. return true;
  2005. }
  2006. }
  2008. return false;
  2009. }
  2011. /**
  2012. * @param \Closure $arrow
  2013. *
  2014. * @internal
  2015. */
  2016. public static function arrayEvery(Environment $env, $array, $arrow)
  2017. {
  2018. if (!is_iterable($array)) {
  2019. throw new RuntimeError(\sprintf('The "has every" test expects a sequence or a mapping, got "%s".', get_debug_type($array)));
  2020. }
  2022. self::checkArrow($env, $arrow, 'has every', 'operator');
  2024. foreach ($array as $k => $v) {
  2025. if (!$arrow($v, $k)) {
  2026. return false;
  2027. }
  2028. }
  2030. return true;
  2031. }
  2033. /**
  2034. * @internal
  2035. */
  2036. public static function checkArrow(Environment $env, $arrow, $thing, $type)
  2037. {
  2038. if ($arrow instanceof \Closure) {
  2039. return;
  2040. }
  2042. if ($env->hasExtension(SandboxExtension::class) && $env->getExtension(SandboxExtension::class)->isSandboxed()) {
  2043. throw new RuntimeError(\sprintf('The callable passed to the "%s" %s must be a Closure in sandbox mode.', $thing, $type));
  2044. }
  2046. trigger_deprecation('twig/twig', '3.15', 'Passing a callable that is not a PHP \Closure as an argument to the "%s" %s is deprecated.', $thing, $type);
  2047. }
  2049. /**
  2050. * @internal to be removed in Twig 4
  2051. */
  2052. public static function captureOutput(iterable $body): string
  2053. {
  2054. $level = ob_get_level();
  2055. ob_start();
  2057. try {
  2058. foreach ($body as $data) {
  2059. echo $data;
  2060. }
  2061. } catch (\Throwable $e) {
  2062. while (ob_get_level() > $level) {
  2063. ob_end_clean();
  2064. }
  2066. throw $e;
  2067. }
  2069. return ob_get_clean();
  2070. }
  2072. /**
  2073. * @internal
  2074. */
  2075. public static function parseParentFunction(Parser $parser, Node $fakeNode, $args, int $line): AbstractExpression
  2076. {
  2077. if (!$blockName = $parser->peekBlockStack()) {
  2078. throw new SyntaxError('Calling the "parent" function outside of a block is forbidden.', $line, $parser->getStream()->getSourceContext());
  2079. }
  2081. if (!$parser->hasInheritance()) {
  2082. throw new SyntaxError('Calling the "parent" function on a template that does not call "extends" or "use" is forbidden.', $line, $parser->getStream()->getSourceContext());
  2083. }
  2085. return new ParentExpression($blockName, $line);
  2086. }
  2088. /**
  2089. * @internal
  2090. */
  2091. public static function parseBlockFunction(Parser $parser, Node $fakeNode, $args, int $line): AbstractExpression
  2092. {
  2093. $fakeFunction = new TwigFunction('block', fn ($name, $template = null) => null);
  2094. $args = (new CallableArgumentsExtractor($fakeNode, $fakeFunction))->extractArguments($args);
  2096. return new BlockReferenceExpression($args[0], $args[1] ?? null, $line);
  2097. }
  2099. /**
  2100. * @internal
  2101. */
  2102. public static function parseAttributeFunction(Parser $parser, Node $fakeNode, $args, int $line): AbstractExpression
  2103. {
  2104. $fakeFunction = new TwigFunction('attribute', fn ($variable, $attribute, $arguments = null) => null);
  2105. $args = (new CallableArgumentsExtractor($fakeNode, $fakeFunction))->extractArguments($args);
  2107. /*
  2108. Deprecation to uncomment sometimes during the lifetime of the 4.x branch
  2109. $src = $parser->getStream()->getSourceContext();
  2110. $dep = new DeprecatedCallableInfo('twig/twig', '3.15', 'The "attribute" function is deprecated, use the "." notation instead.');
  2111. $dep->setName('attribute');
  2112. $dep->setType('function');
  2113. $dep->triggerDeprecation($src->getPath() ?: $src->getName(), $line);
  2114. */
  2116. return new GetAttrExpression($args[0], $args[1], $args[2] ?? null, Template::ANY_CALL, $line);
  2117. }
  2119. private static function getPropertyChecker(string $class, string $property): \Closure
  2120. {
  2121. static $classReflectors = [];
  2123. $class = $classReflectors[$class] ??= new \ReflectionClass($class);
  2125. if (!$class->hasProperty($property)) {
  2126. static $propertyExists;
  2128. return $propertyExists ??= \Closure::fromCallable('property_exists');
  2129. }
  2131. $property = $class->getProperty($property);
  2133. if (!$property->isPublic()) {
  2134. static $false;
  2136. return $false ??= static fn () => false;
  2137. }
  2139. return static fn ($object) => $property->isInitialized($object);
  2140. }
  2141. }