vendor/twig/twig/lib/Twig/Extension/Core.php line 578

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. final class Twig_Extension_Core extends Twig_Extension
  13. {
  14.     private $dateFormats = ['F j, Y H:i', '%d days'];
  15.     private $numberFormat = [0, '.', ','];
  16.     private $timezone = null;
  17.     private $escapers = [];
  19.     /**
  20.      * Defines a new escaper to be used via the escape filter.
  21.      *
  22.      * @param string   $strategy The strategy name that should be used as a strategy in the escape call
  23.      * @param callable $callable A valid PHP callable
  24.      */
  25.     public function setEscaper($strategy, callable $callable)
  26.     {
  27.         $this->escapers[$strategy] = $callable;
  28.     }
  30.     /**
  31.      * Gets all defined escapers.
  32.      *
  33.      * @return callable[] An array of escapers
  34.      */
  35.     public function getEscapers()
  36.     {
  37.         return $this->escapers;
  38.     }
  40.     /**
  41.      * Sets the default format to be used by the date filter.
  42.      *
  43.      * @param string $format             The default date format string
  44.      * @param string $dateIntervalFormat The default date interval format string
  45.      */
  46.     public function setDateFormat($format = null, $dateIntervalFormat = null)
  47.     {
  48.         if (null !== $format) {
  49.             $this->dateFormats[0] = $format;
  50.         }
  52.         if (null !== $dateIntervalFormat) {
  53.             $this->dateFormats[1] = $dateIntervalFormat;
  54.         }
  55.     }
  57.     /**
  58.      * Gets the default format to be used by the date filter.
  59.      *
  60.      * @return array The default date format string and the default date interval format string
  61.      */
  62.     public function getDateFormat()
  63.     {
  64.         return $this->dateFormats;
  65.     }
  67.     /**
  68.      * Sets the default timezone to be used by the date filter.
  69.      *
  70.      * @param DateTimeZone|string $timezone The default timezone string or a DateTimeZone object
  71.      */
  72.     public function setTimezone($timezone)
  73.     {
  74.         $this->timezone = $timezone instanceof DateTimeZone ? $timezone : new DateTimeZone($timezone);
  75.     }
  77.     /**
  78.      * Gets the default timezone to be used by the date filter.
  79.      *
  80.      * @return DateTimeZone The default timezone currently in use
  81.      */
  82.     public function getTimezone()
  83.     {
  84.         if (null === $this->timezone) {
  85.             $this->timezone = new DateTimeZone(date_default_timezone_get());
  86.         }
  88.         return $this->timezone;
  89.     }
  91.     /**
  92.      * Sets the default format to be used by the number_format filter.
  93.      *
  94.      * @param int    $decimal      the number of decimal places to use
  95.      * @param string $decimalPoint the character(s) to use for the decimal point
  96.      * @param string $thousandSep  the character(s) to use for the thousands separator
  97.      */
  98.     public function setNumberFormat($decimal, $decimalPoint, $thousandSep)
  99.     {
  100.         $this->numberFormat = [$decimal, $decimalPoint, $thousandSep];
  101.     }
  103.     /**
  104.      * Get the default format used by the number_format filter.
  105.      *
  106.      * @return array The arguments for number_format()
  107.      */
  108.     public function getNumberFormat()
  109.     {
  110.         return $this->numberFormat;
  111.     }
  113.     public function getTokenParsers()
  114.     {
  115.         return [
  116.             new Twig_TokenParser_For(),
  117.             new Twig_TokenParser_If(),
  118.             new Twig_TokenParser_Extends(),
  119.             new Twig_TokenParser_Include(),
  120.             new Twig_TokenParser_Block(),
  121.             new Twig_TokenParser_Use(),
  122.             new Twig_TokenParser_Filter(),
  123.             new Twig_TokenParser_Macro(),
  124.             new Twig_TokenParser_Import(),
  125.             new Twig_TokenParser_From(),
  126.             new Twig_TokenParser_Set(),
  127.             new Twig_TokenParser_Spaceless(),
  128.             new Twig_TokenParser_Flush(),
  129.             new Twig_TokenParser_Do(),
  130.             new Twig_TokenParser_Embed(),
  131.             new Twig_TokenParser_With(),
  132.             new Twig_TokenParser_Deprecated(),
  133.         ];
  134.     }
  136.     public function getFilters()
  137.     {
  138.         return [
  139.             // formatting filters
  140.             new Twig_Filter('date', 'twig_date_format_filter', ['needs_environment' => true]),
  141.             new Twig_Filter('date_modify', 'twig_date_modify_filter', ['needs_environment' => true]),
  142.             new Twig_Filter('format', 'sprintf'),
  143.             new Twig_Filter('replace', 'twig_replace_filter'),
  144.             new Twig_Filter('number_format', 'twig_number_format_filter', ['needs_environment' => true]),
  145.             new Twig_Filter('abs', 'abs'),
  146.             new Twig_Filter('round', 'twig_round'),
  148.             // encoding
  149.             new Twig_Filter('url_encode', 'twig_urlencode_filter'),
  150.             new Twig_Filter('json_encode', 'json_encode'),
  151.             new Twig_Filter('convert_encoding', 'twig_convert_encoding'),
  153.             // string filters
  154.             new Twig_Filter('title', 'twig_title_string_filter', ['needs_environment' => true]),
  155.             new Twig_Filter('capitalize', 'twig_capitalize_string_filter', ['needs_environment' => true]),
  156.             new Twig_Filter('upper', 'twig_upper_filter', ['needs_environment' => true]),
  157.             new Twig_Filter('lower', 'twig_lower_filter', ['needs_environment' => true]),
  158.             new Twig_Filter('striptags', 'strip_tags'),
  159.             new Twig_Filter('trim', 'twig_trim_filter'),
  160.             new Twig_Filter('nl2br', 'nl2br', ['pre_escape' => 'html', 'is_safe' => ['html']]),
  162.             // array helpers
  163.             new Twig_Filter('join', 'twig_join_filter'),
  164.             new Twig_Filter('split', 'twig_split_filter', ['needs_environment' => true]),
  165.             new Twig_Filter('sort', 'twig_sort_filter'),
  166.             new Twig_Filter('merge', 'twig_array_merge'),
  167.             new Twig_Filter('batch', 'twig_array_batch'),
  169.             // string/array filters
  170.             new Twig_Filter('reverse', 'twig_reverse_filter', ['needs_environment' => true]),
  171.             new Twig_Filter('length', 'twig_length_filter', ['needs_environment' => true]),
  172.             new Twig_Filter('slice', 'twig_slice', ['needs_environment' => true]),
  173.             new Twig_Filter('first', 'twig_first', ['needs_environment' => true]),
  174.             new Twig_Filter('last', 'twig_last', ['needs_environment' => true]),
  176.             // iteration and runtime
  177.             new Twig_Filter('default', '_twig_default_filter', ['node_class' => 'Twig_Node_Expression_Filter_Default']),
  178.             new Twig_Filter('keys', 'twig_get_array_keys_filter'),
  180.             // escaping
  181.             new Twig_Filter('escape', 'twig_escape_filter', ['needs_environment' => true, 'is_safe_callback' => 'twig_escape_filter_is_safe']),
  182.             new Twig_Filter('e', 'twig_escape_filter', ['needs_environment' => true, 'is_safe_callback' => 'twig_escape_filter_is_safe']),
  183.         ];
  184.     }
  186.     public function getFunctions()
  187.     {
  188.         return [
  189.             new Twig_Function('max', 'max'),
  190.             new Twig_Function('min', 'min'),
  191.             new Twig_Function('range', 'range'),
  192.             new Twig_Function('constant', 'twig_constant'),
  193.             new Twig_Function('cycle', 'twig_cycle'),
  194.             new Twig_Function('random', 'twig_random', ['needs_environment' => true]),
  195.             new Twig_Function('date', 'twig_date_converter', ['needs_environment' => true]),
  196.             new Twig_Function('include', 'twig_include', ['needs_environment' => true, 'needs_context' => true, 'is_safe' => ['all']]),
  197.             new Twig_Function('source', 'twig_source', ['needs_environment' => true, 'is_safe' => ['all']]),
  198.         ];
  199.     }
  201.     public function getTests()
  202.     {
  203.         return [
  204.             new Twig_Test('even', null, ['node_class' => 'Twig_Node_Expression_Test_Even']),
  205.             new Twig_Test('odd', null, ['node_class' => 'Twig_Node_Expression_Test_Odd']),
  206.             new Twig_Test('defined', null, ['node_class' => 'Twig_Node_Expression_Test_Defined']),
  207.             new Twig_Test('same as', null, ['node_class' => 'Twig_Node_Expression_Test_Sameas']),
  208.             new Twig_Test('none', null, ['node_class' => 'Twig_Node_Expression_Test_Null']),
  209.             new Twig_Test('null', null, ['node_class' => 'Twig_Node_Expression_Test_Null']),
  210.             new Twig_Test('divisible by', null, ['node_class' => 'Twig_Node_Expression_Test_Divisibleby']),
  211.             new Twig_Test('constant', null, ['node_class' => 'Twig_Node_Expression_Test_Constant']),
  212.             new Twig_Test('empty', 'twig_test_empty'),
  213.             new Twig_Test('iterable', 'twig_test_iterable'),
  214.         ];
  215.     }
  217.     public function getOperators()
  218.     {
  219.         return [
  220.             [
  221.                 'not' => ['precedence' => 50, 'class' => 'Twig_Node_Expression_Unary_Not'],
  222.                 '-' => ['precedence' => 500, 'class' => 'Twig_Node_Expression_Unary_Neg'],
  223.                 '+' => ['precedence' => 500, 'class' => 'Twig_Node_Expression_Unary_Pos'],
  224.             ],
  225.             [
  226.                 'or' => ['precedence' => 10, 'class' => 'Twig_Node_Expression_Binary_Or', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT],
  227.                 'and' => ['precedence' => 15, 'class' => 'Twig_Node_Expression_Binary_And', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT],
  228.                 'b-or' => ['precedence' => 16, 'class' => 'Twig_Node_Expression_Binary_BitwiseOr', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT],
  229.                 'b-xor' => ['precedence' => 17, 'class' => 'Twig_Node_Expression_Binary_BitwiseXor', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT],
  230.                 'b-and' => ['precedence' => 18, 'class' => 'Twig_Node_Expression_Binary_BitwiseAnd', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT],
  231.                 '==' => ['precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_Equal', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT],
  232.                 '!=' => ['precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_NotEqual', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT],
  233.                 '<' => ['precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_Less', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT],
  234.                 '>' => ['precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_Greater', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT],
  235.                 '>=' => ['precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_GreaterEqual', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT],
  236.                 '<=' => ['precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_LessEqual', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT],
  237.                 'not in' => ['precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_NotIn', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT],
  238.                 'in' => ['precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_In', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT],
  239.                 'matches' => ['precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_Matches', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT],
  240.                 'starts with' => ['precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_StartsWith', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT],
  241.                 'ends with' => ['precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_EndsWith', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT],
  242.                 '..' => ['precedence' => 25, 'class' => 'Twig_Node_Expression_Binary_Range', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT],
  243.                 '+' => ['precedence' => 30, 'class' => 'Twig_Node_Expression_Binary_Add', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT],
  244.                 '-' => ['precedence' => 30, 'class' => 'Twig_Node_Expression_Binary_Sub', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT],
  245.                 '~' => ['precedence' => 40, 'class' => 'Twig_Node_Expression_Binary_Concat', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT],
  246.                 '*' => ['precedence' => 60, 'class' => 'Twig_Node_Expression_Binary_Mul', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT],
  247.                 '/' => ['precedence' => 60, 'class' => 'Twig_Node_Expression_Binary_Div', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT],
  248.                 '//' => ['precedence' => 60, 'class' => 'Twig_Node_Expression_Binary_FloorDiv', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT],
  249.                 '%' => ['precedence' => 60, 'class' => 'Twig_Node_Expression_Binary_Mod', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT],
  250.                 'is' => ['precedence' => 100, 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT],
  251.                 'is not' => ['precedence' => 100, 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT],
  252.                 '**' => ['precedence' => 200, 'class' => 'Twig_Node_Expression_Binary_Power', 'associativity' => Twig_ExpressionParser::OPERATOR_RIGHT],
  253.                 '??' => ['precedence' => 300, 'class' => 'Twig_Node_Expression_NullCoalesce', 'associativity' => Twig_ExpressionParser::OPERATOR_RIGHT],
  254.             ],
  255.         ];
  256.     }
  257. }
  259. /**
  260.  * Cycles over a value.
  261.  *
  262.  * @param ArrayAccess|array $values
  263.  * @param int               $position The cycle position
  264.  *
  265.  * @return string The next value in the cycle
  266.  */
  267. function twig_cycle($values, $position)
  268. {
  269.     if (!is_array($values) && !$values instanceof ArrayAccess) {
  270.         return $values;
  271.     }
  273.     return $values[$position % count($values)];
  274. }
  276. /**
  277.  * Returns a random value depending on the supplied parameter type:
  278.  * - a random item from a Traversable or array
  279.  * - a random character from a string
  280.  * - a random integer between 0 and the integer parameter.
  281.  *
  282.  * @param Twig_Environment                   $env
  283.  * @param Traversable|array|int|float|string $values The values to pick a random item from
  284.  *
  285.  * @throws Twig_Error_Runtime when $values is an empty array (does not apply to an empty string which is returned as is)
  286.  *
  287.  * @return mixed A random value from the given sequence
  288.  */
  289. function twig_random(Twig_Environment $env, $values = null)
  290. {
  291.     if (null === $values) {
  292.         return mt_rand();
  293.     }
  295.     if (is_int($values) || is_float($values)) {
  296.         return $values < 0 ? mt_rand($values, 0) : mt_rand(0, $values);
  297.     }
  299.     if ($values instanceof Traversable) {
  300.         $values = iterator_to_array($values);
  301.     } elseif (is_string($values)) {
  302.         if ('' === $values) {
  303.             return '';
  304.         }
  306.         $charset = $env->getCharset();
  308.         if ('UTF-8' !== $charset) {
  309.             $values = iconv($charset, 'UTF-8', $values);
  310.         }
  312.         // unicode version of str_split()
  313.         // split at all positions, but not after the start and not before the end
  314.         $values = preg_split('/(?<!^)(?!$)/u', $values);
  316.         if ('UTF-8' !== $charset) {
  317.             foreach ($values as $i => $value) {
  318.                 $values[$i] = iconv('UTF-8', $charset, $value);
  319.             }
  320.         }
  321.     }
  323.     if (!is_array($values)) {
  324.         return $values;
  325.     }
  327.     if (0 === count($values)) {
  328.         throw new Twig_Error_Runtime('The random function cannot pick from an empty array.');
  329.     }
  331.     return $values[array_rand($values, 1)];
  332. }
  334. /**
  335.  * Converts a date to the given format.
  336.  *
  337.  * <pre>
  338.  *   {{ post.published_at|date("m/d/Y") }}
  339.  * </pre>
  340.  *
  341.  * @param Twig_Environment                      $env
  342.  * @param DateTimeInterface|DateInterval|string $date     A date
  343.  * @param string|null                           $format   The target format, null to use the default
  344.  * @param DateTimeZone|string|false|null        $timezone The target timezone, null to use the default, false to leave unchanged
  345.  *
  346.  * @return string The formatted date
  347.  */
  348. function twig_date_format_filter(Twig_Environment $env, $date, $format = null, $timezone = null)
  349. {
  350.     if (null === $format) {
  351.         $formats = $env->getExtension('Twig_Extension_Core')->getDateFormat();
  352.         $format = $date instanceof DateInterval ? $formats[1] : $formats[0];
  353.     }
  355.     if ($date instanceof DateInterval) {
  356.         return $date->format($format);
  357.     }
  359.     return twig_date_converter($env, $date, $timezone)->format($format);
  360. }
  362. /**
  363.  * Returns a new date object modified.
  364.  *
  365.  * <pre>
  366.  *   {{ post.published_at|date_modify("-1day")|date("m/d/Y") }}
  367.  * </pre>
  368.  *
  369.  * @param Twig_Environment         $env
  370.  * @param DateTimeInterface|string $date     A date
  371.  * @param string                   $modifier A modifier string
  372.  *
  373.  * @return DateTimeInterface A new date object
  374.  */
  375. function twig_date_modify_filter(Twig_Environment $env, $date, $modifier)
  376. {
  377.     $date = twig_date_converter($env, $date, false);
  379.     return $date->modify($modifier);
  380. }
  382. /**
  383.  * Converts an input to a DateTime instance.
  384.  *
  385.  * <pre>
  386.  *    {% if date(user.created_at) < date('+2days') %}
  387.  *      {# do something #}
  388.  *    {% endif %}
  389.  * </pre>
  390.  *
  391.  * @param Twig_Environment               $env
  392.  * @param DateTimeInterface|string|null  $date     A date or null to use the current time
  393.  * @param DateTimeZone|string|false|null $timezone The target timezone, null to use the default, false to leave unchanged
  394.  *
  395.  * @return DateTime A DateTime instance
  396.  */
  397. function twig_date_converter(Twig_Environment $env, $date = null, $timezone = null)
  398. {
  399.     // determine the timezone
  400.     if (false !== $timezone) {
  401.         if (null === $timezone) {
  402.             $timezone = $env->getExtension('Twig_Extension_Core')->getTimezone();
  403.         } elseif (!$timezone instanceof DateTimeZone) {
  404.             $timezone = new DateTimeZone($timezone);
  405.         }
  406.     }
  408.     // immutable dates
  409.     if ($date instanceof DateTimeImmutable) {
  410.         return false !== $timezone ? $date->setTimezone($timezone) : $date;
  411.     }
  413.     if ($date instanceof DateTimeInterface) {
  414.         $date = clone $date;
  415.         if (false !== $timezone) {
  416.             $date->setTimezone($timezone);
  417.         }
  419.         return $date;
  420.     }
  422.     if (null === $date || 'now' === $date) {
  423.         return new DateTime($date, false !== $timezone ? $timezone : $env->getExtension('Twig_Extension_Core')->getTimezone());
  424.     }
  426.     $asString = (string) $date;
  427.     if (ctype_digit($asString) || (!empty($asString) && '-' === $asString[0] && ctype_digit(substr($asString, 1)))) {
  428.         $date = new DateTime('@'.$date);
  429.     } else {
  430.         $date = new DateTime($date, $env->getExtension('Twig_Extension_Core')->getTimezone());
  431.     }
  433.     if (false !== $timezone) {
  434.         $date->setTimezone($timezone);
  435.     }
  437.     return $date;
  438. }
  440. /**
  441.  * Replaces strings within a string.
  442.  *
  443.  * @param string            $str  String to replace in
  444.  * @param array|Traversable $from Replace values
  445.  *
  446.  * @return string
  447.  */
  448. function twig_replace_filter($str, $from)
  449. {
  450.     if ($from instanceof Traversable) {
  451.         $from = iterator_to_array($from);
  452.     } elseif (!is_array($from)) {
  453.         throw new Twig_Error_Runtime(sprintf('The "replace" filter expects an array or "Traversable" as replace values, got "%s".', is_object($from) ? get_class($from) : gettype($from)));
  454.     }
  456.     return strtr($str, $from);
  457. }
  459. /**
  460.  * Rounds a number.
  461.  *
  462.  * @param int|float $value     The value to round
  463.  * @param int|float $precision The rounding precision
  464.  * @param string    $method    The method to use for rounding
  465.  *
  466.  * @return int|float The rounded number
  467.  */
  468. function twig_round($value, $precision = 0, $method = 'common')
  469. {
  470.     if ('common' == $method) {
  471.         return round($value, $precision);
  472.     }
  474.     if ('ceil' != $method && 'floor' != $method) {
  475.         throw new Twig_Error_Runtime('The round filter only supports the "common", "ceil", and "floor" methods.');
  476.     }
  478.     return $method($value * pow(10, $precision)) / pow(10, $precision);
  479. }
  481. /**
  482.  * Number format filter.
  483.  *
  484.  * All of the formatting options can be left null, in that case the defaults will
  485.  * be used.  Supplying any of the parameters will override the defaults set in the
  486.  * environment object.
  487.  *
  488.  * @param Twig_Environment $env
  489.  * @param mixed            $number       A float/int/string of the number to format
  490.  * @param int              $decimal      the number of decimal points to display
  491.  * @param string           $decimalPoint the character(s) to use for the decimal point
  492.  * @param string           $thousandSep  the character(s) to use for the thousands separator
  493.  *
  494.  * @return string The formatted number
  495.  */
  496. function twig_number_format_filter(Twig_Environment $env, $number, $decimal = null, $decimalPoint = null, $thousandSep = null)
  497. {
  498.     $defaults = $env->getExtension('Twig_Extension_Core')->getNumberFormat();
  499.     if (null === $decimal) {
  500.         $decimal = $defaults[0];
  501.     }
  503.     if (null === $decimalPoint) {
  504.         $decimalPoint = $defaults[1];
  505.     }
  507.     if (null === $thousandSep) {
  508.         $thousandSep = $defaults[2];
  509.     }
  511.     return number_format((float) $number, $decimal, $decimalPoint, $thousandSep);
  512. }
  514. /**
  515.  * URL encodes (RFC 3986) a string as a path segment or an array as a query string.
  516.  *
  517.  * @param string|array $url A URL or an array of query parameters
  518.  *
  519.  * @return string The URL encoded value
  520.  */
  521. function twig_urlencode_filter($url)
  522. {
  523.     if (is_array($url)) {
  524.         return http_build_query($url, '', '&', PHP_QUERY_RFC3986);
  525.     }
  527.     return rawurlencode($url);
  528. }
  530. /**
  531.  * Merges an array with another one.
  532.  *
  533.  * <pre>
  534.  *  {% set items = { 'apple': 'fruit', 'orange': 'fruit' } %}
  535.  *
  536.  *  {% set items = items|merge({ 'peugeot': 'car' }) %}
  537.  *
  538.  *  {# items now contains { 'apple': 'fruit', 'orange': 'fruit', 'peugeot': 'car' } #}
  539.  * </pre>
  540.  *
  541.  * @param array|Traversable $arr1 An array
  542.  * @param array|Traversable $arr2 An array
  543.  *
  544.  * @return array The merged array
  545.  */
  546. function twig_array_merge($arr1, $arr2)
  547. {
  548.     if ($arr1 instanceof Traversable) {
  549.         $arr1 = iterator_to_array($arr1);
  550.     } elseif (!is_array($arr1)) {
  551.         throw new Twig_Error_Runtime(sprintf('The merge filter only works with arrays or "Traversable", got "%s" as first argument.', gettype($arr1)));
  552.     }
  554.     if ($arr2 instanceof Traversable) {
  555.         $arr2 = iterator_to_array($arr2);
  556.     } elseif (!is_array($arr2)) {
  557.         throw new Twig_Error_Runtime(sprintf('The merge filter only works with arrays or "Traversable", got "%s" as second argument.', gettype($arr2)));
  558.     }
  560.     return array_merge($arr1, $arr2);
  561. }
  563. /**
  564.  * Slices a variable.
  565.  *
  566.  * @param Twig_Environment $env
  567.  * @param mixed            $item         A variable
  568.  * @param int              $start        Start of the slice
  569.  * @param int              $length       Size of the slice
  570.  * @param bool             $preserveKeys Whether to preserve key or not (when the input is an array)
  571.  *
  572.  * @return mixed The sliced variable
  573.  */
  574. function twig_slice(Twig_Environment $env, $item, $start, $length = null, $preserveKeys = false)
  575. {
  576.     if ($item instanceof Traversable) {
  577.         while ($item instanceof IteratorAggregate) {
  578.             $item = $item->getIterator();
  579.         }
  581.         if ($start >= 0 && $length >= 0 && $item instanceof Iterator) {
  582.             try {
  583.                 return iterator_to_array(new LimitIterator($item, $start, null === $length ? -1 : $length), $preserveKeys);
  584.             } catch (OutOfBoundsException $exception) {
  585.                 return [];
  586.             }
  587.         }
  589.         $item = iterator_to_array($item, $preserveKeys);
  590.     }
  592.     if (is_array($item)) {
  593.         return array_slice($item, $start, $length, $preserveKeys);
  594.     }
  596.     $item = (string) $item;
  598.     return (string) mb_substr($item, $start, $length, $env->getCharset());
  599. }
  601. /**
  602.  * Returns the first element of the item.
  603.  *
  604.  * @param Twig_Environment $env
  605.  * @param mixed            $item A variable
  606.  *
  607.  * @return mixed The first element of the item
  608.  */
  609. function twig_first(Twig_Environment $env, $item)
  610. {
  611.     $elements = twig_slice($env, $item, 0, 1, false);
  613.     return is_string($elements) ? $elements : current($elements);
  614. }
  616. /**
  617.  * Returns the last element of the item.
  618.  *
  619.  * @param Twig_Environment $env
  620.  * @param mixed            $item A variable
  621.  *
  622.  * @return mixed The last element of the item
  623.  */
  624. function twig_last(Twig_Environment $env, $item)
  625. {
  626.     $elements = twig_slice($env, $item, -1, 1, false);
  628.     return is_string($elements) ? $elements : current($elements);
  629. }
  631. /**
  632.  * Joins the values to a string.
  633.  *
  634.  * The separators between elements are empty strings per default, you can define them with the optional parameters.
  635.  *
  636.  * <pre>
  637.  *  {{ [1, 2, 3]|join(', ', ' and ') }}
  638.  *  {# returns 1, 2 and 3 #}
  639.  *
  640.  *  {{ [1, 2, 3]|join('|') }}
  641.  *  {# returns 1|2|3 #}
  642.  *
  643.  *  {{ [1, 2, 3]|join }}
  644.  *  {# returns 123 #}
  645.  * </pre>
  646.  *
  647.  * @param array       $value An array
  648.  * @param string      $glue  The separator
  649.  * @param string|null $and   The separator for the last pair
  650.  *
  651.  * @return string The concatenated string
  652.  */
  653. function twig_join_filter($value, $glue = '', $and = null)
  654. {
  655.     if ($value instanceof Traversable) {
  656.         $value = iterator_to_array($value, false);
  657.     } else {
  658.         $value = (array) $value;
  659.     }
  661.     if (0 === count($value)) {
  662.         return '';
  663.     }
  665.     if (null === $and || $and === $glue) {
  666.         return implode($glue, $value);
  667.     }
  669.     $v = array_values($value);
  670.     if (1 === count($v)) {
  671.         return $v[0];
  672.     }
  674.     return implode($glue, array_slice($value, 0, -1)).$and.$v[count($v) - 1];
  675. }
  677. /**
  678.  * Splits the string into an array.
  679.  *
  680.  * <pre>
  681.  *  {{ "one,two,three"|split(',') }}
  682.  *  {# returns [one, two, three] #}
  683.  *
  684.  *  {{ "one,two,three,four,five"|split(',', 3) }}
  685.  *  {# returns [one, two, "three,four,five"] #}
  686.  *
  687.  *  {{ "123"|split('') }}
  688.  *  {# returns [1, 2, 3] #}
  689.  *
  690.  *  {{ "aabbcc"|split('', 2) }}
  691.  *  {# returns [aa, bb, cc] #}
  692.  * </pre>
  693.  *
  694.  * @param Twig_Environment $env
  695.  * @param string           $value     A string
  696.  * @param string           $delimiter The delimiter
  697.  * @param int              $limit     The limit
  698.  *
  699.  * @return array The split string as an array
  700.  */
  701. function twig_split_filter(Twig_Environment $env, $value, $delimiter, $limit = null)
  702. {
  703.     if (!empty($delimiter)) {
  704.         return null === $limit ? explode($delimiter, $value) : explode($delimiter, $value, $limit);
  705.     }
  707.     if ($limit <= 1) {
  708.         return preg_split('/(?<!^)(?!$)/u', $value);
  709.     }
  711.     $length = mb_strlen($value, $env->getCharset());
  712.     if ($length < $limit) {
  713.         return [$value];
  714.     }
  716.     $r = [];
  717.     for ($i = 0; $i < $length; $i += $limit) {
  718.         $r[] = mb_substr($value, $i, $limit, $env->getCharset());
  719.     }
  721.     return $r;
  722. }
  724. // The '_default' filter is used internally to avoid using the ternary operator
  725. // which costs a lot for big contexts (before PHP 5.4). So, on average,
  726. // a function call is cheaper.
  727. /**
  728.  * @internal
  729.  */
  730. function _twig_default_filter($value, $default = '')
  731. {
  732.     if (twig_test_empty($value)) {
  733.         return $default;
  734.     }
  736.     return $value;
  737. }
  739. /**
  740.  * Returns the keys for the given array.
  741.  *
  742.  * It is useful when you want to iterate over the keys of an array:
  743.  *
  744.  * <pre>
  745.  *  {% for key in array|keys %}
  746.  *      {# ... #}
  747.  *  {% endfor %}
  748.  * </pre>
  749.  *
  750.  * @param array $array An array
  751.  *
  752.  * @return array The keys
  753.  */
  754. function twig_get_array_keys_filter($array)
  755. {
  756.     if ($array instanceof Traversable) {
  757.         while ($array instanceof IteratorAggregate) {
  758.             $array = $array->getIterator();
  759.         }
  761.         if ($array instanceof Iterator) {
  762.             $keys = [];
  763.             $array->rewind();
  764.             while ($array->valid()) {
  765.                 $keys[] = $array->key();
  766.                 $array->next();
  767.             }
  769.             return $keys;
  770.         }
  772.         $keys = [];
  773.         foreach ($array as $key => $item) {
  774.             $keys[] = $key;
  775.         }
  777.         return $keys;
  778.     }
  780.     if (!is_array($array)) {
  781.         return [];
  782.     }
  784.     return array_keys($array);
  785. }
  787. /**
  788.  * Reverses a variable.
  789.  *
  790.  * @param Twig_Environment         $env
  791.  * @param array|Traversable|string $item         An array, a Traversable instance, or a string
  792.  * @param bool                     $preserveKeys Whether to preserve key or not
  793.  *
  794.  * @return mixed The reversed input
  795.  */
  796. function twig_reverse_filter(Twig_Environment $env, $item, $preserveKeys = false)
  797. {
  798.     if ($item instanceof Traversable) {
  799.         return array_reverse(iterator_to_array($item), $preserveKeys);
  800.     }
  802.     if (is_array($item)) {
  803.         return array_reverse($item, $preserveKeys);
  804.     }
  806.     $string = (string) $item;
  808.     $charset = $env->getCharset();
  810.     if ('UTF-8' !== $charset) {
  811.         $item = iconv($charset, 'UTF-8', $string);
  812.     }
  814.     preg_match_all('/./us', $item, $matches);
  816.     $string = implode('', array_reverse($matches[0]));
  818.     if ('UTF-8' !== $charset) {
  819.         $string = iconv('UTF-8', $charset, $string);
  820.     }
  822.     return $string;
  823. }
  825. /**
  826.  * Sorts an array.
  827.  *
  828.  * @param array|Traversable $array
  829.  *
  830.  * @return array
  831.  */
  832. function twig_sort_filter($array)
  833. {
  834.     if ($array instanceof Traversable) {
  835.         $array = iterator_to_array($array);
  836.     } elseif (!is_array($array)) {
  837.         throw new Twig_Error_Runtime(sprintf('The sort filter only works with arrays or "Traversable", got "%s".', gettype($array)));
  838.     }
  840.     asort($array);
  842.     return $array;
  843. }
  845. /**
  846.  * @internal
  847.  */
  848. function twig_in_filter($value, $compare)
  849. {
  850.     if (is_array($compare)) {
  851.         return in_array($value, $compare, is_object($value) || is_resource($value));
  852.     } elseif (is_string($compare) && (is_string($value) || is_int($value) || is_float($value))) {
  853.         return '' === $value || false !== strpos($compare, (string) $value);
  854.     } elseif ($compare instanceof Traversable) {
  855.         if (is_object($value) || is_resource($value)) {
  856.             foreach ($compare as $item) {
  857.                 if ($item === $value) {
  858.                     return true;
  859.                 }
  860.             }
  861.         } else {
  862.             foreach ($compare as $item) {
  863.                 if ($item == $value) {
  864.                     return true;
  865.                 }
  866.             }
  867.         }
  869.         return false;
  870.     }
  872.     return false;
  873. }
  875. /**
  876.  * Returns a trimmed string.
  877.  *
  878.  * @return string
  879.  *
  880.  * @throws Twig_Error_Runtime When an invalid trimming side is used (not a string or not 'left', 'right', or 'both')
  881.  */
  882. function twig_trim_filter($string, $characterMask = null, $side = 'both')
  883. {
  884.     if (null === $characterMask) {
  885.         $characterMask = " \t\n\r\0\x0B";
  886.     }
  888.     switch ($side) {
  889.         case 'both':
  890.             return trim($string, $characterMask);
  891.         case 'left':
  892.             return ltrim($string, $characterMask);
  893.         case 'right':
  894.             return rtrim($string, $characterMask);
  895.         default:
  896.             throw new Twig_Error_Runtime('Trimming side must be "left", "right" or "both".');
  897.     }
  898. }
  900. /**
  901.  * Escapes a string.
  902.  *
  903.  * @param Twig_Environment $env
  904.  * @param mixed            $string     The value to be escaped
  905.  * @param string           $strategy   The escaping strategy
  906.  * @param string           $charset    The charset
  907.  * @param bool             $autoescape Whether the function is called by the auto-escaping feature (true) or by the developer (false)
  908.  *
  909.  * @return string
  910.  */
  911. function twig_escape_filter(Twig_Environment $env, $string, $strategy = 'html', $charset = null, $autoescape = false)
  912. {
  913.     if ($autoescape && $string instanceof Twig_Markup) {
  914.         return $string;
  915.     }
  917.     if (!is_string($string)) {
  918.         if (is_object($string) && method_exists($string, '__toString')) {
  919.             $string = (string) $string;
  920.         } elseif (in_array($strategy, ['html', 'js', 'css', 'html_attr', 'url'])) {
  921.             return $string;
  922.         }
  923.     }
  925.     if ('' === $string) {
  926.         return '';
  927.     }
  929.     if (null === $charset) {
  930.         $charset = $env->getCharset();
  931.     }
  933.     switch ($strategy) {
  934.         case 'html':
  935.             // see https://secure.php.net/htmlspecialchars
  937.             // Using a static variable to avoid initializing the array
  938.             // each time the function is called. Moving the declaration on the
  939.             // top of the function slow downs other escaping strategies.
  940.             static $htmlspecialcharsCharsets = [
  941.                 'ISO-8859-1' => true, 'ISO8859-1' => true,
  942.                 'ISO-8859-15' => true, 'ISO8859-15' => true,
  943.                 'utf-8' => true, 'UTF-8' => true,
  944.                 'CP866' => true, 'IBM866' => true, '866' => true,
  945.                 'CP1251' => true, 'WINDOWS-1251' => true, 'WIN-1251' => true,
  946.                 '1251' => true,
  947.                 'CP1252' => true, 'WINDOWS-1252' => true, '1252' => true,
  948.                 'KOI8-R' => true, 'KOI8-RU' => true, 'KOI8R' => true,
  949.                 'BIG5' => true, '950' => true,
  950.                 'GB2312' => true, '936' => true,
  951.                 'BIG5-HKSCS' => true,
  952.                 'SHIFT_JIS' => true, 'SJIS' => true, '932' => true,
  953.                 'EUC-JP' => true, 'EUCJP' => true,
  954.                 'ISO8859-5' => true, 'ISO-8859-5' => true, 'MACROMAN' => true,
  955.             ];
  957.             if (isset($htmlspecialcharsCharsets[$charset])) {
  958.                 return htmlspecialchars($string, ENT_QUOTES | ENT_SUBSTITUTE, $charset);
  959.             }
  961.             if (isset($htmlspecialcharsCharsets[strtoupper($charset)])) {
  962.                 // cache the lowercase variant for future iterations
  963.                 $htmlspecialcharsCharsets[$charset] = true;
  965.                 return htmlspecialchars($string, ENT_QUOTES | ENT_SUBSTITUTE, $charset);
  966.             }
  968.             $string = iconv($charset, 'UTF-8', $string);
  969.             $string = htmlspecialchars($string, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8');
  971.             return iconv('UTF-8', $charset, $string);
  973.         case 'js':
  974.             // escape all non-alphanumeric characters
  975.             // into their \x or \uHHHH representations
  976.             if ('UTF-8' !== $charset) {
  977.                 $string = iconv($charset, 'UTF-8', $string);
  978.             }
  980.             if (!preg_match('//u', $string)) {
  981.                 throw new Twig_Error_Runtime('The string to escape is not a valid UTF-8 string.');
  982.             }
  984.             $string = preg_replace_callback('#[^a-zA-Z0-9,\._]#Su', function ($matches) {
  985.                 $char = $matches[0];
  987.                 /*
  988.                  * A few characters have short escape sequences in JSON and JavaScript.
  989.                  * Escape sequences supported only by JavaScript, not JSON, are ommitted.
  990.                  * \" is also supported but omitted, because the resulting string is not HTML safe.
  991.                  */
  992.                 static $shortMap = [
  993.                     '\\' => '\\\\',
  994.                     '/' => '\\/',
  995.                     "\x08" => '\b',
  996.                     "\x0C" => '\f',
  997.                     "\x0A" => '\n',
  998.                     "\x0D" => '\r',
  999.                     "\x09" => '\t',
  1000.                 ];
  1002.                 if (isset($shortMap[$char])) {
  1003.                     return $shortMap[$char];
  1004.                 }
  1006.                 // \uHHHH
  1007.                 $char = twig_convert_encoding($char, 'UTF-16BE', 'UTF-8');
  1008.                 $char = strtoupper(bin2hex($char));
  1010.                 if (4 >= strlen($char)) {
  1011.                     return sprintf('\u%04s', $char);
  1012.                 }
  1014.                 return sprintf('\u%04s\u%04s', substr($char, 0, -4), substr($char, -4));
  1015.             }, $string);
  1017.             if ('UTF-8' !== $charset) {
  1018.                 $string = iconv('UTF-8', $charset, $string);
  1019.             }
  1021.             return $string;
  1023.         case 'css':
  1024.             if ('UTF-8' !== $charset) {
  1025.                 $string = iconv($charset, 'UTF-8', $string);
  1026.             }
  1028.             if (!preg_match('//u', $string)) {
  1029.                 throw new Twig_Error_Runtime('The string to escape is not a valid UTF-8 string.');
  1030.             }
  1032.             $string = preg_replace_callback('#[^a-zA-Z0-9]#Su', function ($matches) {
  1033.                 $char = $matches[0];
  1035.                 return sprintf('\\%X ', 1 === strlen($char) ? ord($char) : mb_ord($char, 'UTF-8'));
  1036.             }, $string);
  1038.             if ('UTF-8' !== $charset) {
  1039.                 $string = iconv('UTF-8', $charset, $string);
  1040.             }
  1042.             return $string;
  1044.         case 'html_attr':
  1045.             if ('UTF-8' !== $charset) {
  1046.                 $string = iconv($charset, 'UTF-8', $string);
  1047.             }
  1049.             if (!preg_match('//u', $string)) {
  1050.                 throw new Twig_Error_Runtime('The string to escape is not a valid UTF-8 string.');
  1051.             }
  1053.             $string = preg_replace_callback('#[^a-zA-Z0-9,\.\-_]#Su', function ($matches) {
  1054.                 /**
  1055.                  * This function is adapted from code coming from Zend Framework.
  1056.                  *
  1057.                  * @copyright Copyright (c) 2005-2012 Zend Technologies USA Inc. (https://www.zend.com)
  1058.                  * @license   https://framework.zend.com/license/new-bsd New BSD License
  1059.                  */
  1060.                 $chr = $matches[0];
  1061.                 $ord = ord($chr);
  1063.                 /*
  1064.                  * The following replaces characters undefined in HTML with the
  1065.                  * hex entity for the Unicode replacement character.
  1066.                  */
  1067.                 if (($ord <= 0x1f && "\t" != $chr && "\n" != $chr && "\r" != $chr) || ($ord >= 0x7f && $ord <= 0x9f)) {
  1068.                     return '&#xFFFD;';
  1069.                 }
  1071.                 /*
  1072.                  * Check if the current character to escape has a name entity we should
  1073.                  * replace it with while grabbing the hex value of the character.
  1074.                  */
  1075.                 if (1 === strlen($chr)) {
  1076.                     /*
  1077.                      * While HTML supports far more named entities, the lowest common denominator
  1078.                      * has become HTML5's XML Serialisation which is restricted to the those named
  1079.                      * entities that XML supports. Using HTML entities would result in this error:
  1080.                      *     XML Parsing Error: undefined entity
  1081.                      */
  1082.                     static $entityMap = [
  1083.                         34 => '&quot;', /* quotation mark */
  1084.                         38 => '&amp;',  /* ampersand */
  1085.                         60 => '&lt;',   /* less-than sign */
  1086.                         62 => '&gt;',   /* greater-than sign */
  1087.                     ];
  1089.                     if (isset($entityMap[$ord])) {
  1090.                         return $entityMap[$ord];
  1091.                     }
  1093.                     return sprintf('&#x%02X;', $ord);
  1094.                 }
  1096.                 /*
  1097.                  * Per OWASP recommendations, we'll use hex entities for any other
  1098.                  * characters where a named entity does not exist.
  1099.                  */
  1100.                 return sprintf('&#x%04X;', mb_ord($chr, 'UTF-8'));
  1101.             }, $string);
  1103.             if ('UTF-8' !== $charset) {
  1104.                 $string = iconv('UTF-8', $charset, $string);
  1105.             }
  1107.             return $string;
  1109.         case 'url':
  1110.             return rawurlencode($string);
  1112.         default:
  1113.             static $escapers;
  1115.             if (null === $escapers) {
  1116.                 $escapers = $env->getExtension('Twig_Extension_Core')->getEscapers();
  1117.             }
  1119.             if (isset($escapers[$strategy])) {
  1120.                 return $escapers[$strategy]($env, $string, $charset);
  1121.             }
  1123.             $validStrategies = implode(', ', array_merge(['html', 'js', 'url', 'css', 'html_attr'], array_keys($escapers)));
  1125.             throw new Twig_Error_Runtime(sprintf('Invalid escaping strategy "%s" (valid ones: %s).', $strategy, $validStrategies));
  1126.     }
  1127. }
  1129. /**
  1130.  * @internal
  1131.  */
  1132. function twig_escape_filter_is_safe(Twig_Node $filterArgs)
  1133. {
  1134.     foreach ($filterArgs as $arg) {
  1135.         if ($arg instanceof Twig_Node_Expression_Constant) {
  1136.             return [$arg->getAttribute('value')];
  1137.         }
  1139.         return [];
  1140.     }
  1142.     return ['html'];
  1143. }
  1145. function twig_convert_encoding($string, $to, $from)
  1146. {
  1147.     return iconv($from, $to, $string);
  1148. }
  1150. /**
  1151.  * Returns the length of a variable.
  1152.  *
  1153.  * @param Twig_Environment $env   A Twig_Environment instance
  1154.  * @param mixed            $thing A variable
  1155.  *
  1156.  * @return int The length of the value
  1157.  */
  1158. function twig_length_filter(Twig_Environment $env, $thing)
  1159. {
  1160.     if (null === $thing) {
  1161.         return 0;
  1162.     }
  1164.     if (is_scalar($thing)) {
  1165.         return mb_strlen($thing, $env->getCharset());
  1166.     }
  1168.     if ($thing instanceof \SimpleXMLElement) {
  1169.         return count($thing);
  1170.     }
  1172.     if (method_exists($thing, '__toString') && !$thing instanceof \Countable) {
  1173.         return mb_strlen((string) $thing, $env->getCharset());
  1174.     }
  1176.     if ($thing instanceof \Countable || is_array($thing)) {
  1177.         return count($thing);
  1178.     }
  1180.     if ($thing instanceof \IteratorAggregate) {
  1181.         return iterator_count($thing);
  1182.     }
  1184.     return 1;
  1185. }
  1187. /**
  1188.  * Converts a string to uppercase.
  1189.  *
  1190.  * @param Twig_Environment $env
  1191.  * @param string           $string A string
  1192.  *
  1193.  * @return string The uppercased string
  1194.  */
  1195. function twig_upper_filter(Twig_Environment $env, $string)
  1196. {
  1197.     return mb_strtoupper($string, $env->getCharset());
  1198. }
  1200. /**
  1201.  * Converts a string to lowercase.
  1202.  *
  1203.  * @param Twig_Environment $env
  1204.  * @param string           $string A string
  1205.  *
  1206.  * @return string The lowercased string
  1207.  */
  1208. function twig_lower_filter(Twig_Environment $env, $string)
  1209. {
  1210.     return mb_strtolower($string, $env->getCharset());
  1211. }
  1213. /**
  1214.  * Returns a titlecased string.
  1215.  *
  1216.  * @param Twig_Environment $env
  1217.  * @param string           $string A string
  1218.  *
  1219.  * @return string The titlecased string
  1220.  */
  1221. function twig_title_string_filter(Twig_Environment $env, $string)
  1222. {
  1223.     if (null !== $charset = $env->getCharset()) {
  1224.         return mb_convert_case($string, MB_CASE_TITLE, $charset);
  1225.     }
  1227.     return ucwords(strtolower($string));
  1228. }
  1230. /**
  1231.  * Returns a capitalized string.
  1232.  *
  1233.  * @param Twig_Environment $env
  1234.  * @param string           $string A string
  1235.  *
  1236.  * @return string The capitalized string
  1237.  */
  1238. function twig_capitalize_string_filter(Twig_Environment $env, $string)
  1239. {
  1240.     $charset = $env->getCharset();
  1242.     return mb_strtoupper(mb_substr($string, 0, 1, $charset), $charset).mb_strtolower(mb_substr($string, 1, null, $charset), $charset);
  1243. }
  1245. /**
  1246.  * @internal
  1247.  */
  1248. function twig_ensure_traversable($seq)
  1249. {
  1250.     if ($seq instanceof Traversable || is_array($seq)) {
  1251.         return $seq;
  1252.     }
  1254.     return [];
  1255. }
  1257. /**
  1258.  * Checks if a variable is empty.
  1259.  *
  1260.  * <pre>
  1261.  * {# evaluates to true if the foo variable is null, false, or the empty string #}
  1262.  * {% if foo is empty %}
  1263.  *     {# ... #}
  1264.  * {% endif %}
  1265.  * </pre>
  1266.  *
  1267.  * @param mixed $value A variable
  1268.  *
  1269.  * @return bool true if the value is empty, false otherwise
  1270.  */
  1271. function twig_test_empty($value)
  1272. {
  1273.     if ($value instanceof Countable) {
  1274.         return 0 == count($value);
  1275.     }
  1277.     if (is_object($value) && method_exists($value, '__toString')) {
  1278.         return '' === (string) $value;
  1279.     }
  1281.     return '' === $value || false === $value || null === $value || [] === $value;
  1282. }
  1284. /**
  1285.  * Checks if a variable is traversable.
  1286.  *
  1287.  * <pre>
  1288.  * {# evaluates to true if the foo variable is an array or a traversable object #}
  1289.  * {% if foo is iterable %}
  1290.  *     {# ... #}
  1291.  * {% endif %}
  1292.  * </pre>
  1293.  *
  1294.  * @param mixed $value A variable
  1295.  *
  1296.  * @return bool true if the value is traversable
  1297.  */
  1298. function twig_test_iterable($value)
  1299. {
  1300.     return $value instanceof Traversable || is_array($value);
  1301. }
  1303. /**
  1304.  * Renders a template.
  1305.  *
  1306.  * @param Twig_Environment $env
  1307.  * @param array            $context
  1308.  * @param string|array     $template      The template to render or an array of templates to try consecutively
  1309.  * @param array            $variables     The variables to pass to the template
  1310.  * @param bool             $withContext
  1311.  * @param bool             $ignoreMissing Whether to ignore missing templates or not
  1312.  * @param bool             $sandboxed     Whether to sandbox the template or not
  1313.  *
  1314.  * @return string The rendered template
  1315.  */
  1316. function twig_include(Twig_Environment $env, $context, $template, $variables = [], $withContext = true, $ignoreMissing = false, $sandboxed = false)
  1317. {
  1318.     $alreadySandboxed = false;
  1319.     $sandbox = null;
  1320.     if ($withContext) {
  1321.         $variables = array_merge($context, $variables);
  1322.     }
  1324.     if ($isSandboxed = $sandboxed && $env->hasExtension('Twig_Extension_Sandbox')) {
  1325.         $sandbox = $env->getExtension('Twig_Extension_Sandbox');
  1326.         if (!$alreadySandboxed = $sandbox->isSandboxed()) {
  1327.             $sandbox->enableSandbox();
  1328.         }
  1329.     }
  1331.     $result = '';
  1332.     try {
  1333.         $result = $env->resolveTemplate($template)->render($variables);
  1334.     } catch (Twig_Error_Loader $e) {
  1335.         if (!$ignoreMissing) {
  1336.             if ($isSandboxed && !$alreadySandboxed) {
  1337.                 $sandbox->disableSandbox();
  1338.             }
  1340.             throw $e;
  1341.         }
  1342.     } catch (Throwable $e) {
  1343.         if ($isSandboxed && !$alreadySandboxed) {
  1344.             $sandbox->disableSandbox();
  1345.         }
  1347.         throw $e;
  1348.     }
  1350.     if ($isSandboxed && !$alreadySandboxed) {
  1351.         $sandbox->disableSandbox();
  1352.     }
  1354.     return $result;
  1355. }
  1357. /**
  1358.  * Returns a template content without rendering it.
  1359.  *
  1360.  * @param Twig_Environment $env
  1361.  * @param string           $name          The template name
  1362.  * @param bool             $ignoreMissing Whether to ignore missing templates or not
  1363.  *
  1364.  * @return string The template source
  1365.  */
  1366. function twig_source(Twig_Environment $env, $name, $ignoreMissing = false)
  1367. {
  1368.     $loader = $env->getLoader();
  1369.     try {
  1370.         return $loader->getSourceContext($name)->getCode();
  1371.     } catch (Twig_Error_Loader $e) {
  1372.         if (!$ignoreMissing) {
  1373.             throw $e;
  1374.         }
  1375.     }
  1376. }
  1378. /**
  1379.  * Provides the ability to get constants from instances as well as class/global constants.
  1380.  *
  1381.  * @param string      $constant The name of the constant
  1382.  * @param object|null $object   The object to get the constant from
  1383.  *
  1384.  * @return string
  1385.  */
  1386. function twig_constant($constant, $object = null)
  1387. {
  1388.     if (null !== $object) {
  1389.         $constant = get_class($object).'::'.$constant;
  1390.     }
  1392.     return constant($constant);
  1393. }
  1395. /**
  1396.  * Checks if a constant exists.
  1397.  *
  1398.  * @param string      $constant The name of the constant
  1399.  * @param object|null $object   The object to get the constant from
  1400.  *
  1401.  * @return bool
  1402.  */
  1403. function twig_constant_is_defined($constant, $object = null)
  1404. {
  1405.     if (null !== $object) {
  1406.         $constant = get_class($object).'::'.$constant;
  1407.     }
  1409.     return defined($constant);
  1410. }
  1412. /**
  1413.  * Batches item.
  1414.  *
  1415.  * @param array $items An array of items
  1416.  * @param int   $size  The size of the batch
  1417.  * @param mixed $fill  A value used to fill missing items
  1418.  *
  1419.  * @return array
  1420.  */
  1421. function twig_array_batch($items, $size, $fill = null)
  1422. {
  1423.     if ($items instanceof Traversable) {
  1424.         $items = iterator_to_array($items, false);
  1425.     }
  1427.     $size = ceil($size);
  1429.     $result = array_chunk($items, $size, true);
  1431.     if (null !== $fill && !empty($result)) {
  1432.         $last = count($result) - 1;
  1433.         if ($fillCount = $size - count($result[$last])) {
  1434.             $result[$last] = array_merge(
  1435.                 $result[$last],
  1436.                 array_fill(0, $fillCount, $fill)
  1437.             );
  1438.         }
  1439.     }
  1441.     return $result;
  1442. }
  1444. /**
  1445.  * Returns the attribute value for a given array/object.
  1446.  *
  1447.  * @param mixed  $object            The object or array from where to get the item
  1448.  * @param mixed  $item              The item to get from the array or object
  1449.  * @param array  $arguments         An array of arguments to pass if the item is an object method
  1450.  * @param string $type              The type of attribute (@see Twig_Template constants)
  1451.  * @param bool   $isDefinedTest     Whether this is only a defined check
  1452.  * @param bool   $ignoreStrictCheck Whether to ignore the strict attribute check or not
  1453.  *
  1454.  * @return mixed The attribute value, or a Boolean when $isDefinedTest is true, or null when the attribute is not set and $ignoreStrictCheck is true
  1455.  *
  1456.  * @throws Twig_Error_Runtime if the attribute does not exist and Twig is running in strict mode and $isDefinedTest is false
  1457.  *
  1458.  * @internal
  1459.  */
  1460. function twig_get_attribute(Twig_Environment $env, Twig_Source $source, $object, $item, array $arguments = [], $type = /* Twig_Template::ANY_CALL */ 'any', $isDefinedTest = false, $ignoreStrictCheck = false, $sandboxed = false)
  1461. {
  1462.     // array
  1463.     if (/* Twig_Template::METHOD_CALL */ 'method' !== $type) {
  1464.         $arrayItem = is_bool($item) || is_float($item) ? (int) $item : $item;
  1466.         if (((is_array($object) || $object instanceof ArrayObject) && (isset($object[$arrayItem]) || array_key_exists($arrayItem, $object)))
  1467.             || ($object instanceof ArrayAccess && isset($object[$arrayItem]))
  1468.         ) {
  1469.             if ($isDefinedTest) {
  1470.                 return true;
  1471.             }
  1473.             return $object[$arrayItem];
  1474.         }
  1476.         if (/* Twig_Template::ARRAY_CALL */ 'array' === $type || !is_object($object)) {
  1477.             if ($isDefinedTest) {
  1478.                 return false;
  1479.             }
  1481.             if ($ignoreStrictCheck || !$env->isStrictVariables()) {
  1482.                 return;
  1483.             }
  1485.             if ($object instanceof ArrayAccess) {
  1486.                 $message = sprintf('Key "%s" in object with ArrayAccess of class "%s" does not exist.', $arrayItem, get_class($object));
  1487.             } elseif (is_object($object)) {
  1488.                 $message = sprintf('Impossible to access a key "%s" on an object of class "%s" that does not implement ArrayAccess interface.', $item, get_class($object));
  1489.             } elseif (is_array($object)) {
  1490.                 if (empty($object)) {
  1491.                     $message = sprintf('Key "%s" does not exist as the array is empty.', $arrayItem);
  1492.                 } else {
  1493.                     $message = sprintf('Key "%s" for array with keys "%s" does not exist.', $arrayItem, implode(', ', array_keys($object)));
  1494.                 }
  1495.             } elseif (/* Twig_Template::ARRAY_CALL */ 'array' === $type) {
  1496.                 if (null === $object) {
  1497.                     $message = sprintf('Impossible to access a key ("%s") on a null variable.', $item);
  1498.                 } else {
  1499.                     $message = sprintf('Impossible to access a key ("%s") on a %s variable ("%s").', $item, gettype($object), $object);
  1500.                 }
  1501.             } elseif (null === $object) {
  1502.                 $message = sprintf('Impossible to access an attribute ("%s") on a null variable.', $item);
  1503.             } else {
  1504.                 $message = sprintf('Impossible to access an attribute ("%s") on a %s variable ("%s").', $item, gettype($object), $object);
  1505.             }
  1507.             throw new Twig_Error_Runtime($message, -1, $source);
  1508.         }
  1509.     }
  1511.     if (!is_object($object)) {
  1512.         if ($isDefinedTest) {
  1513.             return false;
  1514.         }
  1516.         if ($ignoreStrictCheck || !$env->isStrictVariables()) {
  1517.             return;
  1518.         }
  1520.         if (null === $object) {
  1521.             $message = sprintf('Impossible to invoke a method ("%s") on a null variable.', $item);
  1522.         } elseif (is_array($object)) {
  1523.             $message = sprintf('Impossible to invoke a method ("%s") on an array.', $item);
  1524.         } else {
  1525.             $message = sprintf('Impossible to invoke a method ("%s") on a %s variable ("%s").', $item, gettype($object), $object);
  1526.         }
  1528.         throw new Twig_Error_Runtime($message, -1, $source);
  1529.     }
  1531.     if ($object instanceof Twig_Template) {
  1532.         throw new Twig_Error_Runtime('Accessing Twig_Template attributes is forbidden.');
  1533.     }
  1535.     // object property
  1536.     if (/* Twig_Template::METHOD_CALL */ 'method' !== $type) {
  1537.         if (isset($object->$item) || array_key_exists((string) $item, $object)) {
  1538.             if ($isDefinedTest) {
  1539.                 return true;
  1540.             }
  1542.             if ($sandboxed) {
  1543.                 $env->getExtension('Twig_Extension_Sandbox')->checkPropertyAllowed($object, $item);
  1544.             }
  1546.             return $object->$item;
  1547.         }
  1548.     }
  1550.     static $cache = [];
  1552.     $class = get_class($object);
  1554.     // object method
  1555.     // precedence: getXxx() > isXxx() > hasXxx()
  1556.     if (!isset($cache[$class])) {
  1557.         $methods = get_class_methods($object);
  1558.         sort($methods);
  1559.         $lcMethods = array_map('strtolower', $methods);
  1560.         $classCache = [];
  1561.         foreach ($methods as $i => $method) {
  1562.             $classCache[$method] = $method;
  1563.             $classCache[$lcName = $lcMethods[$i]] = $method;
  1565.             if ('g' === $lcName[0] && 0 === strpos($lcName, 'get')) {
  1566.                 $name = substr($method, 3);
  1567.                 $lcName = substr($lcName, 3);
  1568.             } elseif ('i' === $lcName[0] && 0 === strpos($lcName, 'is')) {
  1569.                 $name = substr($method, 2);
  1570.                 $lcName = substr($lcName, 2);
  1571.             } elseif ('h' === $lcName[0] && 0 === strpos($lcName, 'has')) {
  1572.                 $name = substr($method, 3);
  1573.                 $lcName = substr($lcName, 3);
  1574.                 if (in_array('is'.$lcName, $lcMethods)) {
  1575.                     continue;
  1576.                 }
  1577.             } else {
  1578.                 continue;
  1579.             }
  1581.             // skip get() and is() methods (in which case, $name is empty)
  1582.             if ($name) {
  1583.                 if (!isset($classCache[$name])) {
  1584.                     $classCache[$name] = $method;
  1585.                 }
  1587.                 if (!isset($classCache[$lcName])) {
  1588.                     $classCache[$lcName] = $method;
  1589.                 }
  1590.             }
  1591.         }
  1592.         $cache[$class] = $classCache;
  1593.     }
  1595.     $call = false;
  1596.     if (isset($cache[$class][$item])) {
  1597.         $method = $cache[$class][$item];
  1598.     } elseif (isset($cache[$class][$lcItem = strtolower($item)])) {
  1599.         $method = $cache[$class][$lcItem];
  1600.     } elseif (isset($cache[$class]['__call'])) {
  1601.         $method = $item;
  1602.         $call = true;
  1603.     } else {
  1604.         if ($isDefinedTest) {
  1605.             return false;
  1606.         }
  1608.         if ($ignoreStrictCheck || !$env->isStrictVariables()) {
  1609.             return;
  1610.         }
  1612.         throw new Twig_Error_Runtime(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), -1, $source);
  1613.     }
  1615.     if ($isDefinedTest) {
  1616.         return true;
  1617.     }
  1619.     if ($sandboxed) {
  1620.         $env->getExtension('Twig_Extension_Sandbox')->checkMethodAllowed($object, $method);
  1621.     }
  1623.     // Some objects throw exceptions when they have __call, and the method we try
  1624.     // to call is not supported. If ignoreStrictCheck is true, we should return null.
  1625.     try {
  1626.         $ret = $object->$method(...$arguments);
  1627.     } catch (BadMethodCallException $e) {
  1628.         if ($call && ($ignoreStrictCheck || !$env->isStrictVariables())) {
  1629.             return;
  1630.         }
  1631.         throw $e;
  1632.     }
  1634.     return $ret;
  1635. }
  1637. class_alias('Twig_Extension_Core', 'Twig\Extension\CoreExtension', false);