PHP AbstractValidator::getDefaultTranslator方法代码示例

 public function testDefaultTranslator()
 {
     $translator = $this->createMock('Zend\\Mvc\\I18n\\Translator');
     $application = \Library\Application::init('Console', true);
     // Run test initializion after application initialization because it
     // would be overwritten otherwise
     \Zend\Validator\AbstractValidator::setDefaultTranslator(null);
     $serviceManager = $application->getServiceManager();
     $serviceManager->setAllowOverride(true);
     $serviceManager->setService('MvcTranslator', $translator);
     // Invoke bootstrap event handler manually. It has already been run
     // during application initialization, but we changed the default
     // translator in the meantime.
     (new \Console\Module())->onBootstrap($application->getMvcEvent());
     $this->assertSame($translator, \Zend\Validator\AbstractValidator::getDefaultTranslator());
 }

 public function testSetGetDefaultTranslator()
 {
     set_error_handler(array($this, 'errorHandlerIgnore'));
     $translator = new \Zend\Translator\Translator('ArrayAdapter', array(), 'en');
     restore_error_handler();
     Validator\AbstractValidator::setDefaultTranslator($translator);
     $this->assertSame($translator->getAdapter(), Validator\AbstractValidator::getDefaultTranslator());
 }

 public function testGlobalDefaultTranslatorNullByDefault()
 {
     $this->assertNull(Validator\AbstractValidator::getDefaultTranslator());
 }

 /**
  * Validate element value
  *
  * If a translation adapter is registered, any error messages will be
  * translated according to the current locale, using the given error code;
  * if no matching translation is found, the original message will be
  * utilized.
  *
  * Note: The *filtered* value is validated.
  *
  * @param  mixed $value
  * @param  mixed $context
  * @return boolean
  */
 public function isValid($value, $context = null)
 {
     $this->setValue($value);
     $value = $this->getValue();
     if (('' === $value || null === $value) && !$this->isRequired() && $this->getAllowEmpty()) {
         return true;
     }
     if ($this->isRequired() && $this->autoInsertNotEmptyValidator() && !$this->getValidator('NotEmpty')) {
         $validators = $this->getValidators();
         $notEmpty = array('validator' => 'NotEmpty', 'breakChainOnFailure' => true);
         array_unshift($validators, $notEmpty);
         $this->setValidators($validators);
     }
     // Find the correct translator. Zend\Validator\AbstractValidator::getDefaultTranslator()
     // will get either the static translator attached to Zend\Validator\AbstractValidator
     // or the 'Zend_Translate' from Zend\Registry.
     if (AbstractValidator::hasDefaultTranslator() && !Form::hasDefaultTranslator()) {
         $translator = AbstractValidator::getDefaultTranslator();
         if ($this->hasTranslator()) {
             // only pick up this element's translator if it was attached directly.
             $translator = $this->getTranslator();
         }
     } else {
         $translator = $this->getTranslator();
     }
     $this->_messages = array();
     $this->_errors = array();
     $result = true;
     $isArray = $this->isArray();
     foreach ($this->getValidators() as $key => $validator) {
         if (method_exists($validator, 'setTranslator')) {
             if (method_exists($validator, 'hasTranslator')) {
                 if (!$validator->hasTranslator()) {
                     $validator->setTranslator($translator);
                 }
             } else {
                 $validator->setTranslator($translator);
             }
         }
         if (method_exists($validator, 'setDisableTranslator')) {
             $validator->setDisableTranslator($this->translatorIsDisabled());
         }
         if ($isArray && is_array($value)) {
             $messages = array();
             $errors = array();
             foreach ($value as $val) {
                 if (!$validator->isValid($val, $context)) {
                     $result = false;
                     if ($this->_hasErrorMessages()) {
                         $messages = $this->_getErrorMessages();
                         $errors = $messages;
                     } else {
                         $messages = array_merge($messages, $validator->getMessages());
                         $errors = array_merge($errors, $validator->getErrors());
                     }
                 }
             }
             if ($result) {
                 continue;
             }
         } elseif ($validator->isValid($value, $context)) {
             continue;
         } else {
             $result = false;
             if ($this->_hasErrorMessages()) {
                 $messages = $this->_getErrorMessages();
                 $errors = $messages;
             } else {
                 $messages = $validator->getMessages();
                 $errors = array_keys($messages);
             }
         }
         $result = false;
         $this->_messages = array_merge($this->_messages, $messages);
         $this->_errors = array_merge($this->_errors, $errors);
         if ($validator->zfBreakChainOnFailure) {
             break;
         }
     }
     // If element manually flagged as invalid, return false
     if ($this->_isErrorForced) {
         return false;
     }
     return $result;
 }

 public function testSetGetDefaultTranslator()
 {
     $translator = new Translator\Translator();
     AbstractValidator::setDefaultTranslator($translator);
     $this->assertSame($translator, AbstractValidator::getDefaultTranslator());
 }

 public function testDefaultTranslatorMethods()
 {
     $this->assertFalse(AbstractValidator::hasDefaultTranslator());
     $this->assertNull(AbstractValidator::getDefaultTranslator());
     $this->assertEquals('default', AbstractValidator::getDefaultTranslatorTextDomain());
     $this->assertFalse($this->validator->hasTranslator());
     $translatorMock = $this->getMock('Zend\\I18n\\Translator\\Translator');
     AbstractValidator::setDefaultTranslator($translatorMock, 'foo');
     $this->assertEquals($translatorMock, AbstractValidator::getDefaultTranslator());
     $this->assertEquals($translatorMock, $this->validator->getTranslator());
     $this->assertEquals('foo', AbstractValidator::getDefaultTranslatorTextDomain());
     $this->assertEquals('foo', $this->validator->getTranslatorTextDomain());
     $this->assertTrue(AbstractValidator::hasDefaultTranslator());
 }

 /**
  * Returns whether translator is enabled and should be used
  *
  * @return bool
  */
 public function isTranslatorEnabled()
 {
     $this->translator = AbstractValidator::getDefaultTranslator();
     return $this->translatorEnabled;
 }