PhpClient::hasError() - Code Metrics - Inspection of "v3.0.0" - kodedphp/http - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#16)

by Mihail
created 2021-05-03 18:01 UTC
PhpClient::hasError() A

↳ Parent: PhpClient
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	3
CRAP Score	1
Importance

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

/*
 * This file is part of the Koded package.
 *
 * (c) Mihail Binev <[email protected]>
 *
 * Please view the LICENSE distributed with this source code
 * for the full copyright and license information.
 *
 */

namespace Koded\Http\Client;

use Koded\Http\{ClientRequest, ServerResponse};
use Koded\Http\Interfaces\{HttpRequestClient, HttpStatus, Response};
use Psr\Http\Message\UriInterface;
use function Koded\Http\create_stream;

/**
 * @link http://php.net/manual/en/context.http.php
 */
class PhpClient extends ClientRequest implements HttpRequestClient
{
    use EncodingTrait, Psr18ClientTrait;

    /** @var array Stream context options */
    private array $options = [
        'protocol_version' => 1.1,
        'user_agent'       => self::USER_AGENT,
        'method'           => 'GET',
        'max_redirects'    => 20,
        'follow_location'  => 1,
        'ignore_errors'    => true,
        'request_fulluri'  => true,
        'ssl'              => [
            'verify_peer'       => true,
            'allow_self_signed' => false,
        ]
    ];

    public function __construct(
        string $method,
        string|UriInterface $uri,
        string|iterable $body = null,
        array $headers = [])
    {
        parent::__construct($method, $uri, $body, $headers);
        $this->options['timeout'] = (\ini_get('default_socket_timeout') ?: 10.0) * 1.0;
    }

    public function read(): Response
    {
        if ($resource = $this->assertSafeMethod()) {
            return $resource;
        }
        $this->prepareRequestBody();
        $this->prepareOptions();
        try {
            $resource = $this->createResource(\stream_context_create(['http' => $this->options]));
            if ($this->hasError($resource)) {
                return $this->getPhpError(HttpStatus::FAILED_DEPENDENCY);
            }
            $this->extractFromResponseHeaders($resource, $headers, $statusCode);
            return new ServerResponse(\stream_get_contents($resource), $statusCode, $headers);
        } catch (\ValueError $e) {
            return $this->getPhpError(HttpStatus::FAILED_DEPENDENCY, $e->getMessage());
        } catch (\Throwable $e) {
            return $this->getPhpError(
                $e->getCode() ?: HttpStatus::INTERNAL_SERVER_ERROR,
                $e->getMessage());
        } finally {
            if (\is_resource($resource)) {
                \fclose($resource);
            }
        }
    }

    public function userAgent(string $value): HttpRequestClient
    {
        $this->options['user_agent'] = $value;
        return $this;
    }

    public function followLocation(bool $value): HttpRequestClient
    {
        $this->options['follow_location'] = (int)$value;
        return $this;
    }

    public function maxRedirects(int $value): HttpRequestClient
    {
        $this->options['max_redirects'] = $value;
        return $this;
    }

    public function timeout(float $value): HttpRequestClient
    {
        $this->options['timeout'] = $value * 1.0;
        return $this;
    }

    public function ignoreErrors(bool $value): HttpRequestClient
    {
        $this->options['ignore_errors'] = $value;
        return $this;
    }

    public function verifySslHost(bool $value): HttpRequestClient
    {
        $this->options['ssl']['allow_self_signed'] = $value;
        return $this;
    }

    public function verifySslPeer(bool $value): HttpRequestClient
    {
        $this->options['ssl']['verify_peer'] = $value;
        return $this;
    }

    /**
     * @param resource $context from stream_context_create()
     *
     * @return resource|bool
     */
    protected function createResource($context)
    {
        return \fopen((string)$this->getUri(), 'rb', false, $context);
    }

    protected function prepareRequestBody(): void
    {
        if (!$this->stream->getSize()) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
            return;
        }
        $this->stream->rewind();
        if (0 === $this->encoding) {
            $this->options['content'] = $this->stream->getContents();
        } elseif ($content = \json_decode($this->stream->getContents() ?: '[]', true)) {
            $this->normalizeHeader('Content-type', self::X_WWW_FORM_URLENCODED, true);
            $this->options['content'] = \http_build_query($content, null, '&', $this->encoding);
            $this->options['content'] = \http_build_query($content, /** @scrutinizer ignore-type */ null, '&', $this->encoding);
        }
        $this->stream = create_stream($this->options['content']);
    }

    protected function hasError($resource): bool
    {
        return false === \is_resource($resource);
    }

    protected function prepareOptions(): void
    {
        $this->options['method'] = $this->getMethod();
        $this->options['header'] = $this->getFlattenedHeaders();
        unset($this->options['header'][0]); // Host header is always present and first
    }

    /**
     * Extracts the headers and status code from the response.
     *
     * @param resource $response   The resource from fopen()
     * @param array    $headers    Parsed response headers
     * @param int      $statusCode Response status code
     */
    protected function extractFromResponseHeaders($response, &$headers, &$statusCode): void
    {
        try {
            $meta = \stream_get_meta_data($response)['wrapper_data'] ?? [];
            /* HTTP status may not always be the first header in the response headers,
             * for example, if the stream follows one or multiple redirects, the last
             * status line is what is expected here.
             */
            $statusCode = \array_filter($meta, function(string $header) {
                return \str_starts_with($header, 'HTTP/');
            });
            $statusCode = \array_pop($statusCode) ?: 'HTTP/1.1 200 OK';
            $statusCode = (int)(\explode(' ', $statusCode)[1] ?? HttpStatus::OK);
            foreach ($meta as $header) {
                [$k, $v] = \explode(':', $header, 2) + [1 => null];
                if (null === $v) {
                    continue;
                }
                $headers[$k] = $v;
            }
        } finally {
            unset($meta, $header, $k, $v);
        }
    }
}

kodedphp / http

Pull Request — master (#16)

PhpClient::hasError() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
