13532154862

Committed 25 Feb 2025 10:24PM UTC coverage: 30.374% (+1.7%) from 28.706%

Build # 13532154862

Build Type

push

github

Committed by

web-flow

Commit Message

Update php.yml

Run Details

544 of 1791 relevant lines covered (30.37%)

9.13 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

21.74

/src/Middleware/BodyParsingMiddleware.php

<?php
declare(strict_types=1);

namespace Ody\Core\Middleware;

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\MiddlewareInterface;
use Psr\Http\Server\RequestHandlerInterface;
use RuntimeException;

use function count;
use function explode;
use function is_array;
use function is_null;
use function is_object;
use function is_string;
use function json_decode;
use function libxml_clear_errors;
use function libxml_disable_entity_loader;
use function libxml_use_internal_errors;
use function parse_str;
use function simplexml_load_string;
use function strtolower;
use function trim;

use const LIBXML_VERSION;

/** @api */
class BodyParsingMiddleware implements MiddlewareInterface
{
    /**
     * @var callable[]
     */
    protected array $bodyParsers;

    /**
     * @param callable[] $bodyParsers list of body parsers as an associative array of mediaType => callable
     */
    public function __construct(array $bodyParsers = [])
    {
        $this->registerDefaultBodyParsers();

        foreach ($bodyParsers as $mediaType => $parser) {
            $this->registerBodyParser($mediaType, $parser);
        }
    }

    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
    {
        $parsedBody = $request->getParsedBody();

        if (empty($parsedBody)) {
            $parsedBody = $this->parseBody($request);
            $request = $request->withParsedBody($parsedBody);
        }

        return $handler->handle($request);
    }

    /**
     * @param string   $mediaType A HTTP media type (excluding content-type params).
     * @param callable $callable  A callable that returns parsed contents for media type.
     */
    public function registerBodyParser(string $mediaType, callable $callable): self
    {
        $this->bodyParsers[$mediaType] = $callable;
        return $this;
    }

    /**
     * @param string   $mediaType A HTTP media type (excluding content-type params).
     */
    public function hasBodyParser(string $mediaType): bool
    {
        return isset($this->bodyParsers[$mediaType]);
    }

    /**
     * @param string    $mediaType A HTTP media type (excluding content-type params).
     * @throws RuntimeException
     */
    public function getBodyParser(string $mediaType): callable
    {
        if (!isset($this->bodyParsers[$mediaType])) {
            throw new RuntimeException('No parser for type ' . $mediaType);
        }
        return $this->bodyParsers[$mediaType];
    }

    protected function registerDefaultBodyParsers(): void
    {
        $this->registerBodyParser('application/json', static function ($input) {
            $result = json_decode($input, true);

            if (!is_array($result)) {
                return null;
            }

            return $result;
        });

        $this->registerBodyParser('application/x-www-form-urlencoded', static function ($input) {
            parse_str($input, $data);
            return $data;
        });

        $xmlCallable = static function ($input): \SimpleXMLElement|null {
            $backup = self::disableXmlEntityLoader(true);
            $backup_errors = libxml_use_internal_errors(true);
            $result = simplexml_load_string($input);

            self::disableXmlEntityLoader($backup);
            libxml_clear_errors();
            libxml_use_internal_errors($backup_errors);

            if ($result === false) {
                return null;
            }

            return $result;
        };

        $this->registerBodyParser('application/xml', $xmlCallable);
        $this->registerBodyParser('text/xml', $xmlCallable);
    }

    /**
     * @return null|array<mixed>|object
     */
    protected function parseBody(ServerRequestInterface $request)
    {
        $mediaType = $this->getMediaType($request);
        if ($mediaType === null) {
            return null;
        }

        // Check if this specific media type has a parser registered first
        if (!isset($this->bodyParsers[$mediaType])) {
            // If not, look for a media type with a structured syntax suffix (RFC 6839)
            $parts = explode('+', $mediaType);
            if (count($parts) >= 2) {
                $mediaType = 'application/' . $parts[count($parts) - 1];
            }
        }

        if (isset($this->bodyParsers[$mediaType])) {
            $body = (string)$request->getBody();
            $parsed = $this->bodyParsers[$mediaType]($body);

            if ($parsed !== null && !is_object($parsed) && !is_array($parsed)) {
                throw new RuntimeException(
                    'Request body media type parser return value must be an array, an object, or null'
                );
            }

            return $parsed;
        }

        return null;
    }

    /**
     * @return string|null The serverRequest media type, minus content-type params
     */
    protected function getMediaType(ServerRequestInterface $request): ?string
    {
        $contentType = $request->getHeader('Content-Type')[0] ?? null;

        if (is_string($contentType) && trim($contentType) !== '') {
            $contentTypeParts = explode(';', $contentType);
            return strtolower(trim($contentTypeParts[0]));
        }

        return null;
    }

    protected static function disableXmlEntityLoader(bool $disable): bool
    {
        if (LIBXML_VERSION >= 20900) {
            // libxml >= 2.9.0 disables entity loading by default, so it is
            // safe to skip the real call (deprecated in PHP 8).
            return true;
        }

        // @codeCoverageIgnoreStart
        return libxml_disable_entity_loader($disable);
        // @codeCoverageIgnoreEnd
    }
}

