Data.php

<?php

namespace Smarty;

/**
 * Smarty Internal Plugin Data
 * This file contains the basic properties and methods for holding config and template variables
 */
class Data
{

	/**
	 * define variable scopes
	 */
	const SCOPE_LOCAL    = 1;
	const SCOPE_PARENT   = 2;
	const SCOPE_TPL_ROOT = 4;
	const SCOPE_ROOT     = 8;
	const SCOPE_SMARTY   = 16;
	const SCOPE_GLOBAL   = 32;

	/**
	 * Global smarty instance
	 *
	 * @var Smarty
	 */
	protected $smarty = null;

    /**
     * template variables
     *
     * @var Variable[]
     */
    public $tpl_vars = array();

    /**
     * parent data container (if any)
     *
     * @var Data
     */
    public $parent = null;

    /**
     * configuration settings
     *
     * @var string[]
     */
    public $config_vars = array();

	/**
	 * This variable will hold a stack of template variables.
	 *
	 * @var null|array
	 */
	private $_var_stack = [];

	/**
	 * This variable will hold a stack of config variables.
	 *
	 * @var null|array
	 */
	private $_config_stack = [];

	/**
	 * Default scope for new variables
	 * @var int
	 */
	protected $defaultScope = self::SCOPE_LOCAL;

	/**
	 * create Smarty data object
	 *
	 * @param Smarty|array $_parent parent template
	 * @param Smarty|Template $smarty global smarty instance
	 * @param string $name optional data block name
	 *
	 * @throws Exception
	 */
	public function __construct($_parent = null, $smarty = null, $name = null) {

		$this->smarty = $smarty;
		if (is_object($_parent)) {
			// when object set up back pointer
			$this->parent = $_parent;
		} elseif (is_array($_parent)) {
			// set up variable values
			foreach ($_parent as $_key => $_val) {
				$this->assign($_key, $_val);
			}
		} elseif ($_parent !== null) {
			throw new Exception('Wrong type for template variables');
		}
	}

	/**
	 * assigns a Smarty variable
	 *
	 * @param array|string $tpl_var the template variable name(s)
	 * @param mixed $value the value to assign
	 * @param boolean $nocache if true any output of this variable will be not cached
	 * @param int $scope one of self::SCOPE_* constants
	 *
	 * @return Data current Data (or Smarty or \Smarty\Template) instance for
	 *                              chaining
	 */
    public function assign($tpl_var, $value = null, $nocache = false, $scope = null)
    {
        if (is_array($tpl_var)) {
            foreach ($tpl_var as $_key => $_val) {
                $this->assign($_key, $_val, $nocache, $scope);
            }
			return $this;
        }
		switch ($scope ?? $this->getDefaultScope()) {
			case self::SCOPE_GLOBAL:
			case self::SCOPE_SMARTY:
				$this->getSmarty()->assign($tpl_var, $value);
				break;
			case self::SCOPE_TPL_ROOT:
				$ptr = $this;
				while (isset($ptr->parent) && ($ptr->parent instanceof Template)) {
					$ptr = $ptr->parent;
				}
				$ptr->assign($tpl_var, $value);
				break;
			case self::SCOPE_ROOT:
				$ptr = $this;
				while (isset($ptr->parent) && !($ptr->parent instanceof Smarty)) {
					$ptr = $ptr->parent;
				}
				$ptr->assign($tpl_var, $value);
				break;
			case self::SCOPE_PARENT:
				if ($this->parent) {
					$this->parent->assign($tpl_var, $value);
				} else {
					// assign local as fallback
					$this->assign($tpl_var, $value);
				}
				break;
			case self::SCOPE_LOCAL:
			default:
				if (isset($this->tpl_vars[$tpl_var])) {
					$this->tpl_vars[$tpl_var]->setValue($value);
					if ($nocache) {
						$this->tpl_vars[$tpl_var]->setNocache(true);
					}
				} else {
					$this->tpl_vars[$tpl_var] = new Variable($value, $nocache);
				}
		}

        return $this;
    }

    /**
     * appends values to template variables
     *
     * @param array|string $tpl_var the template variable name(s)
     * @param mixed        $value   the value to append
     * @param bool         $merge   flag if array elements shall be merged
     * @param bool         $nocache if true any output of this variable will
     *                              be not cached
     *
     * @return Data
     * @api  Smarty::append()
     */
	public function append($tpl_var, $value = null, $merge = false, $nocache = false)
	{
		if (is_array($tpl_var)) {
			foreach ($tpl_var as $_key => $_val) {
				$this->append($_key, $_val, $merge, $nocache);
			}
		} else {

			$newValue = $this->getValue($tpl_var) ?? [];
			if (!is_array($newValue)) {
				$newValue = (array) $newValue;
			}

			if ($merge && is_array($value)) {
				foreach ($value as $_mkey => $_mval) {
					$newValue[$_mkey] = $_mval;
				}
			} else {
				$newValue[] = $value;
			}

			$this->assign($tpl_var, $newValue, $nocache);
		}
		return $this;
	}

