chamilo / chamilo-lms

plugin/buycourses/src/Requests/Exception/Transport/cURL.php

Indentation +50 added lines, -50 removed lines

@@ -2,55 +2,55 @@
 
 class Requests_Exception_Transport_cURL extends Requests_Exception_Transport {
 
-	const EASY = 'cURLEasy';
-	const MULTI = 'cURLMulti';
-	const SHARE = 'cURLShare';
-
-	/**
-	 * cURL error code
-	 *
-	 * @var integer
-	 */
-	protected $code = -1;
-
-	/**
-	 * Which type of cURL error
-	 *
-	 * EASY|MULTI|SHARE
-	 *
-	 * @var string
-	 */
-	protected $type = 'Unknown';
-
-	/**
-	 * Clear text error message
-	 *
-	 * @var string
-	 */
-	protected $reason = 'Unknown';
-
-	public function __construct($message, $type, $data = null, $code = 0) {
-		if ($type !== null) {
-			$this->type = $type;
-		}
-
-		if ($code !== null) {
-			$this->code = $code;
-		}
-
-		if ($message !== null) {
-			$this->reason = $message;
-		}
-
-		$message = sprintf('%d %s', $this->code, $this->reason);
-		parent::__construct($message, $this->type, $data, $this->code);
-	}
-
-	/**
-	 * Get the error message
-	 */
-	public function getReason() {
-		return $this->reason;
-	}
+    const EASY = 'cURLEasy';
+    const MULTI = 'cURLMulti';
+    const SHARE = 'cURLShare';
+
+    /**
+     * cURL error code
+     *
+     * @var integer
+     */
+    protected $code = -1;
+
+    /**
+     * Which type of cURL error
+     *
+     * EASY|MULTI|SHARE
+     *
+     * @var string
+     */
+    protected $type = 'Unknown';
+
+    /**
+     * Clear text error message
+     *
+     * @var string
+     */
+    protected $reason = 'Unknown';
+
+    public function __construct($message, $type, $data = null, $code = 0) {
+        if ($type !== null) {
+            $this->type = $type;
+        }
+
+        if ($code !== null) {
+            $this->code = $code;
+        }
+
+        if ($message !== null) {
+            $this->reason = $message;
+        }
+
+        $message = sprintf('%d %s', $this->code, $this->reason);
+        parent::__construct($message, $this->type, $data, $this->code);
+    }
+
+    /**
+     * Get the error message
+     */
+    public function getReason() {
+        return $this->reason;
+    }
 
 }

plugin/buycourses/src/Requests/Proxy/HTTP.php

Indentation +119 added lines, -119 removed lines

@@ -17,135 +17,135 @@
  * @since 1.6
  */
 class Requests_Proxy_HTTP implements Requests_Proxy {
-	/**
-	 * Proxy host and port
-	 *
-	 * Notation: "host:port" (eg 127.0.0.1:8080 or someproxy.com:3128)
-	 *
-	 * @var string
-	 */
-	public $proxy;
+    /**
+     * Proxy host and port
+     *
+     * Notation: "host:port" (eg 127.0.0.1:8080 or someproxy.com:3128)
+     *
+     * @var string
+     */
+    public $proxy;
 
-	/**
-	 * Username
-	 *
-	 * @var string
-	 */
-	public $user;
+    /**
+     * Username
+     *
+     * @var string
+     */
+    public $user;
 
-	/**
-	 * Password
-	 *
-	 * @var string
-	 */
-	public $pass;
+    /**
+     * Password
+     *
+     * @var string
+     */
+    public $pass;
 
-	/**
-	 * Do we need to authenticate? (ie username & password have been provided)
-	 *
-	 * @var boolean
-	 */
-	public $use_authentication;
+    /**
+     * Do we need to authenticate? (ie username & password have been provided)
+     *
+     * @var boolean
+     */
+    public $use_authentication;
 
-	/**
-	 * Constructor
-	 *
-	 * @since 1.6
-	 * @throws Requests_Exception On incorrect number of arguments (`authbasicbadargs`)
-	 * @param array|null $args Array of user and password. Must have exactly two elements
-	 */
-	public function __construct($args = null) {
-		if (is_string($args)) {
-			$this->proxy = $args;
-		}
-		elseif (is_array($args)) {
-			if (count($args) == 1) {
-				list($this->proxy) = $args;
-			}
-			elseif (count($args) == 3) {
-				list($this->proxy, $this->user, $this->pass) = $args;
-				$this->use_authentication = true;
-			}
-			else {
-				throw new Requests_Exception('Invalid number of arguments', 'proxyhttpbadargs');
-			}
-		}
-	}
+    /**
+     * Constructor
+     *
+     * @since 1.6
+     * @throws Requests_Exception On incorrect number of arguments (`authbasicbadargs`)
+     * @param array|null $args Array of user and password. Must have exactly two elements
+     */
+    public function __construct($args = null) {
+        if (is_string($args)) {
+            $this->proxy = $args;
+        }
+        elseif (is_array($args)) {
+            if (count($args) == 1) {
+                list($this->proxy) = $args;
+            }
+            elseif (count($args) == 3) {
+                list($this->proxy, $this->user, $this->pass) = $args;
+                $this->use_authentication = true;
+            }
+            else {
+                throw new Requests_Exception('Invalid number of arguments', 'proxyhttpbadargs');
+            }
+        }
+    }
 
-	/**
-	 * Register the necessary callbacks
-	 *
-	 * @since 1.6
-	 * @see curl_before_send
-	 * @see fsockopen_remote_socket
-	 * @see fsockopen_remote_host_path
-	 * @see fsockopen_header
-	 * @param Requests_Hooks $hooks Hook system
-	 */
-	public function register(Requests_Hooks &$hooks) {
-		$hooks->register('curl.before_send', array(&$this, 'curl_before_send'));
+    /**
+     * Register the necessary callbacks
+     *
+     * @since 1.6
+     * @see curl_before_send
+     * @see fsockopen_remote_socket
+     * @see fsockopen_remote_host_path
+     * @see fsockopen_header
+     * @param Requests_Hooks $hooks Hook system
+     */
+    public function register(Requests_Hooks &$hooks) {
+        $hooks->register('curl.before_send', array(&$this, 'curl_before_send'));
 
-		$hooks->register('fsockopen.remote_socket', array(&$this, 'fsockopen_remote_socket'));
-		$hooks->register('fsockopen.remote_host_path', array(&$this, 'fsockopen_remote_host_path'));
-		if ($this->use_authentication) {
-			$hooks->register('fsockopen.after_headers', array(&$this, 'fsockopen_header'));
-		}
-	}
+        $hooks->register('fsockopen.remote_socket', array(&$this, 'fsockopen_remote_socket'));
+        $hooks->register('fsockopen.remote_host_path', array(&$this, 'fsockopen_remote_host_path'));
+        if ($this->use_authentication) {
+            $hooks->register('fsockopen.after_headers', array(&$this, 'fsockopen_header'));
+        }
+    }
 
-	/**
-	 * Set cURL parameters before the data is sent
-	 *
-	 * @since 1.6
-	 * @param resource $handle cURL resource
-	 */
-	public function curl_before_send(&$handle) {
-		curl_setopt($handle, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);
-		curl_setopt($handle, CURLOPT_PROXY, $this->proxy);
+    /**
+     * Set cURL parameters before the data is sent
+     *
+     * @since 1.6
+     * @param resource $handle cURL resource
+     */
+    public function curl_before_send(&$handle) {
+        curl_setopt($handle, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);
+        curl_setopt($handle, CURLOPT_PROXY, $this->proxy);
 
-		if ($this->use_authentication) {
-			curl_setopt($handle, CURLOPT_PROXYAUTH, CURLAUTH_ANY);
-			curl_setopt($handle, CURLOPT_PROXYUSERPWD, $this->get_auth_string());
-		}
-	}
+        if ($this->use_authentication) {
+            curl_setopt($handle, CURLOPT_PROXYAUTH, CURLAUTH_ANY);
+            curl_setopt($handle, CURLOPT_PROXYUSERPWD, $this->get_auth_string());
+        }
+    }
 
-	/**
-	 * Alter remote socket information before opening socket connection
-	 *
-	 * @since 1.6
-	 * @param string $remote_socket Socket connection string
-	 */
-	public function fsockopen_remote_socket(&$remote_socket) {
-		$remote_socket = $this->proxy;
-	}
+    /**
+     * Alter remote socket information before opening socket connection
+     *
+     * @since 1.6
+     * @param string $remote_socket Socket connection string
+     */
+    public function fsockopen_remote_socket(&$remote_socket) {
+        $remote_socket = $this->proxy;
+    }
 
-	/**
-	 * Alter remote path before getting stream data
-	 *
-	 * @since 1.6
-	 * @param string $path Path to send in HTTP request string ("GET ...")
-	 * @param string $url Full URL we're requesting
-	 */
-	public function fsockopen_remote_host_path(&$path, $url) {
-		$path = $url;
-	}
+    /**
+     * Alter remote path before getting stream data
+     *
+     * @since 1.6
+     * @param string $path Path to send in HTTP request string ("GET ...")
+     * @param string $url Full URL we're requesting
+     */
+    public function fsockopen_remote_host_path(&$path, $url) {
+        $path = $url;
+    }
 
-	/**
-	 * Add extra headers to the request before sending
-	 *
-	 * @since 1.6
-	 * @param string $out HTTP header string
-	 */
-	public function fsockopen_header(&$out) {
-		$out .= sprintf("Proxy-Authorization: Basic %s\r\n", base64_encode($this->get_auth_string()));
-	}
+    /**
+     * Add extra headers to the request before sending
+     *
+     * @since 1.6
+     * @param string $out HTTP header string
+     */
+    public function fsockopen_header(&$out) {
+        $out .= sprintf("Proxy-Authorization: Basic %s\r\n", base64_encode($this->get_auth_string()));
+    }
 
-	/**
-	 * Get the authentication string (user:pass)
-	 *
-	 * @since 1.6
-	 * @return string
-	 */
-	public function get_auth_string() {
-		return $this->user . ':' . $this->pass;
-	}
+    /**
+     * Get the authentication string (user:pass)
+     *
+     * @since 1.6
+     * @return string
+     */
+    public function get_auth_string() {
+        return $this->user . ':' . $this->pass;
+    }
 }
\ No newline at end of file

plugin/buycourses/src/Requests/IDNAEncoder.php

Indentation +300 added lines, -300 removed lines

