1. sfViewParameterHolder.class.php
  2. /**
 * sfViewParameterHolder stores all variables that will be available to the template.
 *
 * It can also escape variables with an escaping method.
 *
 * @package    symfony
 * @subpackage view
 * @author     Fabien Potencier 
 * @version    SVN: $Id: sfViewParameterHolder.class.php 21884 2009-09-11 07:38:24Z fabien $
 */
  3. class sfViewParameterHolder extends sfParameterHolder
  4. {
  5.   protected
  6.     $dispatcher     = null,
  7.     $escaping       = null,
  8.     $escapingMethod = null;
  10.   /**
  11.    * Constructor.
  12.    */
  13.   public function __construct(sfEventDispatcher $dispatcher, $parameters = array(), $options = array())
  14.   {
  15.     $this->initialize($dispatcher, $parameters, $options);
  16.   }
  18.   /**
  19.    * Initializes this view parameter holder.
  20.    *
  21.    * @param  sfEventDispatcher $dispatcher  An sfEventDispatcher instance.
  22.    * @param  array             $parameters  An associative array of initialization parameters.
  23.    * @param  array             $options     An associative array of options.
  24.    *
  25.    * <b>Options:</b>
  26.    *
  27.    * # <b>escaping_strategy</b> - [off]              - The escaping strategy (on or off)
  28.    * # <b>escaping_method</b>   - [ESC_SPECIALCHARS] - The escaping method (ESC_RAW, ESC_ENTITIES, ESC_JS, ESC_JS_NO_ENTITIES, or ESC_SPECIALCHARS)
  29.    *
  30.    * @return bool true, if initialization completes successfully, otherwise false.
  31.    *
  32.    * @throws sfInitializationException If an error occurs while initializing this view parameter holder.
  33.    */
  34.   public function initialize(sfEventDispatcher $dispatcher, $parameters = array(), $options = array())
  35.   {
  36.     $this->dispatcher = $dispatcher;
  38.     $this->add($parameters);
  40.     $this->setEscaping(isset($options['escaping_strategy']) ? $options['escaping_strategy'] : false);
  41.     $this->setEscapingMethod(isset($options['escaping_method']) ? $options['escaping_method'] : 'ESC_SPECIALCHARS');
  42.   }
  44.   /**
  45.    * Returns true if the current object acts as an escaper.
  46.    *
  47.    * @return bool true if the current object acts as an escaper, false otherwise
  48.    */
  49.   public function isEscaped()
  50.   {
  51.     return in_array($this->getEscaping(), array('on', 'true', true), true);
  52.   }
  54.   /**
  55.    * Returns an array representation of the view parameters.
  56.    *
  57.    * @return array An array of view parameters
  58.    *
  59.    * @throws InvalidArgumentException
  60.    */
  61.   public function toArray()
  62.   {
  63.     $event = $this->dispatcher->filter(new sfEvent($this, 'template.filter_parameters'), $this->getAll());
  64.     $parameters = $event->getReturnValue();
  65.     $attributes = array();
  67.     if ($this->isEscaped())
  68.     {
  69.       $attributes['sf_data'] = sfOutputEscaper::escape($this->getEscapingMethod(), $parameters);
  70.       foreach ($attributes['sf_data'] as $key => $value)
  71.       {
  72.         $attributes[$key] = $value;
  73.       }
  74.     }
  75.     else if (in_array($this->getEscaping(), array('off', false), true))
  76.     {
  77.       $attributes = $parameters;
  78.       $attributes['sf_data'] = sfOutputEscaper::escape(ESC_RAW, $parameters);
  79.     }
  80.     else
  81.     {
  82.       throw new InvalidArgumentException(sprintf('Unknown strategy "%s".', $this->getEscaping()));
  83.     }
  85.     return $attributes;
  86.   }
  88.   /**
  89.    * Gets the default escaping strategy associated with this view.
  90.    *
  91.    * The escaping strategy specifies how the variables get passed to the view.
  92.    *
  93.    * @return string the escaping strategy
  94.    */
  95.   public function getEscaping()
  96.   {
  97.     return $this->escaping;
  98.   }
  100.   /**
  101.    * Sets the escape character strategy.
  102.    *
  103.    * @param string $escaping  Escape code
  104.    */
  105.   public function setEscaping($escaping)
  106.   {
  107.     $this->escaping = $escaping;
  108.   }
  110.   /**
  111.    * Returns the name of the function that is to be used as the escaping method.
  112.    *
  113.    * If the escaping method is empty, then that is returned. The default value
  114.    * specified by the sub-class will be used. If the method does not exist (in
  115.    * the sense there is no define associated with the method), an exception is
  116.    * thrown.
  117.    *
  118.    * @return string The escaping method as the name of the function to use
  119.    *
  120.    * @throws InvalidArgumentException If the method does not exist
  121.    */
  122.   public function getEscapingMethod()
  123.   {
  124.     if (empty($this->escapingMethod))
  125.     {
  126.       return $this->escapingMethod;
  127.     }
  129.     if (!defined($this->escapingMethod))
  130.     {
  131.       throw new InvalidArgumentException(sprintf('The escaping method "%s" is not available.', $this->escapingMethod));
  132.     }
  134.     return constant($this->escapingMethod);
  135.   }
  137.   /**
  138.    * Sets the escaping method for the current view.
  139.    *
  140.    * @param string $method  Method for escaping
  141.    */
  142.   public function setEscapingMethod($method)
  143.   {
  144.     $this->escapingMethod = $method;
  145.   }
  147.   /**
  148.    * Serializes the current instance.
  149.    *
  150.    * @return array Objects instance
  151.    */
  152.   public function serialize()
  153.   {
  154.     return serialize(array($this->getAll(), $this->escapingMethod, $this->escaping));
  155.   }
  157.   /**
  158.    * Unserializes a sfViewParameterHolder instance.
  159.    *
  160.    * @param string $serialized The serialized instance data
  161.    */
  162.   public function unserialize($serialized)
  163.   {
  164.     list($this->parameters, $escapingMethod, $escaping) = unserialize($serialized);
  166.     $this->initialize(sfContext::hasInstance() ? sfContext::getInstance()->getEventDispatcher() : new sfEventDispatcher());
  168.     $this->setEscapingMethod($escapingMethod);
  169.     $this->setEscaping($escaping);
  170.   }
  171. }
Debug toolbar