[Summary view] [Print] [Text view]

   1  <?php
   2  /**
   3   * Zend Framework
   4   *
   5   * LICENSE
   6   *
   7   * This source file is subject to the new BSD license that is bundled
   8   * with this package in the file LICENSE.txt.
   9   * It is also available through the world-wide-web at this URL:
  10   * http://framework.zend.com/license/new-bsd
  11   * If you did not receive a copy of the license and are unable to
  12   * obtain it through the world-wide-web, please send an email
  13   * to [email protected] so we can send you a copy immediately.
  14   *
  15   * @category   Zend
  16   * @package    Zend_Validate
  17   * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
  18   * @license    http://framework.zend.com/license/new-bsd     New BSD License
  19   * @version    $Id$
  20   */
  21  
  22  /**
  23   * @see Zend_Validate_Interface
  24   */
  25  require_once 'Zend/Validate/Interface.php';
  26  
  27  /**
  28   * @category   Zend
  29   * @package    Zend_Validate
  30   * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
  31   * @license    http://framework.zend.com/license/new-bsd     New BSD License
  32   */
  33  abstract class Zend_Validate_Abstract implements Zend_Validate_Interface
  34  {
  35      /**
  36       * The value to be validated
  37       *
  38       * @var mixed
  39       */
  40      protected $_value;
  41  
  42      /**
  43       * Additional variables available for validation failure messages
  44       *
  45       * @var array
  46       */
  47      protected $_messageVariables = array();
  48  
  49      /**
  50       * Validation failure message template definitions
  51       *
  52       * @var array
  53       */
  54      protected $_messageTemplates = array();
  55  
  56      /**
  57       * Array of validation failure messages
  58       *
  59       * @var array
  60       */
  61      protected $_messages = array();
  62  
  63      /**
  64       * Flag indidcating whether or not value should be obfuscated in error
  65       * messages
  66       * @var bool
  67       */
  68      protected $_obscureValue = false;
  69  
  70      /**
  71       * Array of validation failure message codes
  72       *
  73       * @var array
  74       * @deprecated Since 1.5.0
  75       */
  76      protected $_errors = array();
  77  
  78      /**
  79       * Translation object
  80       * @var Zend_Translate
  81       */
  82      protected $_translator;
  83  
  84      /**
  85       * Default translation object for all validate objects
  86       * @var Zend_Translate
  87       */
  88      protected static $_defaultTranslator;
  89  
  90      /**
  91       * Is translation disabled?
  92       * @var Boolean
  93       */
  94      protected $_translatorDisabled = false;
  95  
  96      /**
  97       * Limits the maximum returned length of a error message
  98       *
  99       * @var Integer
 100       */
 101      protected static $_messageLength = -1;
 102  
 103      /**
 104       * Returns array of validation failure messages
 105       *
 106       * @return array
 107       */
 108      public function getMessages()
 109      {
 110          return $this->_messages;
 111      }
 112  
 113      /**
 114       * Returns an array of the names of variables that are used in constructing validation failure messages
 115       *
 116       * @return array
 117       */
 118      public function getMessageVariables()
 119      {
 120          return array_keys($this->_messageVariables);
 121      }
 122  
 123      /**
 124       * Returns the message templates from the validator
 125       *
 126       * @return array
 127       */
 128      public function getMessageTemplates()
 129      {
 130          return $this->_messageTemplates;
 131      }
 132  
 133      /**
 134       * Sets the validation failure message template for a particular key
 135       *
 136       * @param  string $messageString
 137       * @param  string $messageKey     OPTIONAL
 138       * @return Zend_Validate_Abstract Provides a fluent interface
 139       * @throws Zend_Validate_Exception
 140       */
 141      public function setMessage($messageString, $messageKey = null)
 142      {
 143          if ($messageKey === null) {
 144              $keys = array_keys($this->_messageTemplates);
 145              foreach($keys as $key) {
 146                  $this->setMessage($messageString, $key);
 147              }
 148              return $this;
 149          }
 150  
 151          if (!isset($this->_messageTemplates[$messageKey])) {
 152              require_once 'Zend/Validate/Exception.php';
 153              throw new Zend_Validate_Exception("No message template exists for key '$messageKey'");
 154          }
 155  
 156          $this->_messageTemplates[$messageKey] = $messageString;
 157          return $this;
 158      }
 159  
 160      /**
 161       * Sets validation failure message templates given as an array, where the array keys are the message keys,
 162       * and the array values are the message template strings.
 163       *
 164       * @param  array $messages
 165       * @return Zend_Validate_Abstract
 166       */
 167      public function setMessages(array $messages)
 168      {
 169          foreach ($messages as $key => $message) {
 170              $this->setMessage($message, $key);
 171          }
 172          return $this;
 173      }
 174  
 175      /**
 176       * Magic function returns the value of the requested property, if and only if it is the value or a
 177       * message variable.
 178       *
 179       * @param  string $property
 180       * @return mixed
 181       * @throws Zend_Validate_Exception
 182       */
 183      public function __get($property)
 184      {
 185          if ($property == 'value') {
 186              return $this->_value;
 187          }
 188          if (array_key_exists($property, $this->_messageVariables)) {
 189              return $this->{$this->_messageVariables[$property]};
 190          }
 191          /**
 192           * @see Zend_Validate_Exception
 193           */
 194          require_once 'Zend/Validate/Exception.php';
 195          throw new Zend_Validate_Exception("No property exists by the name '$property'");
 196      }
 197  
 198      /**
 199       * Constructs and returns a validation failure message with the given message key and value.
 200       *
 201       * Returns null if and only if $messageKey does not correspond to an existing template.
 202       *
 203       * If a translator is available and a translation exists for $messageKey,
 204       * the translation will be used.
 205       *
 206       * @param  string $messageKey
 207       * @param  string $value
 208       * @return string
 209       */
 210      protected function _createMessage($messageKey, $value)
 211      {
 212          if (!isset($this->_messageTemplates[$messageKey])) {
 213              return null;
 214          }
 215  
 216          $message = $this->_messageTemplates[$messageKey];
 217  
 218          if (null !== ($translator = $this->getTranslator())) {
 219              if ($translator->isTranslated($messageKey)) {
 220                  $message = $translator->translate($messageKey);
 221              } else {
 222                  $message = $translator->translate($message);
 223              }
 224          }
 225  
 226          if (is_object($value)) {
 227              if (!in_array('__toString', get_class_methods($value))) {
 228                  $value = get_class($value) . ' object';
 229              } else {
 230                  $value = $value->__toString();
 231              }
 232          } else {
 233              $value = (string)$value;
 234          }
 235  
 236          if ($this->getObscureValue()) {
 237              $value = str_repeat('*', strlen($value));
 238          }
 239  
 240          $message = str_replace('%value%', (string) $value, $message);
 241          foreach ($this->_messageVariables as $ident => $property) {
 242              $message = str_replace("%$ident%", (string) $this->$property, $message);
 243          }
 244  
 245          $length = self::getMessageLength();
 246          if (($length > -1) && (strlen($message) > $length)) {
 247              $message = substr($message, 0, (self::getMessageLength() - 3)) . '...';
 248          }
 249  
 250          return $message;
 251      }
 252  
 253      /**
 254       * @param  string $messageKey
 255       * @param  string $value      OPTIONAL
 256       * @return void
 257       */
 258      protected function _error($messageKey, $value = null)
 259      {
 260          if ($messageKey === null) {
 261              $keys = array_keys($this->_messageTemplates);
 262              $messageKey = current($keys);
 263          }
 264          if ($value === null) {
 265              $value = $this->_value;
 266          }
 267          $this->_errors[]              = $messageKey;
 268          $this->_messages[$messageKey] = $this->_createMessage($messageKey, $value);
 269      }
 270  
 271      /**
 272       * Sets the value to be validated and clears the messages and errors arrays
 273       *
 274       * @param  mixed $value
 275       * @return void
 276       */
 277      protected function _setValue($value)
 278      {
 279          $this->_value    = $value;
 280          $this->_messages = array();
 281          $this->_errors   = array();
 282      }
 283  
 284      /**
 285       * Returns array of validation failure message codes
 286       *
 287       * @return array
 288       * @deprecated Since 1.5.0
 289       */
 290      public function getErrors()
 291      {
 292          return $this->_errors;
 293      }
 294  
 295      /**
 296       * Set flag indicating whether or not value should be obfuscated in messages
 297       *
 298       * @param  bool $flag
 299       * @return Zend_Validate_Abstract
 300       */
 301      public function setObscureValue($flag)
 302      {
 303          $this->_obscureValue = (bool) $flag;
 304          return $this;
 305      }
 306  
 307      /**
 308       * Retrieve flag indicating whether or not value should be obfuscated in
 309       * messages
 310       *
 311       * @return bool
 312       */
 313      public function getObscureValue()
 314      {
 315          return $this->_obscureValue;
 316      }
 317  
 318      /**
 319       * Set translation object
 320       *
 321       * @param  Zend_Translate|Zend_Translate_Adapter|null $translator
 322       * @return Zend_Validate_Abstract
 323       */
 324      public function setTranslator($translator = null)
 325      {
 326          if ((null === $translator) || ($translator instanceof Zend_Translate_Adapter)) {
 327              $this->_translator = $translator;
 328          } elseif ($translator instanceof Zend_Translate) {
 329              $this->_translator = $translator->getAdapter();
 330          } else {
 331              require_once 'Zend/Validate/Exception.php';
 332              throw new Zend_Validate_Exception('Invalid translator specified');
 333          }
 334          return $this;
 335      }
 336  
 337      /**
 338       * Return translation object
 339       *
 340       * @return Zend_Translate_Adapter|null
 341       */
 342      public function getTranslator()
 343      {
 344          if ($this->translatorIsDisabled()) {
 345              return null;
 346          }
 347  
 348          if (null === $this->_translator) {
 349              return self::getDefaultTranslator();
 350          }
 351  
 352          return $this->_translator;
 353      }
 354  
 355      /**
 356       * Does this validator have its own specific translator?
 357       *
 358       * @return bool
 359       */
 360      public function hasTranslator()
 361      {
 362          return (bool)$this->_translator;
 363      }
 364  
 365      /**
 366       * Set default translation object for all validate objects
 367       *
 368       * @param  Zend_Translate|Zend_Translate_Adapter|null $translator
 369       * @return void
 370       */
 371      public static function setDefaultTranslator($translator = null)
 372      {
 373          if ((null === $translator) || ($translator instanceof Zend_Translate_Adapter)) {
 374              self::$_defaultTranslator = $translator;
 375          } elseif ($translator instanceof Zend_Translate) {
 376              self::$_defaultTranslator = $translator->getAdapter();
 377          } else {
 378              require_once 'Zend/Validate/Exception.php';
 379              throw new Zend_Validate_Exception('Invalid translator specified');
 380          }
 381      }
 382  
 383      /**
 384       * Get default translation object for all validate objects
 385       *
 386       * @return Zend_Translate_Adapter|null
 387       */
 388      public static function getDefaultTranslator()
 389      {
 390          if (null === self::$_defaultTranslator) {
 391              require_once 'Zend/Registry.php';
 392              if (Zend_Registry::isRegistered('Zend_Translate')) {
 393                  $translator = Zend_Registry::get('Zend_Translate');
 394                  if ($translator instanceof Zend_Translate_Adapter) {
 395                      return $translator;
 396                  } elseif ($translator instanceof Zend_Translate) {
 397                      return $translator->getAdapter();
 398                  }
 399              }
 400          }
 401  
 402          return self::$_defaultTranslator;
 403      }
 404  
 405      /**
 406       * Is there a default translation object set?
 407       *
 408       * @return boolean
 409       */
 410      public static function hasDefaultTranslator()
 411      {
 412          return (bool)self::$_defaultTranslator;
 413      }
 414  
 415      /**
 416       * Indicate whether or not translation should be disabled
 417       *
 418       * @param  bool $flag
 419       * @return Zend_Validate_Abstract
 420       */
 421      public function setDisableTranslator($flag)
 422      {
 423          $this->_translatorDisabled = (bool) $flag;
 424          return $this;
 425      }
 426  
 427      /**
 428       * Is translation disabled?
 429       *
 430       * @return bool
 431       */
 432      public function translatorIsDisabled()
 433      {
 434          return $this->_translatorDisabled;
 435      }
 436  
 437      /**
 438       * Returns the maximum allowed message length
 439       *
 440       * @return integer
 441       */
 442      public static function getMessageLength()
 443      {
 444          return self::$_messageLength;
 445      }
 446  
 447      /**
 448       * Sets the maximum allowed message length
 449       *
 450       * @param integer $length
 451       */
 452      public static function setMessageLength($length = -1)
 453      {
 454          self::$_messageLength = $length;
 455      }
 456  }