Subversion Repositories SmartDukaan

<?php
/**
 * CakeValidationSet.
 *
 * Provides the Model validation logic.
 *
 * CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
 * Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
 *
 * Licensed under The MIT License
 * For full copyright and license information, please see the LICENSE.txt
 * Redistributions of files must retain the above copyright notice.
 *
 * @copyright     Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
 * @link          http://cakephp.org CakePHP(tm) Project
 * @package       Cake.Model.Validator
 * @since         CakePHP(tm) v 2.2.0
 * @license       http://www.opensource.org/licenses/mit-license.php MIT License
 */

App::uses('CakeValidationRule', 'Model/Validator');

/**
 * CakeValidationSet object. Holds all validation rules for a field and exposes
 * methods to dynamically add or remove validation rules
 *
 * @package       Cake.Model.Validator
 * @link          http://book.cakephp.org/2.0/en/data-validation.html
 */
class CakeValidationSet implements ArrayAccess, IteratorAggregate, Countable {

/**
 * Holds the CakeValidationRule objects
 *
 * @var array
 */
        protected $_rules = array();

/**
 * List of methods available for validation
 *
 * @var array
 */
        protected $_methods = array();

/**
 * I18n domain for validation messages.
 *
 * @var string
 */
        protected $_validationDomain = null;

/**
 * Whether the validation is stopped
 *
 * @var bool
 */
        public $isStopped = false;

/**
 * Holds the fieldname
 *
 * @var string
 */
        public $field = null;

/**
 * Holds the original ruleSet
 *
 * @var array
 */
        public $ruleSet = array();

/**
 * Constructor
 *
 * @param string $fieldName The fieldname.
 * @param array $ruleSet Rules set.
 */
        public function __construct($fieldName, $ruleSet) {
                $this->field = $fieldName;

                if (!is_array($ruleSet) || (is_array($ruleSet) && isset($ruleSet['rule']))) {
                        $ruleSet = array($ruleSet);
                }

                foreach ($ruleSet as $index => $validateProp) {
                        $this->_rules[$index] = new CakeValidationRule($validateProp);
                }
                $this->ruleSet = $ruleSet;
        }

/**
 * Sets the list of methods to use for validation
 *
 * @param array &$methods Methods list
 * @return void
 */
        public function setMethods(&$methods) {
                $this->_methods =& $methods;
        }

/**
 * Sets the I18n domain for validation messages.
 *
 * @param string $validationDomain The validation domain to be used.
 * @return void
 */
        public function setValidationDomain($validationDomain) {
                $this->_validationDomain = $validationDomain;
        }

/**
 * Runs all validation rules in this set and returns a list of
 * validation errors
 *
 * @param array $data Data array
 * @param bool $isUpdate Is record being updated or created
 * @return array list of validation errors for this field
 */
        public function validate($data, $isUpdate = false) {
                $this->reset();
                $errors = array();
                foreach ($this->getRules() as $name => $rule) {
                        $rule->isUpdate($isUpdate);
                        if ($rule->skip()) {
                                continue;
                        }

                        $checkRequired = $rule->checkRequired($this->field, $data);
                        if (!$checkRequired && array_key_exists($this->field, $data)) {
                                if ($rule->checkEmpty($this->field, $data)) {
                                        break;
                                }
                                $rule->process($this->field, $data, $this->_methods);
                        }

                        if ($checkRequired || !$rule->isValid()) {
                                $errors[] = $this->_processValidationResponse($name, $rule);
                                if ($rule->isLast()) {
                                        break;
                                }
                        }
                }

                return $errors;
        }

/**
 * Resets internal state for all validation rules in this set
 *
 * @return void
 */
        public function reset() {
                foreach ($this->getRules() as $rule) {
                        $rule->reset();
                }
        }

/**
 * Gets a rule for a given name if exists
 *
 * @param string $name Field name.
 * @return CakeValidationRule
 */
        public function getRule($name) {
                if (!empty($this->_rules[$name])) {
                        return $this->_rules[$name];
                }
        }

/**
 * Returns all rules for this validation set
 *
 * @return array
 */
        public function getRules() {
                return $this->_rules;
        }

/**
 * Sets a CakeValidationRule $rule with a $name
 *
 * ## Example:
 *
 * ```
 *              $set
 *                      ->setRule('required', array('rule' => 'notBlank', 'required' => true))
 *                      ->setRule('between', array('rule' => array('lengthBetween', 4, 10))
 * ```
 *
 * @param string $name The name under which the rule should be set
 * @param CakeValidationRule|array $rule The validation rule to be set
 * @return $this
 */
        public function setRule($name, $rule) {
                if (!($rule instanceof CakeValidationRule)) {
                        $rule = new CakeValidationRule($rule);
                }
                $this->_rules[$name] = $rule;
                return $this;
        }

/**
 * Removes a validation rule from the set
 *
 * ## Example:
 *
 * ```
 *              $set
 *                      ->removeRule('required')
 *                      ->removeRule('inRange')
 * ```
 *
 * @param string $name The name under which the rule should be unset
 * @return $this
 */
        public function removeRule($name) {
                unset($this->_rules[$name]);
                return $this;
        }

/**
 * Sets the rules for a given field
 *
 * ## Example:
 *
 * ```
 *              $set->setRules(array(
 *                      'required' => array('rule' => 'notBlank', 'required' => true),
 *                      'inRange' => array('rule' => array('between', 4, 10)
 *              ));
 * ```
 *
 * @param array $rules The rules to be set
 * @param bool $mergeVars [optional] If true, merges vars instead of replace. Defaults to true.
 * @return $this
 */
        public function setRules($rules = array(), $mergeVars = true) {
                if ($mergeVars === false) {
                        $this->_rules = array();
                }
                foreach ($rules as $name => $rule) {
                        $this->setRule($name, $rule);
                }
                return $this;
        }

/**
 * Fetches the correct error message for a failed validation
 *
 * @param string $name the name of the rule as it was configured
 * @param CakeValidationRule $rule the object containing validation information
 * @return string
 */
        protected function _processValidationResponse($name, $rule) {
                $message = $rule->getValidationResult();
                if (is_string($message)) {
                        return $message;
                }
                $message = $rule->message;

                if ($message !== null) {
                        $args = null;
                        if (is_array($message)) {
                                $result = $message[0];
                                $args = array_slice($message, 1);
                        } else {
                                $result = $message;
                        }
                        if (is_array($rule->rule) && $args === null) {
                                $args = array_slice($rule->rule, 1);
                        }
                        $args = $this->_translateArgs($args);

                        $message = __d($this->_validationDomain, $result, $args);
                } elseif (is_string($name)) {
                        if (is_array($rule->rule)) {
                                $args = array_slice($rule->rule, 1);
                                $args = $this->_translateArgs($args);
                                $message = __d($this->_validationDomain, $name, $args);
                        } else {
                                $message = __d($this->_validationDomain, $name);
                        }
                } else {
                        $message = __d('cake', 'This field cannot be left blank');
                }

                return $message;
        }

/**
 * Applies translations to validator arguments.
 *
 * @param array $args The args to translate
 * @return array Translated args.
 */
        protected function _translateArgs($args) {
                foreach ((array)$args as $k => $arg) {
                        if (is_string($arg)) {
                                $args[$k] = __d($this->_validationDomain, $arg);
                        }
                }
                return $args;
        }

/**
 * Returns whether an index exists in the rule set
 *
 * @param string $index name of the rule
 * @return bool
 */
        public function offsetExists($index) {
                return isset($this->_rules[$index]);
        }

/**
 * Returns a rule object by its index
 *
 * @param string $index name of the rule
 * @return CakeValidationRule
 */
        public function offsetGet($index) {
                return $this->_rules[$index];
        }

/**
 * Sets or replace a validation rule.
 *
 * This is a wrapper for ArrayAccess. Use setRule() directly for
 * chainable access.
 *
 * @param string $index Name of the rule.
 * @param CakeValidationRule|array $rule Rule to add to $index.
 * @return void
 * @see http://www.php.net/manual/en/arrayobject.offsetset.php
 */
        public function offsetSet($index, $rule) {
                $this->setRule($index, $rule);
        }

/**
 * Unsets a validation rule
 *
 * @param string $index name of the rule
 * @return void
 */
        public function offsetUnset($index) {
                unset($this->_rules[$index]);
        }

/**
 * Returns an iterator for each of the rules to be applied
 *
 * @return ArrayIterator
 */
        public function getIterator() {
                return new ArrayIterator($this->_rules);
        }

/**
 * Returns the number of rules in this set
 *
 * @return int
 */
        public function count() {
                return count($this->_rules);
        }

}