class Cookie in Zircon Profile 8

Cookie represents an HTTP cookie.

@author Fabien Potencier <[e-mail]>

Hierarchy

• class \Symfony\Component\BrowserKit\Cookie

5 files declare their use of Cookie

BrowserKitDriver.php in vendor/behat/mink-browserkit-driver/src/BrowserKitDriver.php

Client.php in vendor/symfony/http-kernel/Client.php

ClientTest.php in vendor/fabpot/goutte/Goutte/Tests/ClientTest.php

CookieJarTest.php in vendor/symfony/browser-kit/Tests/CookieJarTest.php

CookieTest.php in vendor/symfony/browser-kit/Tests/CookieTest.php

7 string references to 'Cookie'

ClientTest::testUsesCookies in vendor/fabpot/goutte/Goutte/Tests/ClientTest.php

ClientTest::testUsesCookiesWithCustomPort in vendor/fabpot/goutte/Goutte/Tests/ClientTest.php

CookieJar::withCookieHeader in vendor/guzzlehttp/guzzle/src/Cookie/CookieJar.php

Create a request with added cookie headers.

FinishResponseSubscriber::setResponseCacheable in core/lib/Drupal/Core/EventSubscriber/FinishResponseSubscriber.php

Add Cache-Control and Expires headers to a cacheable response.

HttpCache::__construct in vendor/symfony/http-kernel/HttpCache/HttpCache.php

Constructor.

... See full list

File

vendor/symfony/browser-kit/Cookie.php, line 19

Namespace

Symfony\Component\BrowserKit

class Cookie {

  /**
   * Handles dates as defined by RFC 2616 section 3.3.1, and also some other
   * non-standard, but common formats.
   *
   * @var array
   */
  private static $dateFormats = array(
    'D, d M Y H:i:s T',
    'D, d-M-y H:i:s T',
    'D, d-M-Y H:i:s T',
    'D, d-m-y H:i:s T',
    'D, d-m-Y H:i:s T',
    'D M j G:i:s Y',
    'D M d H:i:s Y T',
  );
  protected $name;
  protected $value;
  protected $expires;
  protected $path;
  protected $domain;
  protected $secure;
  protected $httponly;
  protected $rawValue;

  /**
   * Sets a cookie.
   *
   * @param string $name         The cookie name
   * @param string $value        The value of the cookie
   * @param string $expires      The time the cookie expires
   * @param string $path         The path on the server in which the cookie will be available on
   * @param string $domain       The domain that the cookie is available
   * @param bool   $secure       Indicates that the cookie should only be transmitted over a secure HTTPS connection from the client
   * @param bool   $httponly     The cookie httponly flag
   * @param bool   $encodedValue Whether the value is encoded or not
   */
  public function __construct($name, $value, $expires = null, $path = null, $domain = '', $secure = false, $httponly = true, $encodedValue = false) {
    if ($encodedValue) {
      $this->value = urldecode($value);
      $this->rawValue = $value;
    }
    else {
      $this->value = $value;
      $this->rawValue = urlencode($value);
    }
    $this->name = $name;
    $this->path = empty($path) ? '/' : $path;
    $this->domain = $domain;
    $this->secure = (bool) $secure;
    $this->httponly = (bool) $httponly;
    if (null !== $expires) {
      $timestampAsDateTime = \DateTime::createFromFormat('U', $expires);
      if (false === $timestampAsDateTime) {
        throw new \UnexpectedValueException(sprintf('The cookie expiration time "%s" is not valid.', $expires));
      }
      $this->expires = $timestampAsDateTime
        ->getTimestamp();
    }
  }

  /**
   * Returns the HTTP representation of the Cookie.
   *
   * @return string The HTTP representation of the Cookie
   *
   * @throws \UnexpectedValueException
   */
  public function __toString() {
    $cookie = sprintf('%s=%s', $this->name, $this->rawValue);
    if (null !== $this->expires) {
      $dateTime = \DateTime::createFromFormat('U', $this->expires, new \DateTimeZone('GMT'));
      $cookie .= '; expires=' . str_replace('+0000', '', $dateTime
        ->format(self::$dateFormats[0]));
    }
    if ('' !== $this->domain) {
      $cookie .= '; domain=' . $this->domain;
    }
    if ($this->path) {
      $cookie .= '; path=' . $this->path;
    }
    if ($this->secure) {
      $cookie .= '; secure';
    }
    if ($this->httponly) {
      $cookie .= '; httponly';
    }
    return $cookie;
  }

