13814792797

Committed 12 Mar 2025 03:09PM UTC coverage: 5.889% (-1.4%) from 7.289%

Build # 13814792797

Build Type

Pull #7012

github

Committed by

web-flow

Commit Message

Merge 199d44919 into 284937039

Pull Request Pull Request #7012: doc: comment typo in ApiResource.php

Run Details

10048 of 170615 relevant lines covered (5.89%)

5.17 hits per line

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

76.6

/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;	345✔
38	$pos = strpos($mimeType, ';');	345✔
39	if (false !== $pos) {	345✔
40	$canonicalMimeType = trim(substr($mimeType, 0, $pos));	×
41	}
42
43	foreach ($formats as $format => $mimeTypes) {	345✔
44	if (\in_array($mimeType, $mimeTypes, true)) {	342✔
45	return $format;	342✔
46	}
47	if (null !== $canonicalMimeType && \in_array($canonicalMimeType, $mimeTypes, true)) {	204✔
48	return $format;	×
49	}
50	}
51
52	return null;	4✔
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 = [];	99✔
65	foreach ($formats as $format => $mimeTypes) {	99✔
66	foreach ($mimeTypes as $mimeType) {	99✔
67	$flattenedMimeTypes[$mimeType] = $format;	99✔
68	}
69	}
70
71	return $flattenedMimeTypes;	99✔
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 = [];	381✔
80	$flattenedMimeTypes = [];	381✔
81
82	if ($routeFormat = $request->attributes->get('_format') ?: null) {	381✔
83	if (isset($formats[$routeFormat])) {	6✔
84	$mimeTypes = Request::getMimeTypes($routeFormat);	6✔
85	$flattenedMimeTypes = $this->flattenMimeTypes([$routeFormat => $mimeTypes]);	6✔
86	} elseif ($throw) {	×
87	throw new NotFoundHttpException(\sprintf('Format "%s" is not supported', $routeFormat));	×
88	}
89	}
90
91	if (!$mimeTypes) {	381✔
92	$flattenedMimeTypes = $this->flattenMimeTypes($formats);	375✔
93	$mimeTypes = array_keys($flattenedMimeTypes);	375✔
94	}
95
96	// First, try to guess the format from the Accept header
97	/** @var string\|null $accept */
98	$accept = $request->headers->get('Accept');	381✔
99	if (null !== $accept) {	381✔
100	if ($mediaType = $this->negotiator->getBest($accept, $mimeTypes)) {	369✔
101	return $this->getMimeTypeFormat($mediaType->getType(), $formats);	342✔
102	}
103
104	if ($throw) {	87✔
105	throw $this->getNotAcceptableHttpException($accept, $flattenedMimeTypes);	×
106	}
107	}
108
109	// Then, use the Symfony request format if available and applicable
110	$requestFormat = $request->getRequestFormat('') ?: null;	99✔
111	if (null !== $requestFormat) {	99✔
112	$mimeType = $request->getMimeType($requestFormat);	60✔
113
114	if (isset($flattenedMimeTypes[$mimeType])) {	60✔
115	return $requestFormat;	57✔
116	}
117
118	if ($throw) {	3✔
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);	42✔
125	}
126
127	/**
128	* Retrieves an instance of NotAcceptableHttpException.
129	*/
130	private function getNotAcceptableHttpException(string $accept, array $mimeTypes): NotAcceptableHttpException
131	{
132	return new NotAcceptableHttpException(\sprintf(	×
133	'Requested format "%s" is not supported. Supported MIME types are "%s".',	×
134	$accept,	×
135	implode('", "', array_keys($mimeTypes))	×
136	));	×
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) {	3✔
149	$request->setFormat($format, (array) $mimeTypes);	3✔
150	}
151	}
152	}

api-platform / core / 13814792797

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