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 license@zend.com 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: Alpha.php 22668 2010-07-25 14:50:46Z thomas $

    20  */

    21 

    22 /**

    23  * @see Zend_Validate_Abstract

    24  */

    25 require_once 'Zend/Validate/Abstract.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 class Zend_Validate_Alpha extends Zend_Validate_Abstract

    34 {

    35     const INVALID      = 'alphaInvalid';

    36     const NOT_ALPHA    = 'notAlpha';

    37     const STRING_EMPTY = 'alphaStringEmpty';

    38 

    39     /**

    40      * Whether to allow white space characters; off by default

    41      *

    42      * @var boolean

    43      * @deprecated

    44      */

    45     public $allowWhiteSpace;

    46 

    47     /**

    48      * Alphabetic filter used for validation

    49      *

    50      * @var Zend_Filter_Alpha

    51      */

    52     protected static $_filter = null;

    53 

    54     /**

    55      * Validation failure message template definitions

    56      *

    57      * @var array

    58      */

    59     protected $_messageTemplates = array(

    60         self::INVALID      => "Invalid type given. String expected",

    61         self::NOT_ALPHA    => "'%value%' contains non alphabetic characters",

    62         self::STRING_EMPTY => "'%value%' is an empty string"

    63     );

    64 

    65     /**

    66      * Sets default option values for this instance

    67      *

    68      * @param  boolean|Zend_Config $allowWhiteSpace

    69      * @return void

    70      */

    71     public function __construct($allowWhiteSpace = false)

    72     {

    73         if ($allowWhiteSpace instanceof Zend_Config) {

    74             $allowWhiteSpace = $allowWhiteSpace->toArray();

    75         }

    76 

    77         if (is_array($allowWhiteSpace)) {

    78             if (array_key_exists('allowWhiteSpace', $allowWhiteSpace)) {

    79                 $allowWhiteSpace = $allowWhiteSpace['allowWhiteSpace'];

    80             } else {

    81                 $allowWhiteSpace = false;

    82             }

    83         }

    84 

    85         $this->allowWhiteSpace = (boolean) $allowWhiteSpace;

    86     }

    87 

    88     /**

    89      * Returns the allowWhiteSpace option

    90      *

    91      * @return boolean

    92      */

    93     public function getAllowWhiteSpace()

    94     {

    95         return $this->allowWhiteSpace;

    96     }

    97 

    98     /**

    99      * Sets the allowWhiteSpace option

   100      *

   101      * @param boolean $allowWhiteSpace

   102      * @return Zend_Filter_Alpha Provides a fluent interface

   103      */

   104     public function setAllowWhiteSpace($allowWhiteSpace)

   105     {

   106         $this->allowWhiteSpace = (boolean) $allowWhiteSpace;

   107         return $this;

   108     }

   109 

   110     /**

   111      * Defined by Zend_Validate_Interface

   112      *

   113      * Returns true if and only if $value contains only alphabetic characters

   114      *

   115      * @param  string $value

   116      * @return boolean

   117      */

   118     public function isValid($value)

   119     {

   120         if (!is_string($value)) {

   121             $this->_error(self::INVALID);

   122             return false;

   123         }

   124 

   125         $this->_setValue($value);

   126 

   127         if ('' === $value) {

   128             $this->_error(self::STRING_EMPTY);

   129             return false;

   130         }

   131 

   132         if (null === self::$_filter) {

   133             /**

   134              * @see Zend_Filter_Alpha

   135              */

   136             require_once 'Zend/Filter/Alpha.php';

   137             self::$_filter = new Zend_Filter_Alpha();

   138         }

   139 

   140         self::$_filter->allowWhiteSpace = $this->allowWhiteSpace;

   141 

   142         if ($value !== self::$_filter->filter($value)) {

   143             $this->_error(self::NOT_ALPHA);

   144             return false;

   145         }

   146 

   147         return true;

   148     }

   149 

   150 }