10323454690

Committed 09 Aug 2024 05:46PM UTC coverage: 7.841%. Remained the same

Build # 10323454690

Build Type

push

github

Committed by

soyuka

Commit Message

Merge 3.4

Run Details

2 of 2 new or added lines in 1 file covered. (100.0%)

1896 existing lines in 118 files now uncovered.

12688 of 161818 relevant lines covered (7.84%)

26.86 hits per line

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

93.62

/src/Metadata/Util/ContentNegotiationTrait.php

<?php

/*
 * This file is part of the API Platform project.
 *
 * (c) Kévin Dunglas <dunglas@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace ApiPlatform\Metadata\Util;

use Negotiation\Negotiator;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpKernel\Exception\NotAcceptableHttpException;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;

/**
 * @internal
 */
trait ContentNegotiationTrait
{
    private Negotiator $negotiator;

    /**
     * Gets the format associated with the mime type.
     *
     * Adapted from {@see Request::getFormat}.
     *
     * @param array<string, string|string[]> $formats
     */
    private function getMimeTypeFormat(string $mimeType, array $formats): ?string
    {
        $canonicalMimeType = null;
        $pos = strpos($mimeType, ';');
        if (false !== $pos) {
            $canonicalMimeType = trim(substr($mimeType, 0, $pos));
        }

        foreach ($formats as $format => $mimeTypes) {
            if (\in_array($mimeType, $mimeTypes, true)) {
                return $format;
            }
            if (null !== $canonicalMimeType && \in_array($canonicalMimeType, $mimeTypes, true)) {
                return $format;
            }
        }

        return null;
    }

    /**
     * Flattened the list of MIME types.
     *
     * @param array<string, string|string[]> $formats
     *
     * @return array<string, string>
     */
    private function flattenMimeTypes(array $formats): array
    {
        $flattenedMimeTypes = [];
        foreach ($formats as $format => $mimeTypes) {
            foreach ($mimeTypes as $mimeType) {
                $flattenedMimeTypes[$mimeType] = $format;
            }
        }

        return $flattenedMimeTypes;
    }

    /**
     * @param array<string, string|string[]> $formats
     */
    private function getRequestFormat(Request $request, array $formats, bool $throw = true): string
    {
        $mimeTypes = [];
        $flattenedMimeTypes = [];

        if ($routeFormat = $request->attributes->get('_format') ?: null) {
            if (isset($formats[$routeFormat])) {
                $mimeTypes = Request::getMimeTypes($routeFormat);
                $flattenedMimeTypes = $this->flattenMimeTypes([$routeFormat => $mimeTypes]);
            } elseif ($throw) {
                throw new NotFoundHttpException(\sprintf('Format "%s" is not supported', $routeFormat));
            }
        }

        if (!$mimeTypes) {
            $flattenedMimeTypes = $this->flattenMimeTypes($formats);
            $mimeTypes = array_keys($flattenedMimeTypes);
        }

        // First, try to guess the format from the Accept header
        /** @var string|null $accept */
        $accept = $request->headers->get('Accept');
        if (null !== $accept) {
            if ($mediaType = $this->negotiator->getBest($accept, $mimeTypes)) {
                return $this->getMimeTypeFormat($mediaType->getType(), $formats);
            }

            if ($throw) {
                throw $this->getNotAcceptableHttpException($accept, $flattenedMimeTypes);
            }
        }

        // Then, use the Symfony request format if available and applicable
        $requestFormat = $request->getRequestFormat('') ?: null;
        if (null !== $requestFormat) {
            $mimeType = $request->getMimeType($requestFormat);

            if (isset($flattenedMimeTypes[$mimeType])) {
                return $requestFormat;
            }

            if ($throw) {
                throw $this->getNotAcceptableHttpException($mimeType, $flattenedMimeTypes);
            }
        }

        // Finally, if no Accept header nor Symfony request format is set, return the default format
        return array_key_first($formats);
    }

    /**
     * Retrieves an instance of NotAcceptableHttpException.
     */
    private function getNotAcceptableHttpException(string $accept, array $mimeTypes): NotAcceptableHttpException
    {
        return new NotAcceptableHttpException(\sprintf(
            'Requested format "%s" is not supported. Supported MIME types are "%s".',
            $accept,
            implode('", "', array_keys($mimeTypes))
        ));
    }

    /**
     * Adds the supported formats to the request.
     *
     * This is necessary for {@see Request::getMimeType} and {@see Request::getMimeTypes} to work.
     *
     * @param array<string, string|string[]> $formats
     */
    private function addRequestFormats(Request $request, array $formats): void
    {
        foreach ($formats as $format => $mimeTypes) {
            $request->setFormat($format, (array) $mimeTypes);
        }
    }
}

