Code Coverage
 
Classes and Traits
Functions and Methods
Lines
Total
0.00% covered (danger)
0.00%
0 / 1
71.43% covered (warning)
71.43%
10 / 14
CRAP
91.35% covered (success)
91.35%
169 / 185
context
0.00% covered (danger)
0.00%
0 / 1
71.43% covered (warning)
71.43%
10 / 14
94.12
91.35% covered (success)
91.35%
169 / 185
 __construct
100.00% covered (success)
100.00%
1 / 1
1
100.00% covered (success)
100.00%
2 / 2
 clear
100.00% covered (success)
100.00%
1 / 1
1
100.00% covered (success)
100.00%
4 / 4
 assign_var
100.00% covered (success)
100.00%
1 / 1
1
100.00% covered (success)
100.00%
2 / 2
 append_var
100.00% covered (success)
100.00%
1 / 1
2
100.00% covered (success)
100.00%
2 / 2
 retrieve_var
100.00% covered (success)
100.00%
1 / 1
2
100.00% covered (success)
100.00%
1 / 1
 get_data_ref
100.00% covered (success)
100.00%
1 / 1
4
100.00% covered (success)
100.00%
8 / 8
 set_num_rows
100.00% covered (success)
100.00%
1 / 1
6
100.00% covered (success)
100.00%
8 / 8
 get_root_ref
100.00% covered (success)
100.00%
1 / 1
1
100.00% covered (success)
100.00%
1 / 1
 assign_block_vars
100.00% covered (success)
100.00%
1 / 1
9
100.00% covered (success)
100.00%
22 / 22
 assign_block_vars_array
100.00% covered (success)
100.00%
1 / 1
2
100.00% covered (success)
100.00%
3 / 3
 retrieve_block_vars
0.00% covered (danger)
0.00%
0 / 1
13.08
92.31% covered (success)
92.31%
24 / 26
 find_key_index
0.00% covered (danger)
0.00%
0 / 1
16
95.83% covered (success)
95.83%
23 / 24
 alter_block_array
0.00% covered (danger)
0.00%
0 / 1
28.47
91.55% covered (success)
91.55%
65 / 71
 destroy_block_vars
