<?php

/**

* CakePHP(tm) : Rapid Development Framework (https://cakephp.org)

* Copyright (c) Cake Software Foundation, Inc. (https://cakefoundation.org)

*

* Licensed under The MIT License

* For full copyright and license information, please see the LICENSE.txt

* Redistributions of files must retain the above copyright notice.

*

* @copyright Copyright (c) Cake Software Foundation, Inc. (https://cakefoundation.org)

* @link https://cakephp.org CakePHP(tm) Project

* @since 2.0.0

* @license https://opensource.org/licenses/mit-license.php MIT License

*/

namespace Cake\Http;

use ArrayAccess;

use BadMethodCallException;

use Cake\Core\Configure;

use Cake\Http\Cookie\CookieCollection;

use Cake\Http\Exception\MethodNotAllowedException;

use Cake\Http\Session;

use Cake\Utility\Hash;

use InvalidArgumentException;

use Psr\Http\Message\ServerRequestInterface;

use Psr\Http\Message\StreamInterface;

use Psr\Http\Message\UploadedFileInterface;

use Psr\Http\Message\UriInterface;

use Zend\Diactoros\PhpInputStream;

use Zend\Diactoros\Stream;

use Zend\Diactoros\UploadedFile;

/**

* A class that helps wrap Request information and particulars about a single request.

* Provides methods commonly used to introspect on the request headers and request body.

*/

class ServerRequest implements ArrayAccess, ServerRequestInterface