1	<?php
2	declare(strict_types=1);
3
4	namespace Ody\Core\Middleware;
5
6	use Psr\Http\Message\ResponseInterface;
7	use Psr\Http\Message\ServerRequestInterface;
8	use Psr\Http\Server\MiddlewareInterface;
9	use Psr\Http\Server\RequestHandlerInterface;
10	use RuntimeException;
11
12	use function count;
13	use function explode;
14	use function is_array;
15	use function is_null;
16	use function is_object;
17	use function is_string;
18	use function json_decode;
19	use function libxml_clear_errors;
20	use function libxml_disable_entity_loader;
21	use function libxml_use_internal_errors;
22	use function parse_str;
23	use function simplexml_load_string;
24	use function strtolower;
25	use function trim;
26
27	use const LIBXML_VERSION;
28
29	/** @api */
30	class BodyParsingMiddleware implements MiddlewareInterface
31	{
32	/**
33	* @var callable[]
34	*/
35	protected array $bodyParsers;
36
37	/**
38	* @param callable[] $bodyParsers list of body parsers as an associative array of mediaType => callable
39	*/
40	public function __construct(array $bodyParsers = [])	1✔
41	{
42	$this->registerDefaultBodyParsers();	1✔
43
44	foreach ($bodyParsers as $mediaType => $parser) {	1✔
45	$this->registerBodyParser($mediaType, $parser);	×
46	}
47	}
48
49	public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface	×
50	{
51	$parsedBody = $request->getParsedBody();	×
52
53	if (empty($parsedBody)) {	×
54	$parsedBody = $this->parseBody($request);	×
55	$request = $request->withParsedBody($parsedBody);	×
56	}
57
58	return $handler->handle($request);	×
59	}
60
61	/**
62	* @param string $mediaType A HTTP media type (excluding content-type params).
63	* @param callable $callable A callable that returns parsed contents for media type.
64	*/
65	public function registerBodyParser(string $mediaType, callable $callable): self	1✔
66	{
67	$this->bodyParsers[$mediaType] = $callable;	1✔
68	return $this;	1✔
69	}
70
71	/**
72	* @param string $mediaType A HTTP media type (excluding content-type params).
73	*/
74	public function hasBodyParser(string $mediaType): bool	×
75	{
76	return isset($this->bodyParsers[$mediaType]);	×
77	}
78
79	/**
80	* @param string $mediaType A HTTP media type (excluding content-type params).
81	* @throws RuntimeException
82	*/
83	public function getBodyParser(string $mediaType): callable	×
84	{
85	if (!isset($this->bodyParsers[$mediaType])) {	×
86	throw new RuntimeException('No parser for type ' . $mediaType);	×
87	}
88	return $this->bodyParsers[$mediaType];	×
89	}
90
91	protected function registerDefaultBodyParsers(): void	1✔
92	{
93	$this->registerBodyParser('application/json', static function ($input) {	1✔
94	$result = json_decode($input, true);	×
95
96	if (!is_array($result)) {	×
97	return null;	×
98	}
99
100	return $result;	×
101	});	1✔
102
103	$this->registerBodyParser('application/x-www-form-urlencoded', static function ($input) {	1✔
104	parse_str($input, $data);	×
105	return $data;	×
106	});	1✔
107
108	$xmlCallable = static function ($input): \SimpleXMLElement\|null {	1✔
109	$backup = self::disableXmlEntityLoader(true);	×
110	$backup_errors = libxml_use_internal_errors(true);	×
111	$result = simplexml_load_string($input);	×
112
113	self::disableXmlEntityLoader($backup);	×
114	libxml_clear_errors();	×
115	libxml_use_internal_errors($backup_errors);	×
116
117	if ($result === false) {	×
118	return null;	×
119	}
120
121	return $result;	×
122	};	1✔
123
124	$this->registerBodyParser('application/xml', $xmlCallable);	1✔
125	$this->registerBodyParser('text/xml', $xmlCallable);	1✔
126	}
127
128	/**
129	* @return null\|array<mixed>\|object
130	*/
131	protected function parseBody(ServerRequestInterface $request)	×
132	{
133	$mediaType = $this->getMediaType($request);	×
134	if ($mediaType === null) {	×
135	return null;	×
136	}
137
138	// Check if this specific media type has a parser registered first
139	if (!isset($this->bodyParsers[$mediaType])) {	×
140	// If not, look for a media type with a structured syntax suffix (RFC 6839)
141	$parts = explode('+', $mediaType);	×
142	if (count($parts) >= 2) {	×
143	$mediaType = 'application/' . $parts[count($parts) - 1];	×
144	}
145	}
146
147	if (isset($this->bodyParsers[$mediaType])) {	×
148	$body = (string)$request->getBody();	×
149	$parsed = $this->bodyParsers[$mediaType]($body);	×
150
151	if ($parsed !== null && !is_object($parsed) && !is_array($parsed)) {	×
152	throw new RuntimeException(	×
153	'Request body media type parser return value must be an array, an object, or null'	×
154	);	×
155	}
156
157	return $parsed;	×
158	}
159
160	return null;	×
161	}
162
163	/**
164	* @return string\|null The serverRequest media type, minus content-type params
165	*/
166	protected function getMediaType(ServerRequestInterface $request): ?string	×
167	{
168	$contentType = $request->getHeader('Content-Type')[0] ?? null;	×
169
170	if (is_string($contentType) && trim($contentType) !== '') {	×
171	$contentTypeParts = explode(';', $contentType);	×
172	return strtolower(trim($contentTypeParts[0]));	×
173	}
174
175	return null;	×
176	}
177
178	protected static function disableXmlEntityLoader(bool $disable): bool	×
179	{
180	if (LIBXML_VERSION >= 20900) {	×
181	// libxml >= 2.9.0 disables entity loading by default, so it is
182	// safe to skip the real call (deprecated in PHP 8).
183	return true;	×
184	}
185
186	// @codeCoverageIgnoreStart
187	return libxml_disable_entity_loader($disable);
188	// @codeCoverageIgnoreEnd
189	}
190	}

IlyasDeckers / ody-core / 13532154862

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous