Request::hasHeader() - Code Metrics - frqnck/apix - Measure and Improve Code Quality continuously with Scrutinizer

Request::hasHeader() A
last analyzed 2017-05-17 20:31 UTC

↳ Parent: Request
Complexity

Conditions	1
Paths	1
Size

Total Lines	4
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	2
Importance

Changes
Metric	Value
dl	0
loc	4
ccs	0
cts	4
cp	0
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	1
crap	2
<?php

/**
 *
 * This file is part of the Apix Project.
 *
 * (c) Franck Cassedanne <franck at ouarz.net>
 *
 * @license     http://opensource.org/licenses/BSD-3-Clause  New BSD License
 *
 */

namespace Apix;

class Request
{
    const METHOD_OVERRIDE = '_method';

    /**
     * Holds the URI string
     * @var string
     */
    protected $uri = null;

    /**
     * The HTTP response headers array
     * @var array
     */
    protected $headers = array();

    /**
     * Hold the request body (raw) data
     * @var string
     */
    protected $body = null;

    /**
     * Holds the HTTP method
     * @var string
     */
    protected $method = null;

    /**
     * Body stream scheme
     * @var string
     */
    protected $bodyStream = 'php://input';

    /**
     * Constructor, at instanciation sets the minimum request properties
     */
    public function __construct()
    {
        $this->setHeaders();
        $this->setParams();
        $this->setBody();
    }

    /**
     * Sets and parse the provided URI, or if missing guess from the enviroment
     *
     * @param string|false $uri If false, extract one from $_SERVER variables
     */
    public function setUri($uri=false)
    {
        $uri = false === $uri ? $this->getRequestedUri() : $uri;
        $uri = parse_url($uri, PHP_URL_PATH);

        // remove a trailing slash
        if ( $uri != '/' && substr($uri, -1) == '/' ) {
            $uri = substr($uri, 0, -1);
        }

        $this->uri = $uri;
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
    }

    /**
     * Gets the current URI, if undefined guess and set one up.
     *
     * @return string
     */
    public function getUri()
    {
        if (null === $this->uri) {
            $this->setUri();
        }

        return $this->uri;
    }

    /**
     * Gets the requested URI (from client, spoofable).
     *
     * @return string
     */
    public function getRequestedUri()
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        if (isset($_SERVER['HTTP_X_REWRITE_URL'])) {
            $uri = $_SERVER['HTTP_X_REWRITE_URL'];
        } elseif (isset($_SERVER['IIS_WasUrlRewritten'])
                && $_SERVER['IIS_WasUrlRewritten'] == '1'
                && isset($_SERVER['UNENCODED_URL'])
                && $_SERVER['UNENCODED_URL'] != ''
        ) {
            $uri = $_SERVER['UNENCODED_URL'];
        } elseif (isset($_SERVER['REQUEST_URI'])) {
            $uri = $_SERVER['REQUEST_URI'];
        } elseif (isset($_SERVER['PATH_INFO'])) {
            $uri = $_SERVER['PATH_INFO'];
        } elseif (isset($_SERVER['ORIG_PATH_INFO'])) {
            $uri = $_SERVER['ORIG_PATH_INFO'];
        }