  /**
   * Creates a Cookie instance from a Set-Cookie header value.
   *
   * @param string $cookie A Set-Cookie header value
   * @param string $url    The base URL
   *
   * @return Cookie A Cookie instance
   *
   * @throws \InvalidArgumentException
   */
  public static function fromString($cookie, $url = null) {
    $parts = explode(';', $cookie);
    if (false === strpos($parts[0], '=')) {
      throw new \InvalidArgumentException(sprintf('The cookie string "%s" is not valid.', $parts[0]));
    }
    list($name, $value) = explode('=', array_shift($parts), 2);
    $values = array(
      'name' => trim($name),
      'value' => trim($value),
      'expires' => null,
      'path' => '/',
      'domain' => '',
      'secure' => false,
      'httponly' => false,
      'passedRawValue' => true,
    );
    if (null !== $url) {
      if (false === ($urlParts = parse_url($url)) || !isset($urlParts['host'])) {
        throw new \InvalidArgumentException(sprintf('The URL "%s" is not valid.', $url));
      }
      $values['domain'] = $urlParts['host'];
      $values['path'] = isset($urlParts['path']) ? substr($urlParts['path'], 0, strrpos($urlParts['path'], '/')) : '';
    }
    foreach ($parts as $part) {
      $part = trim($part);
      if ('secure' === strtolower($part)) {

        // Ignore the secure flag if the original URI is not given or is not HTTPS
        if (!$url || !isset($urlParts['scheme']) || 'https' != $urlParts['scheme']) {
          continue;
        }
        $values['secure'] = true;
        continue;
      }
      if ('httponly' === strtolower($part)) {
        $values['httponly'] = true;
        continue;
      }
      if (2 === count($elements = explode('=', $part, 2))) {
        if ('expires' === strtolower($elements[0])) {
          $elements[1] = self::parseDate($elements[1]);
        }
        $values[strtolower($elements[0])] = $elements[1];
      }
    }
    return new static($values['name'], $values['value'], $values['expires'], $values['path'], $values['domain'], $values['secure'], $values['httponly'], $values['passedRawValue']);
  }
  private static function parseDate($dateValue) {

    // trim single quotes around date if present
    if (($length = strlen($dateValue)) > 1 && "'" === $dateValue[0] && "'" === $dateValue[$length - 1]) {
      $dateValue = substr($dateValue, 1, -1);
    }
    foreach (self::$dateFormats as $dateFormat) {
      if (false !== ($date = \DateTime::createFromFormat($dateFormat, $dateValue, new \DateTimeZone('GMT')))) {
        return $date
          ->getTimestamp();
      }
    }

    // attempt a fallback for unusual formatting
    if (false !== ($date = date_create($dateValue, new \DateTimeZone('GMT')))) {
      return $date
        ->getTimestamp();
    }
    throw new \InvalidArgumentException(sprintf('Could not parse date "%s".', $dateValue));
  }

  /**
   * Gets the name of the cookie.
   *
   * @return string The cookie name
   */
  public function getName() {
    return $this->name;
  }

  /**
   * Gets the value of the cookie.
   *
   * @return string The cookie value
   */
  public function getValue() {
    return $this->value;
  }

  /**
   * Gets the raw value of the cookie.
   *
   * @return string The cookie value
   */
  public function getRawValue() {
    return $this->rawValue;
  }

  /**
   * Gets the expires time of the cookie.
   *
   * @return string The cookie expires time
   */
  public function getExpiresTime() {
    return $this->expires;
  }

  /**
   * Gets the path of the cookie.
   *
   * @return string The cookie path
   */
  public function getPath() {
    return $this->path;
  }

  /**
   * Gets the domain of the cookie.
   *
   * @return string The cookie domain
   */
  public function getDomain() {
    return $this->domain;
  }

  /**
   * Returns the secure flag of the cookie.
   *
   * @return bool The cookie secure flag
   */
  public function isSecure() {
    return $this->secure;
  }

  /**
   * Returns the httponly flag of the cookie.
   *
   * @return bool The cookie httponly flag
   */
  public function isHttpOnly() {
    return $this->httponly;
  }

  /**
   * Returns true if the cookie has expired.
   *
   * @return bool true if the cookie has expired, false otherwise
   */
  public function isExpired() {
    return null !== $this->expires && 0 !== $this->expires && $this->expires < time();
  }

}

Members

Name	Modifiers	Type	Description	Overrides
Cookie::$dateFormats	private static	property	Handles dates as defined by RFC 2616 section 3.3.1, and also some other non-standard, but common formats.
Cookie::$domain	protected	property
Cookie::$expires	protected	property
Cookie::$httponly	protected	property
Cookie::$name	protected	property
Cookie::$path	protected	property
Cookie::$rawValue	protected	property
Cookie::$secure	protected	property
Cookie::$value	protected	property
Cookie::fromString	public static	function	Creates a Cookie instance from a Set-Cookie header value.
Cookie::getDomain	public	function	Gets the domain of the cookie.
Cookie::getExpiresTime	public	function	Gets the expires time of the cookie.
Cookie::getName	public	function	Gets the name of the cookie.
Cookie::getPath	public	function	Gets the path of the cookie.
Cookie::getRawValue	public	function	Gets the raw value of the cookie.
Cookie::getValue	public	function	Gets the value of the cookie.
Cookie::isExpired	public	function	Returns true if the cookie has expired.
Cookie::isHttpOnly	public	function	Returns the httponly flag of the cookie.
Cookie::isSecure	public	function	Returns the secure flag of the cookie.
Cookie::parseDate	private static	function
Cookie::__construct	public	function	Sets a cookie.
Cookie::__toString	public	function	Returns the HTTP representation of the Cookie.