@@ -11,378 +11,378 @@
  * @see https://tools.ietf.org/html/rfc3492 Punycode/Bootstrap specification
  */
 class Requests_IDNAEncoder {
-	/**
-	 * ACE prefix used for IDNA
-	 *
-	 * @see https://tools.ietf.org/html/rfc3490#section-5
-	 * @var string
-	 */
-	const ACE_PREFIX = 'xn--';
+    /**
+     * ACE prefix used for IDNA
+     *
+     * @see https://tools.ietf.org/html/rfc3490#section-5
+     * @var string
+     */
+    const ACE_PREFIX = 'xn--';
 
-	/**#@+
+    /**#@+
 	 * Bootstrap constant for Punycode
 	 *
 	 * @see https://tools.ietf.org/html/rfc3492#section-5
 	 * @var int
 	 */
-	const BOOTSTRAP_BASE         = 36;
-	const BOOTSTRAP_TMIN         = 1;
-	const BOOTSTRAP_TMAX         = 26;
-	const BOOTSTRAP_SKEW         = 38;
-	const BOOTSTRAP_DAMP         = 700;
-	const BOOTSTRAP_INITIAL_BIAS = 72;
-	const BOOTSTRAP_INITIAL_N    = 128;
-	/**#@-*/
+    const BOOTSTRAP_BASE         = 36;
+    const BOOTSTRAP_TMIN         = 1;
+    const BOOTSTRAP_TMAX         = 26;
+    const BOOTSTRAP_SKEW         = 38;
+    const BOOTSTRAP_DAMP         = 700;
+    const BOOTSTRAP_INITIAL_BIAS = 72;
+    const BOOTSTRAP_INITIAL_N    = 128;
+    /**#@-*/
 
-	/**
-	 * Encode a hostname using Punycode
-	 *
-	 * @param string $string Hostname
-	 * @return string Punycode-encoded hostname
-	 */
-	public static function encode($string) {
-		$parts = explode('.', $string);
-		foreach ($parts as &$part) {
-			$part = self::to_ascii($part);
-		}
-		return implode('.', $parts);
-	}
+    /**
+     * Encode a hostname using Punycode
+     *
+     * @param string $string Hostname
+     * @return string Punycode-encoded hostname
+     */
+    public static function encode($string) {
+        $parts = explode('.', $string);
+        foreach ($parts as &$part) {
+            $part = self::to_ascii($part);
+        }
+        return implode('.', $parts);
+    }
 
-	/**
-	 * Convert a UTF-8 string to an ASCII string using Punycode
-	 *
-	 * @throws Requests_Exception Provided string longer than 64 ASCII characters (`idna.provided_too_long`)
-	 * @throws Requests_Exception Prepared string longer than 64 ASCII characters (`idna.prepared_too_long`)
-	 * @throws Requests_Exception Provided string already begins with xn-- (`idna.provided_is_prefixed`)
-	 * @throws Requests_Exception Encoded string longer than 64 ASCII characters (`idna.encoded_too_long`)
-	 *
-	 * @param string $string ASCII or UTF-8 string (max length 64 characters)
-	 * @return string ASCII string
-	 */
-	public static function to_ascii($string) {
-		// Step 1: Check if the string is already ASCII
-		if (self::is_ascii($string)) {
-			// Skip to step 7
-			if (strlen($string) < 64) {
-				return $string;
-			}
+    /**
+     * Convert a UTF-8 string to an ASCII string using Punycode
+     *
+     * @throws Requests_Exception Provided string longer than 64 ASCII characters (`idna.provided_too_long`)
+     * @throws Requests_Exception Prepared string longer than 64 ASCII characters (`idna.prepared_too_long`)
+     * @throws Requests_Exception Provided string already begins with xn-- (`idna.provided_is_prefixed`)
+     * @throws Requests_Exception Encoded string longer than 64 ASCII characters (`idna.encoded_too_long`)
+     *
+     * @param string $string ASCII or UTF-8 string (max length 64 characters)
+     * @return string ASCII string
+     */
+    public static function to_ascii($string) {
+        // Step 1: Check if the string is already ASCII
+        if (self::is_ascii($string)) {
+            // Skip to step 7
+            if (strlen($string) < 64) {
+                return $string;
+            }
 
-			throw new Requests_Exception('Provided string is too long', 'idna.provided_too_long', $string);
-		}
+            throw new Requests_Exception('Provided string is too long', 'idna.provided_too_long', $string);
+        }
 
-		// Step 2: nameprep
-		$string = self::nameprep($string);
+        // Step 2: nameprep
+        $string = self::nameprep($string);
 
-		// Step 3: UseSTD3ASCIIRules is false, continue
-		// Step 4: Check if it's ASCII now
-		if (self::is_ascii($string)) {
-			// Skip to step 7
-			if (strlen($string) < 64) {
-				return $string;
-			}
+        // Step 3: UseSTD3ASCIIRules is false, continue
+        // Step 4: Check if it's ASCII now
+        if (self::is_ascii($string)) {
+            // Skip to step 7
+            if (strlen($string) < 64) {
+                return $string;
+            }
 
-			throw new Requests_Exception('Prepared string is too long', 'idna.prepared_too_long', $string);
-		}
+            throw new Requests_Exception('Prepared string is too long', 'idna.prepared_too_long', $string);
+        }
 
-		// Step 5: Check ACE prefix
-		if (strpos($string, self::ACE_PREFIX) === 0) {
-			throw new Requests_Exception('Provided string begins with ACE prefix', 'idna.provided_is_prefixed', $string);
-		}
+        // Step 5: Check ACE prefix
+        if (strpos($string, self::ACE_PREFIX) === 0) {
+            throw new Requests_Exception('Provided string begins with ACE prefix', 'idna.provided_is_prefixed', $string);
+        }
 
-		// Step 6: Encode with Punycode
-		$string = self::punycode_encode($string);
+        // Step 6: Encode with Punycode
+        $string = self::punycode_encode($string);
 
-		// Step 7: Prepend ACE prefix
-		$string = self::ACE_PREFIX . $string;
+        // Step 7: Prepend ACE prefix
+        $string = self::ACE_PREFIX . $string;
 
-		// Step 8: Check size
-		if (strlen($string) < 64) {
-			return $string;
-		}
+        // Step 8: Check size
+        if (strlen($string) < 64) {
+            return $string;
+        }
 
-		throw new Requests_Exception('Encoded string is too long', 'idna.encoded_too_long', $string);
-	}
+        throw new Requests_Exception('Encoded string is too long', 'idna.encoded_too_long', $string);
+    }
 
-	/**
-	 * Check whether a given string contains only ASCII characters
-	 *
-	 * @internal (Testing found regex was the fastest implementation)
-	 *
-	 * @param string $string
-	 * @return bool Is the string ASCII-only?
-	 */
-	protected static function is_ascii($string) {
-		return (preg_match('/(?:[^\x00-\x7F])/', $string) !== 1);
-	}
+    /**
+     * Check whether a given string contains only ASCII characters
+     *
+     * @internal (Testing found regex was the fastest implementation)
+     *
+     * @param string $string
+     * @return bool Is the string ASCII-only?
+     */
+    protected static function is_ascii($string) {
+        return (preg_match('/(?:[^\x00-\x7F])/', $string) !== 1);
+    }
 
-	/**
-	 * Prepare a string for use as an IDNA name
-	 *
-	 * @todo Implement this based on RFC 3491 and the newer 5891
-	 * @param string $string
-	 * @return string Prepared string
-	 */
-	protected static function nameprep($string) {
-		return $string;
-	}
+    /**
+     * Prepare a string for use as an IDNA name
+     *
+     * @todo Implement this based on RFC 3491 and the newer 5891
+     * @param string $string
+     * @return string Prepared string
+     */
+    protected static function nameprep($string) {
+        return $string;
+    }
 
-	/**
-	 * Convert a UTF-8 string to a UCS-4 codepoint array
-	 *
-	 * Based on Requests_IRI::replace_invalid_with_pct_encoding()
-	 *
-	 * @throws Requests_Exception Invalid UTF-8 codepoint (`idna.invalidcodepoint`)
-	 * @param string $input
-	 * @return array Unicode code points
-	 */
-	protected static function utf8_to_codepoints($input) {
-		$codepoints = array();
+    /**
+     * Convert a UTF-8 string to a UCS-4 codepoint array
+     *
+     * Based on Requests_IRI::replace_invalid_with_pct_encoding()
+     *
+     * @throws Requests_Exception Invalid UTF-8 codepoint (`idna.invalidcodepoint`)
+     * @param string $input
+     * @return array Unicode code points
+     */
+    protected static function utf8_to_codepoints($input) {
+        $codepoints = array();
 
-		// Get number of bytes
-		$strlen = strlen($input);
+        // Get number of bytes
+        $strlen = strlen($input);
 
-		for ($position = 0; $position < $strlen; $position++) {
-			$value = ord($input[$position]);
+        for ($position = 0; $position < $strlen; $position++) {
+            $value = ord($input[$position]);
 
-			// One byte sequence:
-			if ((~$value & 0x80) === 0x80) {
-				$character = $value;
-				$length = 1;
-				$remaining = 0;
-			}
-			// Two byte sequence:
-			elseif (($value & 0xE0) === 0xC0) {
-				$character = ($value & 0x1F) << 6;
-				$length = 2;
-				$remaining = 1;
-			}
-			// Three byte sequence:
-			elseif (($value & 0xF0) === 0xE0) {
-				$character = ($value & 0x0F) << 12;
-				$length = 3;
-				$remaining = 2;
-			}
-			// Four byte sequence:
-			elseif (($value & 0xF8) === 0xF0) {
-				$character = ($value & 0x07) << 18;
-				$length = 4;
-				$remaining = 3;
-			}
-			// Invalid byte:
-			else {
-				throw new Requests_Exception('Invalid Unicode codepoint', 'idna.invalidcodepoint', $value);
-			}
+            // One byte sequence:
+            if ((~$value & 0x80) === 0x80) {
+                $character = $value;
+                $length = 1;
+                $remaining = 0;
+            }
+            // Two byte sequence:
+            elseif (($value & 0xE0) === 0xC0) {
+                $character = ($value & 0x1F) << 6;
+                $length = 2;
+                $remaining = 1;
+            }
+            // Three byte sequence:
+            elseif (($value & 0xF0) === 0xE0) {
+                $character = ($value & 0x0F) << 12;
+                $length = 3;
+                $remaining = 2;
+            }
+            // Four byte sequence:
+            elseif (($value & 0xF8) === 0xF0) {
+                $character = ($value & 0x07) << 18;
+                $length = 4;
+                $remaining = 3;
+            }
+            // Invalid byte:
+            else {
+                throw new Requests_Exception('Invalid Unicode codepoint', 'idna.invalidcodepoint', $value);
+            }
 
-			if ($remaining > 0) {
-				if ($position + $length > $strlen) {
-					throw new Requests_Exception('Invalid Unicode codepoint', 'idna.invalidcodepoint', $character);
-				}
-				for ($position++; $remaining > 0; $position++) {
-					$value = ord($input[$position]);
+            if ($remaining > 0) {
+                if ($position + $length > $strlen) {
+                    throw new Requests_Exception('Invalid Unicode codepoint', 'idna.invalidcodepoint', $character);
+                }
+                for ($position++; $remaining > 0; $position++) {
+                    $value = ord($input[$position]);
 
-					// If it is invalid, count the sequence as invalid and reprocess the current byte:
-					if (($value & 0xC0) !== 0x80) {
-						throw new Requests_Exception('Invalid Unicode codepoint', 'idna.invalidcodepoint', $character);
-					}
+                    // If it is invalid, count the sequence as invalid and reprocess the current byte:
+                    if (($value & 0xC0) !== 0x80) {
+                        throw new Requests_Exception('Invalid Unicode codepoint', 'idna.invalidcodepoint', $character);
+                    }
 
-					$character |= ($value & 0x3F) << (--$remaining * 6);
-				}
-				$position--;
-			}
+                    $character |= ($value & 0x3F) << (--$remaining * 6);
+                }
+                $position--;
+            }
 
-			if (
-				// Non-shortest form sequences are invalid
-				   $length > 1 && $character <= 0x7F
-				|| $length > 2 && $character <= 0x7FF
-				|| $length > 3 && $character <= 0xFFFF
-				// Outside of range of ucschar codepoints
-				// Noncharacters
-				|| ($character & 0xFFFE) === 0xFFFE
-				|| $character >= 0xFDD0 && $character <= 0xFDEF
-				|| (
-					// Everything else not in ucschar
-					   $character > 0xD7FF && $character < 0xF900
-					|| $character < 0x20
-					|| $character > 0x7E && $character < 0xA0
-					|| $character > 0xEFFFD
-				)
-			) {
-				throw new Requests_Exception('Invalid Unicode codepoint', 'idna.invalidcodepoint', $character);
-			}
+            if (
+                // Non-shortest form sequences are invalid
+                    $length > 1 && $character <= 0x7F
+                || $length > 2 && $character <= 0x7FF
+                || $length > 3 && $character <= 0xFFFF
+                // Outside of range of ucschar codepoints
+                // Noncharacters
+                || ($character & 0xFFFE) === 0xFFFE
+                || $character >= 0xFDD0 && $character <= 0xFDEF
+                || (
+                    // Everything else not in ucschar
+                        $character > 0xD7FF && $character < 0xF900
+                    || $character < 0x20
+                    || $character > 0x7E && $character < 0xA0
+                    || $character > 0xEFFFD
+                )
+            ) {
+                throw new Requests_Exception('Invalid Unicode codepoint', 'idna.invalidcodepoint', $character);
+            }
 
-			$codepoints[] = $character;
-		}
+            $codepoints[] = $character;
+        }
 
-		return $codepoints;
-	}
+        return $codepoints;
+    }
 
-	/**
-	 * RFC3492-compliant encoder
-	 *
-	 * @internal Pseudo-code from Section 6.3 is commented with "#" next to relevant code
-	 * @throws Requests_Exception On character outside of the domain (never happens with Punycode) (`idna.character_outside_domain`)
-	 *
-	 * @param string $input UTF-8 encoded string to encode
-	 * @return string Punycode-encoded string
-	 */
-	public static function punycode_encode($input) {
-		$output = '';
+    /**
+     * RFC3492-compliant encoder
+     *
+     * @internal Pseudo-code from Section 6.3 is commented with "#" next to relevant code
+     * @throws Requests_Exception On character outside of the domain (never happens with Punycode) (`idna.character_outside_domain`)
+     *
+     * @param string $input UTF-8 encoded string to encode
+     * @return string Punycode-encoded string
+     */
+    public static function punycode_encode($input) {
+        $output = '';
 #		let n = initial_n
-		$n = self::BOOTSTRAP_INITIAL_N;
+        $n = self::BOOTSTRAP_INITIAL_N;
 #		let delta = 0
-		$delta = 0;
+        $delta = 0;
 #		let bias = initial_bias
-		$bias = self::BOOTSTRAP_INITIAL_BIAS;
+        $bias = self::BOOTSTRAP_INITIAL_BIAS;
 #		let h = b = the number of basic code points in the input
-		$h = $b = 0; // see loop
+        $h = $b = 0; // see loop
 #		copy them to the output in order
-		$codepoints = self::utf8_to_codepoints($input);
-		$extended = array();
+        $codepoints = self::utf8_to_codepoints($input);
+        $extended = array();
 
-		foreach ($codepoints as $char) {
-			if ($char < 128) {
-				// Character is valid ASCII
-				// TODO: this should also check if it's valid for a URL
-				$output .= chr($char);
-				$h++;
-			}
-			// Check if the character is non-ASCII, but below initial n
-			// This never occurs for Punycode, so ignore in coverage
-			// @codeCoverageIgnoreStart
-			elseif ($char < $n) {
-				throw new Requests_Exception('Invalid character', 'idna.character_outside_domain', $char);
-			}
-			// @codeCoverageIgnoreEnd
-			else {
-				$extended[$char] = true;
-			}
-		}
-		$extended = array_keys($extended);
-		sort($extended);
-		$b = $h;
+        foreach ($codepoints as $char) {
+            if ($char < 128) {
+                // Character is valid ASCII
+                // TODO: this should also check if it's valid for a URL
+                $output .= chr($char);
+                $h++;
+            }
+            // Check if the character is non-ASCII, but below initial n
+            // This never occurs for Punycode, so ignore in coverage
+            // @codeCoverageIgnoreStart
+            elseif ($char < $n) {
+                throw new Requests_Exception('Invalid character', 'idna.character_outside_domain', $char);
+            }
+            // @codeCoverageIgnoreEnd
+            else {
+                $extended[$char] = true;
+            }
+        }
+        $extended = array_keys($extended);
+        sort($extended);
+        $b = $h;
 #		[copy them] followed by a delimiter if b > 0
-		if (strlen($output) > 0) {
-			$output .= '-';
-		}
+        if (strlen($output) > 0) {
+            $output .= '-';
+        }
 #		{if the input contains a non-basic code point < n then fail}
 #		while h < length(input) do begin
-		while ($h < count($codepoints)) {
+        while ($h < count($codepoints)) {
 #			let m = the minimum code point >= n in the input
-			$m = array_shift($extended);
-			//printf('next code point to insert is %s' . PHP_EOL, dechex($m));
+            $m = array_shift($extended);
+            //printf('next code point to insert is %s' . PHP_EOL, dechex($m));
 #			let delta = delta + (m - n) * (h + 1), fail on overflow
-			$delta += ($m - $n) * ($h + 1);
+            $delta += ($m - $n) * ($h + 1);
 #			let n = m
-			$n = $m;
+            $n = $m;
 #			for each code point c in the input (in order) do begin
-			for ($num = 0; $num < count($codepoints); $num++) {
-				$c = $codepoints[$num];
+            for ($num = 0; $num < count($codepoints); $num++) {
+                $c = $codepoints[$num];
 #				if c < n then increment delta, fail on overflow
-				if ($c < $n) {
-					$delta++;
-				}
+                if ($c < $n) {
+                    $delta++;
+                }
 #				if c == n then begin
-				elseif ($c === $n) {
+                elseif ($c === $n) {
 #					let q = delta
-					$q = $delta;
+                    $q = $delta;
 #					for k = base to infinity in steps of base do begin
-					for ($k = self::BOOTSTRAP_BASE; ; $k += self::BOOTSTRAP_BASE) {
+                    for ($k = self::BOOTSTRAP_BASE; ; $k += self::BOOTSTRAP_BASE) {
 #						let t = tmin if k <= bias {+ tmin}, or
 #								tmax if k >= bias + tmax, or k - bias otherwise
-						if ($k <= ($bias + self::BOOTSTRAP_TMIN)) {
-							$t = self::BOOTSTRAP_TMIN;
-						}
-						elseif ($k >= ($bias + self::BOOTSTRAP_TMAX)) {
-							$t = self::BOOTSTRAP_TMAX;
-						}
-						else {
-							$t = $k - $bias;
-						}
+                        if ($k <= ($bias + self::BOOTSTRAP_TMIN)) {
+                            $t = self::BOOTSTRAP_TMIN;
+                        }
+                        elseif ($k >= ($bias + self::BOOTSTRAP_TMAX)) {
+                            $t = self::BOOTSTRAP_TMAX;
+                        }
+                        else {
+                            $t = $k - $bias;
+                        }
 #						if q < t then break
-						if ($q < $t) {
-							break;
-						}
+                        if ($q < $t) {
+                            break;
+                        }
 #						output the code point for digit t + ((q - t) mod (base - t))
-						$digit = $t + (($q - $t) % (self::BOOTSTRAP_BASE - $t));
-						$output .= self::digit_to_char($digit);
+                        $digit = $t + (($q - $t) % (self::BOOTSTRAP_BASE - $t));
+                        $output .= self::digit_to_char($digit);
 #						let q = (q - t) div (base - t)
-						$q = floor(($q - $t) / (self::BOOTSTRAP_BASE - $t));
+                        $q = floor(($q - $t) / (self::BOOTSTRAP_BASE - $t));
 #					end
-					}
+                    }
 #					output the code point for digit q
-					$output .= self::digit_to_char($q);
+                    $output .= self::digit_to_char($q);
 #					let bias = adapt(delta, h + 1, test h equals b?)
-					$bias = self::adapt($delta, $h + 1, $h === $b);
+                    $bias = self::adapt($delta, $h + 1, $h === $b);
 #					let delta = 0
-					$delta = 0;
+                    $delta = 0;
 #					increment h
-					$h++;
+                    $h++;
 #				end
-				}
+                }
 #			end
-			}
+            }
 #			increment delta and n
-			$delta++;
-			$n++;
+            $delta++;
+            $n++;
 #		end
-		}
+        }
 
-		return $output;
-	}
+        return $output;
+    }
 
-	/**
-	 * Convert a digit to its respective character
-	 *
-	 * @see https://tools.ietf.org/html/rfc3492#section-5
-	 * @throws Requests_Exception On invalid digit (`idna.invalid_digit`)
-	 *
-	 * @param int $digit Digit in the range 0-35
-	 * @return string Single character corresponding to digit
-	 */
-	protected static function digit_to_char($digit) {
-		// @codeCoverageIgnoreStart
-		// As far as I know, this never happens, but still good to be sure.
-		if ($digit < 0 || $digit > 35) {
-			throw new Requests_Exception(sprintf('Invalid digit %d', $digit), 'idna.invalid_digit', $digit);
-		}
-		// @codeCoverageIgnoreEnd
-		$digits = 'abcdefghijklmnopqrstuvwxyz0123456789';
-		return substr($digits, $digit, 1);
-	}
+    /**
+     * Convert a digit to its respective character
+     *
+     * @see https://tools.ietf.org/html/rfc3492#section-5
+     * @throws Requests_Exception On invalid digit (`idna.invalid_digit`)
+     *
+     * @param int $digit Digit in the range 0-35
+     * @return string Single character corresponding to digit
+     */
+    protected static function digit_to_char($digit) {
+        // @codeCoverageIgnoreStart
+        // As far as I know, this never happens, but still good to be sure.
+        if ($digit < 0 || $digit > 35) {
+            throw new Requests_Exception(sprintf('Invalid digit %d', $digit), 'idna.invalid_digit', $digit);
+        }
+        // @codeCoverageIgnoreEnd
+        $digits = 'abcdefghijklmnopqrstuvwxyz0123456789';
+        return substr($digits, $digit, 1);
+    }
 
-	/**
-	 * Adapt the bias
-	 *
-	 * @see https://tools.ietf.org/html/rfc3492#section-6.1
-	 * @param int $delta
-	 * @param int $numpoints
-	 * @param bool $firsttime
-	 * @return int New bias
-	 */
-	protected static function adapt($delta, $numpoints, $firsttime) {
+    /**
+     * Adapt the bias
+     *
+     * @see https://tools.ietf.org/html/rfc3492#section-6.1
+     * @param int $delta
+     * @param int $numpoints
+     * @param bool $firsttime
+     * @return int New bias
+     */
+    protected static function adapt($delta, $numpoints, $firsttime) {
 #	function adapt(delta,numpoints,firsttime):
 #		if firsttime then let delta = delta div damp
-		if ($firsttime) {
-			$delta = floor($delta / self::BOOTSTRAP_DAMP);
-		}
+        if ($firsttime) {
+            $delta = floor($delta / self::BOOTSTRAP_DAMP);
+        }
 #		else let delta = delta div 2
-		else {
-			$delta = floor($delta / 2);
-		}
+        else {
+            $delta = floor($delta / 2);
+        }
 #		let delta = delta + (delta div numpoints)
-		$delta += floor($delta / $numpoints);
+        $delta += floor($delta / $numpoints);
 #		let k = 0
-		$k = 0;
+        $k = 0;
 #		while delta > ((base - tmin) * tmax) div 2 do begin
-		$max = floor(((self::BOOTSTRAP_BASE - self::BOOTSTRAP_TMIN) * self::BOOTSTRAP_TMAX) / 2);
-		while ($delta > $max) {
+        $max = floor(((self::BOOTSTRAP_BASE - self::BOOTSTRAP_TMIN) * self::BOOTSTRAP_TMAX) / 2);
+        while ($delta > $max) {
 #			let delta = delta div (base - tmin)
-			$delta = floor($delta / (self::BOOTSTRAP_BASE - self::BOOTSTRAP_TMIN));
+            $delta = floor($delta / (self::BOOTSTRAP_BASE - self::BOOTSTRAP_TMIN));
 #			let k = k + base
-			$k += self::BOOTSTRAP_BASE;
+            $k += self::BOOTSTRAP_BASE;
 #		end
-		}
+        }
 #		return k + (((base - tmin + 1) * delta) div (delta + skew))
-		return $k + floor(((self::BOOTSTRAP_BASE - self::BOOTSTRAP_TMIN + 1) * $delta) / ($delta + self::BOOTSTRAP_SKEW));
-	}
+        return $k + floor(((self::BOOTSTRAP_BASE - self::BOOTSTRAP_TMIN + 1) * $delta) / ($delta + self::BOOTSTRAP_SKEW));
+    }
 }
\ No newline at end of file

plugin/buycourses/src/Requests/Auth.php

Indentation +11 added lines, -11 removed lines

@@ -19,15 +19,15 @@
  * @subpackage Authentication
  */
 interface Requests_Auth {
-	/**
-	 * Register hooks as needed
-	 *
-	 * This method is called in {@see Requests::request} when the user has set
-	 * an instance as the 'auth' option. Use this callback to register all the
-	 * hooks you'll need.
-	 *
-	 * @see Requests_Hooks::register
-	 * @param Requests_Hooks $hooks Hook system
-	 */
-	public function register(Requests_Hooks &$hooks);
+    /**
+     * Register hooks as needed
+     *
+     * This method is called in {@see Requests::request} when the user has set
+     * an instance as the 'auth' option. Use this callback to register all the
+     * hooks you'll need.
+     *
+     * @see Requests_Hooks::register
+     * @param Requests_Hooks $hooks Hook system
+     */
+    public function register(Requests_Hooks &$hooks);
 }
\ No newline at end of file

plugin/buycourses/src/Requests/Response.php

Indentation +93 added lines, -93 removed lines

@@ -13,109 +13,109 @@
  * @package Requests
  */
 class Requests_Response {
-	/**
-	 * Constructor
-	 */
-	public function __construct() {
-		$this->headers = new Requests_Response_Headers();
-		$this->cookies = new Requests_Cookie_Jar();
-	}
+    /**
+     * Constructor
+     */
+    public function __construct() {
+        $this->headers = new Requests_Response_Headers();
+        $this->cookies = new Requests_Cookie_Jar();
+    }
 
-	/**
-	 * Response body
-	 *
-	 * @var string
-	 */
-	public $body = '';
+    /**
+     * Response body
+     *
+     * @var string
+     */
+    public $body = '';
 
-	/**
-	 * Raw HTTP data from the transport
-	 *
-	 * @var string
-	 */
-	public $raw = '';
+    /**
+     * Raw HTTP data from the transport
+     *
+     * @var string
+     */
+    public $raw = '';
 
-	/**
-	 * Headers, as an associative array
-	 *
-	 * @var Requests_Response_Headers Array-like object representing headers
-	 */
-	public $headers = array();
+    /**
+     * Headers, as an associative array
+     *
+     * @var Requests_Response_Headers Array-like object representing headers
+     */
+    public $headers = array();
 
-	/**
-	 * Status code, false if non-blocking
-	 *
-	 * @var integer|boolean
-	 */
-	public $status_code = false;
+    /**
+     * Status code, false if non-blocking
+     *
+     * @var integer|boolean
+     */
+    public $status_code = false;
 
-	/**
-	 * Protocol version, false if non-blocking
-	 * @var float|boolean
-	 */
-	public $protocol_version = false;
+    /**
+     * Protocol version, false if non-blocking
+     * @var float|boolean
+     */
+    public $protocol_version = false;
 
-	/**
-	 * Whether the request succeeded or not
-	 *
-	 * @var boolean
-	 */
-	public $success = false;
+    /**
+     * Whether the request succeeded or not
+     *
+     * @var boolean
+     */
+    public $success = false;
 
-	/**
-	 * Number of redirects the request used
-	 *
-	 * @var integer
-	 */
-	public $redirects = 0;
+    /**
+     * Number of redirects the request used
+     *
+     * @var integer
+     */
+    public $redirects = 0;
 
-	/**
-	 * URL requested
-	 *
-	 * @var string
-	 */
-	public $url = '';
+    /**
+     * URL requested
+     *
+     * @var string
+     */
+    public $url = '';
 
-	/**
-	 * Previous requests (from redirects)
-	 *
-	 * @var array Array of Requests_Response objects
-	 */
-	public $history = array();
+    /**
+     * Previous requests (from redirects)
+     *
+     * @var array Array of Requests_Response objects
+     */
+    public $history = array();
 
-	/**
-	 * Cookies from the request
-	 *
-	 * @var Requests_Cookie_Jar Array-like object representing a cookie jar
-	 */
-	public $cookies = array();
+    /**
+     * Cookies from the request
+     *
+     * @var Requests_Cookie_Jar Array-like object representing a cookie jar
+     */
+    public $cookies = array();
 
-	/**
-	 * Is the response a redirect?
-	 *
-	 * @return boolean True if redirect (3xx status), false if not.
-	 */
-	public function is_redirect() {
-		$code = $this->status_code;
-		return in_array($code, array(300, 301, 302, 303, 307)) || $code > 307 && $code < 400;
-	}
+    /**
+     * Is the response a redirect?
+     *
+     * @return boolean True if redirect (3xx status), false if not.
+     */
+    public function is_redirect() {
+        $code = $this->status_code;
+        return in_array($code, array(300, 301, 302, 303, 307)) || $code > 307 && $code < 400;
+    }
 
-	/**
-	 * Throws an exception if the request was not successful
-	 *
-	 * @throws Requests_Exception If `$allow_redirects` is false, and code is 3xx (`response.no_redirects`)
-	 * @throws Requests_Exception_HTTP On non-successful status code. Exception class corresponds to code (e.g. {@see Requests_Exception_HTTP_404})
-	 * @param boolean $allow_redirects Set to false to throw on a 3xx as well
-	 */
-	public function throw_for_status($allow_redirects = true) {
-		if ($this->is_redirect()) {
-			if (!$allow_redirects) {
-				throw new Requests_Exception('Redirection not allowed', 'response.no_redirects', $this);
-			}
-		}
-		elseif (!$this->success) {
-			$exception = Requests_Exception_HTTP::get_class($this->status_code);
-			throw new $exception(null, $this);
-		}
-	}
+    /**
+     * Throws an exception if the request was not successful
+     *
+     * @throws Requests_Exception If `$allow_redirects` is false, and code is 3xx (`response.no_redirects`)
+     * @throws Requests_Exception_HTTP On non-successful status code. Exception class corresponds to code (e.g. {@see Requests_Exception_HTTP_404})
+     * @param boolean $allow_redirects Set to false to throw on a 3xx as well
+     */
+    public function throw_for_status($allow_redirects = true) {
+        if ($this->is_redirect()) {
+            if (!$allow_redirects) {
+                throw new Requests_Exception('Redirection not allowed', 'response.no_redirects', $this);
+            }
+        }
+        elseif (!$this->success) {
+            $exception = Requests_Exception_HTTP::get_class($this->status_code);
+            throw new $exception(null, $this);
+        }
+    }
 }