        return isset($uri) ? $uri : '/';
    }

    /**
     * Gets the requested Scheme (from server).
     *
     * @return string
     */
    public function getRequestedScheme()
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        return isset($_SERVER['HTTPS']) ? 'https' : 'http';
    }

    /**
     * Gets the requested host (from client, spoofable).
     *
     * @return string
     */
    public function getRequestedHost()
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        $s = $_SERVER;
        $host = '';
        if ( !empty($s['HTTP_X_FORWARDED_HOST']) ) {
            $host = $s['HTTP_X_FORWARDED_HOST'];
            // handles multiple forwarders.
            if (strpos($host, ',') !== false) {
                $host = trim(array_pop( explode(',', $host) ));

            }
        } elseif ( !empty($s['HTTP_HOST']) ) {
            $host = $s['HTTP_HOST'];
        } elseif ( !empty($s['SERVER_NAME']) ) {
            $host = $s['SERVER_NAME'];
            $host .= !empty($s['SERVER_PORT'])
                        ? ':' . $s['SERVER_PORT']
                        : '';
        }

        return rtrim($host, '/');
    }

    /**
     * Gets the request Url.
     *
     * @return string
     */
    public function getRequestedUrl()
    {
        // TODO here
        echo $this->getRequestedHost();
        if($host = $this->getRequestedHost() ) {
            $host = $this->getRequestedScheme() . '://' . $host;
        }
        return $host . $this->getRequestedUri();

        // return 'http' . (isset($_SERVER['HTTPS']) ? 's' : '') . '://'

        //         . $this->getRequestedHost()

        //         . $this->getRequestedUri();

    }

    /**
     * Sets a parameter by name
     *
     * @param string $key   The key
     * @param mixed  $value The value
     */
    public function setParam($key, $value)
    {
        $this->params[$key] = $value;
class MyClass { }

$x = new MyClass();
$x->foo = true;
    }

    /**
     * Gets a specified param
     *
     * @param  string  $key
     * @param  boolean $raw    Set to true to get the raw URL encoded value
     * @param  string  $filter POSIX character classes e.g. alnum, alpha
     * @return mixed
     */
    public function getParam($key, $raw=false, $filter=null)
    {
        if (isset($this->params[$key])) {

            $param = $raw===false ? rawurldecode($this->params[$key])
                                  : $this->params[$key];

            if (null !== $filter) {
                return preg_replace('/[^[:' . $filter . ':]]/', '', $param);
            }

            return $param;
        }
    }

    /**
     * Sets all parameters
     *
     * @param array|null $params
     */
    public function setParams(array $params = null)
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        $this->params = null === $params ? $_REQUEST : $params;
    }

    /**
     * Returns all the request parameters
     *
     * @return array
     */
    public function getParams()
    {
        return $this->params;
    }

    /**
     * Sets the request method either using:
     *   - the passed method value,
     *   - or from an override value:
     *       - X-HTTP-Method-Override,
     *       - a GET param override,
     *       - server env or use the default value.
     *
     * @param string $method
     * @param string $default
     */
    public function setMethod($method = null, $default = 'GET')
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        if (null === $method) {
            if ($this->hasHeader('X-HTTP-Method-Override')) {
                $method = $this->getHeader('X-HTTP-Method-Override');
            } elseif ($this->getParam(self::METHOD_OVERRIDE)) {
                $method = $this->getParam(self::METHOD_OVERRIDE);
            } else {
                $method = isset($_SERVER['REQUEST_METHOD'])
                    ? $_SERVER['REQUEST_METHOD']
                    : $default;
            }
        }
        $this->method = strtoupper($method);
    }

    /**
     * Returns the current requet method
     *
     * @param string
     */
    public function getMethod()
    {
        if (null === $this->method) {
            $this->setMethod();
        }

        return $this->method;
    }

    /**
     * Sets a request header by name
     *
     * @param string $name
     * @param string $value
     */
    public function setHeader($name, $value)
    {
        $this->headers[strtoupper($name)] = $value;
    }

    /**
     * Checks if specified header exists
     *
     * @param  string  $name
     * @return boolean
     */
    public function hasHeader($name)
    {
        return isset($this->headers[strtoupper($name)]);
    }

    /**
     * Returns the specified header
     *
     * @param  string $name
     * @return string
     */
    public function getHeader($name)
    {
        $name = strtoupper($name);
        if (isset($this->headers[$name])) {
            return $this->headers[$name];
        }
    }

    /**
     * Populates the headers properties
     * Will use the provided associative array or extract things from $_SERVER
     *
     * @param array $headers The value
     */
    public function setHeaders(array $headers = null)
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        if (null === $headers) {
            #$headers = http_get_request_headers();

            $headers = $_SERVER;
        }
        $this->headers = $headers;
        // $this->headers = array_change_key_case($headers);

    }

    /**
     * Returns all the headers
     *
     * @return array
     */
    public function getHeaders()
    {
        return $this->headers;
    }

    /**
     * Returns the client's IP address
     *
     * @return string
     */
    public function getIp()
    {
        $ip = $this->getHeader('HTTP_CLIENT_IP');
        if (empty($ip)) {
            $ip = $this->getHeader('HTTP_X_FORWARDED_FOR');
        }

        return empty($ip) ? $this->getHeader('REMOTE_ADDR') : $ip;
    }

    /**
     * Sets the body stream property
     *
     * @param string $string
     */
    public function setBodyStream($string)
    {
        $this->bodyStream = $string;
    }

    /**
     * Sets the body using the provided string or retrieve it from a PHP stream
     *
     * @param string $body
     */
    public function setBody($body = null)
    {
        $this->body = null === $body
            ? file_get_contents($this->bodyStream)
            : $body;
    }

    /**
     * Checks wether the body contains data
     *
     * @return boolean
     */
    public function hasBody()
    {
        return !empty($this->body);
    }

    /**
     * Returns the raw (undecoded) body data
     *
     * @return string
     */
     public function getRawBody()
    {
        return $this->body;
        #return = http_get_request_body();

        #return file_get_contents($this->bodyStream);

    }

    /**
     * Returns the (decoded) body data of a request
     *
     * @param  boolean                   $cache Wether to cache the body after decoding.
     * @return string
     * @throws \BadFunctionCallException
     */
    public function getBody($cache=true)
    {
        static $body = null;
        if ($cache && null !== $body) {
            return $body;
        }

        // Decode any content-encoding (gzip or deflate) if needed
        switch (strtolower($this->getHeader('content-encoding'))) {
            // Handle gzip encoding
            case 'gzip':
                $body = $this->gzDecode($this->body);
                break;

            // Handle deflate encoding
            case 'deflate':
                $body = $this->gzInflate($this->body);
                break;

            default:
                return $this->body;
        }

        return $body;
    }

    /**
     * Handles gzip decoding
     *
     * @param  boolean                   $cache Wether to cache the body after decoding.
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * @return string
     * @throws \BadFunctionCallException
     * @codeCoverageIgnore
     */
    public function gzDecode($data)
    {
        return function_exists('gzdecode')
                ? gzdecode($data)
                : file_get_contents(
                    'compress.zlib://data:;base64,'
                    . base64_encode($data)
                );
    }

    /**
     * Handles inflating a deflated string
     *
     * @param  string                    $data
     * @return string
     * @throws \BadFunctionCallException
     * @codeCoverageIgnore
     */
    public function gzInflate($data)
    {

        if (! function_exists('gzinflate')) {
            throw new \BadFunctionCallException(
                'zlib extension is required to deflate this'
            );
        }

        return gzinflate($data);
    }

}

1			<?php
2
3			/**
4			*
5			* This file is part of the Apix Project.
6			*
7			* (c) Franck Cassedanne <franck at ouarz.net>
8			*
9			* @license http://opensource.org/licenses/BSD-3-Clause New BSD License
10			*
11			*/
12
13			namespace Apix;
14
15			class Request
16			{
17			const METHOD_OVERRIDE = '_method';
18
19			/**
20			* Holds the URI string
21			* @var string
22			*/
23			protected $uri = null;
24
25			/**
26			* The HTTP response headers array
27			* @var array
28			*/
29			protected $headers = array();
30
31			/**
32			* Hold the request body (raw) data
33			* @var string
34			*/
35			protected $body = null;
36
37			/**
38			* Holds the HTTP method
39			* @var string
40			*/
frqnck / apix

Request::hasHeader() A last analyzed 2017-05-17 20:31 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Request::hasHeader() A
last analyzed 2017-05-17 20:31 UTC
