DMT\Aura\Psr\Message\Request

Complexity

Total Complexity

18

Size/Duplication

Total Lines	152
Duplicated Lines	0 %

Test Coverage

Coverage

94%

Importance

Changes	1
Bugs	1	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	withUri()	0	15	4
A	getInnerObject()	0	13	2
A	getUri()	0	7	2
A	getRequestTarget()	0	3	1
A	updateHostFromUri()	0	14	3
A	withRequestTarget()	0	8	1
A	getMethod()	0	3	2
A	withMethod()	0	10	2

<?php

namespace DMT\Aura\Psr\Message;

use Aura\Web\Request as AuraRequest;
use Aura\Web\WebFactory;
use DMT\Aura\Psr\Factory\StreamFactory;
use DMT\Aura\Psr\Factory\UriFactory;
use InvalidArgumentException;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\UriInterface;

/**
 * Class Request
 *
 * @package DMT\Aura\Psr\Message
 */
class Request implements RequestInterface
{
    use MessageTrait;

The trait DMT\Aura\Psr\Message\MessageTrait requires some properties which are not provided by DMT\Aura\Psr\Message\Request: $server, $status, $content, $headers

    /** @var UriInterface $uri */
    protected $uri;

    /**
     * Request constructor.
     *
     * @param string $method The HTTP method associated with the request.
     * @param UriInterface|string $uri The URI associated with the request.
     */
    public function __construct(string $method, $uri)
    {
        $request = $this->getInnerObject();
        $this->setObjectProperty($request->method , 'value', $method);

        $this->uri = (new UriFactory())->createUri($uri);
        $this->body = (new StreamFactory())->createStream();
    }

    /**
     * @return AuraRequest
     */
    public function getInnerObject(): AuraRequest
    {
        if (!$this->object) {
            $this->object = (new WebFactory([]))->newRequest();
        }

        $this->setObjectProperty(
            $this->object ,
            'client',
            new AuraRequest\Client($this->object->server->get())
        );

        return $this->object;

The expression return $this->object could return the type Aura\Web\Response which is incompatible with the type-hinted return Aura\Web\Request. Consider adding an additional type-check to rule them out.

    }

    /**
     * Retrieves the message's request target.
     *
     * @return string
     */
    public function getRequestTarget(): string
    {
        return $this->getInnerObject()->server->get('REQUEST_URI', '/');

The expression return $this->getInnerObject()->server->get('REQUEST_URI', '/') could return the type array which is incompatible with the type-hinted return string. Consider adding an additional type-check to rule them out.

    }

    /**
     * Return an instance with the specific request-target.
     *
     * @param mixed $requestTarget
     * @return static
     */
    public function withRequestTarget($requestTarget): self
    {
        $instance = clone($this);

        $server = $instance->getInnerObject()->server;
        $server['REQUEST_URI'] = $requestTarget;

        return $instance;
    }

    /**
     * Retrieves the HTTP method of the request.
     *
     * @return string Returns the request method.
     */
    public function getMethod(): string
    {
        return $this->getInnerObject()->method->get() ?: 'GET';
    }

    /**
     * Return an instance with the provided HTTP method.
     *
     * @param string $method Case-sensitive method.
     * @return static
     * @throws InvalidArgumentException for invalid HTTP methods.
     */
    public function withMethod($method): self
    {
        if (!is_string($method)) {

The condition is_string($method) is always true.

            throw new InvalidArgumentException('Invalid method given');
        }

        $instance = clone($this);
        $instance->setObjectProperty($instance->getInnerObject()->method, 'value', $method);

        return $instance;
    }

    /**
     * Retrieves the URI instance.
     *
     * @return UriInterface
     */
    public function getUri(): UriInterface
    {
        if (!$this->uri instanceof Uri) {
            $this->uri = new Uri($this->getInnerObject()->url);

$this->getInnerObject()->url of type Aura\Web\Request\Url is incompatible with the type null|string expected by parameter $uri of DMT\Aura\Psr\Message\Uri::__construct().

        }

        return $this->uri;
    }

    /**
     * Returns an instance with the provided URI.
     *
     * @param UriInterface $uri
     * @param bool $preserveHost
     * @return static
     */
    public function withUri(UriInterface $uri, $preserveHost = false): self
    {
        if (!$uri instanceof Uri) {
            $uri = (new UriFactory())->createUri((string)$uri);
        }

        $instance = clone($this);
        $instance->uri = $uri;
        $instance->setObjectProperty($instance->getInnerObject(), 'url', $uri->getInnerObject());

        if (!$preserveHost || !$this->hasHeader('host')) {
            return $instance->updateHostFromUri();
        }

        return $instance;
    }

    /**
     * Update the host whilst setting a new URI.
     *
     * @return static
     */
    protected function updateHostFromUri(): self
    {
        $host = $this->uri->getHost();
        $port = $this->uri->getPort();

        if ($host === '') {
            return $this;
        }

        if ($port !== null) {
            $host .= ':' . $port;
        }

        return $this->withHeader('host', $host);
    }
}