plugin/buycourses/src/Requests/Auth/Basic.php

Indentation +62 added lines, -62 removed lines

@@ -16,73 +16,73 @@
  * @subpackage Authentication
  */
 class Requests_Auth_Basic implements Requests_Auth {
-	/**
-	 * Username
-	 *
-	 * @var string
-	 */
-	public $user;
+    /**
+     * Username
+     *
+     * @var string
+     */
+    public $user;
 
-	/**
-	 * Password
-	 *
-	 * @var string
-	 */
-	public $pass;
+    /**
+     * Password
+     *
+     * @var string
+     */
+    public $pass;
 
-	/**
-	 * Constructor
-	 *
-	 * @throws Requests_Exception On incorrect number of arguments (`authbasicbadargs`)
-	 * @param array|null $args Array of user and password. Must have exactly two elements
-	 */
-	public function __construct($args = null) {
-		if (is_array($args)) {
-			if (count($args) !== 2) {
-				throw new Requests_Exception('Invalid number of arguments', 'authbasicbadargs');
-			}
+    /**
+     * Constructor
+     *
+     * @throws Requests_Exception On incorrect number of arguments (`authbasicbadargs`)
+     * @param array|null $args Array of user and password. Must have exactly two elements
+     */
+    public function __construct($args = null) {
+        if (is_array($args)) {
+            if (count($args) !== 2) {
+                throw new Requests_Exception('Invalid number of arguments', 'authbasicbadargs');
+            }
 
-			list($this->user, $this->pass) = $args;
-		}
-	}
+            list($this->user, $this->pass) = $args;
+        }
+    }
 
-	/**
-	 * Register the necessary callbacks
-	 *
-	 * @see curl_before_send
-	 * @see fsockopen_header
-	 * @param Requests_Hooks $hooks Hook system
-	 */
-	public function register(Requests_Hooks &$hooks) {
-		$hooks->register('curl.before_send', array(&$this, 'curl_before_send'));
-		$hooks->register('fsockopen.after_headers', array(&$this, 'fsockopen_header'));
-	}
+    /**
+     * Register the necessary callbacks
+     *
+     * @see curl_before_send
+     * @see fsockopen_header
+     * @param Requests_Hooks $hooks Hook system
+     */
+    public function register(Requests_Hooks &$hooks) {
+        $hooks->register('curl.before_send', array(&$this, 'curl_before_send'));
+        $hooks->register('fsockopen.after_headers', array(&$this, 'fsockopen_header'));
+    }
 
-	/**
-	 * Set cURL parameters before the data is sent
-	 *
-	 * @param resource $handle cURL resource
-	 */
-	public function curl_before_send(&$handle) {
-		curl_setopt($handle, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
-		curl_setopt($handle, CURLOPT_USERPWD, $this->getAuthString());
-	}
+    /**
+     * Set cURL parameters before the data is sent
+     *
+     * @param resource $handle cURL resource
+     */
+    public function curl_before_send(&$handle) {
+        curl_setopt($handle, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
+        curl_setopt($handle, CURLOPT_USERPWD, $this->getAuthString());
+    }
 
-	/**
-	 * Add extra headers to the request before sending
-	 *
-	 * @param string $out HTTP header string
-	 */
-	public function fsockopen_header(&$out) {
-		$out .= sprintf("Authorization: Basic %s\r\n", base64_encode($this->getAuthString()));
-	}
+    /**
+     * Add extra headers to the request before sending
+     *
+     * @param string $out HTTP header string
+     */
+    public function fsockopen_header(&$out) {
+        $out .= sprintf("Authorization: Basic %s\r\n", base64_encode($this->getAuthString()));
+    }
 
-	/**
-	 * Get the authentication string (user:pass)
-	 *
-	 * @return string
-	 */
-	public function getAuthString() {
-		return $this->user . ':' . $this->pass;
-	}
+    /**
+     * Get the authentication string (user:pass)
+     *
+     * @return string
+     */
+    public function getAuthString() {
+        return $this->user . ':' . $this->pass;
+    }
 }
\ No newline at end of file

plugin/buycourses/src/Requests/Cookie/Jar.php

Indentation +159 added lines, -159 removed lines

@@ -13,163 +13,163 @@
  * @subpackage Cookies
  */
 class Requests_Cookie_Jar implements ArrayAccess, IteratorAggregate {
-	/**
-	 * Actual item data
-	 *
-	 * @var array
-	 */
-	protected $cookies = array();
-
-	/**
-	 * Create a new jar
-	 *
-	 * @param array $cookies Existing cookie values
-	 */
-	public function __construct($cookies = array()) {
-		$this->cookies = $cookies;
-	}
-
-	/**
-	 * Normalise cookie data into a Requests_Cookie
-	 *
-	 * @param string|Requests_Cookie $cookie
-	 * @return Requests_Cookie
-	 */
-	public function normalize_cookie($cookie, $key = null) {
-		if ($cookie instanceof Requests_Cookie) {
-			return $cookie;
-		}
-
-		return Requests_Cookie::parse($cookie, $key);
-	}
-
-	/**
-	 * Normalise cookie data into a Requests_Cookie
-	 *
-	 * @codeCoverageIgnore
-	 * @deprecated Use {@see Requests_Cookie_Jar::normalize_cookie}
-	 * @return Requests_Cookie
-	 */
-	public function normalizeCookie($cookie, $key = null) {
-		return $this->normalize_cookie($cookie, $key);
-	}
-
-	/**
-	 * Check if the given item exists
-	 *
-	 * @param string $key Item key
-	 * @return boolean Does the item exist?
-	 */
-	public function offsetExists($key) {
-		return isset($this->cookies[$key]);
-	}
-
-	/**
-	 * Get the value for the item
-	 *
-	 * @param string $key Item key
-	 * @return string Item value
-	 */
-	public function offsetGet($key) {
-		if (!isset($this->cookies[$key])) {
-			return null;
-		}
-
-		return $this->cookies[$key];
-	}
-
-	/**
-	 * Set the given item
-	 *
-	 * @throws Requests_Exception On attempting to use dictionary as list (`invalidset`)
-	 *
-	 * @param string $key Item name
-	 * @param string $value Item value
-	 */
-	public function offsetSet($key, $value) {
-		if ($key === null) {
-			throw new Requests_Exception('Object is a dictionary, not a list', 'invalidset');
-		}
-
-		$this->cookies[$key] = $value;
-	}
-
-	/**
-	 * Unset the given header
-	 *
-	 * @param string $key
-	 */
-	public function offsetUnset($key) {
-		unset($this->cookies[$key]);
-	}
-
-	/**
-	 * Get an iterator for the data
-	 *
-	 * @return ArrayIterator
-	 */
-	public function getIterator() {
-		return new ArrayIterator($this->cookies);
-	}
-
-	/**
-	 * Register the cookie handler with the request's hooking system
-	 *
-	 * @param Requests_Hooker $hooks Hooking system
-	 */
-	public function register(Requests_Hooker $hooks) {
-		$hooks->register('requests.before_request', array($this, 'before_request'));
-		$hooks->register('requests.before_redirect_check', array($this, 'before_redirect_check'));
-	}
-
-	/**
-	 * Add Cookie header to a request if we have any
-	 *
-	 * As per RFC 6265, cookies are separated by '; '
-	 *
-	 * @param string $url
-	 * @param array $headers
-	 * @param array $data
-	 * @param string $type
-	 * @param array $options
-	 */
-	public function before_request($url, &$headers, &$data, &$type, &$options) {
-		if (!$url instanceof Requests_IRI) {
-			$url = new Requests_IRI($url);
-		}
-
-		if (!empty($this->cookies)) {
-			$cookies = array();
-			foreach ($this->cookies as $key => $cookie) {
-				$cookie = $this->normalize_cookie($cookie, $key);
-
-				// Skip expired cookies
-				if ($cookie->is_expired()) {
-					continue;
-				}
-
-				if ($cookie->domain_matches($url->host)) {
-					$cookies[] = $cookie->format_for_header();
-				}
-			}
-
-			$headers['Cookie'] = implode('; ', $cookies);
-		}
-	}
-
-	/**
-	 * Parse all cookies from a response and attach them to the response
-	 *
-	 * @var Requests_Response $response
-	 */
-	public function before_redirect_check(Requests_Response &$return) {
-		$url = $return->url;
-		if (!$url instanceof Requests_IRI) {
-			$url = new Requests_IRI($url);
-		}
-
-		$cookies = Requests_Cookie::parse_from_headers($return->headers, $url);
-		$this->cookies = array_merge($this->cookies, $cookies);
-		$return->cookies = $this;
-	}
+    /**
+     * Actual item data
+     *
+     * @var array
+     */
+    protected $cookies = array();
+
+    /**
+     * Create a new jar
+     *
+     * @param array $cookies Existing cookie values
+     */
+    public function __construct($cookies = array()) {
+        $this->cookies = $cookies;
+    }
+
+    /**
+     * Normalise cookie data into a Requests_Cookie
+     *
+     * @param string|Requests_Cookie $cookie
+     * @return Requests_Cookie
+     */
+    public function normalize_cookie($cookie, $key = null) {
+        if ($cookie instanceof Requests_Cookie) {
+            return $cookie;
+        }
+
+        return Requests_Cookie::parse($cookie, $key);
+    }
+
+    /**
+     * Normalise cookie data into a Requests_Cookie
+     *
+     * @codeCoverageIgnore
+     * @deprecated Use {@see Requests_Cookie_Jar::normalize_cookie}
+     * @return Requests_Cookie
+     */
+    public function normalizeCookie($cookie, $key = null) {
+        return $this->normalize_cookie($cookie, $key);
+    }
+
+    /**
+     * Check if the given item exists
+     *
+     * @param string $key Item key
+     * @return boolean Does the item exist?
+     */
+    public function offsetExists($key) {
+        return isset($this->cookies[$key]);
+    }
+
+    /**
+     * Get the value for the item
+     *
+     * @param string $key Item key
+     * @return string Item value
+     */
+    public function offsetGet($key) {
+        if (!isset($this->cookies[$key])) {
+            return null;
+        }
+
+        return $this->cookies[$key];
+    }
+
+    /**
+     * Set the given item
+     *
+     * @throws Requests_Exception On attempting to use dictionary as list (`invalidset`)
+     *
+     * @param string $key Item name
+     * @param string $value Item value
+     */
+    public function offsetSet($key, $value) {
+        if ($key === null) {
+            throw new Requests_Exception('Object is a dictionary, not a list', 'invalidset');
+        }
+
+        $this->cookies[$key] = $value;
+    }
+
+    /**
+     * Unset the given header
+     *
+     * @param string $key
+     */
+    public function offsetUnset($key) {
+        unset($this->cookies[$key]);
+    }
+
+    /**
+     * Get an iterator for the data
+     *
+     * @return ArrayIterator
+     */
+    public function getIterator() {
+        return new ArrayIterator($this->cookies);
+    }
+
+    /**
+     * Register the cookie handler with the request's hooking system
+     *
+     * @param Requests_Hooker $hooks Hooking system
+     */
+    public function register(Requests_Hooker $hooks) {
+        $hooks->register('requests.before_request', array($this, 'before_request'));
+        $hooks->register('requests.before_redirect_check', array($this, 'before_redirect_check'));
+    }
+
+    /**
+     * Add Cookie header to a request if we have any
+     *
+     * As per RFC 6265, cookies are separated by '; '
+     *
+     * @param string $url
+     * @param array $headers
+     * @param array $data
+     * @param string $type
+     * @param array $options
+     */
+    public function before_request($url, &$headers, &$data, &$type, &$options) {
+        if (!$url instanceof Requests_IRI) {
+            $url = new Requests_IRI($url);
+        }
+
+        if (!empty($this->cookies)) {
+            $cookies = array();
+            foreach ($this->cookies as $key => $cookie) {
+                $cookie = $this->normalize_cookie($cookie, $key);
+
+                // Skip expired cookies
+                if ($cookie->is_expired()) {
+                    continue;
+                }
+
+                if ($cookie->domain_matches($url->host)) {
+                    $cookies[] = $cookie->format_for_header();
+                }
+            }
+
+            $headers['Cookie'] = implode('; ', $cookies);
+        }
+    }
+
+    /**
+     * Parse all cookies from a response and attach them to the response
+     *
+     * @var Requests_Response $response
+     */
+    public function before_redirect_check(Requests_Response &$return) {
+        $url = $return->url;
+        if (!$url instanceof Requests_IRI) {
+            $url = new Requests_IRI($url);
+        }
+
+        $cookies = Requests_Cookie::parse_from_headers($return->headers, $url);
+        $this->cookies = array_merge($this->cookies, $cookies);
+        $return->cookies = $this;
+    }
 }
\ No newline at end of file

plugin/buycourses/src/Requests/Session.php

Indentation +204 added lines, -204 removed lines

@@ -18,136 +18,136 @@ 
  * @subpackage Session Handler
  */
 class Requests_Session {
-	/**
-	 * Base URL for requests
-	 *
-	 * URLs will be made absolute using this as the base
-	 * @var string|null
-	 */
-	public $url = null;
+    /**
+     * Base URL for requests
+     *
+     * URLs will be made absolute using this as the base
+     * @var string|null
+     */
+    public $url = null;
 
-	/**
-	 * Base headers for requests
-	 * @var array
-	 */
-	public $headers = array();
+    /**
+     * Base headers for requests
+     * @var array
+     */
+    public $headers = array();
 
-	/**
-	 * Base data for requests
-	 *
-	 * If both the base data and the per-request data are arrays, the data will
-	 * be merged before sending the request.
-	 *
-	 * @var array
-	 */
-	public $data = array();
+    /**
+     * Base data for requests
+     *
+     * If both the base data and the per-request data are arrays, the data will
+     * be merged before sending the request.
+     *
+     * @var array
+     */
+    public $data = array();
 
-	/**
-	 * Base options for requests
-	 *
-	 * The base options are merged with the per-request data for each request.
-	 * The only default option is a shared cookie jar between requests.
-	 *
-	 * Values here can also be set directly via properties on the Session
-	 * object, e.g. `$session->useragent = 'X';`
-	 *
-	 * @var array
-	 */
-	public $options = array();
+    /**
+     * Base options for requests
+     *
+     * The base options are merged with the per-request data for each request.
+     * The only default option is a shared cookie jar between requests.
+     *
+     * Values here can also be set directly via properties on the Session
+     * object, e.g. `$session->useragent = 'X';`
+     *
+     * @var array
+     */
+    public $options = array();
 
-	/**
-	 * Create a new session
-	 *
-	 * @param string|null $url Base URL for requests
-	 * @param array $headers Default headers for requests
-	 * @param array $data Default data for requests
-	 * @param array $options Default options for requests
-	 */
-	public function __construct($url = null, $headers = array(), $data = array(), $options = array()) {
-		$this->url = $url;
-		$this->headers = $headers;
-		$this->data = $data;
-		$this->options = $options;
+    /**
+     * Create a new session
+     *
+     * @param string|null $url Base URL for requests
+     * @param array $headers Default headers for requests
+     * @param array $data Default data for requests
+     * @param array $options Default options for requests
+     */
+    public function __construct($url = null, $headers = array(), $data = array(), $options = array()) {
+        $this->url = $url;
+        $this->headers = $headers;
+        $this->data = $data;
+        $this->options = $options;
 
-		if (empty($this->options['cookies'])) {
-			$this->options['cookies'] = new Requests_Cookie_Jar();
-		}
-	}
+        if (empty($this->options['cookies'])) {
+            $this->options['cookies'] = new Requests_Cookie_Jar();
+        }
+    }
 
-	/**
-	 * Get a property's value
-	 *
-	 * @param string $key Property key
-	 * @return mixed|null Property value, null if none found
-	 */
-	public function __get($key) {
-		if (isset($this->options[$key])) {
-			return $this->options[$key];
-		}
+    /**
+     * Get a property's value
+     *
+     * @param string $key Property key
+     * @return mixed|null Property value, null if none found
+     */
+    public function __get($key) {
+        if (isset($this->options[$key])) {
+            return $this->options[$key];
+        }
 
-		return null;
-	}
+        return null;
+    }
 
-	/**
-	 * Set a property's value
-	 *
-	 * @param string $key Property key
-	 * @param mixed $value Property value
-	 */
-	public function __set($key, $value) {
-		$this->options[$key] = $value;
-	}
+    /**
+     * Set a property's value
+     *
+     * @param string $key Property key
+     * @param mixed $value Property value
+     */
+    public function __set($key, $value) {
+        $this->options[$key] = $value;
+    }
 
-	/**
-	 * Remove a property's value
-	 *
-	 * @param string $key Property key
-	 */
-	public function __isset($key) {
-		return isset($this->options[$key]);
-	}
+    /**
+     * Remove a property's value
+     *
+     * @param string $key Property key
+     */
+    public function __isset($key) {
+        return isset($this->options[$key]);
+    }
 
-	/**
-	 * Remove a property's value
-	 *
-	 * @param string $key Property key
-	 */
-	public function __unset($key) {
-		if (isset($this->options[$key])) {
-			unset($this->options[$key]);
-		}
-	}
+    /**
+     * Remove a property's value
+     *
+     * @param string $key Property key
+     */
+    public function __unset($key) {
+        if (isset($this->options[$key])) {
+            unset($this->options[$key]);
+        }
+    }
 
-	/**#@+
+    /**#@+
 	 * @see request()
 	 * @param string $url
 	 * @param array $headers
 	 * @param array $options
 	 * @return Requests_Response
 	 */
-	/**
-	 * Send a GET request
-	 */
-	public function get($url, $headers = array(), $options = array()) {
-		return $this->request($url, $headers, null, Requests::GET, $options);
-	}
+    /**
+     * Send a GET request
+     */
+    public function get($url, $headers = array(), $options = array()) {
+        return $this->request($url, $headers, null, Requests::GET, $options);
+    }
 
-	/**
-	 * Send a HEAD request
-	 */
-	public function head($url, $headers = array(), $options = array()) {
-		return $this->request($url, $headers, null, Requests::HEAD, $options);
-	}
+    /**
+     * Send a HEAD request
+     */
+    public function head($url, $headers = array(), $options = array()) {
+        return $this->request($url, $headers, null, Requests::HEAD, $options);
+    }
 
-	/**
-	 * Send a DELETE request
-	 */
-	public function delete($url, $headers = array(), $options = array()) {
-		return $this->request($url, $headers, null, Requests::DELETE, $options);
-	}
-	/**#@-*/
+    /**
+     * Send a DELETE request
+     */
+    public function delete($url, $headers = array(), $options = array()) {
+        return $this->request($url, $headers, null, Requests::DELETE, $options);
+    }
+    /**#@-*/
 
-	/**#@+
+    /**#@+
 	 * @see request()
 	 * @param string $url
 	 * @param array $headers
@@ -155,112 +155,112 @@ 
 	 * @param array $options
 	 * @return Requests_Response
 	 */
-	/**
-	 * Send a POST request
-	 */
-	public function post($url, $headers = array(), $data = array(), $options = array()) {
-		return $this->request($url, $headers, $data, Requests::POST, $options);
-	}
+    /**
+     * Send a POST request
+     */
+    public function post($url, $headers = array(), $data = array(), $options = array()) {
+        return $this->request($url, $headers, $data, Requests::POST, $options);
+    }
 
-	/**
-	 * Send a PUT request
-	 */
-	public function put($url, $headers = array(), $data = array(), $options = array()) {
-		return $this->request($url, $headers, $data, Requests::PUT, $options);
-	}
+    /**
+     * Send a PUT request
+     */
+    public function put($url, $headers = array(), $data = array(), $options = array()) {
+        return $this->request($url, $headers, $data, Requests::PUT, $options);
+    }
 
-	/**
-	 * Send a PATCH request
-	 *
-	 * Note: Unlike {@see post} and {@see put}, `$headers` is required, as the
-	 * specification recommends that should send an ETag
-	 *
-	 * @link https://tools.ietf.org/html/rfc5789
-	 */
-	public function patch($url, $headers, $data = array(), $options = array()) {
-		return $this->request($url, $headers, $data, Requests::PATCH, $options);
-	}
-	/**#@-*/
+    /**
+     * Send a PATCH request
+     *
+     * Note: Unlike {@see post} and {@see put}, `$headers` is required, as the
+     * specification recommends that should send an ETag
+     *
+     * @link https://tools.ietf.org/html/rfc5789
+     */
+    public function patch($url, $headers, $data = array(), $options = array()) {
+        return $this->request($url, $headers, $data, Requests::PATCH, $options);
+    }
+    /**#@-*/
 
-	/**
-	 * Main interface for HTTP requests
-	 *
-	 * This method initiates a request and sends it via a transport before
-	 * parsing.
-	 *
-	 * @see Requests::request()
-	 *
-	 * @throws Requests_Exception On invalid URLs (`nonhttp`)
-	 *
-	 * @param string $url URL to request
-	 * @param array $headers Extra headers to send with the request
-	 * @param array|null $data Data to send either as a query string for GET/HEAD requests, or in the body for POST requests
-	 * @param string $type HTTP request type (use Requests constants)
-	 * @param array $options Options for the request (see {@see Requests::request})
-	 * @return Requests_Response
-	 */
-	public function request($url, $headers = array(), $data = array(), $type = Requests::GET, $options = array()) {
-		$request = $this->merge_request(compact('url', 'headers', 'data', 'options'));
+    /**
+     * Main interface for HTTP requests
+     *
+     * This method initiates a request and sends it via a transport before
+     * parsing.
+     *
+     * @see Requests::request()
+     *
+     * @throws Requests_Exception On invalid URLs (`nonhttp`)
+     *
+     * @param string $url URL to request
+     * @param array $headers Extra headers to send with the request
+     * @param array|null $data Data to send either as a query string for GET/HEAD requests, or in the body for POST requests
+     * @param string $type HTTP request type (use Requests constants)
+     * @param array $options Options for the request (see {@see Requests::request})
+     * @return Requests_Response
+     */
+    public function request($url, $headers = array(), $data = array(), $type = Requests::GET, $options = array()) {
+        $request = $this->merge_request(compact('url', 'headers', 'data', 'options'));
 
-		return Requests::request($request['url'], $request['headers'], $request['data'], $type, $request['options']);
-	}
+        return Requests::request($request['url'], $request['headers'], $request['data'], $type, $request['options']);
+    }
 
-	/**
-	 * Send multiple HTTP requests simultaneously
-	 *
-	 * @see Requests::request_multiple()
-	 *
-	 * @param array $requests Requests data (see {@see Requests::request_multiple})
-	 * @param array $options Global and default options (see {@see Requests::request})
-	 * @return array Responses (either Requests_Response or a Requests_Exception object)
-	 */
-	public function request_multiple($requests, $options = array()) {
-		foreach ($requests as $key => $request) {
-			$requests[$key] = $this->merge_request($request, false);
-		}
+    /**
+     * Send multiple HTTP requests simultaneously
+     *
+     * @see Requests::request_multiple()
+     *
+     * @param array $requests Requests data (see {@see Requests::request_multiple})
+     * @param array $options Global and default options (see {@see Requests::request})
+     * @return array Responses (either Requests_Response or a Requests_Exception object)
+     */
+    public function request_multiple($requests, $options = array()) {
+        foreach ($requests as $key => $request) {
+            $requests[$key] = $this->merge_request($request, false);
+        }
 
-		$options = array_merge($this->options, $options);
+        $options = array_merge($this->options, $options);
 
-		// Disallow forcing the type, as that's a per request setting
-		unset($options['type']);
+        // Disallow forcing the type, as that's a per request setting
+        unset($options['type']);
 
-		return Requests::request_multiple($requests, $options);
-	}
+        return Requests::request_multiple($requests, $options);
+    }
 
-	/**
-	 * Merge a request's data with the default data
-	 *
-	 * @param array $request Request data (same form as {@see request_multiple})
-	 * @param boolean $merge_options Should we merge options as well?
-	 * @return array Request data
-	 */
-	protected function merge_request($request, $merge_options = true) {
-		if ($this->url !== null) {
-			$request['url'] = Requests_IRI::absolutize($this->url, $request['url']);
-			$request['url'] = $request['url']->uri;
-		}
+    /**
+     * Merge a request's data with the default data
+     *
+     * @param array $request Request data (same form as {@see request_multiple})
+     * @param boolean $merge_options Should we merge options as well?
+     * @return array Request data
+     */
+    protected function merge_request($request, $merge_options = true) {
+        if ($this->url !== null) {
+            $request['url'] = Requests_IRI::absolutize($this->url, $request['url']);
+            $request['url'] = $request['url']->uri;
+        }
 
-		if (empty($request['headers'])) {
-			$request['headers'] = array();
-		}
-		$request['headers'] = array_merge($this->headers, $request['headers']);
+        if (empty($request['headers'])) {
+            $request['headers'] = array();
+        }
+        $request['headers'] = array_merge($this->headers, $request['headers']);
 
-		if (empty($request['data'])) {
-			if (is_array($this->data)) {
-				$request['data'] = $this->data;
-			}
-		}
-		elseif (is_array($request['data']) && is_array($this->data)) {
-			$request['data'] = array_merge($this->data, $request['data']);
-		}
+        if (empty($request['data'])) {
+            if (is_array($this->data)) {
+                $request['data'] = $this->data;
+            }
+        }
+        elseif (is_array($request['data']) && is_array($this->data)) {
+            $request['data'] = array_merge($this->data, $request['data']);
+        }
 
-		if ($merge_options !== false) {
-			$request['options'] = array_merge($this->options, $request['options']);
+        if ($merge_options !== false) {
+            $request['options'] = array_merge($this->options, $request['options']);
 
-			// Disallow forcing the type, as that's a per request setting
-			unset($request['options']['type']);
-		}
+            // Disallow forcing the type, as that's a per request setting
+            unset($request['options']['type']);
+        }
 
-		return $request;
-	}
+        return $request;
+    }
 }

plugin/buycourses/src/Requests/Cookie.php

Indentation +484 added lines, -484 removed lines

@@ -13,488 +13,488 @@
  * @subpackage Cookies
  */
 class Requests_Cookie {
-	/**
-	 * Cookie name.
-	 *
-	 * @var string
-	 */
-	public $name;
-
-	/**
-	 * Cookie value.
-	 *
-	 * @var string
-	 */
-	public $value;
-
-	/**
-	 * Cookie attributes
-	 *
-	 * Valid keys are (currently) path, domain, expires, max-age, secure and
-	 * httponly.
-	 *
-	 * @var Requests_Utility_CaseInsensitiveDictionary|array Array-like object
-	 */
-	public $attributes = array();
-
-	/**
-	 * Cookie flags
-	 *
-	 * Valid keys are (currently) creation, last-access, persistent and
-	 * host-only.
-	 *
-	 * @var array
-	 */
-	public $flags = array();
-
-	/**
-	 * Reference time for relative calculations
-	 *
-	 * This is used in place of `time()` when calculating Max-Age expiration and
-	 * checking time validity.
-	 *
-	 * @var int
-	 */
-	public $reference_time = 0;
-
-	/**
-	 * Create a new cookie object
-	 *
-	 * @param string $name
-	 * @param string $value
-	 * @param array|Requests_Utility_CaseInsensitiveDictionary $attributes Associative array of attribute data
-	 */
-	public function __construct($name, $value, $attributes = array(), $flags = array(), $reference_time = null) {
-		$this->name = $name;
-		$this->value = $value;
-		$this->attributes = $attributes;
-		$default_flags = array(
-			'creation' => time(),
-			'last-access' => time(),
-			'persistent' => false,
-			'host-only' => true,
-		);
-		$this->flags = array_merge($default_flags, $flags);
-
-		$this->reference_time = time();
-		if ($reference_time !== null) {
-			$this->reference_time = $reference_time;
-		}
-
-		$this->normalize();
-	}
-
-	/**
-	 * Check if a cookie is expired.
-	 *
-	 * Checks the age against $this->reference_time to determine if the cookie
-	 * is expired.
-	 *
-	 * @return boolean True if expired, false if time is valid.
-	 */
-	public function is_expired() {
-		// RFC6265, s. 4.1.2.2:
-		// If a cookie has both the Max-Age and the Expires attribute, the Max-
-		// Age attribute has precedence and controls the expiration date of the
-		// cookie.
-		if (isset($this->attributes['max-age'])) {
-			$max_age = $this->attributes['max-age'];
-			return $max_age < $this->reference_time;
-		}
-
-		if (isset($this->attributes['expires'])) {
-			$expires = $this->attributes['expires'];
-			return $expires < $this->reference_time;
-		}
-
-		return false;
-	}
-
-	/**
-	 * Check if a cookie is valid for a given URI
-	 *
-	 * @param Requests_IRI $uri URI to check
-	 * @return boolean Whether the cookie is valid for the given URI
-	 */
-	public function uri_matches(Requests_IRI $uri) {
-		if (!$this->domain_matches($uri->host)) {
-			return false;
-		}
-
-		if (!$this->path_matches($uri->path)) {
-			return false;
-		}
-
-		return empty($this->attributes['secure']) || $uri->scheme === 'https';
-	}
-
-	/**
-	 * Check if a cookie is valid for a given domain
-	 *
-	 * @param string $string Domain to check
-	 * @return boolean Whether the cookie is valid for the given domain
-	 */
-	public function domain_matches($string) {
-		if (!isset($this->attributes['domain'])) {
-			// Cookies created manually; cookies created by Requests will set
-			// the domain to the requested domain
-			return true;
-		}
-
-		$domain_string = $this->attributes['domain'];
-		if ($domain_string === $string) {
-			// The domain string and the string are identical.
-			return true;
-		}
-
-		// If the cookie is marked as host-only and we don't have an exact
-		// match, reject the cookie
-		if ($this->flags['host-only'] === true) {
-			return false;
-		}
-
-		if (strlen($string) <= strlen($domain_string)) {
-			// For obvious reasons, the string cannot be a suffix if the domain
-			// is shorter than the domain string
-			return false;
-		}
-
-		if (substr($string, -1 * strlen($domain_string)) !== $domain_string) {
-			// The domain string should be a suffix of the string.
-			return false;
-		}
-
-		$prefix = substr($string, 0, strlen($string) - strlen($domain_string));
-		if (substr($prefix, -1) !== '.') {
-			// The last character of the string that is not included in the
-			// domain string should be a %x2E (".") character.
-			return false;
-		}
-
-		// The string should be a host name (i.e., not an IP address).
-		return !preg_match('#^(.+\.)\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$#', $string);
-	}
-
-	/**
-	 * Check if a cookie is valid for a given path
-	 *
-	 * From the path-match check in RFC 6265 section 5.1.4
-	 *
-	 * @param string $request_path Path to check
-	 * @return boolean Whether the cookie is valid for the given path
-	 */
-	public function path_matches($request_path) {
-		if (empty($request_path)) {
-			// Normalize empty path to root
-			$request_path = '/';
-		}
-
-		if (!isset($this->attributes['path'])) {
-			// Cookies created manually; cookies created by Requests will set
-			// the path to the requested path
-			return true;
-		}
-
-		$cookie_path = $this->attributes['path'];
-
-		if ($cookie_path === $request_path) {
-			// The cookie-path and the request-path are identical.
-			return true;
-		}
-
-		if (strlen($request_path) > strlen($cookie_path) && substr($request_path, 0, strlen($cookie_path)) === $cookie_path) {
-			if (substr($cookie_path, -1) === '/') {
-				// The cookie-path is a prefix of the request-path, and the last
-				// character of the cookie-path is %x2F ("/").
-				return true;
-			}
-
-			if (substr($request_path, strlen($cookie_path), 1) === '/') {
-				// The cookie-path is a prefix of the request-path, and the
-				// first character of the request-path that is not included in
-				// the cookie-path is a %x2F ("/") character.
-				return true;
-			}
-		}
-
-		return false;
-	}
-
-	/**
-	 * Normalize cookie and attributes
-	 *
-	 * @return boolean Whether the cookie was successfully normalized
-	 */
-	public function normalize() {
-		foreach ($this->attributes as $key => $value) {
-			$orig_value = $value;
-			$value = $this->normalize_attribute($key, $value);
-			if ($value === null) {
-				unset($this->attributes[$key]);
-				continue;
-			}
-
-			if ($value !== $orig_value) {
-				$this->attributes[$key] = $value;
-			}
-		}
-
-		return true;
-	}
-
-	/**
-	 * Parse an individual cookie attribute
-	 *
-	 * Handles parsing individual attributes from the cookie values.
-	 *
-	 * @param string $name Attribute name
-	 * @param string|boolean $value Attribute value (string value, or true if empty/flag)
-	 * @return mixed Value if available, or null if the attribute value is invalid (and should be skipped)
-	 */
-	protected function normalize_attribute($name, $value) {
-		switch (strtolower($name)) {
-			case 'expires':
-				// Expiration parsing, as per RFC 6265 section 5.2.1
-				if (is_int($value)) {
-					return $value;
-				}
-
-				$expiry_time = strtotime($value);
-				if ($expiry_time === false) {
-					return null;
-				}
-
-				return $expiry_time;
-
-			case 'max-age':
-				// Expiration parsing, as per RFC 6265 section 5.2.2
-				if (is_int($value)) {
-					return $value;
-				}
-
-				// Check that we have a valid age
-				if (!preg_match('/^-?\d+$/', $value)) {
-					return null;
-				}
-
-				$delta_seconds = (int) $value;
-				if ($delta_seconds <= 0) {
-					$expiry_time = 0;
-				}
-				else {
-					$expiry_time = $this->reference_time + $delta_seconds;
-				}
-
-				return $expiry_time;
-
-			case 'domain':
-				// Domain normalization, as per RFC 6265 section 5.2.3
-				if ($value[0] === '.') {
-					$value = substr($value, 1);
-				}
-
-				return $value;
-
-			default:
-				return $value;
-		}
-	}
-
-	/**
-	 * Format a cookie for a Cookie header
-	 *
-	 * This is used when sending cookies to a server.
-	 *
-	 * @return string Cookie formatted for Cookie header
-	 */
-	public function format_for_header() {
-		return sprintf('%s=%s', $this->name, $this->value);
-	}
-
-	/**
-	 * Format a cookie for a Cookie header
-	 *
-	 * @codeCoverageIgnore
-	 * @deprecated Use {@see Requests_Cookie::format_for_header}
-	 * @return string
-	 */
-	public function formatForHeader() {
-		return $this->format_for_header();
-	}
-
-	/**
-	 * Format a cookie for a Set-Cookie header
-	 *
-	 * This is used when sending cookies to clients. This isn't really
-	 * applicable to client-side usage, but might be handy for debugging.
-	 *
-	 * @return string Cookie formatted for Set-Cookie header
-	 */
-	public function format_for_set_cookie() {
-		$header_value = $this->format_for_header();
-		if (!empty($this->attributes)) {
-			$parts = array();
-			foreach ($this->attributes as $key => $value) {
-				// Ignore non-associative attributes
-				if (is_numeric($key)) {
-					$parts[] = $value;
-				}
-				else {
-					$parts[] = sprintf('%s=%s', $key, $value);
-				}
-			}
-
-			$header_value .= '; ' . implode('; ', $parts);
-		}
-		return $header_value;
-	}
-
-	/**
-	 * Format a cookie for a Set-Cookie header
-	 *
-	 * @codeCoverageIgnore
-	 * @deprecated Use {@see Requests_Cookie::format_for_set_cookie}
-	 * @return string
-	 */
-	public function formatForSetCookie() {
-		return $this->format_for_set_cookie();
-	}
-
-	/**
-	 * Get the cookie value
-	 *
-	 * Attributes and other data can be accessed via methods.
-	 */
-	public function __toString() {
-		return $this->value;
-	}
-
-	/**
-	 * Parse a cookie string into a cookie object
-	 *
-	 * Based on Mozilla's parsing code in Firefox and related projects, which
-	 * is an intentional deviation from RFC 2109 and RFC 2616. RFC 6265
-	 * specifies some of this handling, but not in a thorough manner.
-	 *
-	 * @param string Cookie header value (from a Set-Cookie header)
-	 * @return Requests_Cookie Parsed cookie object
-	 */
-	public static function parse($string, $name = '', $reference_time = null) {
-		$parts = explode(';', $string);
-		$kvparts = array_shift($parts);
-
-		if (!empty($name)) {
-			$value = $string;
-		}
-		elseif (strpos($kvparts, '=') === false) {
-			// Some sites might only have a value without the equals separator.
-			// Deviate from RFC 6265 and pretend it was actually a blank name
-			// (`=foo`)
-			//
-			// https://bugzilla.mozilla.org/show_bug.cgi?id=169091
-			$name = '';
-			$value = $kvparts;
-		}
-		else {
-			list($name, $value) = explode('=', $kvparts, 2);
-		}
-		$name = trim($name);
-		$value = trim($value);
-
-		// Attribute key are handled case-insensitively
-		$attributes = new Requests_Utility_CaseInsensitiveDictionary();
-
-		if (!empty($parts)) {
-			foreach ($parts as $part) {
-				if (strpos($part, '=') === false) {
-					$part_key = $part;
-					$part_value = true;
-				}
-				else {
-					list($part_key, $part_value) = explode('=', $part, 2);
-					$part_value = trim($part_value);
-				}
-
-				$part_key = trim($part_key);
-				$attributes[$part_key] = $part_value;
-			}
-		}
-
-		return new Requests_Cookie($name, $value, $attributes, array(), $reference_time);
-	}
-
-	/**
-	 * Parse all Set-Cookie headers from request headers
-	 *
-	 * @param Requests_Response_Headers $headers Headers to parse from
-	 * @param Requests_IRI|null $origin URI for comparing cookie origins
-	 * @param int|null $time Reference time for expiration calculation
-	 * @return array
-	 */
-	public static function parse_from_headers(Requests_Response_Headers $headers, Requests_IRI $origin = null, $time = null) {
-		$cookie_headers = $headers->getValues('Set-Cookie');
-		if (empty($cookie_headers)) {
-			return array();
-		}
-
-		$cookies = array();
-		foreach ($cookie_headers as $header) {
-			$parsed = self::parse($header, '', $time);
-
-			// Default domain/path attributes
-			if (empty($parsed->attributes['domain']) && !empty($origin)) {
-				$parsed->attributes['domain'] = $origin->host;
-				$parsed->flags['host-only'] = true;
-			}
-			else {
-				$parsed->flags['host-only'] = false;
-			}
-
-			$path_is_valid = (!empty($parsed->attributes['path']) && $parsed->attributes['path'][0] === '/');
-			if (!$path_is_valid && !empty($origin)) {
-				$path = $origin->path;
-
-				// Default path normalization as per RFC 6265 section 5.1.4
-				if (substr($path, 0, 1) !== '/') {
-					// If the uri-path is empty or if the first character of
-					// the uri-path is not a %x2F ("/") character, output
-					// %x2F ("/") and skip the remaining steps.
-					$path = '/';
-				}
-				elseif (substr_count($path, '/') === 1) {
-					// If the uri-path contains no more than one %x2F ("/")
-					// character, output %x2F ("/") and skip the remaining
-					// step.
-					$path = '/';
-				}
-				else {
-					// Output the characters of the uri-path from the first
-					// character up to, but not including, the right-most
-					// %x2F ("/").
-					$path = substr($path, 0, strrpos($path, '/'));
-				}
-				$parsed->attributes['path'] = $path;
-			}
-
-			// Reject invalid cookie domains
-			if (!empty($origin) && !$parsed->domain_matches($origin->host)) {
-				continue;
-			}
-
-			$cookies[$parsed->name] = $parsed;
-		}
-
-		return $cookies;
-	}
-
-	/**
-	 * Parse all Set-Cookie headers from request headers
-	 *
-	 * @codeCoverageIgnore
-	 * @deprecated Use {@see Requests_Cookie::parse_from_headers}
-	 * @return string
-	 */
-	public static function parseFromHeaders(Requests_Response_Headers $headers) {
-		return self::parse_from_headers($headers);
-	}
+    /**
+     * Cookie name.
+     *
+     * @var string
+     */
+    public $name;
+
+    /**
+     * Cookie value.
+     *
+     * @var string
+     */
+    public $value;
+
+    /**
+     * Cookie attributes
+     *
+     * Valid keys are (currently) path, domain, expires, max-age, secure and
+     * httponly.
+     *
+     * @var Requests_Utility_CaseInsensitiveDictionary|array Array-like object
+     */
+    public $attributes = array();
+
+    /**
+     * Cookie flags
+     *
+     * Valid keys are (currently) creation, last-access, persistent and
+     * host-only.
+     *
+     * @var array
+     */
+    public $flags = array();
+
+    /**
+     * Reference time for relative calculations
+     *
+     * This is used in place of `time()` when calculating Max-Age expiration and
+     * checking time validity.
+     *
+     * @var int
+     */
+    public $reference_time = 0;
+
+    /**
+     * Create a new cookie object
+     *
+     * @param string $name
+     * @param string $value
+     * @param array|Requests_Utility_CaseInsensitiveDictionary $attributes Associative array of attribute data
+     */
+    public function __construct($name, $value, $attributes = array(), $flags = array(), $reference_time = null) {
+        $this->name = $name;
+        $this->value = $value;
+        $this->attributes = $attributes;
+        $default_flags = array(
+            'creation' => time(),
+            'last-access' => time(),
+            'persistent' => false,
+            'host-only' => true,
+        );
+        $this->flags = array_merge($default_flags, $flags);
+
+        $this->reference_time = time();
+        if ($reference_time !== null) {
+            $this->reference_time = $reference_time;
+        }
+
+        $this->normalize();
+    }
+
+    /**
+     * Check if a cookie is expired.
+     *
+     * Checks the age against $this->reference_time to determine if the cookie
+     * is expired.
+     *
+     * @return boolean True if expired, false if time is valid.
+     */
+    public function is_expired() {
+        // RFC6265, s. 4.1.2.2:
+        // If a cookie has both the Max-Age and the Expires attribute, the Max-
+        // Age attribute has precedence and controls the expiration date of the
+        // cookie.
+        if (isset($this->attributes['max-age'])) {
+            $max_age = $this->attributes['max-age'];
+            return $max_age < $this->reference_time;
+        }
+
+        if (isset($this->attributes['expires'])) {
+            $expires = $this->attributes['expires'];
+            return $expires < $this->reference_time;
+        }
+
+        return false;
+    }
+
+    /**
+     * Check if a cookie is valid for a given URI
+     *
+     * @param Requests_IRI $uri URI to check
+     * @return boolean Whether the cookie is valid for the given URI
+     */
+    public function uri_matches(Requests_IRI $uri) {
+        if (!$this->domain_matches($uri->host)) {
+            return false;
+        }
+
+        if (!$this->path_matches($uri->path)) {
+            return false;
+        }
+
+        return empty($this->attributes['secure']) || $uri->scheme === 'https';
+    }
+
+    /**
+     * Check if a cookie is valid for a given domain
+     *
+     * @param string $string Domain to check
+     * @return boolean Whether the cookie is valid for the given domain
+     */
+    public function domain_matches($string) {
+        if (!isset($this->attributes['domain'])) {
+            // Cookies created manually; cookies created by Requests will set
+            // the domain to the requested domain
+            return true;
+        }
+
+        $domain_string = $this->attributes['domain'];
+        if ($domain_string === $string) {
+            // The domain string and the string are identical.
+            return true;
+        }
+
+        // If the cookie is marked as host-only and we don't have an exact
+        // match, reject the cookie
+        if ($this->flags['host-only'] === true) {
+            return false;
+        }
+
+        if (strlen($string) <= strlen($domain_string)) {
+            // For obvious reasons, the string cannot be a suffix if the domain
+            // is shorter than the domain string
+            return false;
+        }
+
+        if (substr($string, -1 * strlen($domain_string)) !== $domain_string) {
+            // The domain string should be a suffix of the string.
+            return false;
+        }
+
+        $prefix = substr($string, 0, strlen($string) - strlen($domain_string));
+        if (substr($prefix, -1) !== '.') {
+            // The last character of the string that is not included in the
+            // domain string should be a %x2E (".") character.
+            return false;
+        }
+
+        // The string should be a host name (i.e., not an IP address).
+        return !preg_match('#^(.+\.)\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$#', $string);
+    }
+
+    /**
+     * Check if a cookie is valid for a given path
+     *
+     * From the path-match check in RFC 6265 section 5.1.4
+     *
+     * @param string $request_path Path to check
+     * @return boolean Whether the cookie is valid for the given path
+     */
+    public function path_matches($request_path) {
+        if (empty($request_path)) {
+            // Normalize empty path to root
+            $request_path = '/';
+        }
+
+        if (!isset($this->attributes['path'])) {
+            // Cookies created manually; cookies created by Requests will set
+            // the path to the requested path
+            return true;
+        }
+
+        $cookie_path = $this->attributes['path'];
+
+        if ($cookie_path === $request_path) {
+            // The cookie-path and the request-path are identical.
+            return true;
+        }
+
+        if (strlen($request_path) > strlen($cookie_path) && substr($request_path, 0, strlen($cookie_path)) === $cookie_path) {
+            if (substr($cookie_path, -1) === '/') {
+                // The cookie-path is a prefix of the request-path, and the last
+                // character of the cookie-path is %x2F ("/").
+                return true;
+            }
+
+            if (substr($request_path, strlen($cookie_path), 1) === '/') {
+                // The cookie-path is a prefix of the request-path, and the
+                // first character of the request-path that is not included in
+                // the cookie-path is a %x2F ("/") character.
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Normalize cookie and attributes
+     *
+     * @return boolean Whether the cookie was successfully normalized
+     */
+    public function normalize() {
+        foreach ($this->attributes as $key => $value) {
+            $orig_value = $value;
+            $value = $this->normalize_attribute($key, $value);
+            if ($value === null) {
+                unset($this->attributes[$key]);
+                continue;
+            }
+
+            if ($value !== $orig_value) {
+                $this->attributes[$key] = $value;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Parse an individual cookie attribute
+     *
+     * Handles parsing individual attributes from the cookie values.
+     *
+     * @param string $name Attribute name
+     * @param string|boolean $value Attribute value (string value, or true if empty/flag)
+     * @return mixed Value if available, or null if the attribute value is invalid (and should be skipped)
+     */
+    protected function normalize_attribute($name, $value) {
+        switch (strtolower($name)) {
+            case 'expires':
+                // Expiration parsing, as per RFC 6265 section 5.2.1
+                if (is_int($value)) {
+                    return $value;
+                }
+
+                $expiry_time = strtotime($value);
+                if ($expiry_time === false) {
+                    return null;
+                }
+
+                return $expiry_time;
+
+            case 'max-age':
+                // Expiration parsing, as per RFC 6265 section 5.2.2
+                if (is_int($value)) {
+                    return $value;
+                }
+
+                // Check that we have a valid age
+                if (!preg_match('/^-?\d+$/', $value)) {
+                    return null;
+                }
+
+                $delta_seconds = (int) $value;
+                if ($delta_seconds <= 0) {
+                    $expiry_time = 0;
+                }
+                else {
+                    $expiry_time = $this->reference_time + $delta_seconds;
+                }
+
+                return $expiry_time;
+
+            case 'domain':
+                // Domain normalization, as per RFC 6265 section 5.2.3
+                if ($value[0] === '.') {
+                    $value = substr($value, 1);
+                }
+
+                return $value;
+
+            default:
+                return $value;
+        }
+    }
+
+    /**
+     * Format a cookie for a Cookie header
+     *
+     * This is used when sending cookies to a server.
+     *
+     * @return string Cookie formatted for Cookie header
+     */
+    public function format_for_header() {
+        return sprintf('%s=%s', $this->name, $this->value);
+    }
+
+    /**
+     * Format a cookie for a Cookie header
+     *
+     * @codeCoverageIgnore
+     * @deprecated Use {@see Requests_Cookie::format_for_header}
+     * @return string
+     */
+    public function formatForHeader() {
+        return $this->format_for_header();
+    }
+
+    /**
+     * Format a cookie for a Set-Cookie header
+     *
+     * This is used when sending cookies to clients. This isn't really
+     * applicable to client-side usage, but might be handy for debugging.
+     *
+     * @return string Cookie formatted for Set-Cookie header
+     */
+    public function format_for_set_cookie() {
+        $header_value = $this->format_for_header();
+        if (!empty($this->attributes)) {
+            $parts = array();
+            foreach ($this->attributes as $key => $value) {
+                // Ignore non-associative attributes
+                if (is_numeric($key)) {
+                    $parts[] = $value;
+                }
+                else {
+                    $parts[] = sprintf('%s=%s', $key, $value);
+                }
+            }
+
+            $header_value .= '; ' . implode('; ', $parts);
+        }
+        return $header_value;
+    }
+
+    /**
+     * Format a cookie for a Set-Cookie header
+     *
+     * @codeCoverageIgnore
+     * @deprecated Use {@see Requests_Cookie::format_for_set_cookie}
+     * @return string
+     */
+    public function formatForSetCookie() {
+        return $this->format_for_set_cookie();
+    }
+
+    /**
+     * Get the cookie value
+     *
+     * Attributes and other data can be accessed via methods.
+     */
+    public function __toString() {
+        return $this->value;
+    }
+
+    /**
+     * Parse a cookie string into a cookie object
+     *
+     * Based on Mozilla's parsing code in Firefox and related projects, which
+     * is an intentional deviation from RFC 2109 and RFC 2616. RFC 6265
+     * specifies some of this handling, but not in a thorough manner.
+     *
+     * @param string Cookie header value (from a Set-Cookie header)
+     * @return Requests_Cookie Parsed cookie object
+     */
+    public static function parse($string, $name = '', $reference_time = null) {
+        $parts = explode(';', $string);
+        $kvparts = array_shift($parts);
+
+        if (!empty($name)) {
+            $value = $string;
+        }
+        elseif (strpos($kvparts, '=') === false) {
+            // Some sites might only have a value without the equals separator.
+            // Deviate from RFC 6265 and pretend it was actually a blank name
+            // (`=foo`)
+            //
+            // https://bugzilla.mozilla.org/show_bug.cgi?id=169091
+            $name = '';
+            $value = $kvparts;
+        }
+        else {
+            list($name, $value) = explode('=', $kvparts, 2);
+        }
+        $name = trim($name);
+        $value = trim($value);
+
+        // Attribute key are handled case-insensitively
+        $attributes = new Requests_Utility_CaseInsensitiveDictionary();
+
+        if (!empty($parts)) {
+            foreach ($parts as $part) {
+                if (strpos($part, '=') === false) {
+                    $part_key = $part;
+                    $part_value = true;
+                }
+                else {
+                    list($part_key, $part_value) = explode('=', $part, 2);
+                    $part_value = trim($part_value);
+                }
+
+                $part_key = trim($part_key);
+                $attributes[$part_key] = $part_value;
+            }
+        }
+
+        return new Requests_Cookie($name, $value, $attributes, array(), $reference_time);
+    }
+
+    /**
+     * Parse all Set-Cookie headers from request headers
+     *
+     * @param Requests_Response_Headers $headers Headers to parse from
+     * @param Requests_IRI|null $origin URI for comparing cookie origins
+     * @param int|null $time Reference time for expiration calculation
+     * @return array
+     */
+    public static function parse_from_headers(Requests_Response_Headers $headers, Requests_IRI $origin = null, $time = null) {
+        $cookie_headers = $headers->getValues('Set-Cookie');
+        if (empty($cookie_headers)) {
+            return array();
+        }
+
+        $cookies = array();
+        foreach ($cookie_headers as $header) {
+            $parsed = self::parse($header, '', $time);
+
+            // Default domain/path attributes
+            if (empty($parsed->attributes['domain']) && !empty($origin)) {
+                $parsed->attributes['domain'] = $origin->host;
+                $parsed->flags['host-only'] = true;
+            }
+            else {
+                $parsed->flags['host-only'] = false;
+            }
+
+            $path_is_valid = (!empty($parsed->attributes['path']) && $parsed->attributes['path'][0] === '/');
+            if (!$path_is_valid && !empty($origin)) {
+                $path = $origin->path;
+
+                // Default path normalization as per RFC 6265 section 5.1.4
+                if (substr($path, 0, 1) !== '/') {
+                    // If the uri-path is empty or if the first character of
+                    // the uri-path is not a %x2F ("/") character, output
+                    // %x2F ("/") and skip the remaining steps.
+                    $path = '/';
+                }
+                elseif (substr_count($path, '/') === 1) {
+                    // If the uri-path contains no more than one %x2F ("/")
+                    // character, output %x2F ("/") and skip the remaining
+                    // step.
+                    $path = '/';
+                }
+                else {
+                    // Output the characters of the uri-path from the first
+                    // character up to, but not including, the right-most
+                    // %x2F ("/").
+                    $path = substr($path, 0, strrpos($path, '/'));
+                }
+                $parsed->attributes['path'] = $path;
+            }
+
+            // Reject invalid cookie domains
+            if (!empty($origin) && !$parsed->domain_matches($origin->host)) {
+                continue;
+            }
+
+            $cookies[$parsed->name] = $parsed;
+        }
+
+        return $cookies;
+    }
+
+    /**
+     * Parse all Set-Cookie headers from request headers
+     *
+     * @codeCoverageIgnore
+     * @deprecated Use {@see Requests_Cookie::parse_from_headers}
+     * @return string
+     */
+    public static function parseFromHeaders(Requests_Response_Headers $headers) {
+        return self::parse_from_headers($headers);
+    }
 }