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

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 = array('F j, Y H:i', '%d days');
  15.     private $numberFormat = array(0, '.', ',');
  16.     private $timezone = null;
  17.     private $escapers = array();
  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 = array($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 array(
  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.         );
  133.     }
  135.     public function getFilters()
  136.     {
  137.         return array(
  138.             // formatting filters
  139.             new Twig_Filter('date', 'twig_date_format_filter', array('needs_environment' => true)),
  140.             new Twig_Filter('date_modify', 'twig_date_modify_filter', array('needs_environment' => true)),
  141.             new Twig_Filter('format', 'sprintf'),
  142.             new Twig_Filter('replace', 'twig_replace_filter'),
  143.             new Twig_Filter('number_format', 'twig_number_format_filter', array('needs_environment' => true)),
  144.             new Twig_Filter('abs', 'abs'),
  145.             new Twig_Filter('round', 'twig_round'),
  147.             // encoding
  148.             new Twig_Filter('url_encode', 'twig_urlencode_filter'),
  149.             new Twig_Filter('json_encode', 'json_encode'),
  150.             new Twig_Filter('convert_encoding', 'twig_convert_encoding'),
  152.             // string filters
  153.             new Twig_Filter('title', 'twig_title_string_filter', array('needs_environment' => true)),
  154.             new Twig_Filter('capitalize', 'twig_capitalize_string_filter', array('needs_environment' => true)),
  155.             new Twig_Filter('upper', 'twig_upper_filter', array('needs_environment' => true)),
  156.             new Twig_Filter('lower', 'twig_lower_filter', array('needs_environment' => true)),
  157.             new Twig_Filter('striptags', 'strip_tags'),
  158.             new Twig_Filter('trim', 'twig_trim_filter'),
  159.             new Twig_Filter('nl2br', 'nl2br', array('pre_escape' => 'html', 'is_safe' => array('html'))),
  161.             // array helpers
  162.             new Twig_Filter('join', 'twig_join_filter'),
  163.             new Twig_Filter('split', 'twig_split_filter', array('needs_environment' => true)),
  164.             new Twig_Filter('sort', 'twig_sort_filter'),
  165.             new Twig_Filter('merge', 'twig_array_merge'),
  166.             new Twig_Filter('batch', 'twig_array_batch'),
  168.             // string/array filters
  169.             new Twig_Filter('reverse', 'twig_reverse_filter', array('needs_environment' => true)),
  170.             new Twig_Filter('length', 'twig_length_filter', array('needs_environment' => true)),
  171.             new Twig_Filter('slice', 'twig_slice', array('needs_environment' => true)),
  172.             new Twig_Filter('first', 'twig_first', array('needs_environment' => true)),
  173.             new Twig_Filter('last', 'twig_last', array('needs_environment' => true)),
  175.             // iteration and runtime
  176.             new Twig_Filter('default', '_twig_default_filter', array('node_class' => 'Twig_Node_Expression_Filter_Default')),
  177.             new Twig_Filter('keys', 'twig_get_array_keys_filter'),
  179.             // escaping
  180.             new Twig_Filter('escape', 'twig_escape_filter', array('needs_environment' => true, 'is_safe_callback' => 'twig_escape_filter_is_safe')),
  181.             new Twig_Filter('e', 'twig_escape_filter', array('needs_environment' => true, 'is_safe_callback' => 'twig_escape_filter_is_safe')),
  182.         );
  183.     }
  185.     public function getFunctions()
  186.     {
  187.         return array(
  188.             new Twig_Function('max', 'max'),
  189.             new Twig_Function('min', 'min'),
  190.             new Twig_Function('range', 'range'),
  191.             new Twig_Function('constant', 'twig_constant'),
  192.             new Twig_Function('cycle', 'twig_cycle'),
  193.             new Twig_Function('random', 'twig_random', array('needs_environment' => true)),
  194.             new Twig_Function('date', 'twig_date_converter', array('needs_environment' => true)),
  195.             new Twig_Function('include', 'twig_include', array('needs_environment' => true, 'needs_context' => true, 'is_safe' => array('all'))),
  196.             new Twig_Function('source', 'twig_source', array('needs_environment' => true, 'is_safe' => array('all'))),
  197.         );
  198.     }
  200.     public function getTests()
  201.     {
  202.         return array(
  203.             new Twig_Test('even', null, array('node_class' => 'Twig_Node_Expression_Test_Even')),
  204.             new Twig_Test('odd', null, array('node_class' => 'Twig_Node_Expression_Test_Odd')),
  205.             new Twig_Test('defined', null, array('node_class' => 'Twig_Node_Expression_Test_Defined')),
  206.             new Twig_Test('same as', null, array('node_class' => 'Twig_Node_Expression_Test_Sameas')),
  207.             new Twig_Test('none', null, array('node_class' => 'Twig_Node_Expression_Test_Null')),
  208.             new Twig_Test('null', null, array('node_class' => 'Twig_Node_Expression_Test_Null')),
  209.             new Twig_Test('divisible by', null, array('node_class' => 'Twig_Node_Expression_Test_Divisibleby')),
  210.             new Twig_Test('constant', null, array('node_class' => 'Twig_Node_Expression_Test_Constant')),
  211.             new Twig_Test('empty', 'twig_test_empty'),
  212.             new Twig_Test('iterable', 'twig_test_iterable'),
  213.         );
  214.     }
  216.     public function getOperators()
  217.     {
  218.         return array(
  219.             array(
  220.                 'not' => array('precedence' => 50, 'class' => 'Twig_Node_Expression_Unary_Not'),
  221.                 '-' => array('precedence' => 500, 'class' => 'Twig_Node_Expression_Unary_Neg'),
  222.                 '+' => array('precedence' => 500, 'class' => 'Twig_Node_Expression_Unary_Pos'),
  223.             ),
  224.             array(
  225.                 'or' => array('precedence' => 10, 'class' => 'Twig_Node_Expression_Binary_Or', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
  226.                 'and' => array('precedence' => 15, 'class' => 'Twig_Node_Expression_Binary_And', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
  227.                 'b-or' => array('precedence' => 16, 'class' => 'Twig_Node_Expression_Binary_BitwiseOr', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
  228.                 'b-xor' => array('precedence' => 17, 'class' => 'Twig_Node_Expression_Binary_BitwiseXor', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
  229.                 'b-and' => array('precedence' => 18, 'class' => 'Twig_Node_Expression_Binary_BitwiseAnd', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
  230.                 '==' => array('precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_Equal', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
  231.                 '!=' => array('precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_NotEqual', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
  232.                 '<' => array('precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_Less', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
  233.                 '>' => array('precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_Greater', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
  234.                 '>=' => array('precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_GreaterEqual', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
  235.                 '<=' => array('precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_LessEqual', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
  236.                 'not in' => array('precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_NotIn', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
  237.                 'in' => array('precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_In', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
  238.                 'matches' => array('precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_Matches', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
  239.                 'starts with' => array('precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_StartsWith', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
  240.                 'ends with' => array('precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_EndsWith', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
  241.                 '..' => array('precedence' => 25, 'class' => 'Twig_Node_Expression_Binary_Range', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
  242.                 '+' => array('precedence' => 30, 'class' => 'Twig_Node_Expression_Binary_Add', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
  243.                 '-' => array('precedence' => 30, 'class' => 'Twig_Node_Expression_Binary_Sub', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
  244.                 '~' => array('precedence' => 40, 'class' => 'Twig_Node_Expression_Binary_Concat', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
  245.                 '*' => array('precedence' => 60, 'class' => 'Twig_Node_Expression_Binary_Mul', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
  246.                 '/' => array('precedence' => 60, 'class' => 'Twig_Node_Expression_Binary_Div', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
  247.                 '//' => array('precedence' => 60, 'class' => 'Twig_Node_Expression_Binary_FloorDiv', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
  248.                 '%' => array('precedence' => 60, 'class' => 'Twig_Node_Expression_Binary_Mod', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
  249.                 'is' => array('precedence' => 100, 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
  250.                 'is not' => array('precedence' => 100, 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
  251.                 '**' => array('precedence' => 200, 'class' => 'Twig_Node_Expression_Binary_Power', 'associativity' => Twig_ExpressionParser::OPERATOR_RIGHT),
  252.                 '??' => array('precedence' => 300, 'class' => 'Twig_Node_Expression_NullCoalesce', 'associativity' => Twig_ExpressionParser::OPERATOR_RIGHT),
  253.             ),
  254.         );
  255.     }
  256. }
  258. /**
  259.  * Cycles over a value.
  260.  *
  261.  * @param ArrayAccess|array $values
  262.  * @param int               $position The cycle position
  263.  *
  264.  * @return string The next value in the cycle
  265.  */
  266. function twig_cycle($values, $position)
  267. {
  268.     if (!is_array($values) && !$values instanceof ArrayAccess) {
  269.         return $values;
  270.     }
  272.     return $values[$position % count($values)];
  273. }
  275. /**
  276.  * Returns a random value depending on the supplied parameter type:
  277.  * - a random item from a Traversable or array
  278.  * - a random character from a string
  279.  * - a random integer between 0 and the integer parameter.
  280.  *
  281.  * @param Twig_Environment                   $env
  282.  * @param Traversable|array|int|float|string $values The values to pick a random item from
  283.  *
  284.  * @throws Twig_Error_Runtime when $values is an empty array (does not apply to an empty string which is returned as is)
  285.  *
  286.  * @return mixed A random value from the given sequence
  287.  */
  288. function twig_random(Twig_Environment $env, $values = null)
  289. {
  290.     if (null === $values) {
  291.         return mt_rand();
  292.     }
  294.     if (is_int($values) || is_float($values)) {
  295.         return $values < 0 ? mt_rand($values, 0) : mt_rand(0, $values);
  296.     }
  298.     if ($values instanceof Traversable) {
  299.         $values = iterator_to_array($values);
  300.     } elseif (is_string($values)) {
  301.         if ('' === $values) {
  302.             return '';
  303.         }
  305.         $charset = $env->getCharset();
  307.         if ('UTF-8' !== $charset) {
  308.             $values = iconv($charset, 'UTF-8', $values);
  309.         }
  311.         // unicode version of str_split()
  312.         // split at all positions, but not after the start and not before the end
  313.         $values = preg_split('/(?<!^)(?!$)/u', $values);
  315.         if ('UTF-8' !== $charset) {
  316.             foreach ($values as $i => $value) {
  317.                 $values[$i] = iconv('UTF-8', $charset, $value);
  318.             }
  319.         }
  320.     }
  322.     if (!is_array($values)) {
  323.         return $values;
  324.     }
  326.     if (0 === count($values)) {
  327.         throw new Twig_Error_Runtime('The random function cannot pick from an empty array.');
  328.     }
  330.     return $values[array_rand($values, 1)];
  331. }
  333. /**
  334.  * Converts a date to the given format.
  335.  *
  336.  * <pre>
  337.  *   {{ post.published_at|date("m/d/Y") }}
  338.  * </pre>
  339.  *
  340.  * @param Twig_Environment                      $env
  341.  * @param DateTimeInterface|DateInterval|string $date     A date
  342.  * @param string|null                           $format   The target format, null to use the default
  343.  * @param DateTimeZone|string|null|false        $timezone The target timezone, null to use the default, false to leave unchanged
  344.  *
  345.  * @return string The formatted date
  346.  */
  347. function twig_date_format_filter(Twig_Environment $env, $date, $format = null, $timezone = null)
  348. {
  349.     if (null === $format) {
  350.         $formats = $env->getExtension('Twig_Extension_Core')->getDateFormat();
  351.         $format = $date instanceof DateInterval ? $formats[1] : $formats[0];
  352.     }
  354.     if ($date instanceof DateInterval) {
  355.         return $date->format($format);
  356.     }
  358.     return twig_date_converter($env, $date, $timezone)->format($format);
  359. }
  361. /**
  362.  * Returns a new date object modified.
  363.  *
  364.  * <pre>
  365.  *   {{ post.published_at|date_modify("-1day")|date("m/d/Y") }}
  366.  * </pre>
  367.  *
  368.  * @param Twig_Environment         $env
  369.  * @param DateTimeInterface|string $date     A date
  370.  * @param string                   $modifier A modifier string
  371.  *
  372.  * @return DateTimeInterface A new date object
  373.  */
  374. function twig_date_modify_filter(Twig_Environment $env, $date, $modifier)
  375. {
  376.     $date = twig_date_converter($env, $date, false);
  378.     return $date->modify($modifier);
  379. }
  381. /**
  382.  * Converts an input to a DateTime instance.
  383.  *
  384.  * <pre>
  385.  *    {% if date(user.created_at) < date('+2days') %}
  386.  *      {# do something #}
  387.  *    {% endif %}
  388.  * </pre>
  389.  *
  390.  * @param Twig_Environment               $env
  391.  * @param DateTimeInterface|string|null  $date     A date or null to use the current time
  392.  * @param DateTimeZone|string|null|false $timezone The target timezone, null to use the default, false to leave unchanged
  393.  *
  394.  * @return DateTime A DateTime instance
  395.  */
  396. function twig_date_converter(Twig_Environment $env, $date = null, $timezone = null)
  397. {
  398.     // determine the timezone
  399.     if (false !== $timezone) {
  400.         if (null === $timezone) {
  401.             $timezone = $env->getExtension('Twig_Extension_Core')->getTimezone();
  402.         } elseif (!$timezone instanceof DateTimeZone) {
  403.             $timezone = new DateTimeZone($timezone);
  404.         }
  405.     }
  407.     // immutable dates
  408.     if ($date instanceof DateTimeImmutable) {
  409.         return false !== $timezone ? $date->setTimezone($timezone) : $date;
  410.     }
  412.     if ($date instanceof DateTimeInterface) {
  413.         $date = clone $date;
  414.         if (false !== $timezone) {
  415.             $date->setTimezone($timezone);
  416.         }
  418.         return $date;
  419.     }
  421.     if (null === $date || 'now' === $date) {
  422.         return new DateTime($date, false !== $timezone ? $timezone : $env->getExtension('Twig_Extension_Core')->getTimezone());
  423.     }
  425.     $asString = (string) $date;
  426.     if (ctype_digit($asString) || (!empty($asString) && '-' === $asString[0] && ctype_digit(substr($asString, 1)))) {
  427.         $date = new DateTime('@'.$date);
  428.     } else {
  429.         $date = new DateTime($date, $env->getExtension('Twig_Extension_Core')->getTimezone());
  430.     }
  432.     if (false !== $timezone) {
  433.         $date->setTimezone($timezone);
  434.     }
  436.     return $date;
  437. }
  439. /**
  440.  * Replaces strings within a string.
  441.  *
  442.  * @param string            $str  String to replace in
  443.  * @param array|Traversable $from Replace values
  444.  *
  445.  * @return string
  446.  */
  447. function twig_replace_filter($str, $from)
  448. {
  449.     if ($from instanceof Traversable) {
  450.         $from = iterator_to_array($from);
  451.     } elseif (!is_array($from)) {
  452.         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)));
  453.     }
  455.     return strtr($str, $from);
  456. }
  458. /**
  459.  * Rounds a number.
  460.  *
  461.  * @param int|float $value     The value to round
  462.  * @param int|float $precision The rounding precision
  463.  * @param string    $method    The method to use for rounding
  464.  *
  465.  * @return int|float The rounded number
  466.  */
  467. function twig_round($value, $precision = 0, $method = 'common')
  468. {
  469.     if ('common' == $method) {
  470.         return round($value, $precision);
  471.     }
  473.     if ('ceil' != $method && 'floor' != $method) {
  474.         throw new Twig_Error_Runtime('The round filter only supports the "common", "ceil", and "floor" methods.');
  475.     }
  477.     return $method($value * pow(10, $precision)) / pow(10, $precision);
  478. }
  480. /**
  481.  * Number format filter.
  482.  *
  483.  * All of the formatting options can be left null, in that case the defaults will
  484.  * be used.  Supplying any of the parameters will override the defaults set in the
  485.  * environment object.
  486.  *
  487.  * @param Twig_Environment $env
  488.  * @param mixed            $number       A float/int/string of the number to format
  489.  * @param int              $decimal      the number of decimal points to display
  490.  * @param string           $decimalPoint the character(s) to use for the decimal point
  491.  * @param string           $thousandSep  the character(s) to use for the thousands separator
  492.  *
  493.  * @return string The formatted number
  494.  */
  495. function twig_number_format_filter(Twig_Environment $env, $number, $decimal = null, $decimalPoint = null, $thousandSep = null)
  496. {
  497.     $defaults = $env->getExtension('Twig_Extension_Core')->getNumberFormat();
  498.     if (null === $decimal) {
  499.         $decimal = $defaults[0];
  500.     }
  502.     if (null === $decimalPoint) {
  503.         $decimalPoint = $defaults[1];
  504.     }
  506.     if (null === $thousandSep) {
  507.         $thousandSep = $defaults[2];
  508.     }
  510.     return number_format((float) $number, $decimal, $decimalPoint, $thousandSep);
  511. }
  513. /**
  514.  * URL encodes (RFC 3986) a string as a path segment or an array as a query string.
  515.  *
  516.  * @param string|array $url A URL or an array of query parameters
  517.  *
  518.  * @return string The URL encoded value
  519.  */
  520. function twig_urlencode_filter($url)
  521. {
  522.     if (is_array($url)) {
  523.         return http_build_query($url, '', '&', PHP_QUERY_RFC3986);
  524.     }
  526.     return rawurlencode($url);
  527. }
  529. /**
  530.  * Merges an array with another one.
  531.  *
  532.  * <pre>
  533.  *  {% set items = { 'apple': 'fruit', 'orange': 'fruit' } %}
  534.  *
  535.  *  {% set items = items|merge({ 'peugeot': 'car' }) %}
  536.  *
  537.  *  {# items now contains { 'apple': 'fruit', 'orange': 'fruit', 'peugeot': 'car' } #}
  538.  * </pre>
  539.  *
  540.  * @param array|Traversable $arr1 An array
  541.  * @param array|Traversable $arr2 An array
  542.  *
  543.  * @return array The merged array
  544.  */
  545. function twig_array_merge($arr1, $arr2)
  546. {
  547.     if ($arr1 instanceof Traversable) {
  548.         $arr1 = iterator_to_array($arr1);
  549.     } elseif (!is_array($arr1)) {
  550.         throw new Twig_Error_Runtime(sprintf('The merge filter only works with arrays or "Traversable", got "%s" as first argument.', gettype($arr1)));
  551.     }
  553.     if ($arr2 instanceof Traversable) {
  554.         $arr2 = iterator_to_array($arr2);
  555.     } elseif (!is_array($arr2)) {
  556.         throw new Twig_Error_Runtime(sprintf('The merge filter only works with arrays or "Traversable", got "%s" as second argument.', gettype($arr2)));
  557.     }
  559.     return array_merge($arr1, $arr2);
  560. }
  562. /**
  563.  * Slices a variable.
  564.  *
  565.  * @param Twig_Environment $env
  566.  * @param mixed            $item         A variable
  567.  * @param int              $start        Start of the slice
  568.  * @param int              $length       Size of the slice
  569.  * @param bool             $preserveKeys Whether to preserve key or not (when the input is an array)
  570.  *
  571.  * @return mixed The sliced variable
  572.  */
  573. function twig_slice(Twig_Environment $env, $item, $start, $length = null, $preserveKeys = false)
  574. {
  575.     if ($item instanceof Traversable) {
  576.         while ($item instanceof IteratorAggregate) {
  577.             $item = $item->getIterator();
  578.         }
  580.         if ($start >= 0 && $length >= 0 && $item instanceof Iterator) {
  581.             try {
  582.                 return iterator_to_array(new LimitIterator($item, $start, null === $length ? -1 : $length), $preserveKeys);
  583.             } catch (OutOfBoundsException $exception) {
  584.                 return array();
  585.             }
  586.         }
  588.         $item = iterator_to_array($item, $preserveKeys);
  589.     }
  591.     if (is_array($item)) {
  592.         return array_slice($item, $start, $length, $preserveKeys);
  593.     }
  595.     $item = (string) $item;
  597.     return (string) mb_substr($item, $start, $length, $env->getCharset());
  598. }
  600. /**
  601.  * Returns the first element of the item.
  602.  *
  603.  * @param Twig_Environment $env
  604.  * @param mixed            $item A variable
  605.  *
  606.  * @return mixed The first element of the item
  607.  */
  608. function twig_first(Twig_Environment $env, $item)
  609. {
  610.     $elements = twig_slice($env, $item, 0, 1, false);
  612.     return is_string($elements) ? $elements : current($elements);
  613. }
  615. /**
  616.  * Returns the last element of the item.
  617.  *
  618.  * @param Twig_Environment $env
  619.  * @param mixed            $item A variable
  620.  *
  621.  * @return mixed The last element of the item
  622.  */
  623. function twig_last(Twig_Environment $env, $item)
  624. {
  625.     $elements = twig_slice($env, $item, -1, 1, false);
  627.     return is_string($elements) ? $elements : current($elements);
  628. }
  630. /**
  631.  * Joins the values to a string.
  632.  *
  633.  * The separator between elements is an empty string per default, you can define it with the optional parameter.
  634.  *
  635.  * <pre>
  636.  *  {{ [1, 2, 3]|join('|') }}
  637.  *  {# returns 1|2|3 #}
  638.  *
  639.  *  {{ [1, 2, 3]|join }}
  640.  *  {# returns 123 #}
  641.  * </pre>
  642.  *
  643.  * @param array  $value An array
  644.  * @param string $glue  The separator
  645.  *
  646.  * @return string The concatenated string
  647.  */
  648. function twig_join_filter($value, $glue = '')
  649. {
  650.     if ($value instanceof Traversable) {
  651.         $value = iterator_to_array($value, false);
  652.     }
  654.     return implode($glue, (array) $value);
  655. }
  657. /**
  658.  * Splits the string into an array.
  659.  *
  660.  * <pre>
  661.  *  {{ "one,two,three"|split(',') }}
  662.  *  {# returns [one, two, three] #}
  663.  *
  664.  *  {{ "one,two,three,four,five"|split(',', 3) }}
  665.  *  {# returns [one, two, "three,four,five"] #}
  666.  *
  667.  *  {{ "123"|split('') }}
  668.  *  {# returns [1, 2, 3] #}
  669.  *
  670.  *  {{ "aabbcc"|split('', 2) }}
  671.  *  {# returns [aa, bb, cc] #}
  672.  * </pre>
  673.  *
  674.  * @param Twig_Environment $env
  675.  * @param string           $value     A string
  676.  * @param string           $delimiter The delimiter
  677.  * @param int              $limit     The limit
  678.  *
  679.  * @return array The split string as an array
  680.  */
  681. function twig_split_filter(Twig_Environment $env, $value, $delimiter, $limit = null)
  682. {
  683.     if (!empty($delimiter)) {
  684.         return null === $limit ? explode($delimiter, $value) : explode($delimiter, $value, $limit);
  685.     }
  687.     if ($limit <= 1) {
  688.         return preg_split('/(?<!^)(?!$)/u', $value);
  689.     }
  691.     $length = mb_strlen($value, $env->getCharset());
  692.     if ($length < $limit) {
  693.         return array($value);
  694.     }
  696.     $r = array();
  697.     for ($i = 0; $i < $length; $i += $limit) {
  698.         $r[] = mb_substr($value, $i, $limit, $env->getCharset());
  699.     }
  701.     return $r;
  702. }
  704. // The '_default' filter is used internally to avoid using the ternary operator
  705. // which costs a lot for big contexts (before PHP 5.4). So, on average,
  706. // a function call is cheaper.
  707. /**
  708.  * @internal
  709.  */
  710. function _twig_default_filter($value, $default = '')
  711. {
  712.     if (twig_test_empty($value)) {
  713.         return $default;
  714.     }
  716.     return $value;
  717. }
  719. /**
  720.  * Returns the keys for the given array.
  721.  *
  722.  * It is useful when you want to iterate over the keys of an array:
  723.  *
  724.  * <pre>
  725.  *  {% for key in array|keys %}
  726.  *      {# ... #}
  727.  *  {% endfor %}
  728.  * </pre>
  729.  *
  730.  * @param array $array An array
  731.  *
  732.  * @return array The keys
  733.  */
  734. function twig_get_array_keys_filter($array)
  735. {
  736.     if ($array instanceof Traversable) {
  737.         while ($array instanceof IteratorAggregate) {
  738.             $array = $array->getIterator();
  739.         }
  741.         if ($array instanceof Iterator) {
  742.             $keys = array();
  743.             $array->rewind();
  744.             while ($array->valid()) {
  745.                 $keys[] = $array->key();
  746.                 $array->next();
  747.             }
  749.             return $keys;
  750.         }
  752.         $keys = array();
  753.         foreach ($array as $key => $item) {
  754.             $keys[] = $key;
  755.         }
  757.         return $keys;
  758.     }
  760.     if (!is_array($array)) {
  761.         return array();
  762.     }
  764.     return array_keys($array);
  765. }
  767. /**
  768.  * Reverses a variable.
  769.  *
  770.  * @param Twig_Environment         $env
  771.  * @param array|Traversable|string $item         An array, a Traversable instance, or a string
  772.  * @param bool                     $preserveKeys Whether to preserve key or not
  773.  *
  774.  * @return mixed The reversed input
  775.  */
  776. function twig_reverse_filter(Twig_Environment $env, $item, $preserveKeys = false)
  777. {
  778.     if ($item instanceof Traversable) {
  779.         return array_reverse(iterator_to_array($item), $preserveKeys);
  780.     }
  782.     if (is_array($item)) {
  783.         return array_reverse($item, $preserveKeys);
  784.     }
  786.     $string = (string) $item;
  788.     $charset = $env->getCharset();
  790.     if ('UTF-8' !== $charset) {
  791.         $item = iconv($charset, 'UTF-8', $string);
  792.     }
  794.     preg_match_all('/./us', $item, $matches);
  796.     $string = implode('', array_reverse($matches[0]));
  798.     if ('UTF-8' !== $charset) {
  799.         $string = iconv('UTF-8', $charset, $string);
  800.     }
  802.     return $string;
  803. }
  805. /**
  806.  * Sorts an array.
  807.  *
  808.  * @param array|Traversable $array
  809.  *
  810.  * @return array
  811.  */
  812. function twig_sort_filter($array)
  813. {
  814.     if ($array instanceof Traversable) {
  815.         $array = iterator_to_array($array);
  816.     } elseif (!is_array($array)) {
  817.         throw new Twig_Error_Runtime(sprintf('The sort filter only works with arrays or "Traversable", got "%s".', gettype($array)));
  818.     }
  820.     asort($array);
  822.     return $array;
  823. }
  825. /**
  826.  * @internal
  827.  */
  828. function twig_in_filter($value, $compare)
  829. {
  830.     if (is_array($compare)) {
  831.         return in_array($value, $compare, is_object($value) || is_resource($value));
  832.     } elseif (is_string($compare) && (is_string($value) || is_int($value) || is_float($value))) {
  833.         return '' === $value || false !== strpos($compare, (string) $value);
  834.     } elseif ($compare instanceof Traversable) {
  835.         if (is_object($value) || is_resource($value)) {
  836.             foreach ($compare as $item) {
  837.                 if ($item === $value) {
  838.                     return true;
  839.                 }
  840.             }
  841.         } else {
  842.             foreach ($compare as $item) {
  843.                 if ($item == $value) {
  844.                     return true;
  845.                 }
  846.             }
  847.         }
  849.         return false;
  850.     }
  852.     return false;
  853. }
  855. /**
  856.  * Returns a trimmed string.
  857.  *
  858.  * @return string
  859.  *
  860.  * @throws Twig_Error_Runtime When an invalid trimming side is used (not a string or not 'left', 'right', or 'both')
  861.  */
  862. function twig_trim_filter($string, $characterMask = null, $side = 'both')
  863. {
  864.     if (null === $characterMask) {
  865.         $characterMask = " \t\n\r\0\x0B";
  866.     }
  868.     switch ($side) {
  869.         case 'both':
  870.             return trim($string, $characterMask);
  871.         case 'left':
  872.             return ltrim($string, $characterMask);
  873.         case 'right':
  874.             return rtrim($string, $characterMask);
  875.         default:
  876.             throw new Twig_Error_Runtime('Trimming side must be "left", "right" or "both".');
  877.     }
  878. }
  880. /**
  881.  * Escapes a string.
  882.  *
  883.  * @param Twig_Environment $env
  884.  * @param mixed            $string     The value to be escaped
  885.  * @param string           $strategy   The escaping strategy
  886.  * @param string           $charset    The charset
  887.  * @param bool             $autoescape Whether the function is called by the auto-escaping feature (true) or by the developer (false)
  888.  *
  889.  * @return string
  890.  */
  891. function twig_escape_filter(Twig_Environment $env, $string, $strategy = 'html', $charset = null, $autoescape = false)
  892. {
  893.     if ($autoescape && $string instanceof Twig_Markup) {
  894.         return $string;
  895.     }
  897.     if (!is_string($string)) {
  898.         if (is_object($string) && method_exists($string, '__toString')) {
  899.             $string = (string) $string;
  900.         } elseif (in_array($strategy, array('html', 'js', 'css', 'html_attr', 'url'))) {
  901.             return $string;
  902.         }
  903.     }
  905.     if (null === $charset) {
  906.         $charset = $env->getCharset();
  907.     }
  909.     switch ($strategy) {
  910.         case 'html':
  911.             // see https://secure.php.net/htmlspecialchars
  913.             // Using a static variable to avoid initializing the array
  914.             // each time the function is called. Moving the declaration on the
  915.             // top of the function slow downs other escaping strategies.
  916.             static $htmlspecialcharsCharsets = array(
  917.                 'ISO-8859-1' => true, 'ISO8859-1' => true,
  918.                 'ISO-8859-15' => true, 'ISO8859-15' => true,
  919.                 'utf-8' => true, 'UTF-8' => true,
  920.                 'CP866' => true, 'IBM866' => true, '866' => true,
  921.                 'CP1251' => true, 'WINDOWS-1251' => true, 'WIN-1251' => true,
  922.                 '1251' => true,
  923.                 'CP1252' => true, 'WINDOWS-1252' => true, '1252' => true,
  924.                 'KOI8-R' => true, 'KOI8-RU' => true, 'KOI8R' => true,
  925.                 'BIG5' => true, '950' => true,
  926.                 'GB2312' => true, '936' => true,
  927.                 'BIG5-HKSCS' => true,
  928.                 'SHIFT_JIS' => true, 'SJIS' => true, '932' => true,
  929.                 'EUC-JP' => true, 'EUCJP' => true,
  930.                 'ISO8859-5' => true, 'ISO-8859-5' => true, 'MACROMAN' => true,
  931.             );
  933.             if (isset($htmlspecialcharsCharsets[$charset])) {
  934.                 return htmlspecialchars($string, ENT_QUOTES | ENT_SUBSTITUTE, $charset);
  935.             }
  937.             if (isset($htmlspecialcharsCharsets[strtoupper($charset)])) {
  938.                 // cache the lowercase variant for future iterations
  939.                 $htmlspecialcharsCharsets[$charset] = true;
  941.                 return htmlspecialchars($string, ENT_QUOTES | ENT_SUBSTITUTE, $charset);
  942.             }
  944.             $string = iconv($charset, 'UTF-8', $string);
  945.             $string = htmlspecialchars($string, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8');
  947.             return iconv('UTF-8', $charset, $string);
  949.         case 'js':
  950.             // escape all non-alphanumeric characters
  951.             // into their \x or \uHHHH representations
  952.             if ('UTF-8' !== $charset) {
  953.                 $string = iconv($charset, 'UTF-8', $string);
  954.             }
  956.             if (0 == strlen($string) ? false : 1 !== preg_match('/^./su', $string)) {
  957.                 throw new Twig_Error_Runtime('The string to escape is not a valid UTF-8 string.');
  958.             }
  960.             $string = preg_replace_callback('#[^a-zA-Z0-9,\._]#Su', function ($matches) {
  961.                 $char = $matches[0];
  963.                 /*
  964.                  * A few characters have short escape sequences in JSON and JavaScript.
  965.                  * Escape sequences supported only by JavaScript, not JSON, are ommitted.
  966.                  * \" is also supported but omitted, because the resulting string is not HTML safe.
  967.                  */
  968.                 static $shortMap = array(
  969.                     '\\' => '\\\\',
  970.                     '/' => '\\/',
  971.                     "\x08" => '\b',
  972.                     "\x0C" => '\f',
  973.                     "\x0A" => '\n',
  974.                     "\x0D" => '\r',
  975.                     "\x09" => '\t',
  976.                 );
  978.                 if (isset($shortMap[$char])) {
  979.                     return $shortMap[$char];
  980.                 }
  982.                 // \uHHHH
  983.                 $char = twig_convert_encoding($char, 'UTF-16BE', 'UTF-8');
  984.                 $char = strtoupper(bin2hex($char));
  986.                 if (4 >= strlen($char)) {
  987.                     return sprintf('\u%04s', $char);
  988.                 }
  990.                 return sprintf('\u%04s\u%04s', substr($char, 0, -4), substr($char, -4));
  991.             }, $string);
  993.             if ('UTF-8' !== $charset) {
  994.                 $string = iconv('UTF-8', $charset, $string);
  995.             }
  997.             return $string;
  999.         case 'css':
  1000.             if ('UTF-8' !== $charset) {
  1001.                 $string = iconv($charset, 'UTF-8', $string);
  1002.             }
  1004.             if (0 == strlen($string) ? false : 1 !== preg_match('/^./su', $string)) {
  1005.                 throw new Twig_Error_Runtime('The string to escape is not a valid UTF-8 string.');
  1006.             }
  1008.             $string = preg_replace_callback('#[^a-zA-Z0-9]#Su', function ($matches) {
  1009.                 $char = $matches[0];
  1011.                 // \xHH
  1012.                 if (!isset($char[1])) {
  1013.                     $hex = ltrim(strtoupper(bin2hex($char)), '0');
  1014.                     if (0 === strlen($hex)) {
  1015.                         $hex = '0';
  1016.                     }
  1018.                     return '\\'.$hex.' ';
  1019.                 }
  1021.                 // \uHHHH
  1022.                 $char = twig_convert_encoding($char, 'UTF-16BE', 'UTF-8');
  1024.                 return '\\'.ltrim(strtoupper(bin2hex($char)), '0').' ';
  1025.             }, $string);
  1027.             if ('UTF-8' !== $charset) {
  1028.                 $string = iconv('UTF-8', $charset, $string);
  1029.             }
  1031.             return $string;
  1033.         case 'html_attr':
  1034.             if ('UTF-8' !== $charset) {
  1035.                 $string = iconv($charset, 'UTF-8', $string);
  1036.             }
  1038.             if (0 == strlen($string) ? false : 1 !== preg_match('/^./su', $string)) {
  1039.                 throw new Twig_Error_Runtime('The string to escape is not a valid UTF-8 string.');
  1040.             }
  1042.             $string = preg_replace_callback('#[^a-zA-Z0-9,\.\-_]#Su', function ($matches) {
  1043.                 /**
  1044.                  * This function is adapted from code coming from Zend Framework.
  1045.                  *
  1046.                  * @copyright Copyright (c) 2005-2012 Zend Technologies USA Inc. (https://www.zend.com)
  1047.                  * @license   https://framework.zend.com/license/new-bsd New BSD License
  1048.                  */
  1049.                 /*
  1050.                  * While HTML supports far more named entities, the lowest common denominator
  1051.                  * has become HTML5's XML Serialisation which is restricted to the those named
  1052.                  * entities that XML supports. Using HTML entities would result in this error:
  1053.                  *     XML Parsing Error: undefined entity
  1054.                  */
  1055.                 static $entityMap = array(
  1056.                     34 => 'quot', /* quotation mark */
  1057.                     38 => 'amp',  /* ampersand */
  1058.                     60 => 'lt',   /* less-than sign */
  1059.                     62 => 'gt',   /* greater-than sign */
  1060.                 );
  1062.                 $chr = $matches[0];
  1063.                 $ord = ord($chr);
  1065.                 /*
  1066.                  * The following replaces characters undefined in HTML with the
  1067.                  * hex entity for the Unicode replacement character.
  1068.                  */
  1069.                 if (($ord <= 0x1f && "\t" != $chr && "\n" != $chr && "\r" != $chr) || ($ord >= 0x7f && $ord <= 0x9f)) {
  1070.                     return '&#xFFFD;';
  1071.                 }
  1073.                 /*
  1074.                  * Check if the current character to escape has a name entity we should
  1075.                  * replace it with while grabbing the hex value of the character.
  1076.                  */
  1077.                 if (1 == strlen($chr)) {
  1078.                     $hex = strtoupper(substr('00'.bin2hex($chr), -2));
  1079.                 } else {
  1080.                     $chr = twig_convert_encoding($chr, 'UTF-16BE', 'UTF-8');
  1081.                     $hex = strtoupper(substr('0000'.bin2hex($chr), -4));
  1082.                 }
  1084.                 $int = hexdec($hex);
  1085.                 if (array_key_exists($int, $entityMap)) {
  1086.                     return sprintf('&%s;', $entityMap[$int]);
  1087.                 }
  1089.                 /*
  1090.                  * Per OWASP recommendations, we'll use hex entities for any other
  1091.                  * characters where a named entity does not exist.
  1092.                  */
  1093.                 return sprintf('&#x%s;', $hex);
  1094.             }, $string);
  1096.             if ('UTF-8' !== $charset) {
  1097.                 $string = iconv('UTF-8', $charset, $string);
  1098.             }
  1100.             return $string;
  1102.         case 'url':
  1103.             return rawurlencode($string);
  1105.         default:
  1106.             static $escapers;
  1108.             if (null === $escapers) {
  1109.                 $escapers = $env->getExtension('Twig_Extension_Core')->getEscapers();
  1110.             }
  1112.             if (isset($escapers[$strategy])) {
  1113.                 return $escapers[$strategy]($env, $string, $charset);
  1114.             }
  1116.             $validStrategies = implode(', ', array_merge(array('html', 'js', 'url', 'css', 'html_attr'), array_keys($escapers)));
  1118.             throw new Twig_Error_Runtime(sprintf('Invalid escaping strategy "%s" (valid ones: %s).', $strategy, $validStrategies));
  1119.     }
  1120. }
  1122. /**
  1123.  * @internal
  1124.  */
  1125. function twig_escape_filter_is_safe(Twig_Node $filterArgs)
  1126. {
  1127.     foreach ($filterArgs as $arg) {
  1128.         if ($arg instanceof Twig_Node_Expression_Constant) {
  1129.             return array($arg->getAttribute('value'));
  1130.         }
  1132.         return array();
  1133.     }
  1135.     return array('html');
  1136. }
  1138. function twig_convert_encoding($string, $to, $from)
  1139. {
  1140.     return iconv($from, $to, $string);
  1141. }
  1143. /**
  1144.  * Returns the length of a variable.
  1145.  *
  1146.  * @param Twig_Environment $env   A Twig_Environment instance
  1147.  * @param mixed            $thing A variable
  1148.  *
  1149.  * @return int The length of the value
  1150.  */
  1151. function twig_length_filter(Twig_Environment $env, $thing)
  1152. {
  1153.     if (null === $thing) {
  1154.         return 0;
  1155.     }
  1157.     if (is_scalar($thing)) {
  1158.         return mb_strlen($thing, $env->getCharset());
  1159.     }
  1161.     if ($thing instanceof \SimpleXMLElement) {
  1162.         return count($thing);
  1163.     }
  1165.     if (method_exists($thing, '__toString') && !$thing instanceof \Countable) {
  1166.         return mb_strlen((string) $thing, $env->getCharset());
  1167.     }
  1169.     if ($thing instanceof \Countable || is_array($thing)) {
  1170.         return count($thing);
  1171.     }
  1173.     if ($thing instanceof \IteratorAggregate) {
  1174.         return iterator_count($thing);
  1175.     }
  1177.     return 1;
  1178. }
  1180. /**
  1181.  * Converts a string to uppercase.
  1182.  *
  1183.  * @param Twig_Environment $env
  1184.  * @param string           $string A string
  1185.  *
  1186.  * @return string The uppercased string
  1187.  */
  1188. function twig_upper_filter(Twig_Environment $env, $string)
  1189. {
  1190.     return mb_strtoupper($string, $env->getCharset());
  1191. }
  1193. /**
  1194.  * Converts a string to lowercase.
  1195.  *
  1196.  * @param Twig_Environment $env
  1197.  * @param string           $string A string
  1198.  *
  1199.  * @return string The lowercased string
  1200.  */
  1201. function twig_lower_filter(Twig_Environment $env, $string)
  1202. {
  1203.     return mb_strtolower($string, $env->getCharset());
  1204. }
  1206. /**
  1207.  * Returns a titlecased string.
  1208.  *
  1209.  * @param Twig_Environment $env
  1210.  * @param string           $string A string
  1211.  *
  1212.  * @return string The titlecased string
  1213.  */
  1214. function twig_title_string_filter(Twig_Environment $env, $string)
  1215. {
  1216.     if (null !== $charset = $env->getCharset()) {
  1217.         return mb_convert_case($string, MB_CASE_TITLE, $charset);
  1218.     }
  1220.     return ucwords(strtolower($string));
  1221. }
  1223. /**
  1224.  * Returns a capitalized string.
  1225.  *
  1226.  * @param Twig_Environment $env
  1227.  * @param string           $string A string
  1228.  *
  1229.  * @return string The capitalized string
  1230.  */
  1231. function twig_capitalize_string_filter(Twig_Environment $env, $string)
  1232. {
  1233.     $charset = $env->getCharset();
  1235.     return mb_strtoupper(mb_substr($string, 0, 1, $charset), $charset).mb_strtolower(mb_substr($string, 1, null, $charset), $charset);
  1236. }
  1238. /**
  1239.  * @internal
  1240.  */
  1241. function twig_ensure_traversable($seq)
  1242. {
  1243.     if ($seq instanceof Traversable || is_array($seq)) {
  1244.         return $seq;
  1245.     }
  1247.     return array();
  1248. }
  1250. /**
  1251.  * Checks if a variable is empty.
  1252.  *
  1253.  * <pre>
  1254.  * {# evaluates to true if the foo variable is null, false, or the empty string #}
  1255.  * {% if foo is empty %}
  1256.  *     {# ... #}
  1257.  * {% endif %}
  1258.  * </pre>
  1259.  *
  1260.  * @param mixed $value A variable
  1261.  *
  1262.  * @return bool true if the value is empty, false otherwise
  1263.  */
  1264. function twig_test_empty($value)
  1265. {
  1266.     if ($value instanceof Countable) {
  1267.         return 0 == count($value);
  1268.     }
  1270.     if (is_object($value) && method_exists($value, '__toString')) {
  1271.         return '' === (string) $value;
  1272.     }
  1274.     return '' === $value || false === $value || null === $value || array() === $value;
  1275. }
  1277. /**
  1278.  * Checks if a variable is traversable.
  1279.  *
  1280.  * <pre>
  1281.  * {# evaluates to true if the foo variable is an array or a traversable object #}
  1282.  * {% if foo is iterable %}
  1283.  *     {# ... #}
  1284.  * {% endif %}
  1285.  * </pre>
  1286.  *
  1287.  * @param mixed $value A variable
  1288.  *
  1289.  * @return bool true if the value is traversable
  1290.  */
  1291. function twig_test_iterable($value)
  1292. {
  1293.     return $value instanceof Traversable || is_array($value);
  1294. }
  1296. /**
  1297.  * Renders a template.
  1298.  *
  1299.  * @param Twig_Environment $env
  1300.  * @param array            $context
  1301.  * @param string|array     $template      The template to render or an array of templates to try consecutively
  1302.  * @param array            $variables     The variables to pass to the template
  1303.  * @param bool             $withContext
  1304.  * @param bool             $ignoreMissing Whether to ignore missing templates or not
  1305.  * @param bool             $sandboxed     Whether to sandbox the template or not
  1306.  *
  1307.  * @return string The rendered template
  1308.  */
  1309. function twig_include(Twig_Environment $env, $context, $template, $variables = array(), $withContext = true, $ignoreMissing = false, $sandboxed = false)
  1310. {
  1311.     $alreadySandboxed = false;
  1312.     $sandbox = null;
  1313.     if ($withContext) {
  1314.         $variables = array_merge($context, $variables);
  1315.     }
  1317.     if ($isSandboxed = $sandboxed && $env->hasExtension('Twig_Extension_Sandbox')) {
  1318.         $sandbox = $env->getExtension('Twig_Extension_Sandbox');
  1319.         if (!$alreadySandboxed = $sandbox->isSandboxed()) {
  1320.             $sandbox->enableSandbox();
  1321.         }
  1322.     }
  1324.     $result = null;
  1325.     try {
  1326.         $result = $env->resolveTemplate($template)->render($variables);
  1327.     } catch (Twig_Error_Loader $e) {
  1328.         if (!$ignoreMissing) {
  1329.             if ($isSandboxed && !$alreadySandboxed) {
  1330.                 $sandbox->disableSandbox();
  1331.             }
  1333.             throw $e;
  1334.         }
  1335.     } catch (Throwable $e) {
  1336.         if ($isSandboxed && !$alreadySandboxed) {
  1337.             $sandbox->disableSandbox();
  1338.         }
  1340.         throw $e;
  1341.     }
  1343.     if ($isSandboxed && !$alreadySandboxed) {
  1344.         $sandbox->disableSandbox();
  1345.     }
  1347.     return $result;
  1348. }
  1350. /**
  1351.  * Returns a template content without rendering it.
  1352.  *
  1353.  * @param Twig_Environment $env
  1354.  * @param string           $name          The template name
  1355.  * @param bool             $ignoreMissing Whether to ignore missing templates or not
  1356.  *
  1357.  * @return string The template source
  1358.  */
  1359. function twig_source(Twig_Environment $env, $name, $ignoreMissing = false)
  1360. {
  1361.     $loader = $env->getLoader();
  1362.     try {
  1363.         return $loader->getSourceContext($name)->getCode();
  1364.     } catch (Twig_Error_Loader $e) {
  1365.         if (!$ignoreMissing) {
  1366.             throw $e;
  1367.         }
  1368.     }
  1369. }
  1371. /**
  1372.  * Provides the ability to get constants from instances as well as class/global constants.
  1373.  *
  1374.  * @param string      $constant The name of the constant
  1375.  * @param null|object $object   The object to get the constant from
  1376.  *
  1377.  * @return string
  1378.  */
  1379. function twig_constant($constant, $object = null)
  1380. {
  1381.     if (null !== $object) {
  1382.         $constant = get_class($object).'::'.$constant;
  1383.     }
  1385.     return constant($constant);
  1386. }
  1388. /**
  1389.  * Checks if a constant exists.
  1390.  *
  1391.  * @param string      $constant The name of the constant
  1392.  * @param null|object $object   The object to get the constant from
  1393.  *
  1394.  * @return bool
  1395.  */
  1396. function twig_constant_is_defined($constant, $object = null)
  1397. {
  1398.     if (null !== $object) {
  1399.         $constant = get_class($object).'::'.$constant;
  1400.     }
  1402.     return defined($constant);
  1403. }
  1405. /**
  1406.  * Batches item.
  1407.  *
  1408.  * @param array $items An array of items
  1409.  * @param int   $size  The size of the batch
  1410.  * @param mixed $fill  A value used to fill missing items
  1411.  *
  1412.  * @return array
  1413.  */
  1414. function twig_array_batch($items, $size, $fill = null)
  1415. {
  1416.     if ($items instanceof Traversable) {
  1417.         $items = iterator_to_array($items, false);
  1418.     }
  1420.     $size = ceil($size);
  1422.     $result = array_chunk($items, $size, true);
  1424.     if (null !== $fill && !empty($result)) {
  1425.         $last = count($result) - 1;
  1426.         if ($fillCount = $size - count($result[$last])) {
  1427.             $result[$last] = array_merge(
  1428.                 $result[$last],
  1429.                 array_fill(0, $fillCount, $fill)
  1430.             );
  1431.         }
  1432.     }
  1434.     return $result;
  1435. }
  1437. /**
  1438.  * Returns the attribute value for a given array/object.
  1439.  *
  1440.  * @param mixed  $object            The object or array from where to get the item
  1441.  * @param mixed  $item              The item to get from the array or object
  1442.  * @param array  $arguments         An array of arguments to pass if the item is an object method
  1443.  * @param string $type              The type of attribute (@see Twig_Template constants)
  1444.  * @param bool   $isDefinedTest     Whether this is only a defined check
  1445.  * @param bool   $ignoreStrictCheck Whether to ignore the strict attribute check or not
  1446.  *
  1447.  * @return mixed The attribute value, or a Boolean when $isDefinedTest is true, or null when the attribute is not set and $ignoreStrictCheck is true
  1448.  *
  1449.  * @throws Twig_Error_Runtime if the attribute does not exist and Twig is running in strict mode and $isDefinedTest is false
  1450.  *
  1451.  * @internal
  1452.  */
  1453. function twig_get_attribute(Twig_Environment $env, Twig_Source $source, $object, $item, array $arguments = array(), $type = /* Twig_Template::ANY_CALL */ 'any', $isDefinedTest = false, $ignoreStrictCheck = false, $sandboxed = false)
  1454. {
  1455.     // array
  1456.     if (/* Twig_Template::METHOD_CALL */ 'method' !== $type) {
  1457.         $arrayItem = is_bool($item) || is_float($item) ? (int) $item : $item;
  1459.         if ((is_array($object) && (isset($object[$arrayItem]) || array_key_exists($arrayItem, $object)))
  1460.             || ($object instanceof ArrayAccess && isset($object[$arrayItem]))
  1461.         ) {
  1462.             if ($isDefinedTest) {
  1463.                 return true;
  1464.             }
  1466.             return $object[$arrayItem];
  1467.         }
  1469.         if (/* Twig_Template::ARRAY_CALL */ 'array' === $type || !is_object($object)) {
  1470.             if ($isDefinedTest) {
  1471.                 return false;
  1472.             }
  1474.             if ($ignoreStrictCheck || !$env->isStrictVariables()) {
  1475.                 return;
  1476.             }
  1478.             if ($object instanceof ArrayAccess) {
  1479.                 $message = sprintf('Key "%s" in object with ArrayAccess of class "%s" does not exist.', $arrayItem, get_class($object));
  1480.             } elseif (is_object($object)) {
  1481.                 $message = sprintf('Impossible to access a key "%s" on an object of class "%s" that does not implement ArrayAccess interface.', $item, get_class($object));
  1482.             } elseif (is_array($object)) {
  1483.                 if (empty($object)) {
  1484.                     $message = sprintf('Key "%s" does not exist as the array is empty.', $arrayItem);
  1485.                 } else {
  1486.                     $message = sprintf('Key "%s" for array with keys "%s" does not exist.', $arrayItem, implode(', ', array_keys($object)));
  1487.                 }
  1488.             } elseif (/* Twig_Template::ARRAY_CALL */ 'array' === $type) {
  1489.                 if (null === $object) {
  1490.                     $message = sprintf('Impossible to access a key ("%s") on a null variable.', $item);
  1491.                 } else {
  1492.                     $message = sprintf('Impossible to access a key ("%s") on a %s variable ("%s").', $item, gettype($object), $object);
  1493.                 }
  1494.             } elseif (null === $object) {
  1495.                 $message = sprintf('Impossible to access an attribute ("%s") on a null variable.', $item);
  1496.             } else {
  1497.                 $message = sprintf('Impossible to access an attribute ("%s") on a %s variable ("%s").', $item, gettype($object), $object);
  1498.             }
  1500.             throw new Twig_Error_Runtime($message, -1, $source);
  1501.         }
  1502.     }
  1504.     if (!is_object($object)) {
  1505.         if ($isDefinedTest) {
  1506.             return false;
  1507.         }
  1509.         if ($ignoreStrictCheck || !$env->isStrictVariables()) {
  1510.             return;
  1511.         }
  1513.         if (null === $object) {
  1514.             $message = sprintf('Impossible to invoke a method ("%s") on a null variable.', $item);
  1515.         } elseif (is_array($object)) {
  1516.             $message = sprintf('Impossible to invoke a method ("%s") on an array.', $item);
  1517.         } else {
  1518.             $message = sprintf('Impossible to invoke a method ("%s") on a %s variable ("%s").', $item, gettype($object), $object);
  1519.         }
  1521.         throw new Twig_Error_Runtime($message, -1, $source);
  1522.     }
  1524.     if ($object instanceof Twig_Template) {
  1525.         throw new Twig_Error_Runtime('Accessing Twig_Template attributes is forbidden.');
  1526.     }
  1528.     // object property
  1529.     if (/* Twig_Template::METHOD_CALL */ 'method' !== $type) {
  1530.         if (isset($object->$item) || array_key_exists((string) $item, $object)) {
  1531.             if ($isDefinedTest) {
  1532.                 return true;
  1533.             }
  1535.             if ($sandboxed) {
  1536.                 $env->getExtension('Twig_Extension_Sandbox')->checkPropertyAllowed($object, $item);
  1537.             }
  1539.             return $object->$item;
  1540.         }
  1541.     }
  1543.     static $cache = array();
  1545.     $class = get_class($object);
  1547.     // object method
  1548.     // precedence: getXxx() > isXxx() > hasXxx()
  1549.     if (!isset($cache[$class])) {
  1550.         $methods = get_class_methods($object);
  1551.         sort($methods);
  1552.         $lcMethods = array_map('strtolower', $methods);
  1553.         $classCache = array();
  1554.         foreach ($methods as $i => $method) {
  1555.             $classCache[$method] = $method;
  1556.             $classCache[$lcName = $lcMethods[$i]] = $method;
  1558.             if ('g' === $lcName[0] && 0 === strpos($lcName, 'get')) {
  1559.                 $name = substr($method, 3);
  1560.                 $lcName = substr($lcName, 3);
  1561.             } elseif ('i' === $lcName[0] && 0 === strpos($lcName, 'is')) {
  1562.                 $name = substr($method, 2);
  1563.                 $lcName = substr($lcName, 2);
  1564.             } elseif ('h' === $lcName[0] && 0 === strpos($lcName, 'has')) {
  1565.                 $name = substr($method, 3);
  1566.                 $lcName = substr($lcName, 3);
  1567.                 if (in_array('is'.$lcName, $lcMethods)) {
  1568.                     continue;
  1569.                 }
  1570.             } else {
  1571.                 continue;
  1572.             }
  1574.             // skip get() and is() methods (in which case, $name is empty)
  1575.             if ($name) {
  1576.                 if (!isset($classCache[$name])) {
  1577.                     $classCache[$name] = $method;
  1578.                 }
  1580.                 if (!isset($classCache[$lcName])) {
  1581.                     $classCache[$lcName] = $method;
  1582.                 }
  1583.             }
  1584.         }
  1585.         $cache[$class] = $classCache;
  1586.     }
  1588.     $call = false;
  1589.     if (isset($cache[$class][$item])) {
  1590.         $method = $cache[$class][$item];
  1591.     } elseif (isset($cache[$class][$lcItem = strtolower($item)])) {
  1592.         $method = $cache[$class][$lcItem];
  1593.     } elseif (isset($cache[$class]['__call'])) {
  1594.         $method = $item;
  1595.         $call = true;
  1596.     } else {
  1597.         if ($isDefinedTest) {
  1598.             return false;
  1599.         }
  1601.         if ($ignoreStrictCheck || !$env->isStrictVariables()) {
  1602.             return;
  1603.         }
  1605.         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);
  1606.     }
  1608.     if ($isDefinedTest) {
  1609.         return true;
  1610.     }
  1612.     if ($sandboxed) {
  1613.         $env->getExtension('Twig_Extension_Sandbox')->checkMethodAllowed($object, $method);
  1614.     }
  1616.     // Some objects throw exceptions when they have __call, and the method we try
  1617.     // to call is not supported. If ignoreStrictCheck is true, we should return null.
  1618.     try {
  1619.         $ret = $object->$method(...$arguments);
  1620.     } catch (BadMethodCallException $e) {
  1621.         if ($call && ($ignoreStrictCheck || !$env->isStrictVariables())) {
  1622.             return;
  1623.         }
  1624.         throw $e;
  1625.     }
  1627.     return $ret;
  1628. }
  1630. class_alias('Twig_Extension_Core', 'Twig\Extension\CoreExtension', false);