예제 #1
0
 /**
  * Add a Header
  *
  * @param mixed $header
  *   Header name. Possible values are:
  *
  *   <ul>
  *
  *       <li>An integer as HTTP Response State Header</li>
  *
  *       <li>
  *
  *           A well-formed Header Field.
  *
  *           It'll be used "as is", an instance of
  *           Next\HTTP\Headers\Fields\Field
  *       </li>
  *
  *       <li>
  *
  *           A Header Field Name.
  *
  *           We'll try to match a valid one or send it as "Generic"
  *       </li>
  *
  *       <li>
  *
  *           An associative array of Header Fields to be added
  *           recursively, where each value can be a well-formed
  *           Header Field or a Header Field Name
  *       </li>
  *
  *   </ul>
  *
  * @param string|optional $value
  *   Header Field Value
  *
  * @return Next\HTTP\Headers\AbstractHeaders
  *   AbstractHeaders Object (Fluent Interface)
  *
  * @throws Next\HTTP\Headers\Fields\FieldsException
  *   Invalid or mal-formed Header Value
  */
 public function addHeader($header, $value = NULL)
 {
     if (is_null($header)) {
         return $this;
     }
     // Well-formed Header Field. Don't need to be known
     if ($header instanceof Field) {
         if ($this->accept($header)) {
             $this->headers->add($header);
         }
         return $this;
     }
     // Recursion...
     if (is_array($header)) {
         foreach ($header as $n => $v) {
             // Usually non-associative arrays have Headers in their values
             if ($v instanceof Field) {
                 $this->addHeader($v, $n);
             } else {
                 $this->addHeader($n, $v);
             }
         }
     } else {
         // Preparing Header Name for Classname Mapping
         $header = strtolower(str_replace('HTTP_', '', $header));
         $header = ucfirst(preg_replace('/(-|_)(\\w)/e', "strtoupper( '\\2' )", $header));
         // Checking if its a known Header Field
         if (array_key_exists($header, $this->known)) {
             // Building full Classname...
             $class = sprintf('%s\\%s', self::FIELDS_NS, $this->known[$header]);
             // ... checking if it exists...
             if (class_exists($class)) {
                 try {
                     // ...and trying to add it
                     $object = new $class($value);
                     if ($this->accept($object)) {
                         $this->headers->add($object);
                     }
                 } catch (FieldsException $e) {
                     /**
                      * @internal
                      * We'll rethrow the same Exception caught if a true error occur
                      * so our Exception Handler can do the rest
                      */
                     if ($e->getCode() !== FieldsException::ALL_INVALID) {
                         throw FieldsException::invalidHeaderValue($e->getMessage(), $e->getCode());
                     }
                 }
             }
         } else {
             /**
              * @internal
              * If it is a unknown header, let's add it as Generic Header
              *
              * Generic Header don't need to be accepted
              */
             $this->addHeader(new Generic(sprintf('%s: %s', $header, $value)));
         }
     }
     return $this;
 }
예제 #2
0
 /**
  * Add a Coookie
  *
  * Cookie definition: <em>cookiename[=cookievalue]</em>
  *
  * @param string|array $cookie
  *   Cookie to add
  *
  * @param string|optional $value
  *   Cookie value, in case a non RFC definition is being used
  *
  * @return Next\HTTP\Cookies
  *   Cookies Object (Fluent Interface)
  *
  * @throws Next\HTTP\Headers\Fields\FieldsException
  *   Invalid or mal-formed Cookie Value
  */
 public function addCookie($cookie, $value = NULL)
 {
     // Well-formed Cookie. Will be added "as is"
     if ($cookie instanceof Cookie) {
         $this->cookies->add($cookie);
         return $this;
     }
     // Recursion...
     if (is_array($cookie)) {
         foreach ($cookie as $n => $v) {
             $this->addCookie($n, $v);
         }
     } else {
         /**
          * @internal
          * In case Next\HTTP\Cookies::addCookie() was invoked like:
          *
          * $cookies -> addCookie( 'cookiename', 'cookievalue' )
          *
          * Instead of:
          *
          * $cookies -> addCookie( 'cookiename=cookievalue' )
          *
          * Let's build the full Cookie representation before add it
          */
         if (!is_null($value) && strpos($value, '=') === FALSE) {
             $cookie = sprintf('%s=%s', $cookie, $value);
         }
         try {
             $this->cookies->add(new Cookie($cookie));
         } catch (FieldsException $e) {
             /**
              * @internal
              * We'll rethrow the same Exception caught if a true error occur
              * so our Exception Handler can do the rest
              */
             if ($e->getCode() !== FieldsException::ALL_INVALID) {
                 throw FieldsException::invalidHeaderValue($e->getMessage(), $e->getCode());
             }
         }
     }
     return $this;
 }
예제 #3
0
 /**
  * Set Header Value
  *
  *  - Prepare it by cleaning and/or apply pre-verification routines
  *
  *  - Check it, using specific validators which follows one or more RFC specification(s)
  *
  *  - Adjust it by apply a post-validation callback over it
  *
  * @param string $value
  *   Header Value
  *
  * @throws Next\HTTP\Headers\Fields\FieldsException
  *   All possible values assigned to the Header are invalid
  */
 private function setValue($value)
 {
     // Removing Header's Name from value, if present
     $value = preg_replace(sprintf('/%s:?/', $this->options->name), '', $value);
     /**
      * @internal
      * Will the header need whitespaces?
      *
      * Most of Header's Fields does not need any whitespace, but some, like Date, does.
      * So, before remove them, we have to check if they are required, or not
      */
     if ($this->options->preserveWhitespace === FALSE) {
         $value = preg_replace('/\\s{2,}/', ' ', $value);
     }
     $value = trim($value);
     // Removing all remaining boundary whitespaces
     // Executing Routines BEFORE Validation
     $value = $this->preCheck($value);
     //--------------------------
     $valid = array();
     // The Header accepts multiple values?
     /**
      * @internal
      * Test if this seperation is REALLY necessary and,
      * if not, use just one foreach, outside the IF
      */
     if ($this->options->acceptMultiples !== FALSE && strpos($value, $this->options->multiplesSeparator) !== FALSE) {
         // Splitting and cleaning it
         $value = array_map('trim', array_filter(explode($this->options->multiplesSeparator, $value)));
         // Counting, in order to make sure we have something to work
         if (count($value) != 0) {
             foreach ($value as $v) {
                 if ($this->getValidator()->validate(trim($v)) !== FALSE) {
                     // Adding value, AFTER applied POST Validations Routines
                     $valid[] = $this->postCheck($v);
                 }
             }
         }
     } else {
         // If the Header does not accepts multiple values, let's validate just once
         if ($this->getValidator()->validate($value) !== FALSE) {
             // Adding value, AFTER applied POST Validations Routines
             $valid[] = $this->postCheck($value);
         }
     }
     // Do we have at least one valid value?
     if (count($valid) == 0) {
         throw FieldsException::invalidHeaderValue($this->options->name);
     }
     // Building Header
     $this->value = implode(sprintf('%s ', $this->options->multiplesSeparator), $valid);
 }