1	<?php
2
3	/*
4	* This file is part of the API Platform project.
5	*
6	* (c) Kévin Dunglas <dunglas@gmail.com>
7	*
8	* For the full copyright and license information, please view the LICENSE
9	* file that was distributed with this source code.
10	*/
11
12	declare(strict_types=1);
13
14	namespace ApiPlatform\Metadata\Util;
15
16	use Negotiation\Negotiator;
17	use Symfony\Component\HttpFoundation\Request;
18	use Symfony\Component\HttpKernel\Exception\NotAcceptableHttpException;
19	use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
20
21	/**
22	* @internal
23	*/
24	trait ContentNegotiationTrait
25	{
26	private Negotiator $negotiator;
27
28	/**
29	* Gets the format associated with the mime type.
30	*
31	* Adapted from {@see Request::getFormat}.
32	*
33	* @param array<string, string\|string[]> $formats
34	*/
35	private function getMimeTypeFormat(string $mimeType, array $formats): ?string
36	{
37	$canonicalMimeType = null;	1,485✔
38	$pos = strpos($mimeType, ';');	1,485✔
39	if (false !== $pos) {	1,485✔
40	$canonicalMimeType = trim(substr($mimeType, 0, $pos));	×
41	}
42
43	foreach ($formats as $format => $mimeTypes) {	1,485✔
44	if (\in_array($mimeType, $mimeTypes, true)) {	1,485✔
45	return $format;	1,464✔
46	}
47	if (null !== $canonicalMimeType && \in_array($canonicalMimeType, $mimeTypes, true)) {	785✔
48	return $format;	×
49	}
50	}
51
52	return null;	35✔
53	}
54
55	/**
56	* Flattened the list of MIME types.
57	*
58	* @param array<string, string\|string[]> $formats
59	*
60	* @return array<string, string>
61	*/
62	private function flattenMimeTypes(array $formats): array
63	{
64	$flattenedMimeTypes = [];	775✔
65	foreach ($formats as $format => $mimeTypes) {	775✔
66	foreach ($mimeTypes as $mimeType) {	775✔
67	$flattenedMimeTypes[$mimeType] = $format;	775✔
68	}
69	}
70
71	return $flattenedMimeTypes;	775✔
72	}
73
74	/**
75	* @param array<string, string\|string[]> $formats
76	*/
77	private function getRequestFormat(Request $request, array $formats, bool $throw = true): string
78	{
79	$mimeTypes = [];	2,600✔
80	$flattenedMimeTypes = [];	2,600✔
81
82	if ($routeFormat = $request->attributes->get('_format') ?: null) {	2,600✔
83	if (isset($formats[$routeFormat])) {	72✔
84	$mimeTypes = Request::getMimeTypes($routeFormat);	66✔
85	$flattenedMimeTypes = $this->flattenMimeTypes([$routeFormat => $mimeTypes]);	66✔
UNCOV 86	} elseif ($throw) {	6✔
UNCOV 87	throw new NotFoundHttpException(\sprintf('Format "%s" is not supported', $routeFormat));	6✔
88	}
89	}
90
91	if (!$mimeTypes) {	2,600✔
92	$flattenedMimeTypes = $this->flattenMimeTypes($formats);	2,534✔
93	$mimeTypes = array_keys($flattenedMimeTypes);	2,534✔
94	}
95
96	// First, try to guess the format from the Accept header
97	/** @var string\|null $accept */
98	$accept = $request->headers->get('Accept');	2,600✔
99	if (null !== $accept) {	2,600✔
100	if ($mediaType = $this->negotiator->getBest($accept, $mimeTypes)) {	1,087✔
101	return $this->getMimeTypeFormat($mediaType->getType(), $formats);	1,045✔
102	}
103
104	if ($throw) {	194✔
UNCOV 105	throw $this->getNotAcceptableHttpException($accept, $flattenedMimeTypes);	15✔
106	}
107	}
108
109	// Then, use the Symfony request format if available and applicable
110	$requestFormat = $request->getRequestFormat('') ?: null;	1,716✔
111	if (null !== $requestFormat) {	1,716✔
112	$mimeType = $request->getMimeType($requestFormat);	328✔
113
114	if (isset($flattenedMimeTypes[$mimeType])) {	328✔
115	return $requestFormat;	302✔
116	}
117
118	if ($throw) {	26✔
119	throw $this->getNotAcceptableHttpException($mimeType, $flattenedMimeTypes);	×
120	}
121	}
122
123	// Finally, if no Accept header nor Symfony request format is set, return the default format
124	return array_key_first($formats);	1,516✔
125	}
126
127	/**
128	* Retrieves an instance of NotAcceptableHttpException.
129	*/
130	private function getNotAcceptableHttpException(string $accept, array $mimeTypes): NotAcceptableHttpException
131	{
UNCOV 132	return new NotAcceptableHttpException(\sprintf(	15✔
UNCOV 133	'Requested format "%s" is not supported. Supported MIME types are "%s".',	15✔
UNCOV 134	$accept,	15✔
UNCOV 135	implode('", "', array_keys($mimeTypes))	15✔
UNCOV 136	));	15✔
137	}
138
139	/**
140	* Adds the supported formats to the request.
141	*
142	* This is necessary for {@see Request::getMimeType} and {@see Request::getMimeTypes} to work.
143	*
144	* @param array<string, string\|string[]> $formats
145	*/
146	private function addRequestFormats(Request $request, array $formats): void
147	{
148	foreach ($formats as $format => $mimeTypes) {	39✔
149	$request->setFormat($format, (array) $mimeTypes);	39✔
150	}
151	}
152	}

api-platform / core / 10323454690

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