pictcode

<?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);

        }

}