1. sfValidatorSchema.class.php
  2. /**
 * sfValidatorSchema represents an array of fields.
 *
 * A field is a named validator.
 *
 * @package    symfony
 * @subpackage validator
 * @author     Fabien Potencier 
 * @version    SVN: $Id: sfValidatorSchema.class.php 22446 2009-09-26 07:55:47Z fabien $
 */
  3. class sfValidatorSchema extends sfValidatorBase implements ArrayAccess
  4. {
  5.   protected
  6.     $fields        = array(),
  7.     $preValidator  = null,
  8.     $postValidator = null;
  10.   /**
  11.    * Constructor.
  12.    *
  13.    * The first argument can be:
  14.    *
  15.    *  * null
  16.    *  * an array of named sfValidatorBase instances
  17.    *
  18.    * @param mixed $fields    Initial fields
  19.    * @param array $options   An array of options
  20.    * @param array $messages  An array of error messages
  21.    *
  22.    * @see sfValidatorBase
  23.    */
  24.   public function __construct($fields = null, $options = array(), $messages = array())
  25.   {
  26.     if (is_array($fields))
  27.     {
  28.       foreach ($fields as $name => $validator)
  29.       {
  30.         $this[$name] = $validator;
  31.       }
  32.     }
  33.     else if (null !== $fields)
  34.     {
  35.       throw new InvalidArgumentException('sfValidatorSchema constructor takes an array of sfValidatorBase objects.');
  36.     }
  38.     parent::__construct($options, $messages);
  39.   }
  41.   /**
  42.    * Configures the validator.
  43.    *
  44.    * Available options:
  45.    *
  46.    *  * allow_extra_fields:  if false, the validator adds an error if extra fields are given in the input array of values (default to false)
  47.    *  * filter_extra_fields: if true, the validator filters extra fields from the returned array of cleaned values (default to true)
  48.    *
  49.    * Available error codes:
  50.    *
  51.    *  * extra_fields
  52.    *
  53.    * @param array $options   An array of options
  54.    * @param array $messages  An array of error messages
  55.    *
  56.    * @see sfValidatorBase
  57.    */
  58.   protected function configure($options = array(), $messages = array())
  59.   {
  60.     $this->addOption('allow_extra_fields', false);
  61.     $this->addOption('filter_extra_fields', true);
  63.     $this->addMessage('extra_fields', 'Unexpected extra form field named "%field%".');
  64.     $this->addMessage('post_max_size', 'The form submission cannot be processed. It probably means that you have uploaded a file that is too big.');
  65.   }
  67.   /**
  68.    * @see sfValidatorBase
  69.    */
  70.   public function clean($values)
  71.   {
  72.     return $this->doClean($values);
  73.   }
  75.   /**
  76.    * @see sfValidatorBase
  77.    */
  78.   protected function doClean($values)
  79.   {
  80.     if (null === $values)
  81.     {
  82.       $values = array();
  83.     }
  85.     if (!is_array($values))
  86.     {
  87.       throw new InvalidArgumentException('You must pass an array parameter to the clean() method');
  88.     }
  90.     $clean  = array();
  91.     $unused = array_keys($this->fields);
  92.     $errorSchema = new sfValidatorErrorSchema($this);
  94.     // check that post_max_size has not been reached
  95.     if (isset($_SERVER['CONTENT_LENGTH']) && (int) $_SERVER['CONTENT_LENGTH'] > $this->getBytes(ini_get('post_max_size')))
  96.     {
  97.       $errorSchema->addError(new sfValidatorError($this, 'post_max_size'));
  99.       throw $errorSchema;
  100.     }
  102.     // pre validator
  103.     try
  104.     {
  105.       $this->preClean($values);
  106.     }
  107.     catch (sfValidatorErrorSchema $e)
  108.     {
  109.       $errorSchema->addErrors($e);
  110.     }
  111.     catch (sfValidatorError $e)
  112.     {
  113.       $errorSchema->addError($e);
  114.     }
  116.     // validate given values
  117.     foreach ($values as $name => $value)
  118.     {
  119.       // field exists in our schema?
  120.       if (!array_key_exists($name, $this->fields))
  121.       {
  122.         if (!$this->options['allow_extra_fields'])
  123.         {
  124.           $errorSchema->addError(new sfValidatorError($this, 'extra_fields', array('field' => $name)));
  125.         }
  126.         else if (!$this->options['filter_extra_fields'])
  127.         {
  128.           $clean[$name] = $value;
  129.         }
  131.         continue;
  132.       }
  134.       unset($unused[array_search($name, $unused, true)]);
  136.       // validate value
  137.       try
  138.       {
  139.         $clean[$name] = $this->fields[$name]->clean($value);
  140.       }
  141.       catch (sfValidatorError $e)
  142.       {
  143.         $clean[$name] = null;
  145.         $errorSchema->addError($e, (string) $name);
  146.       }
  147.     }
  149.     // are non given values required?
  150.     foreach ($unused as $name)
  151.     {
  152.       // validate value
  153.       try
  154.       {
  155.         $clean[$name] = $this->fields[$name]->clean(null);
  156.       }
  157.       catch (sfValidatorError $e)
  158.       {
  159.         $clean[$name] = null;
  161.         $errorSchema->addError($e, (string) $name);
  162.       }
  163.     }
  165.     // post validator
  166.     try
  167.     {
  168.       $clean = $this->postClean($clean);
  169.     }
  170.     catch (sfValidatorErrorSchema $e)
  171.     {
  172.       $errorSchema->addErrors($e);
  173.     }
  174.     catch (sfValidatorError $e)
  175.     {
  176.       $errorSchema->addError($e);
  177.     }
  179.     if (count($errorSchema))
  180.     {
  181.       throw $errorSchema;
  182.     }
  184.     return $clean;
  185.   }
  187.   /**
  188.    * Cleans the input values.
  189.    *
  190.    * This method is the first validator executed by doClean().
  191.    *
  192.    * It executes the validator returned by getPreValidator()
  193.    * on the global array of values.
  194.    *
  195.    * @param  array $values  The input values
  196.    *
  197.    * @throws sfValidatorError
  198.    */
  199.   public function preClean($values)
  200.   {
  201.     if (null === $validator = $this->getPreValidator())
  202.     {
  203.       return;
  204.     }
  206.     $validator->clean($values);
  207.   }
  209.   /**
  210.    * Cleans the input values.
  211.    *
  212.    * This method is the last validator executed by doClean().
  213.    *
  214.    * It executes the validator returned by getPostValidator()
  215.    * on the global array of cleaned values.
  216.    *
  217.    * @param  array $values  The input values
  218.    *
  219.    * @throws sfValidatorError
  220.    */
  221.   public function postClean($values)
  222.   {
  223.     if (null === $validator = $this->getPostValidator())
  224.     {
  225.       return $values;
  226.     }
  228.     return $validator->clean($values);
  229.   }
  231.   /**
  232.    * Sets the pre validator.
  233.    *
  234.    * @param sfValidatorBase $validator  An sfValidatorBase instance
  235.    *
  236.    * @return sfValidatorBase The current validator instance
  237.    */
  238.   public function setPreValidator(sfValidatorBase $validator)
  239.   {
  240.     $this->preValidator = clone $validator;
  242.     return $this;
  243.   }
  245.   /**
  246.    * Returns the pre validator.
  247.    *
  248.    * @return sfValidatorBase A sfValidatorBase instance
  249.    */
  250.   public function getPreValidator()
  251.   {
  252.     return $this->preValidator;
  253.   }
  255.   /**
  256.    * Sets the post validator.
  257.    *
  258.    * @param sfValidatorBase $validator  An sfValidatorBase instance
  259.    *
  260.    * @return sfValidatorBase The current validator instance
  261.    */
  262.   public function setPostValidator(sfValidatorBase $validator)
  263.   {
  264.     $this->postValidator = clone $validator;
  266.     return $this;
  267.   }
  269.   /**
  270.    * Returns the post validator.
  271.    *
  272.    * @return sfValidatorBase An sfValidatorBase instance
  273.    */
  274.   public function getPostValidator()
  275.   {
  276.     return $this->postValidator;
  277.   }
  279.   /**
  280.    * Returns true if the schema has a field with the given name (implements the ArrayAccess interface).
  281.    *
  282.    * @param  string  $name  The field name
  283.    *
  284.    * @return bool true if the schema has a field with the given name, false otherwise
  285.    */
  286.   public function offsetExists($name)
  287.   {
  288.     return isset($this->fields[$name]);
  289.   }
  291.   /**
  292.    * Gets the field associated with the given name (implements the ArrayAccess interface).
  293.    *
  294.    * @param  string $name  The field name
  295.    *
  296.    * @return sfValidatorBase The sfValidatorBase instance associated with the given name, null if it does not exist
  297.    */
  298.   public function offsetGet($name)
  299.   {
  300.     return isset($this->fields[$name]) ? $this->fields[$name] : null;
  301.   }
  303.   /**
  304.    * Sets a field (implements the ArrayAccess interface).
  305.    *
  306.    * @param string          $name       The field name
  307.    * @param sfValidatorBase $validator  An sfValidatorBase instance
  308.    */
  309.   public function offsetSet($name, $validator)
  310.   {
  311.     if (!$validator instanceof sfValidatorBase)
  312.     {
  313.       throw new InvalidArgumentException('A field must be an instance of sfValidatorBase.');
  314.     }
  316.     $this->fields[$name] = clone $validator;
  317.   }
  319.   /**
  320.    * Removes a field by name (implements the ArrayAccess interface).
  321.    *
  322.    * @param string $name
  323.    */
  324.   public function offsetUnset($name)
  325.   {
  326.     unset($this->fields[$name]);
  327.   }
  329.   /**
  330.    * Returns an array of fields.
  331.    *
  332.    * @return sfValidatorBase An array of sfValidatorBase instances
  333.    */
  334.   public function getFields()
  335.   {
  336.     return $this->fields;
  337.   }
  339.   /**
  340.    * @see sfValidatorBase
  341.    */
  342.   public function asString($indent = 0)
  343.   {
  344.     throw new Exception('Unable to convert a sfValidatorSchema to string.');
  345.   }
  347.   public function __clone()
  348.   {
  349.     foreach ($this->fields as $name => $field)
  350.     {
  351.       $this->fields[$name] = clone $field;
  352.     }
  354.     if (null !== $this->preValidator)
  355.     {
  356.       $this->preValidator = clone $this->preValidator;
  357.     }
  359.     if (null !== $this->postValidator)
  360.     {
  361.       $this->postValidator = clone $this->postValidator;
  362.     }
  363.   }
  365.   protected function getBytes($value)
  366.   {
  367.     $value = trim($value);
  368.     switch (strtolower($value[strlen($value) - 1]))
  369.     {
  370.       // The 'G' modifier is available since PHP 5.1.0
  371.       case 'g':
  372.         $value *= 1024;
  373.       case 'm':
  374.         $value *= 1024;
  375.       case 'k':
  376.         $value *= 1024;
  377.     }
  379.     return $value;
  380.   }
  381. }
Debug toolbar