0.00% covered (danger)
0.00%
0 / 1
5.32
36.36% covered (danger)
36.36%
4 / 11
<?php
/**
*
* This file is part of the phpBB Forum Software package.
*
* @copyright (c) phpBB Limited <https://www.phpbb.com>
* @license GNU General Public License, version 2 (GPL-2.0)
*
* For full copyright and license information, please see
* the docs/CREDITS.txt file.
*
*/
namespace phpbb\template;
/**
* Stores variables assigned to template.
*/
class context
{
    /**
    * variable that holds all the data we'll be substituting into
    * the compiled templates. Takes form:
    * --> $this->tpldata[block][iteration#][child][iteration#][child2][iteration#][variablename] == value
    * if it's a root-level variable, it'll be like this:
    * --> $this->tpldata[.][0][varname] == value
    *
    * @var array
    */
    private $tpldata = array('.' => array(0 => array()));
    /**
    * @var array Reference to template->tpldata['.'][0]
    */
    private $rootref;
    /**
    * @var bool
    */
    private $num_rows_is_set;
    public function __construct()
    {
        $this->clear();
    }
    /**
    * Clears template data set.
    */
    public function clear()
    {
        $this->tpldata = array('.' => array(0 => array()));
        $this->rootref = &$this->tpldata['.'][0];
        $this->num_rows_is_set = false;
    }
    /**
    * Assign a single scalar value to a single key.
    *
    * Value can be a string, an integer or a boolean.
    *
    * @param string $varname Variable name
    * @param string $varval Value to assign to variable
    * @return true
    */
    public function assign_var($varname, $varval)
    {
        $this->rootref[$varname] = $varval;
        return true;
    }
    /**
    * Append text to the string value stored in a key.
    *
    * Text is appended using the string concatenation operator (.).
    *
    * @param string $varname Variable name
    * @param string $varval Value to append to variable
    * @return true
    */
    public function append_var($varname, $varval)
    {
        $this->rootref[$varname] = (isset($this->rootref[$varname]) ? $this->rootref[$varname] : '') . $varval;
        return true;
    }
    /**
    * Retrieve a single scalar value from a single key.
    *
    * @param string $varname Variable name
    * @return mixed Variable value, or null if not set
    */
    public function retrieve_var($varname)
    {
        return isset($this->rootref[$varname]) ? $this->rootref[$varname] : null;
    }
    /**
    * Returns a reference to template data array.
    *
    * This function is public so that template renderer may invoke it.
    * Users should alter template variables via functions in \phpbb\template\template.
    *
    * Note: modifying returned array will affect data stored in the context.
    *
    * @return array template data
    */
    public function &get_data_ref()
    {
        // returning a reference directly is not
        // something php is capable of doing
        $ref = &$this->tpldata;
        if (!$this->num_rows_is_set)
        {
            /*
            * We do not set S_NUM_ROWS while adding a row, to reduce the complexity
            * If we would set it on adding, each subsequent adding would cause
            * n modifications, resulting in a O(n!) complexity, rather then O(n)
            */
            foreach ($ref as $loop_name => &$loop_data)
            {
                if ($loop_name === '.')
                {
                    continue;
                }
                $this->set_num_rows($loop_data);
            }
            $this->num_rows_is_set = true;
        }
        return $ref;
    }
    /**
    * Set S_NUM_ROWS for each row in this template block
    *
    * @param array $loop_data
    */
    protected function set_num_rows(&$loop_data)
    {
        $s_num_rows = count($loop_data);
        foreach ($loop_data as &$mod_block)
        {
            foreach ($mod_block as $sub_block_name => &$sub_block)
            {
                // If the key name is lowercase and the data is an array,
                // it could be a template loop. So we set the S_NUM_ROWS there
                // as well.
                if ($sub_block_name === strtolower($sub_block_name) && is_array($sub_block))
                {
                    $this->set_num_rows($sub_block);
                }
            }
            // Check whether we are inside a block before setting the variable
            if (isset($mod_block['S_BLOCK_NAME']))
            {
                $mod_block['S_NUM_ROWS'] = $s_num_rows;
            }
        }
    }
    /**
    * Returns a reference to template root scope.
    *
    * This function is public so that template renderer may invoke it.
    * Users should not need to invoke this function.
    *
    * Note: modifying returned array will affect data stored in the context.
    *
    * @return array template data
    */
    public function &get_root_ref()
    {
        // rootref is already a reference
        return $this->rootref;
    }
    /**
    * Assign key variable pairs from an array to a specified block
    *
    * @param string $blockname Name of block to assign $vararray to
    * @param array $vararray A hash of variable name => value pairs
    * @return true
    */
    public function assign_block_vars($blockname, array $vararray)
    {
        $this->num_rows_is_set = false;
        // For nested block, $blockcount > 0, for top-level block, $blockcount == 0
        $blocks = explode('.', $blockname);
        $blockcount = count($blocks) - 1;
        $block = &$this->tpldata;
        for ($i = 0; $i < $blockcount; $i++)
        {
            $pos = strpos($blocks[$i], '[');
            $name = ($pos !== false) ? substr($blocks[$i], 0, $pos) : $blocks[$i];
            $block = &$block[$name];
            $block_count = empty($block) ? 0 : count($block) - 1;
            $index = (!$pos || strpos($blocks[$i], '[]') === $pos) ? $block_count : (min((int) substr($blocks[$i], $pos + 1, -1), $block_count));
            $block = &$block[$index];
        }
        // $block = &$block[$blocks[$i]]; // Do not traverse the last block as it might be empty
        $name = $blocks[$i];
        // Assign S_ROW_COUNT and S_ROW_NUM
        $s_row_count = isset($block[$name]) ? count($block[$name]) : 0;
        $vararray['S_ROW_COUNT'] = $vararray['S_ROW_NUM'] = $s_row_count;
        // Assign S_FIRST_ROW
        if (!$s_row_count)
        {
            $vararray['S_FIRST_ROW'] = true;
        }
        // Assign S_BLOCK_NAME
        $vararray['S_BLOCK_NAME'] = $name;
        // Now the tricky part, we always assign S_LAST_ROW and remove the entry before
        // This is much more clever than going through the complete template data on display (phew)
        $vararray['S_LAST_ROW'] = true;
        if ($s_row_count > 0)
        {
            unset($block[$name][($s_row_count - 1)]['S_LAST_ROW']);
        }
        // Now we add the block that we're actually assigning to.
        // We're adding a new iteration to this block with the given
        // variable assignments.
        $block[$name][] = $vararray;
        return true;
    }
    /**
    * Assign key variable pairs from an array to a whole specified block loop
    *
    * @param string $blockname Name of block to assign $block_vars_array to
    * @param array $block_vars_array An array of hashes of variable name => value pairs
    * @return true
    */
    public function assign_block_vars_array($blockname, array $block_vars_array)
    {
        foreach ($block_vars_array as $vararray)
        {
            $this->assign_block_vars($blockname, $vararray);
        }
        return true;
    }
    /**
    * Retrieve key variable pairs from the specified block
    *
    * @param string $blockname Name of block to retrieve $vararray from
    * @param array $vararray An array of variable names, empty array retrieves all vars
    * @return array of hashes with variable name as key and retrieved value or null as value
    */
    public function retrieve_block_vars($blockname, array $vararray)
    {
        // For nested block, $blockcount > 0, for top-level block, $blockcount == 0
        $blocks = explode('.', $blockname);
        $blockcount = count($blocks) - 1;
        $block = $this->tpldata;
        for ($i = 0; $i <= $blockcount; $i++)
        {
            if (($pos = strpos($blocks[$i], '[')) !== false)
            {
                $name = substr($blocks[$i], 0, $pos);
                if (empty($block[$name]))
                {
                    return array();
                }
                if (strpos($blocks[$i], '[]') === $pos)
                {
                    $index = count($block[$name]) - 1;
                }
                else
                {
                    $index = min((int) substr($blocks[$i], $pos + 1, -1), count($block[$name]) - 1);
                }
            }
            else
            {
                $name = $blocks[$i];
                if (empty($block[$name]))
                {
                    return array();
                }
                $index = count($block[$name]) - 1;
            }
            $block = $block[$name];
            $block = $block[$index];
        }
        $result = array();
        if ($vararray === array())
        {
            // The calculated vars that depend on the block position are excluded from the complete block returned results
            $excluded_vars = array('S_FIRST_ROW', 'S_LAST_ROW', 'S_BLOCK_NAME', 'S_NUM_ROWS', 'S_ROW_COUNT', 'S_ROW_NUM');
            foreach ($block as $varname => $varvalue)
            {
                if ($varname === strtoupper($varname) && !is_array($varvalue) && !in_array($varname, $excluded_vars))
                {
                    $result[$varname] = $varvalue;
                }
            }
        }
        else
        {
            foreach ($vararray as $varname)
            {
                $result[$varname] = isset($block[$varname]) ? $block[$varname] : null;
            }
        }
        return $result;
    }
    /**
    * Find the index for a specified key in the innermost specified block
    *
    * @param    string    $blockname    the blockname, for example 'loop'
    * @param    mixed    $key        Key to search for
    *
    * array: KEY => VALUE [the key/value pair to search for within the loop to determine the correct position]
    *
    * int: Position [the position to search for]
    *
    * If key is false the position is set to 0
    * If key is true the position is set to the last entry
    *
    * @return mixed false if not found, index position otherwise; be sure to test with ===
    */
    public function find_key_index($blockname, $key)
    {
        // For nested block, $blockcount > 0, for top-level block, $blockcount == 0
        $blocks = explode('.', $blockname);
        $blockcount = count($blocks) - 1;
        $block = $this->tpldata;
        for ($i = 0; $i < $blockcount; $i++)
        {
            $pos = strpos($blocks[$i], '[');
            $name = ($pos !== false) ? substr($blocks[$i], 0, $pos) : $blocks[$i];
            if (!isset($block[$name]))
            {
                return false;
            }
            $index = (!$pos || strpos($blocks[$i], '[]') === $pos) ? (count($block[$name]) - 1) : (min((int) substr($blocks[$i], $pos + 1, -1), count($block[$name]) - 1));
            if (!isset($block[$name][$index]))
            {
                return false;
            }
            $block = $block[$name][$index];
        }
        if (!isset($block[$blocks[$i]]))
        {
            return false;
        }
        $block = $block[$blocks[$i]]; // Traverse the last block
        // Change key to zero (change first position) if false and to last position if true
        if (is_bool($key))
        {
            return (!$key) ? 0 : count($block) - 1;
        }
        // Get correct position if array given
        if (is_array($key))
        {
            // Search array to get correct position
            $search_key = key($key);
            $search_value = current($key);
            foreach ($block as $i => $val_ary)
            {
                if ($val_ary[$search_key] === $search_value)
                {
                    return $i;
                }
            }
        }
        return (is_int($key) && ((0 <= $key) && ($key < count($block)))) ? $key : false;
    }
    /**
    * Change already assigned key variable pair (one-dimensional - single loop entry)
    *
    * An example of how to use this function:
    * {@example alter_block_array.php}
    *
    * @param    string    $blockname    the blockname, for example 'loop'
    * @param    array    $vararray    the var array to insert/add or merge
    * @param    mixed    $key        Key to search for
    *
    * array: KEY => VALUE [the key/value pair to search for within the loop to determine the correct position]
    *
    * int: Position [the position to change or insert at directly given]
    *
    * If key is false the position is set to 0
    * If key is true the position is set to the last entry
    *
    * @param    string    $mode        Mode to execute (valid modes are 'insert', 'change' and 'delete')
    *
    *    If insert, the vararray is inserted at the given position (position counting from zero).
    *    If change, the current block gets merged with the vararray (resulting in new key/value pairs be added and existing keys be replaced by the new \value).
    *    If delete, the vararray is ignored, and the block at the given position (counting from zero) is removed.
    *
    * Since counting begins by zero, inserting at the last position will result in this array: array(vararray, last positioned array)
    * and inserting at position 1 will result in this array: array(first positioned array, vararray, following vars)
    *
    * @return bool false on error, true on success
    */
    public function alter_block_array($blockname, array $vararray, $key = false, $mode = 'insert')
    {
        $this->num_rows_is_set = false;
        // For nested block, $blockcount > 0, for top-level block, $blockcount == 0
        $blocks = explode('.', $blockname);
        $blockcount = count($blocks) - 1;
        $block = &$this->tpldata;
        for ($i = 0; $i < $blockcount; $i++)
        {
            if (($pos = strpos($blocks[$i], '[')) !== false)
            {
                $name = substr($blocks[$i], 0, $pos);
                if (strpos($blocks[$i], '[]') === $pos)
                {
                    $index = count($block[$name]) - 1;
                }
                else
                {
                    $index = min((int) substr($blocks[$i], $pos + 1, -1), count($block[$name]) - 1);
                }
            }
            else
            {
                $name = $blocks[$i];
                $index = count($block[$name]) - 1;
            }
            $block = &$block[$name];
            $block = &$block[$index];
        }
        $name = $blocks[$i];
        // If last block does not exist and we are inserting, and not searching for key, we create it empty; otherwise, nothing to do
        if (!isset($block[$name]))
        {
            if ($mode != 'insert' || is_array($key))
            {
                return false;
            }
            $block[$name] = array();
        }
        $block = &$block[$name]; // Now we can traverse the last block
        // Change key to zero (change first position) if false and to last position if true
        if ($key === false || $key === true)
        {
            $key = ($key === false) ? 0 : count($block);
        }
        // Get correct position if array given
        if (is_array($key))
        {
            // Search array to get correct position
            $search_key = key($key);
            $search_value = current($key);
            $key = null;
            foreach ($block as $i => $val_ary)
            {
                if ($val_ary[$search_key] === $search_value)
                {
                    $key = $i;
                    break;
                }
            }
            // key/value pair not found
            if ($key === null)
            {
                return false;
            }
        }
        // Insert Block
        if ($mode == 'insert')
        {
            // Make sure we are not exceeding the last iteration
            if ($key >= count($block))
            {
                $key = count($block);
                unset($block[($key - 1)]['S_LAST_ROW']);
                $vararray['S_LAST_ROW'] = true;
            }
            if ($key <= 0)
            {
                $key = 0;
                unset($block[0]['S_FIRST_ROW']);
                $vararray['S_FIRST_ROW'] = true;
            }
            // Assign S_BLOCK_NAME
            $vararray['S_BLOCK_NAME'] = $name;
            // Re-position template blocks
            for ($i = count($block); $i > $key; $i--)
            {
                $block[$i] = $block[$i-1];
                $block[$i]['S_ROW_COUNT'] = $block[$i]['S_ROW_NUM'] = $i;
            }
            // Insert vararray at given position
            $block[$key] = $vararray;
            $block[$key]['S_ROW_COUNT'] = $block[$key]['S_ROW_NUM'] = $key;
            return true;
        }
        // Which block to change?
        if ($mode == 'change')
        {
            // If key is out of bounds, do not change anything
            if ($key > count($block) || $key < 0)
            {
                return false;
            }
            if ($key == count($block))
            {
                $key--;
            }
            $block[$key] = array_merge($block[$key], $vararray);
            return true;
        }
        // Delete Block
        if ($mode == 'delete')
        {
            // If we are exceeding last iteration, do not delete anything
            if ($key > count($block) || $key < 0)
            {
                return false;
            }
            // If we are positioned at the end, we remove the last element
            if ($key == count($block))
            {
                $key--;
            }
            // We are deleting the last element in the block, so remove the block
            if (count($block) === 1)
            {
                $block = null; // unset($block); does not work on references
                return true;
            }
            // Re-position template blocks
            for ($i = $key; $i < count($block)-1; $i++)
            {
                $block[$i] = $block[$i+1];
                $block[$i]['S_ROW_COUNT'] = $block[$i]['S_ROW_NUM'] = $i;
            }
            // Remove the last element
            unset($block[$i]);
            // Set first and last elements again, in case they were removed
            $block[0]['S_FIRST_ROW'] = true;
            $block[count($block)-1]['S_LAST_ROW'] = true;
            return true;
        }
        return false;
    }
    /**
    * Reset/empty complete block
    *
    * @param string $blockname Name of block to destroy
    * @return true
    */
    public function destroy_block_vars($blockname)
    {
        $this->num_rows_is_set = false;
        if (strpos($blockname, '.') !== false)
        {
            // Nested block.
            $blocks = explode('.', $blockname);
            $blockcount = count($blocks) - 1;
            $str = &$this->tpldata;
            for ($i = 0; $i < $blockcount; $i++)
            {
                $str = &$str[$blocks[$i]];
                $str = &$str[count($str) - 1];
            }
            unset($str[$blocks[$blockcount]]);
        }
        else
        {
            // Top-level block.
            unset($this->tpldata[$blockname]);
        }
        return true;
    }
}