Request::isMuting() - Code Metrics - hfw/site - Measure and Improve Code Quality continuously with Scrutinizer

Request::isMuting() A
last analyzed 2021-06-20 23:55 UTC

↳ Parent: Request
Complexity

Conditions	2
Paths	2
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Importance

Changes	2
Bugs	0	Features	0
Metric	Value
cc	2
eloc	1
c	2
b	0
f	0
nc	2
nop	0
dl	0
loc	3
rs	10
<?php

namespace Helix\Site;

use ArrayAccess;
use LogicException;

/**
 * The request.
 */
class Request implements ArrayAccess
{

    /**
     * Grouped file uploads (multiple).
     *
     * `[ name => Upload[] ]`
     *
     * @var Upload[][]
     */
    protected $fileGroups = [];

    /**
     * File uploads (singular).
     *
     * `[ name => Upload ]`
     *
     * @var Upload[]
     */
    protected $files = [];

    /**
     * Request headers, keyed in lowercase.
     *
     * @var string[]
     */
    protected $headers = [];

    /**
     * The request path, without arguments, cleaned up.
     *
     * @var string
     */
    protected $path;

    /**
     * Trust client IP forwarding from these proxies.
     *
     * @var string[]
     */
    protected $proxies = [];

    /**
     * Constructs using CGI data.
     */
    public function __construct()
    {
        $this->path = Util::path(urldecode(strtok($_SERVER['REQUEST_URI'], '?')));
        $this->headers = array_change_key_case(getallheaders());
        $this->headers = array_change_key_case(/** @scrutinizer ignore-type */ getallheaders());
        foreach ($_FILES as $name => $file) {
            if (is_array($file['name'])) {
                // php makes file groups an inside-out table. unwrap it.
                for ($i = 0; $i < count($file['name']); $i++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
                    $this->fileGroups[$name][$i] = new Upload(
                        $file['error_code'][$i],
                        $file['name'][$i],
                        $file['tmp_name'][$i]
                    );
                }
            } else {
                $this->files[$name] = new Upload(
                    $file['error_code'],
                    $file['name'],
                    $file['tmp_name']
                );
            }
        }
    }

    /**
     * @return string
     */
    final public function __toString()
    {
        return $this->path;
    }

    /**
     * Returns `POST` args merged over `GET` args.
     *
     * @return array
     */
    public function getArgs(): array
    {
        return array_merge($_GET, $_POST);
    }

    /**
     * Returns the client IP, which may have been forwarded.
     *
     * @return string
     */
    public function getClient()
    {
        if (in_array($_SERVER['REMOTE_ADDR'], $this->proxies)) {
            return $this['X-Forwarded-For'] ?? $_SERVER['REMOTE_ADDR'];
        }
        return $_SERVER['REMOTE_ADDR'];
    }

    /**
     * @param string $name
     * @return null|Upload
     */
    final public function getFile(string $name)
    {
        return $this->files[$name] ?? null;
    }

    /**
     * @param string $name
     * @return Upload[]
     */
    final public function getFileGroup(string $name)
    {
        return $this->fileGroups[$name] ?? [];
    }

    /**
     * @return Upload[][]
     */
    final public function getFileGroups()
    {
        return $this->fileGroups;
    }

    /**
     * @return Upload[]
     */
    final public function getFiles()
    {
        return $this->files;
    }

    /**
     * @return string[]
     */
    public function getHeaders(): array
    {
        return $this->headers;
    }

    /**
     * @return string
     */
    final public function getMethod(): string
    {
        return $_SERVER['REQUEST_METHOD'];
    }

    /**
     * @return string
     */
    final public function getPath(): string
    {
        return $this->path;
    }

    /**
     * @return string[]
     */
    public function getProxies(): array
    {
        return $this->proxies;
    }

    /**
     * @return bool
     */
    final public function isDelete(): bool
    {
        return $_SERVER['REQUEST_METHOD'] === 'DELETE';
    }

    /**
     * @return bool
     */
    final public function isGet(): bool
    {
        return $_SERVER['REQUEST_METHOD'] === 'GET';
    }

    /**
     * @return bool
     */
    final public function isHead(): bool
    {
        return $_SERVER['REQUEST_METHOD'] === 'HEAD';
    }

    /**
     * Whether the request can produce side-effects.
     *
     * @return bool
     */
    final public function isMuting(): bool
    {
        return !$this->isGet() and !$this->isHead();
    }

    /**
     * @return bool
     */
    final public function isPost(): bool
    {
        return $_SERVER['REQUEST_METHOD'] === 'POST';
    }

    /**
     * Checks for a request header.
     *
     * @param string $key
     * @return bool
     */
    public function offsetExists($key): bool
    {
        return isset($this->headers[strtolower($key)]);
    }

    /**
     * Returns a request header.
     *
     * @param string $key
     * @return null|string
     */
    public function offsetGet($key): ?string
    {
        return $this->headers[strtolower($key)] ?? null;
    }

    /**
     * Throws.
     *
     * @param mixed $key
     * @param mixed $value
     * @throws LogicException
     */
    final public function offsetSet($key, $value): void
    {
        throw new LogicException('Request headers are immutable.');
    }

    /**
     * Throws.
     *
     * @param mixed $key
     * @throws LogicException
     */
    final public function offsetUnset($key): void
    {
        throw new LogicException('Request headers are immutable.');
    }

    /**
     * @param string[] $proxies
     * @return $this
     */
    public function setProxies(array $proxies)
    {
        $this->proxies = $proxies;
        return $this;
    }
}

hfw / site

Request::isMuting() A last analyzed 2021-06-20 23:55 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Request::isMuting() A
last analyzed 2021-06-20 23:55 UTC