    /**
     * assigns a global Smarty variable
     *
     * @param string  $varName the global variable name
     * @param mixed   $value   the value to assign
     * @param boolean $nocache if true any output of this variable will be not cached
     *
     * @return Data
     * @deprecated since 5.0
     */
    public function assignGlobal($varName, $value = null, $nocache = false)
    {
		trigger_error(__METHOD__ . " is deprecated. Use \\Smarty\\Smarty::assign() to assign a variable " .
		" at the Smarty level.", E_USER_DEPRECATED);
	    return $this->getSmarty()->assign($varName, $value, $nocache);
    }

    /**
     * Returns a single or all template variables
     *
     * @param string                                                  $varName       variable name or null
     * @param bool $searchParents include parent templates?
     *
     * @return mixed variable value or or array of variables
     * @api  Smarty::getTemplateVars()
     *
     */
    public function getTemplateVars($varName = null, $searchParents = true)
    {
	    if (isset($varName)) {
			return $this->getValue($varName, $searchParents);
	    }

		return array_merge(
			$this->parent && $searchParents ? $this->parent->getTemplateVars() : [],
			array_map(function(Variable $var) { return $var->getValue(); }, $this->tpl_vars)
		);
    }

	/**
	 * Wrapper for ::getVariable()
	 *
	 * @deprecated since 5.0
	 *
	 * @param $varName
	 * @param $searchParents
	 * @param $errorEnable
	 *
	 * @return void
	 */
	public function _getVariable($varName, $searchParents = true, $errorEnable = true) {
		trigger_error('Using ::_getVariable() to is deprecated and will be ' .
			'removed in a future release. Use getVariable() instead.', E_USER_DEPRECATED);
		return $this->getVariable($varName, $searchParents, $errorEnable);
	}

	/**
	 * Gets the object of a Smarty variable
	 *
	 * @param string $varName the name of the Smarty variable
	 * @param bool $searchParents search also in parent data
	 * @param bool $errorEnable
	 *
	 * @return Variable
	 */
	public function getVariable($varName, $searchParents = true, $errorEnable = true) {
		if (isset($this->tpl_vars[$varName])) {
			return $this->tpl_vars[$varName];
		}

		if ($searchParents && $this->parent) {
			return $this->parent->getVariable($varName, $searchParents, $errorEnable);
		}

		if ($errorEnable && $this->getSmarty()->error_unassigned) {
			// force a notice
			$x = $$varName;
		}
		return new UndefinedVariable();
	}

	/**
	 * Directly sets a complete Variable object in the variable with the given name.
	 * @param $varName
	 * @param Variable $variableObject
	 *
	 * @return void
	 */
	public function setVariable($varName, Variable $variableObject) {
		$this->tpl_vars[$varName] = $variableObject;
	}

	/**
	 * Indicates if given variable has been set.
	 * @param $varName
	 *
	 * @return bool
	 */
	public function hasVariable($varName): bool {
		return !($this->getVariable($varName) instanceof UndefinedVariable);
	}

	/**
	 * Returns the value of the Smarty\Variable given by $varName, or null if the variable does not exist.
	 *
	 * @param $varName
	 * @param bool $searchParents
	 *
	 * @return mixed|null
	 */
	public function getValue($varName, $searchParents = true) {
		$variable = $this->getVariable($varName, $searchParents);
		return isset($variable) ? $variable->getValue() : null;
	}

	/**
	 * load config variables into template object
	 *
	 * @param array $new_config_vars
	 */
	public function assignConfigVars($new_config_vars, array $sections = []) {

		// copy global config vars
		foreach ($new_config_vars['vars'] as $variable => $value) {
			if ($this->getSmarty()->config_overwrite || !isset($this->config_vars[$variable])) {
				$this->config_vars[$variable] = $value;
			} else {
				$this->config_vars[$variable] = array_merge((array)$this->config_vars[$variable], (array)$value);
			}
		}

		foreach ($sections as $tpl_section) {
			if (isset($new_config_vars['sections'][$tpl_section])) {
				foreach ($new_config_vars['sections'][$tpl_section]['vars'] as $variable => $value) {
					if ($this->getSmarty()->config_overwrite || !isset($this->config_vars[$variable])) {
						$this->config_vars[$variable] = $value;
					} else {
						$this->config_vars[$variable] = array_merge((array)$this->config_vars[$variable], (array)$value);
					}
				}
			}
		}
	}

