PHP ValidatorChain::addValidator方法代碼示例

 public function testValidatorChain()
 {
     $validatorChain = new ValidatorChain();
     $validatorChain->addValidator(new DigitsFilter());
     $validatorChain->addValidator(new Int());
     $filter = new Validator($validatorChain);
     $this->assertTrue($filter->filter(array('message' => '123')));
     $this->assertFalse($filter->filter(array('message' => 'test')));
 }

 /**
  * Constructor.
  *
  * @param  string  $host OPTIONAL Hostname of remote connection (default: 127.0.0.1)
  * @param  integer $port OPTIONAL Port number (default: null)
  * @throws Exception\RuntimeException
  */
 public function __construct($host = '127.0.0.1', $port = null)
 {
     $this->_validHost = new Validator\ValidatorChain();
     $this->_validHost->addValidator(new Validator\Hostname(Validator\Hostname::ALLOW_ALL));
     if (!$this->_validHost->isValid($host)) {
         throw new Exception\RuntimeException(implode(', ', $this->_validHost->getMessages()));
     }
     $this->_host = $host;
     $this->_port = $port;
 }

 /**
  * Create a new simple console route.
  *
  * @param  string                                   $route
  * @param  array                                    $constraints
  * @param  array                                    $defaults
  * @param  array                                    $aliases
  * @param  null|array|Traversable|FilterChain       $filters
  * @param  null|array|Traversable|ValidatorChain    $validators
  * @throws \Zend\Mvc\Exception\InvalidArgumentException
  * @return \Zend\Mvc\Router\Console\Simple
  */
 public function __construct($route, array $constraints = array(), array $defaults = array(), array $aliases = array(), $filters = null, $validators = null)
 {
     $this->defaults = $defaults;
     $this->constraints = $constraints;
     $this->aliases = $aliases;
     if ($filters !== null) {
         if ($filters instanceof FilterChain) {
             $this->filters = $filters;
         } elseif ($filters instanceof Traversable) {
             $this->filters = new FilterChain(array('filters' => ArrayUtils::iteratorToArray($filters, false)));
         } elseif (is_array($filters)) {
             $this->filters = new FilterChain(array('filters' => $filters));
         } else {
             throw new InvalidArgumentException('Cannot use ' . gettype($filters) . ' as filters for ' . __CLASS__);
         }
     }
     if ($validators !== null) {
         if ($validators instanceof ValidatorChain) {
             $this->validators = $validators;
         } elseif ($validators instanceof Traversable || is_array($validators)) {
             $this->validators = new ValidatorChain();
             foreach ($validators as $v) {
                 $this->validators->addValidator($v);
             }
         } else {
             throw new InvalidArgumentException('Cannot use ' . gettype($validators) . ' as validators for ' . __CLASS__);
         }
     }
     $this->parts = $this->parseRouteDefinition($route);
 }

 public function testAllowsPrependingValidatorsByName()
 {
     $this->validator->addValidator($this->getValidatorTrue())->prependByName('NotEmpty', array(), true);
     $this->assertFalse($this->validator->isValid(''));
     $messages = $this->validator->getMessages();
     $this->assertArrayHasKey('isEmpty', $messages);
 }

 /**
  * @param array $validatorRule
  * @return void
  */
 protected function _validateRule(array $validatorRule)
 {
     /**
      * Get one or more data values from input, and check for missing fields.
      * Apply defaults if fields are missing.
      */
     $data = array();
     foreach ((array) $validatorRule[self::FIELDS] as $key => $field) {
         if (array_key_exists($field, $this->_data)) {
             $data[$field] = $this->_data[$field];
         } else {
             if (isset($validatorRule[self::DEFAULT_VALUE])) {
                 /** @todo according to this code default value can't be an array. It has to be reviewed */
                 if (!is_array($validatorRule[self::DEFAULT_VALUE])) {
                     // Default value is a scalar
                     $data[$field] = $validatorRule[self::DEFAULT_VALUE];
                 } else {
                     // Default value is an array. Search for corresponding key
                     if (isset($validatorRule[self::DEFAULT_VALUE][$key])) {
                         $data[$field] = $validatorRule[self::DEFAULT_VALUE][$key];
                     } else {
                         if ($validatorRule[self::PRESENCE] == self::PRESENCE_REQUIRED) {
                             // Default value array is provided, but it doesn't have an entry for current field
                             // and presence is required
                             $this->_missingFields[$validatorRule[self::RULE]][] = $this->_getMissingMessage($validatorRule[self::RULE], $field);
                         }
                     }
                 }
             } else {
                 if ($validatorRule[self::PRESENCE] == self::PRESENCE_REQUIRED) {
                     $this->_missingFields[$validatorRule[self::RULE]][] = $this->_getMissingMessage($validatorRule[self::RULE], $field);
                 }
             }
         }
     }
     /**
      * If any required fields are missing, break the loop.
      */
     if (isset($this->_missingFields[$validatorRule[self::RULE]]) && count($this->_missingFields[$validatorRule[self::RULE]]) > 0) {
         return;
     }
     /**
      * Evaluate the inputs against the validator chain.
      */
     if (count((array) $validatorRule[self::FIELDS]) > 1) {
         if (!$validatorRule[self::ALLOW_EMPTY]) {
             $emptyFieldsFound = false;
             $errorsList = array();
             $messages = array();
             foreach ($data as $fieldKey => $field) {
                 $notEmptyValidator = $this->_getValidator('NotEmpty');
                 $notEmptyValidator->setMessage($this->_getNotEmptyMessage($validatorRule[self::RULE], $fieldKey));
                 if (!$notEmptyValidator->isValid($field)) {
                     foreach ($notEmptyValidator->getMessages() as $messageKey => $message) {
                         if (!isset($messages[$messageKey])) {
                             $messages[$messageKey] = $message;
                         } else {
                             $messages[] = $message;
                         }
                     }
                     $errorsList[] = $notEmptyValidator->getErrors();
                     $emptyFieldsFound = true;
                 }
             }
             if ($emptyFieldsFound) {
                 $this->_invalidMessages[$validatorRule[self::RULE]] = $messages;
                 $this->_invalidErrors[$validatorRule[self::RULE]] = array_unique(call_user_func_array('array_merge', $errorsList));
                 return;
             }
         }
         if (!$validatorRule[self::VALIDATOR_CHAIN]->isValid($data)) {
             $this->_invalidMessages[$validatorRule[self::RULE]] = $validatorRule[self::VALIDATOR_CHAIN]->getMessages();
             $this->_invalidErrors[$validatorRule[self::RULE]] = $validatorRule[self::VALIDATOR_CHAIN]->getErrors();
             return;
         }
     } else {
         if (count($data) > 0) {
             // $data is actually a one element array
             $fieldNames = array_keys($data);
             $fieldName = reset($fieldNames);
             $field = reset($data);
             $failed = false;
             if (!is_array($field)) {
                 $field = array($field);
             }
             $notEmptyValidator = $this->_getValidator('NotEmpty');
             $notEmptyValidator->setMessage($this->_getNotEmptyMessage($validatorRule[self::RULE], $fieldName));
             if ($validatorRule[self::ALLOW_EMPTY]) {
                 $validatorChain = $validatorRule[self::VALIDATOR_CHAIN];
             } else {
                 $validatorChain = new Validator\ValidatorChain();
                 $validatorChain->addValidator($notEmptyValidator, true);
                 $validatorChain->addValidator($validatorRule[self::VALIDATOR_CHAIN]);
             }
             foreach ($field as $value) {
                 if ($validatorRule[self::ALLOW_EMPTY] && !$notEmptyValidator->isValid($value)) {
//.........這裏部分代碼省略.........

 protected function populateValidators(ValidatorChain $chain, $validators)
 {
     foreach ($validators as $validator) {
         if ($validator instanceof ValidatorInterface) {
             $chain->addValidator($validator);
             continue;
         }
         if (is_array($validator)) {
             if (!isset($validator['name'])) {
                 throw new Exception\RuntimeException('Invalid validator specification provided; does not include "name" key');
             }
             $name = $validator['name'];
             $options = array();
             if (isset($validator['options'])) {
                 $options = $validator['options'];
             }
             $breakChainOnFailure = false;
             if (isset($validator['break_chain_on_failure'])) {
                 $breakChainOnFailure = $validator['break_chain_on_failure'];
             }
             $chain->addByName($name, $options, $breakChainOnFailure);
             continue;
         }
         throw new Exception\RuntimeException('Invalid validator specification provided; was neither a validator instance nor an array specification');
     }
 }