{

/**

* Array of parameters parsed from the URL.

*

* @var array

* @deprecated 3.4.0 This public property will be removed in 4.0.0. Use getParam() instead.

*/

protected $params = [

'plugin' => null,

'controller' => null,

'action' => null,

'_ext' => null,

'pass' => []

];

/**

* Array of POST data. Will contain form data as well as uploaded files.

* In PUT/PATCH/DELETE requests this property will contain the form-urlencoded

* data.

*

* @var null|array|object

* @deprecated 3.4.0 This public property will be removed in 4.0.0. Use getData() instead.

*/

protected $data = [];

/**

* Array of query string arguments

*

* @var array

* @deprecated 3.4.0 This public property will be removed in 4.0.0. Use getQuery() or getQueryParams() instead.

*/

protected $query = [];

/**

* Array of cookie data.

*

* @var array

* @deprecated 3.4.0 This public property will be removed in 4.0.0. Use getCookie() instead.

*/

protected $cookies = [];

/**

* Array of environment data.

*

* @var array

*/

protected $_environment = [];

/**

* The URL string used for the request.

*

* @var string

* @deprecated 3.6.0 This public property will be removed in 4.0.0. Use getPath() instead.

*/

protected $url;

/**

* Base URL path.

*

* @var string

* @deprecated 3.4.0 This public property will be removed in 4.0.0. Use getAttribute('base') instead.

*/

protected $base;

/**

* webroot path segment for the request.

*

* @var string

* @deprecated 3.4.0 This public property will be removed in 4.0.0. Use getAttribute('webroot') instead.

*/

protected $webroot = '/';

/**

* The full address to the current request

*

* @var string

* @deprecated 3.4.0 This public property will be removed in 4.0.0. Use getAttribute('here') or getUri()->getPath() instead.

*/

protected $here;

/**

* Whether or not to trust HTTP_X headers set by most load balancers.

* Only set to true if your application runs behind load balancers/proxies

* that you control.

*

* @var bool

*/

public $trustProxy = false;

/**

* trusted proxies list

*

* @var array

*/

protected $trustedProxies = [];

/**

* Contents of php://input

*

* @var string

*/

protected $_input;

/**

* The built in detectors used with `is()` can be modified with `addDetector()`.

*

* There are several ways to specify a detector, see \Cake\Http\ServerRequest::addDetector() for the

* various formats and ways to define detectors.

*

* @var array

*/

protected static $_detectors = [

'get' => ['env' => 'REQUEST_METHOD', 'value' => 'GET'],

'post' => ['env' => 'REQUEST_METHOD', 'value' => 'POST'],

'put' => ['env' => 'REQUEST_METHOD', 'value' => 'PUT'],

'patch' => ['env' => 'REQUEST_METHOD', 'value' => 'PATCH'],

'delete' => ['env' => 'REQUEST_METHOD', 'value' => 'DELETE'],

'head' => ['env' => 'REQUEST_METHOD', 'value' => 'HEAD'],

'options' => ['env' => 'REQUEST_METHOD', 'value' => 'OPTIONS'],

'ssl' => ['env' => 'HTTPS', 'options' => [1, 'on']],

'ajax' => ['env' => 'HTTP_X_REQUESTED_WITH', 'value' => 'XMLHttpRequest'],

'flash' => ['env' => 'HTTP_USER_AGENT', 'pattern' => '/^(Shockwave|Adobe) Flash/'],

'requested' => ['param' => 'requested', 'value' => 1],

'json' => ['accept' => ['application/json'], 'param' => '_ext', 'value' => 'json'],

'xml' => ['accept' => ['application/xml', 'text/xml'], 'param' => '_ext', 'value' => 'xml'],

];

/**

* Instance cache for results of is(something) calls

*

* @var array

*/

protected $_detectorCache = [];

/**

* Request body stream. Contains php://input unless `input` constructor option is used.

*

* @var \Psr\Http\Message\StreamInterface

*/

protected $stream;

/**

* Uri instance

*

* @var \Psr\Http\Message\UriInterface

*/

protected $uri;

/**

* Instance of a Session object relative to this request

*

* @var \Cake\Http\Session

*/

protected $session;

/**

* Store the additional attributes attached to the request.

*

* @var array

*/

protected $attributes = [];

/**

* A list of propertes that emulated by the PSR7 attribute methods.

*

* @var array

*/

protected $emulatedAttributes = ['session', 'webroot', 'base', 'params', 'here'];

/**

* Array of Psr\Http\Message\UploadedFileInterface objects.

*

* @var array

*/

protected $uploadedFiles = [];

/**

* The HTTP protocol version used.

*

* @var string|null

*/

protected $protocol;

/**

* The request target if overridden

*

* @var string|null

*/

protected $requestTarget;

/**

* List of deprecated properties that have backwards

* compatibility offered through magic methods.

*

* @var array

*/

private $deprecatedProperties = [

'data' => ['get' => 'getData()', 'set' => 'withData()'],

'query' => ['get' => 'getQuery()', 'set' => 'withQueryParams()'],

'params' => ['get' => 'getParam()', 'set' => 'withParam()'],

'cookies' => ['get' => 'getCookie()', 'set' => 'withCookieParams()'],

'url' => ['get' => 'getPath()', 'set' => 'withRequestTarget()'],

'base' => ['get' => 'getAttribute("base")', 'set' => 'withAttribute("base")'],

'webroot' => ['get' => 'getAttribute("webroot")', 'set' => 'withAttribute("webroot")'],

'here' => ['get' => 'getAttribute("here")', 'set' => 'withAttribute("here")'],

];

/**

* Wrapper method to create a new request from PHP superglobals.

*

* Uses the $_GET, $_POST, $_FILES, $_COOKIE, $_SERVER, $_ENV and php://input data to construct

* the request.

*

* @return self

* @deprecated 3.4.0 Use `Cake\Http\ServerRequestFactory` instead.

*/

public static function createFromGlobals()

{

deprecationWarning(

'ServerRequest::createFromGlobals() is deprecated. ' .

'Use `Cake\Http\ServerRequestFactory` instead.'

);

return ServerRequestFactory::fromGlobals();

}

/**

* Create a new request object.

*

* You can supply the data as either an array or as a string. If you use

* a string you can only supply the URL for the request. Using an array will

* let you provide the following keys:

*

* - `post` POST data or non query string data

* - `query` Additional data from the query string.

* - `files` Uploaded file data formatted like $_FILES.

* - `cookies` Cookies for this request.

* - `environment` $_SERVER and $_ENV data.

* - `url` The URL without the base path for the request.

* - `uri` The PSR7 UriInterface object. If null, one will be created.

* - `base` The base URL for the request.

* - `webroot` The webroot directory for the request.

* - `input` The data that would come from php://input this is useful for simulating

* requests with put, patch or delete data.

* - `session` An instance of a Session object

*

* @param string|array $config An array of request data to create a request with.

* The string version of this argument is *deprecated* and will be removed in 4.0.0

*/

public function __construct($config = [])

{

if (is_string($config)) {

$config = ['url' => $config];

}

$config += [

'params' => $this->params,

'query' => [],

'post' => [],

'files' => [],

'cookies' => [],

'environment' => [],

'url' => '',

'uri' => null,

'base' => '',

'webroot' => '',

'input' => null,

];

$this->_setConfig($config);

}

/**

* Process the config/settings data into properties.

*

* @param array $config The config data to use.

* @return void

*/

protected function _setConfig($config)

{

if (strlen($config['url']) > 1 && $config['url'][0] === '/') {

$config['url'] = substr($config['url'], 1);

}

if (empty($config['session'])) {

$config['session'] = new Session([

'cookiePath' => $config['base']

]);

}

$this->_environment = $config['environment'];

$this->cookies = $config['cookies'];

if (isset($config['uri']) && $config['uri'] instanceof UriInterface) {

$uri = $config['uri'];

} else {

$uri = ServerRequestFactory::createUri($config['environment']);

}

// Extract a query string from config[url] if present.

// This is required for backwards compatibility and keeping

// UriInterface implementations happy.

$querystr = '';

if (strpos($config['url'], '?') !== false) {

list($config['url'], $querystr) = explode('?', $config['url']);

}

if (strlen($config['url'])) {

$uri = $uri->withPath('/' . $config['url']);

}

if (strlen($querystr)) {

$uri = $uri->withQuery($querystr);

}

$this->uri = $uri;

$this->base = $config['base'];

$this->webroot = $config['webroot'];

$this->url = substr($uri->getPath(), 1);

$this->here = $this->base . '/' . $this->url;

if (isset($config['input'])) {

$stream = new Stream('php://memory', 'rw');

$stream->write($config['input']);

$stream->rewind();

} else {

$stream = new PhpInputStream();

}

$this->stream = $stream;

$config['post'] = $this->_processPost($config['post']);

$this->data = $this->_processFiles($config['post'], $config['files']);

$this->query = $this->_processGet($config['query'], $querystr);

$this->params = $config['params'];

$this->session = $config['session'];

}

/**

* Sets the REQUEST_METHOD environment variable based on the simulated _method

* HTTP override value. The 'ORIGINAL_REQUEST_METHOD' is also preserved, if you

* want the read the non-simulated HTTP method the client used.

*

* @param array $data Array of post data.

* @return array

*/

protected function _processPost($data)

{

$method = $this->getEnv('REQUEST_METHOD');

$override = false;

if (in_array($method, ['PUT', 'DELETE', 'PATCH']) &&

strpos($this->contentType(), 'application/x-www-form-urlencoded') === 0

) {

$data = $this->input();

parse_str($data, $data);

}

if ($this->hasHeader('X-Http-Method-Override')) {

$data['_method'] = $this->getHeaderLine('X-Http-Method-Override');

$override = true;

}

$this->_environment['ORIGINAL_REQUEST_METHOD'] = $method;

if (isset($data['_method'])) {

$this->_environment['REQUEST_METHOD'] = $data['_method'];

unset($data['_method']);

$override = true;

}

if ($override && !in_array($this->_environment['REQUEST_METHOD'], ['PUT', 'POST', 'DELETE', 'PATCH'])) {

$data = [];

}

return $data;

}

/**

* Process the GET parameters and move things into the object.

*

* @param array $query The array to which the parsed keys/values are being added.

* @param string $queryString A query string from the URL if provided

* @return array An array containing the parsed query string as keys/values.

*/

protected function _processGet($query, $queryString = '')

{

$unsetUrl = '/' . str_replace(['.', ' '], '_', urldecode($this->url));

unset($query[$unsetUrl], $query[$this->base . $unsetUrl]);

if (strlen($queryString)) {

parse_str($queryString, $queryArgs);

$query += $queryArgs;

}

return $query;

}

/**

* Process uploaded files and move things onto the post data.

*

* @param array $post Post data to merge files onto.

* @param array $files Uploaded files to merge in.

* @return array merged post + file data.

*/

protected function _processFiles($post, $files)

{

if (!is_array($files)) {

return $post;

}

$fileData = [];

foreach ($files as $key => $value) {

if ($value instanceof UploadedFileInterface) {

$fileData[$key] = $value;

continue;

}

if (is_array($value) && isset($value['tmp_name'])) {

$fileData[$key] = $this->_createUploadedFile($value);

continue;

}

throw new InvalidArgumentException(sprintf(

'Invalid value in FILES "%s"',

json_encode($value)

));

}

$this->uploadedFiles = $fileData;

// Make a flat map that can be inserted into $post for BC.

$fileMap = Hash::flatten($fileData);

foreach ($fileMap as $key => $file) {

$error = $file->getError();

$tmpName = '';

if ($error === UPLOAD_ERR_OK) {

$tmpName = $file->getStream()->getMetadata('uri');

}

$post = Hash::insert($post, $key, [

'tmp_name' => $tmpName,

'error' => $error,

'name' => $file->getClientFilename(),

'type' => $file->getClientMediaType(),

'size' => $file->getSize(),

]);

}

return $post;

}

/**

* Create an UploadedFile instance from a $_FILES array.

*

* If the value represents an array of values, this method will

* recursively process the data.

*

* @param array $value $_FILES struct

* @return array|UploadedFileInterface

*/

protected function _createUploadedFile(array $value)

{

if (is_array($value['tmp_name'])) {

return $this->_normalizeNestedFiles($value);

}

return new UploadedFile(

$value['tmp_name'],

$value['size'],

$value['error'],

$value['name'],

$value['type']

);

}

/**

* Normalize an array of file specifications.

*

* Loops through all nested files and returns a normalized array of

* UploadedFileInterface instances.

*

* @param array $files The file data to normalize & convert.

* @return array An array of UploadedFileInterface objects.

*/

protected function _normalizeNestedFiles(array $files = [])

{

$normalizedFiles = [];

foreach (array_keys($files['tmp_name']) as $key) {

$spec = [

'tmp_name' => $files['tmp_name'][$key],

'size' => $files['size'][$key],

'error' => $files['error'][$key],

'name' => $files['name'][$key],

'type' => $files['type'][$key],

];

$normalizedFiles[$key] = $this->_createUploadedFile($spec);

}

return $normalizedFiles;

}

/**

* Get the content type used in this request.

*

* @return string

*/

public function contentType()

{

$type = $this->getEnv('CONTENT_TYPE');

if ($type) {

return $type;

}

return $this->getEnv('HTTP_CONTENT_TYPE');

}

/**

* Returns the instance of the Session object for this request

*

* @return \Cake\Http\Session

*/

public function getSession()

{

return $this->session;

}

/**

* Returns the instance of the Session object for this request

*

* If a session object is passed as first argument it will be set as

* the session to use for this request

*

* @deprecated 3.5.0 Use getSession() instead. The setter part will be removed.

* @param \Cake\Http\Session|null $session the session object to use

* @return \Cake\Http\Session

*/

public function session(Session $session = null)

{

deprecationWarning(

'ServerRequest::session() is deprecated. ' .

'Use getSession() instead. The setter part will be removed.'

);

if ($session === null) {

return $this->session;

}

return $this->session = $session;

}

/**

* Get the IP the client is using, or says they are using.

*

* @return string The client IP.

*/

public function clientIp()

{

if ($this->trustProxy && $this->getEnv('HTTP_X_FORWARDED_FOR')) {

$addresses = array_map('trim', explode(',', $this->getEnv('HTTP_X_FORWARDED_FOR')));

$trusted = (count($this->trustedProxies) > 0);

$n = count($addresses);

if ($trusted) {

$trusted = array_diff($addresses, $this->trustedProxies);

$trusted = (count($trusted) === 1);

}

if ($trusted) {

return $addresses[0];

}

return $addresses[$n - 1];

}

if ($this->trustProxy && $this->getEnv('HTTP_X_REAL_IP')) {

$ipaddr = $this->getEnv('HTTP_X_REAL_IP');

} elseif ($this->trustProxy && $this->getEnv('HTTP_CLIENT_IP')) {

$ipaddr = $this->getEnv('HTTP_CLIENT_IP');

} else {

$ipaddr = $this->getEnv('REMOTE_ADDR');

}

return trim($ipaddr);

}

/**

* register trusted proxies

*

* @param array $proxies ips list of trusted proxies

* @return void

*/

public function setTrustedProxies(array $proxies)

{

$this->trustedProxies = $proxies;

$this->trustProxy = true;

}

/**

* Get trusted proxies

*

* @return array

*/

public function getTrustedProxies()

{

return $this->trustedProxies;

}

/**

* Returns the referer that referred this request.

*

* @param bool $local Attempt to return a local address.

* Local addresses do not contain hostnames.

* @return string The referring address for this request.

*/

public function referer($local = false)

{

$ref = $this->getEnv('HTTP_REFERER');

$base = Configure::read('App.fullBaseUrl') . $this->webroot;

if (!empty($ref) && !empty($base)) {

if ($local && strpos($ref, $base) === 0) {

$ref = substr($ref, strlen($base));

if (!strlen($ref) || strpos($ref, '//') === 0) {

$ref = '/';

}

if ($ref[0] !== '/') {

$ref = '/' . $ref;

}

return $ref;

}

if (!$local) {

return $ref;

}

}

return '/';

}

/**

* Missing method handler, handles wrapping older style isAjax() type methods

*

* @param string $name The method called

* @param array $params Array of parameters for the method call

* @return mixed

* @throws \BadMethodCallException when an invalid method is called.

*/

public function __call($name, $params)

{

if (strpos($name, 'is') === 0) {

$type = strtolower(substr($name, 2));

array_unshift($params, $type);

return $this->is(...$params);

}

throw new BadMethodCallException(sprintf('Method %s does not exist', $name));

}

/**

* Magic set method allows backward compatibility for former public properties

*

*

* @param string $name The property being accessed.

* @param mixed $value The property value.

* @return mixed Either the value of the parameter or null.

* @deprecated 3.6.0 Public properties will be removed in 4.0.0.

* Use appropriate setters instead.

*/

public function __set($name, $value)

{

if (isset($this->deprecatedProperties[$name])) {

$method = $this->deprecatedProperties[$name]['set'];

deprecationWarning(

"Setting {$name} as a property will be removed in 4.0.0. " .

"Use {$method} instead."

);

return $this->{$name} = $value;

}

throw new BadMethodCallException("Cannot set {$name} it is not a known property.");

}

/**

* Magic get method allows access to parsed routing parameters directly on the object.

*

* Allows access to `$this->params['controller']` via `$this->controller`

*

* @param string $name The property being accessed.

* @return mixed Either the value of the parameter or null.

* @deprecated 3.4.0 Accessing routing parameters through __get will removed in 4.0.0.

* Use getParam() instead.

*/

public function &__get($name)

{

if (isset($this->deprecatedProperties[$name])) {

$method = $this->deprecatedProperties[$name]['get'];

deprecationWarning(

"Accessing `{$name}` as a property will be removed in 4.0.0. " .

"Use request->{$method} instead."

);

return $this->{$name};

}

deprecationWarning(sprintf(

'Accessing routing parameters through `%s` will removed in 4.0.0. ' .

'Use `getParam()` instead.',

$name

));

if (isset($this->params[$name])) {

return $this->params[$name];

}

$value = null;

return $value;

}

/**

* Magic isset method allows isset/empty checks

* on routing parameters.

*

* @param string $name The property being accessed.

* @return bool Existence

* @deprecated 3.4.0 Accessing routing parameters through __isset will removed in 4.0.0.

* Use getParam() instead.

*/

public function __isset($name)

{

if (isset($this->deprecatedProperties[$name])) {

$method = $this->deprecatedProperties[$name]['get'];

deprecationWarning(

"Accessing {$name} as a property will be removed in 4.0.0. " .

"Use {$method} instead."

);

return isset($this->{$name});

}

deprecationWarning(

'Accessing routing parameters through __isset will removed in 4.0.0. ' .

'Use getParam() instead.'

);

return isset($this->params[$name]);

}

/**

* Check whether or not a Request is a certain type.

*

* Uses the built in detection rules as well as additional rules

* defined with Cake\Http\ServerRequest::addDetector(). Any detector can be called

* as `is($type)` or `is$Type()`.

*

* @param string|array $type The type of request you want to check. If an array

* this method will return true if the request matches any type.

* @param array ...$args List of arguments

* @return bool Whether or not the request is the type you are checking.

*/

public function is($type, ...$args)

{

if (is_array($type)) {

$result = array_map([$this, 'is'], $type);

return count(array_filter($result)) > 0;

}

$type = strtolower($type);

if (!isset(static::$_detectors[$type])) {

return false;

}

if ($args) {

return $this->_is($type, $args);

}

if (!isset($this->_detectorCache[$type])) {

$this->_detectorCache[$type] = $this->_is($type, $args);

}

return $this->_detectorCache[$type];

}

/**

* Clears the instance detector cache, used by the is() function

*

* @return void

*/

public function clearDetectorCache()

{

$this->_detectorCache = [];

}

/**

* Worker for the public is() function

*

* @param string $type The type of request you want to check.

* @param array $args Array of custom detector arguments.

* @return bool Whether or not the request is the type you are checking.

*/

protected function _is($type, $args)

{

$detect = static::$_detectors[$type];

if (is_callable($detect)) {

array_unshift($args, $this);

return $detect(...$args);

}

if (isset($detect['env']) && $this->_environmentDetector($detect)) {

return true;

}

if (isset($detect['header']) && $this->_headerDetector($detect)) {

return true;

}

if (isset($detect['accept']) && $this->_acceptHeaderDetector($detect)) {

return true;

}

if (isset($detect['param']) && $this->_paramDetector($detect)) {

return true;

}

return false;

}

/**

* Detects if a specific accept header is present.

*

* @param array $detect Detector options array.

* @return bool Whether or not the request is the type you are checking.

*/

protected function _acceptHeaderDetector($detect)

{

$acceptHeaders = explode(',', $this->getEnv('HTTP_ACCEPT'));

foreach ($detect['accept'] as $header) {

if (in_array($header, $acceptHeaders)) {

return true;

}

}

return false;

}

/**

* Detects if a specific header is present.

*

* @param array $detect Detector options array.

* @return bool Whether or not the request is the type you are checking.

*/

protected function _headerDetector($detect)

{

foreach ($detect['header'] as $header => $value) {

$header = $this->getEnv('http_' . $header);

if ($header !== null) {

if (!is_string($value) && !is_bool($value) && is_callable($value)) {

return call_user_func($value, $header);

}

return ($header === $value);

}

}

return false;

}

/**

* Detects if a specific request parameter is present.

*

* @param array $detect Detector options array.

* @return bool Whether or not the request is the type you are checking.

*/

protected function _paramDetector($detect)

{

$key = $detect['param'];

if (isset($detect['value'])) {

$value = $detect['value'];

return isset($this->params[$key]) ? $this->params[$key] == $value : false;

}

if (isset($detect['options'])) {

return isset($this->params[$key]) ? in_array($this->params[$key], $detect['options']) : false;

}

return false;

}

/**

* Detects if a specific environment variable is present.

*

* @param array $detect Detector options array.

* @return bool Whether or not the request is the type you are checking.

*/

protected function _environmentDetector($detect)

{

if (isset($detect['env'])) {

if (isset($detect['value'])) {

return $this->getEnv($detect['env']) == $detect['value'];

}

if (isset($detect['pattern'])) {

return (bool)preg_match($detect['pattern'], $this->getEnv($detect['env']));

}

if (isset($detect['options'])) {

$pattern = '/' . implode('|', $detect['options']) . '/i';

return (bool)preg_match($pattern, $this->getEnv($detect['env']));

}

}

return false;

}

/**

* Check that a request matches all the given types.

*

* Allows you to test multiple types and union the results.

* See Request::is() for how to add additional types and the

* built-in types.

*

* @param array $types The types to check.

* @return bool Success.

* @see \Cake\Http\ServerRequest::is()

*/

public function isAll(array $types)

{

$result = array_filter(array_map([$this, 'is'], $types));

return count($result) === count($types);

}

/**

* Add a new detector to the list of detectors that a request can use.

* There are several different formats and types of detectors that can be set.

*

* ### Callback detectors

*

* Callback detectors allow you to provide a callable to handle the check.

* The callback will receive the request object as its only parameter.

*

* ```

* addDetector('custom', function ($request) { //Return a boolean });

* addDetector('custom', ['SomeClass', 'somemethod']);

* ```

*

* ### Environment value comparison

*

* An environment value comparison, compares a value fetched from `env()` to a known value

* the environment value is equality checked against the provided value.

*

* e.g `addDetector('post', ['env' => 'REQUEST_METHOD', 'value' => 'POST'])`

*

* ### Pattern value comparison

*

* Pattern value comparison allows you to compare a value fetched from `env()` to a regular expression.

*

* ```

* addDetector('iphone', ['env' => 'HTTP_USER_AGENT', 'pattern' => '/iPhone/i']);

* ```

*

* ### Option based comparison

*

* Option based comparisons use a list of options to create a regular expression. Subsequent calls

* to add an already defined options detector will merge the options.

*

* ```

* addDetector('mobile', ['env' => 'HTTP_USER_AGENT', 'options' => ['Fennec']]);

* ```

*

* ### Request parameter detectors

*

* Allows for custom detectors on the request parameters.

*

* e.g `addDetector('requested', ['param' => 'requested', 'value' => 1]`

*