    /**
     * Get Smarty object
     *
     * @return Smarty
     */
    public function getSmarty()
    {
        return $this->smarty;
    }

	/**
	 * clear the given assigned template variable(s).
	 *
	 * @param string|array $tpl_var the template variable(s) to clear
	 *
	 * @return Data
	 *
	 * @api  Smarty::clearAssign()
	 */
	public function clearAssign($tpl_var)
	{
		if (is_array($tpl_var)) {
			foreach ($tpl_var as $curr_var) {
				unset($this->tpl_vars[ $curr_var ]);
			}
		} else {
			unset($this->tpl_vars[ $tpl_var ]);
		}
		return $this;
	}

	/**
	 * clear all the assigned template variables.
	 *
	 * @return Data
	 *
	 * @api  Smarty::clearAllAssign()
	 */
	public function clearAllAssign()
	{
		$this->tpl_vars = array();
		return $this;
	}

	/**
	 * clear a single or all config variables
	 *
	 * @param string|null $name variable name or null
	 *
	 * @return Data
	 *
	 * @api  Smarty::clearConfig()
	 */
	public function clearConfig($name = null)
	{
		if (isset($name)) {
			unset($this->config_vars[ $name ]);
		} else {
			$this->config_vars = array();
		}
		return $this;
	}

	/**
	 * Gets a config variable value
	 *
	 * @param string $varName the name of the config variable
	 *
	 * @return mixed  the value of the config variable
	 * @throws Exception
	 */
	public function getConfigVariable($varName)
	{

		if (isset($this->config_vars[$varName])) {
			return $this->config_vars[$varName];
		}

		$returnValue = $this->parent ? $this->parent->getConfigVariable($varName) : null;

		if ($returnValue === null && $this->getSmarty()->error_unassigned) {
			throw new Exception("Undefined variable $varName");
		}

		return $returnValue;
	}

	public function hasConfigVariable($varName): bool {
		try {
			return $this->getConfigVariable($varName) !== null;
		} catch (Exception $e) {
			return false;
		}
	}

	/**
	 * Returns a single or all config variables
	 *
	 * @param string $varname variable name or null
	 *
	 * @return mixed variable value or or array of variables
	 * @throws Exception
	 *
	 * @api  Smarty::getConfigVars()
	 */
	public function getConfigVars($varname = null)
	{
		if (isset($varname)) {
			return $this->getConfigVariable($varname);
		}

		return array_merge($this->parent ? $this->parent->getConfigVars() : [], $this->config_vars);
	}

	/**
	 * load a config file, optionally load just selected sections
	 *
	 * @param string $config_file filename
	 * @param mixed                                                   $sections    array of section names, single
	 *                                                                             section or null

	 * @returns $this
	 * @throws \Exception
	 *
	 * @api  Smarty::configLoad()
	 */
	public function configLoad($config_file, $sections = null)
	{
		$template = $this->getSmarty()->doCreateTemplate($config_file, null, null, $this, null, null, true);
		$template->caching = Smarty::CACHING_OFF;
		$template->assign('sections', (array) $sections ?? []);
		// trigger a call to $this->assignConfigVars
		$template->fetch();
		return $this;
	}

	/**
	 * Sets the default scope for new variables assigned in this template.
	 * @param int $scope
	 *
	 * @return void
	 */
	protected function setDefaultScope(int $scope) {
		$this->defaultScope = $scope;
	}

	/**
	 * Returns the default scope for new variables assigned in this template.
	 * @return int
	 */
	public function getDefaultScope(): int {
		return $this->defaultScope;
	}

	/**
	 * @return Data|Smarty|null
	 */
	public function getParent() {
		return $this->parent;
	}

	/**
	 * @param Data|Smarty|null $parent
	 */
	public function setParent($parent): void {
		$this->parent = $parent;
	}

	public function pushStack(): void {
		$stackList = [];
		foreach ($this->tpl_vars as $name => $variable) {
			$stackList[$name] = clone $variable; // variables are stored in Variable objects
		}
		$this->_var_stack[] = $this->tpl_vars;
		$this->tpl_vars = $stackList;

		$this->_config_stack[] = $this->config_vars;
	}

	public function popStack(): void {
		$this->tpl_vars = array_pop($this->_var_stack);
		$this->config_vars = array_pop($this->_config_stack);
	}
}