www.aleph1.co.uk Git - yaffs-website/blob - vendor/symfony/http-foundation/HeaderBag.php

   1 <?php
   2
   3 /*
   4  * This file is part of the Symfony package.
   5  *
   6  * (c) Fabien Potencier <fabien@symfony.com>
   7  *
   8  * For the full copyright and license information, please view the LICENSE
   9  * file that was distributed with this source code.
  10  */
  11
  12 namespace Symfony\Component\HttpFoundation;
  13
  14 /**
  15  * HeaderBag is a container for HTTP headers.
  16  *
  17  * @author Fabien Potencier <fabien@symfony.com>
  18  */
  19 class HeaderBag implements \IteratorAggregate, \Countable
  20 {
  21     protected $headers = array();
  22     protected $cacheControl = array();
  23
  24     /**
  25      * @param array $headers An array of HTTP headers
  26      */
  27     public function __construct(array $headers = array())
  28     {
  29         foreach ($headers as $key => $values) {
  30             $this->set($key, $values);
  31         }
  32     }
  33
  34     /**
  35      * Returns the headers as a string.
  36      *
  37      * @return string The headers
  38      */
  39     public function __toString()
  40     {
  41         if (!$headers = $this->all()) {
  42             return '';
  43         }
  44
  45         ksort($headers);
  46         $max = max(array_map('strlen', array_keys($headers))) + 1;
  47         $content = '';
  48         foreach ($headers as $name => $values) {
  49             $name = implode('-', array_map('ucfirst', explode('-', $name)));
  50             foreach ($values as $value) {
  51                 $content .= sprintf("%-{$max}s %s\r\n", $name.':', $value);
  52             }
  53         }
  54
  55         return $content;
  56     }
  57
  58     /**
  59      * Returns the headers.
  60      *
  61      * @return array An array of headers
  62      */
  63     public function all()
  64     {
  65         return $this->headers;
  66     }
  67
  68     /**
  69      * Returns the parameter keys.
  70      *
  71      * @return array An array of parameter keys
  72      */
  73     public function keys()
  74     {
  75         return array_keys($this->all());
  76     }
  77
  78     /**
  79      * Replaces the current HTTP headers by a new set.
  80      *
  81      * @param array $headers An array of HTTP headers
  82      */
  83     public function replace(array $headers = array())
  84     {
  85         $this->headers = array();
  86         $this->add($headers);
  87     }
  88
  89     /**
  90      * Adds new headers the current HTTP headers set.
  91      *
  92      * @param array $headers An array of HTTP headers
  93      */
  94     public function add(array $headers)
  95     {
  96         foreach ($headers as $key => $values) {
  97             $this->set($key, $values);
  98         }
  99     }
 100
 101     /**
 102      * Returns a header value by name.
 103      *
 104      * @param string          $key     The header name
 105      * @param string|string[] $default The default value
 106      * @param bool            $first   Whether to return the first value or all header values
 107      *
 108      * @return string|string[] The first header value or default value if $first is true, an array of values otherwise
 109      */
 110     public function get($key, $default = null, $first = true)
 111     {
 112         $key = str_replace('_', '-', strtolower($key));
 113         $headers = $this->all();
 114
 115         if (!array_key_exists($key, $headers)) {
 116             if (null === $default) {
 117                 return $first ? null : array();
 118             }
 119
 120             return $first ? $default : array($default);
 121         }
 122
 123         if ($first) {
 124             return \count($headers[$key]) ? $headers[$key][0] : $default;
 125         }
 126
 127         return $headers[$key];
 128     }
 129
 130     /**
 131      * Sets a header by name.
 132      *
 133      * @param string          $key     The key
 134      * @param string|string[] $values  The value or an array of values
 135      * @param bool            $replace Whether to replace the actual value or not (true by default)
 136      */
 137     public function set($key, $values, $replace = true)
 138     {
 139         $key = str_replace('_', '-', strtolower($key));
 140
 141         if (\is_array($values)) {
 142             $values = array_values($values);
 143
 144             if (true === $replace || !isset($this->headers[$key])) {
 145                 $this->headers[$key] = $values;
 146             } else {
 147                 $this->headers[$key] = array_merge($this->headers[$key], $values);
 148             }
 149         } else {
 150             if (true === $replace || !isset($this->headers[$key])) {
 151                 $this->headers[$key] = array($values);
 152             } else {
 153                 $this->headers[$key][] = $values;
 154             }
 155         }
 156
 157         if ('cache-control' === $key) {
 158             $this->cacheControl = $this->parseCacheControl(implode(', ', $this->headers[$key]));
 159         }
 160     }
 161
 162     /**
 163      * Returns true if the HTTP header is defined.
 164      *
 165      * @param string $key The HTTP header
 166      *
 167      * @return bool true if the parameter exists, false otherwise
 168      */
 169     public function has($key)
 170     {
 171         return array_key_exists(str_replace('_', '-', strtolower($key)), $this->all());
 172     }
 173
 174     /**
 175      * Returns true if the given HTTP header contains the given value.
 176      *
 177      * @param string $key   The HTTP header name
 178      * @param string $value The HTTP value
 179      *
 180      * @return bool true if the value is contained in the header, false otherwise
 181      */
 182     public function contains($key, $value)
 183     {
 184         return in_array($value, $this->get($key, null, false));
 185     }
 186
 187     /**
 188      * Removes a header.
 189      *
 190      * @param string $key The HTTP header name
 191      */
 192     public function remove($key)
 193     {
 194         $key = str_replace('_', '-', strtolower($key));
 195
 196         unset($this->headers[$key]);
 197
 198         if ('cache-control' === $key) {
 199             $this->cacheControl = array();
 200         }
 201     }
 202
 203     /**
 204      * Returns the HTTP header value converted to a date.
 205      *
 206      * @param string    $key     The parameter key
 207      * @param \DateTime $default The default value
 208      *
 209      * @return null|\DateTime The parsed DateTime or the default value if the header does not exist
 210      *
 211      * @throws \RuntimeException When the HTTP header is not parseable
 212      */
 213     public function getDate($key, \DateTime $default = null)
 214     {
 215         if (null === $value = $this->get($key)) {
 216             return $default;
 217         }
 218
 219         if (false === $date = \DateTime::createFromFormat(DATE_RFC2822, $value)) {
 220             throw new \RuntimeException(sprintf('The %s HTTP header is not parseable (%s).', $key, $value));
 221         }
 222
 223         return $date;
 224     }
 225
 226     /**
 227      * Adds a custom Cache-Control directive.
 228      *
 229      * @param string $key   The Cache-Control directive name
 230      * @param mixed  $value The Cache-Control directive value
 231      */
 232     public function addCacheControlDirective($key, $value = true)
 233     {
 234         $this->cacheControl[$key] = $value;
 235
 236         $this->set('Cache-Control', $this->getCacheControlHeader());
 237     }
 238
 239     /**
 240      * Returns true if the Cache-Control directive is defined.
 241      *
 242      * @param string $key The Cache-Control directive
 243      *
 244      * @return bool true if the directive exists, false otherwise
 245      */
 246     public function hasCacheControlDirective($key)
 247     {
 248         return array_key_exists($key, $this->cacheControl);
 249     }
 250
 251     /**
 252      * Returns a Cache-Control directive value by name.
 253      *
 254      * @param string $key The directive name
 255      *
 256      * @return mixed|null The directive value if defined, null otherwise
 257      */
 258     public function getCacheControlDirective($key)
 259     {
 260         return array_key_exists($key, $this->cacheControl) ? $this->cacheControl[$key] : null;
 261     }
 262
 263     /**
 264      * Removes a Cache-Control directive.
 265      *
 266      * @param string $key The Cache-Control directive
 267      */
 268     public function removeCacheControlDirective($key)
 269     {
 270         unset($this->cacheControl[$key]);
 271
 272         $this->set('Cache-Control', $this->getCacheControlHeader());
 273     }
 274
 275     /**
 276      * Returns an iterator for headers.
 277      *
 278      * @return \ArrayIterator An \ArrayIterator instance
 279      */
 280     public function getIterator()
 281     {
 282         return new \ArrayIterator($this->headers);
 283     }
 284
 285     /**
 286      * Returns the number of headers.
 287      *
 288      * @return int The number of headers
 289      */
 290     public function count()
 291     {
 292         return count($this->headers);
 293     }
 294
 295     protected function getCacheControlHeader()
 296     {
 297         $parts = array();
 298         ksort($this->cacheControl);
 299         foreach ($this->cacheControl as $key => $value) {
 300             if (true === $value) {
 301                 $parts[] = $key;
 302             } else {
 303                 if (preg_match('#[^a-zA-Z0-9._-]#', $value)) {
 304                     $value = '"'.$value.'"';
 305                 }
 306
 307                 $parts[] = "$key=$value";
 308             }
 309         }
 310
 311         return implode(', ', $parts);
 312     }
 313
 314     /**
 315      * Parses a Cache-Control HTTP header.
 316      *
 317      * @param string $header The value of the Cache-Control HTTP header
 318      *
 319      * @return array An array representing the attribute values
 320      */
 321     protected function parseCacheControl($header)
 322     {
 323         $cacheControl = array();
 324         preg_match_all('#([a-zA-Z][a-zA-Z_-]*)\s*(?:=(?:"([^"]*)"|([^ \t",;]*)))?#', $header, $matches, PREG_SET_ORDER);
 325         foreach ($matches as $match) {
 326             $cacheControl[strtolower($match[1])] = isset($match[3]) ? $match[3] : (isset($match[2]) ? $match[2] : true);
 327         }
 328
 329         return $cacheControl;
 330     }
 331 }