interface/modules/zend_modules/library/Zend/Validator/Uri.php

   1 <?php
   2 /**
   3  * Zend Framework (http://framework.zend.com/)
   4  *
   5  * @link      http://github.com/zendframework/zf2 for the canonical source repository
   6  * @copyright Copyright (c) 2005-2013 Zend Technologies USA Inc. (http://www.zend.com)
   7  * @license   http://framework.zend.com/license/new-bsd New BSD License
   8  */
   9
  10 namespace Zend\Validator;
  11
  12 use Traversable;
  13 use Zend\Uri\Exception\ExceptionInterface as UriException;
  14 use Zend\Uri\Uri as UriHandler;
  15 use Zend\Validator\Exception\InvalidArgumentException;
  16
  17 class Uri extends AbstractValidator
  18 {
  19     const INVALID = 'uriInvalid';
  20     const NOT_URI = 'notUri';
  21
  22     /**
  23      * @var array
  24      */
  25     protected $messageTemplates = array(
  26         self::INVALID => "Invalid type given. String expected",
  27         self::NOT_URI => "The input does not appear to be a valid Uri",
  28     );
  29
  30     /**
  31      * @var UriHandler
  32      */
  33     protected $uriHandler;
  34
  35     /**
  36      * @var bool
  37      */
  38     protected $allowRelative = true;
  39
  40     /**
  41      * @var bool
  42      */
  43     protected $allowAbsolute = true;
  44
  45     /**
  46      * Sets default option values for this instance
  47      *
  48      * @param array|Traversable $options
  49      */
  50     public function __construct($options = array())
  51     {
  52         if ($options instanceof Traversable) {
  53             $options = iterator_to_array($options);
  54         } elseif (!is_array($options)) {
  55             $options = func_get_args();
  56             $temp['uriHandler'] = array_shift($options);
  57             if (!empty($options)) {
  58                 $temp['allowRelative'] = array_shift($options);
  59             }
  60             if (!empty($options)) {
  61                 $temp['allowAbsolute'] = array_shift($options);
  62             }
  63
  64             $options = $temp;
  65         }
  66
  67         if (isset($options['uriHandler'])) {
  68             $this->setUriHandler($options['uriHandler']);
  69         }
  70         if (isset($options['allowRelative'])) {
  71             $this->setAllowRelative($options['allowRelative']);
  72         }
  73         if (isset($options['allowAbsolute'])) {
  74             $this->setAllowAbsolute($options['allowAbsolute']);
  75         }
  76
  77         parent::__construct($options);
  78     }
  79
  80     /**
  81      * @throws InvalidArgumentException
  82      * @return UriHandler
  83      */
  84     public function getUriHandler()
  85     {
  86         if (null === $this->uriHandler) {
  87             // Lazy load the base Uri handler
  88             $this->uriHandler = new UriHandler();
  89         } elseif (is_string($this->uriHandler) && class_exists($this->uriHandler)) {
  90             // Instantiate string Uri handler that references a class
  91             $this->uriHandler = new $this->uriHandler;
  92         }
  93
  94         if (! $this->uriHandler instanceof UriHandler) {
  95             throw new InvalidArgumentException('URI handler is expected to be a Zend\Uri\Uri object');
  96         }
  97
  98         return $this->uriHandler;
  99     }
 100
 101     /**
 102      * @param  UriHandler $uriHandler
 103      * @throws InvalidArgumentException
 104      * @return Uri
 105      */
 106     public function setUriHandler($uriHandler)
 107     {
 108         if (! is_subclass_of($uriHandler, 'Zend\Uri\Uri')) {
 109             throw new InvalidArgumentException('Expecting a subclass name or instance of Zend\Uri\Uri as $uriHandler');
 110         }
 111
 112         $this->uriHandler = $uriHandler;
 113         return $this;
 114     }
 115
 116     /**
 117      * Returns the allowAbsolute option
 118      *
 119      * @return bool
 120      */
 121     public function getAllowAbsolute()
 122     {
 123         return $this->allowAbsolute;
 124     }
 125
 126     /**
 127      * Sets the allowAbsolute option
 128      *
 129      * @param  bool $allowAbsolute
 130      * @return Uri
 131      */
 132     public function setAllowAbsolute($allowAbsolute)
 133     {
 134         $this->allowAbsolute = (bool) $allowAbsolute;
 135         return $this;
 136     }
 137
 138     /**
 139      * Returns the allowRelative option
 140      *
 141      * @return bool
 142      */
 143     public function getAllowRelative()
 144     {
 145         return $this->allowRelative;
 146     }
 147
 148     /**
 149      * Sets the allowRelative option
 150      *
 151      * @param  bool $allowRelative
 152      * @return Uri
 153      */
 154     public function setAllowRelative($allowRelative)
 155     {
 156         $this->allowRelative = (bool) $allowRelative;
 157         return $this;
 158     }
 159
 160     /**
 161      * Returns true if and only if $value validates as a Uri
 162      *
 163      * @param  string $value
 164      * @return bool
 165      */
 166     public function isValid($value)
 167     {
 168         if (!is_string($value)) {
 169             $this->error(self::INVALID);
 170             return false;
 171         }
 172
 173         $uriHandler = $this->getUriHandler();
 174         try {
 175             $uriHandler->parse($value);
 176             if ($uriHandler->isValid()) {
 177                 // It will either be a valid absolute or relative URI
 178                 if (($this->allowRelative && $this->allowAbsolute)
 179                     || ($this->allowAbsolute && $uriHandler->isAbsolute())
 180                     || ($this->allowRelative && $uriHandler->isValidRelative())
 181                 ) {
 182                     return true;
 183                 }
 184             }
 185         } catch (UriException $ex) {
 186             // Error parsing URI, it must be invalid
 187         }
 188
 189         $this->error(self::NOT_URI);
 190         return false;
 191     }
 192 }