Negotiator::match() - Code Metrics - Inspection of "style: application de rector pour un code plus pro..." - blitz-php/framework - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — main (#16)

by Dimitri

created 2024-08-08 13:33 UTC

Negotiator::match() A

↳ Parent: Negotiator

Complexity

Conditions	4
Paths	6

Size

Total Lines	19
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	20

Importance

Changes

Metric	Value
cc	4
eloc	9
nc	6
nop	3
dl	0
loc	19
ccs	0
cts	5
cp	0
crap	20
rs	9.9666
c	0
b	0
f	0

<?php

/**
 * This file is part of Blitz PHP framework.
 *
 * (c) 2022 Dimitri Sitchet Tomkeu <[email protected]>
 *
 * For the full copyright and license information, please view
 * the LICENSE file that was distributed with this source code.
 */

namespace BlitzPHP\Http;

use BlitzPHP\Exceptions\HttpException;

class Negotiator
{
    /**
     * Request
     *
     * @var ServerRequest
     */
    protected $request;

    /**
     * Constructor
     */
    public function __construct(?ServerRequest $request = null)
    {
        if (null !== $request) {
            $this->request = $request;
        }
    }

    /**
     * Stores the request instance to grab the headers from.
     */
    public function setRequest(ServerRequest $request): self
    {
        $this->request = $request;

        return $this;
    }

    /**
     * Determines the best content-type to use based on the $supported
     * types the application says it supports, and the types requested
     * by the client.
     *
     * If no match is found, the first, highest-ranking client requested
     * type is returned.
     *
     * @param bool $strictMatch If TRUE, will return an empty string when no match found.
     *                          If FALSE, will return the first supported element.
     */
    public function media(array $supported, bool $strictMatch = false): string
    {
        return $this->getBestMatch($supported, $this->request->getHeaderLine('accept'), true, $strictMatch);
    }

    /**
     * Determines the best charset to use based on the $supported
     * types the application says it supports, and the types requested
     * by the client.
     *
     * If no match is found, the first, highest-ranking client requested
     * type is returned.
     */
    public function charset(array $supported): string
    {
        $match = $this->getBestMatch($supported, $this->request->getHeaderLine('accept-charset'), false, true);

        // If no charset is shown as a match, ignore the directive
        // as allowed by the RFC, and tell it a default value.
        if ($match === '' || $match === '0') {
            return 'utf-8';
        }

        return $match;
    }

    /**
     * Determines the best encoding type to use based on the $supported
     * types the application says it supports, and the types requested
     * by the client.
     *
     * If no match is found, the first, highest-ranking client requested
     * type is returned.
     */
    public function encoding(array $supported = []): string
    {
        $supported[] = 'identity';

        return $this->getBestMatch($supported, $this->request->getHeaderLine('accept-encoding'));
    }

    /**
     * Determines the best language to use based on the $supported
     * types the application says it supports, and the types requested
     * by the client.
     *
     * If no match is found, the first, highest-ranking client requested
     * type is returned.
     */
    public function language(array $supported): string
    {
        return $this->getBestMatch($supported, $this->request->getHeaderLine('accept-language'));
    }

    // --------------------------------------------------------------------
    // Utility Methods
    // --------------------------------------------------------------------

    /**
     * Does the grunt work of comparing any of the app-supported values
     * against a given Accept* header string.
     *
     * Portions of this code base on Aura.Accept library.
     *
     * @param array  $supported    App-supported values
     * @param string $header       header string
     * @param bool   $enforceTypes If TRUE, will compare media types and sub-types.
     * @param bool   $strictMatch  If TRUE, will return empty string on no match.
     *                             If FALSE, will return the first supported element.
     *
     * @return string Best match
     */
    protected function getBestMatch(array $supported, ?string $header = null, bool $enforceTypes = false, bool $strictMatch = false): string
    {
        if ($supported === []) {
            throw new HttpException('You must provide an array of supported values to all Negotiations.');
        }

        if ($header === null || $header === '' || $header === '0') {
            return $strictMatch ? '' : $supported[0];
        }

        $acceptable = $this->parseHeader($header);

        foreach ($acceptable as $accept) {
            // if acceptable quality is zero, skip it.
            if ($accept['q'] === 0.0) {
                continue;
            }

            // if acceptable value is "anything", return the first available
            if ($accept['value'] === '*' || $accept['value'] === '*/*') {
                return $supported[0];
            }

            // If an acceptable value is supported, return it
            foreach ($supported as $available) {
                if ($this->match($accept, $available, $enforceTypes)) {
                    return $available;
                }
            }
        }

        // No matches? Return the first supported element.
        return $strictMatch ? '' : $supported[0];
    }

    /**
     * Parses an Accept* header into it's multiple values.
     *
     * This is based on code from Aura.Accept library.
     */
    public function parseHeader(string $header): array
    {
        $results    = [];
        $acceptable = explode(',', $header);

        foreach ($acceptable as $value) {
            $pairs = explode(';', $value);

            $value = $pairs[0];

            unset($pairs[0]);

            $parameters = [];

            foreach ($pairs as $pair) {
                $param = [];
                preg_match(
                    '/^(?P<name>.+?)=(?P<quoted>"|\')?(?P<value>.*?)(?:\k<quoted>)?$/',
                    $pair,
                    $param
                );
                $parameters[trim($param['name'])] = trim($param['value']);
            }

            $quality = 1.0;

            if (array_key_exists('q', $parameters)) {
                $quality = $parameters['q'];
                unset($parameters['q']);
            }

            $results[] = [
                'value'  => trim($value),
                'q'      => (float) $quality,
                'params' => $parameters,
            ];
        }

        // Sort to get the highest results first
        usort($results, static function ($a, $b) {
            if ($a['q'] === $b['q']) {
                $a_ast = substr_count($a['value'], '*');
                $b_ast = substr_count($b['value'], '*');

                // '*/*' has lower precedence than 'text/*',
                // and 'text/*' has lower priority than 'text/plain'
                //
                // This seems backwards, but needs to be that way
                // due to the way PHP7 handles ordering or array
                // elements created by reference.
                if ($a_ast > $b_ast) {
                    return 1;
                }

                // If the counts are the same, but one element
                // has more params than another, it has higher precedence.
                //
                // This seems backwards, but needs to be that way
                // due to the way PHP7 handles ordering or array
                // elements created by reference.
                if ($a_ast === $b_ast) {
                    return count($b['params']) - count($a['params']);
                }

                return 0;
            }

            // Still here? Higher q values have precedence.
            return ($a['q'] > $b['q']) ? -1 : 1;
        });

        return $results;
    }

    /**
     * Match-maker
     */
    protected function match(array $acceptable, string $supported, bool $enforceTypes = false): bool
    {
        $supported = $this->parseHeader($supported);
        if (count($supported) === 1) {
            $supported = $supported[0];
        }

        // Is it an exact match?
        if ($acceptable['value'] === $supported['value']) {
            return $this->matchParameters($acceptable, $supported);
        }

        // Do we need to compare types/sub-types? Only used
        // by negotiateMedia().
        if ($enforceTypes) {
            return $this->matchTypes($acceptable, $supported);
        }

        return false;
    }

    /**
     * Checks two Accept values with matching 'values' to see if their
     * 'params' are the same.
     */
    protected function matchParameters(array $acceptable, array $supported): bool
    {
        if (count($acceptable['params']) !== count($supported['params'])) {
            return false;
        }

        foreach ($supported['params'] as $label => $value) {
            if (! isset($acceptable['params'][$label]) || $acceptable['params'][$label] !== $value) {
                return false;
            }
        }

        return true;
    }

    /**
     * Compares the types/subtypes of an acceptable Media type and
     * the supported string.
     */
    public function matchTypes(array $acceptable, array $supported): bool
    {
        [$aType, $aSubType] = explode('/', $acceptable['value']);
        [$sType, $sSubType] = explode('/', $supported['value']);

        // If the types don't match, we're done.
        if ($aType !== $sType) {
            return false;
        }

        // If there's an asterisk, we're cool
        if ($aSubType === '*') {
            return true;
        }

        // Otherwise, subtypes must match also.
        return $aSubType === $sSubType;
    }
}


1		<?php
2
3		/**
4		* This file is part of Blitz PHP framework.
5		*
6		* (c) 2022 Dimitri Sitchet Tomkeu <[email protected]>
7		*
8		* For the full copyright and license information, please view
9		* the LICENSE file that was distributed with this source code.
10		*/
11
12		namespace BlitzPHP\Http;
13
14		use BlitzPHP\Exceptions\HttpException;
15
16		class Negotiator
17		{
18		/**
19		* Request
20		*
21		* @var ServerRequest
22		*/
23		protected $request;
24
25		/**
26		* Constructor
27		*/
28		public function __construct(?ServerRequest $request = null)
29		{
30		if (null !== $request) {
31	2	$this->request = $request;
32		}
33		}
34
35		/**
36		* Stores the request instance to grab the headers from.
37		*/
38		public function setRequest(ServerRequest $request): self
39		{
40		$this->request = $request;
41
42		return $this;
43		}
44
45		/**
46		* Determines the best content-type to use based on the $supported
47		* types the application says it supports, and the types requested
48		* by the client.
49		*
50		* If no match is found, the first, highest-ranking client requested
51		* type is returned.
52		*
53		* @param bool $strictMatch If TRUE, will return an empty string when no match found.
54		* If FALSE, will return the first supported element.
55		*/
56		public function media(array $supported, bool $strictMatch = false): string
57		{
58		return $this->getBestMatch($supported, $this->request->getHeaderLine('accept'), true, $strictMatch);
59		}
60
61		/**
62		* Determines the best charset to use based on the $supported
63		* types the application says it supports, and the types requested
64		* by the client.
65		*
66		* If no match is found, the first, highest-ranking client requested
67		* type is returned.
68		*/
69		public function charset(array $supported): string
70		{
71		$match = $this->getBestMatch($supported, $this->request->getHeaderLine('accept-charset'), false, true);
72
73		// If no charset is shown as a match, ignore the directive
74		// as allowed by the RFC, and tell it a default value.
75		if ($match === '' \|\| $match === '0') {
76		return 'utf-8';
77		}
78
79		return $match;
80		}
81
82		/**
83		* Determines the best encoding type to use based on the $supported
84		* types the application says it supports, and the types requested
85		* by the client.
86		*
87		* If no match is found, the first, highest-ranking client requested
88		* type is returned.
89		*/
90		public function encoding(array $supported = []): string
91		{
92		$supported[] = 'identity';
93
94		return $this->getBestMatch($supported, $this->request->getHeaderLine('accept-encoding'));
95		}
96
97		/**
98		* Determines the best language to use based on the $supported
99		* types the application says it supports, and the types requested
100		* by the client.
101		*
102		* If no match is found, the first, highest-ranking client requested
103		* type is returned.
104		*/
105		public function language(array $supported): string
106		{
107	2	return $this->getBestMatch($supported, $this->request->getHeaderLine('accept-language'));
108		}
109
110		// --------------------------------------------------------------------
111		// Utility Methods
112		// --------------------------------------------------------------------
113
114		/**
115		* Does the grunt work of comparing any of the app-supported values
116		* against a given Accept* header string.
117		*
118		* Portions of this code base on Aura.Accept library.
119		*
120		* @param array $supported App-supported values
121		* @param string $header header string
122		* @param bool $enforceTypes If TRUE, will compare media types and sub-types.
123		* @param bool $strictMatch If TRUE, will return empty string on no match.
124		* If FALSE, will return the first supported element.
125		*
126		* @return string Best match
127		*/
128		protected function getBestMatch(array $supported, ?string $header = null, bool $enforceTypes = false, bool $strictMatch = false): string
129		{
130		if ($supported === []) {
131	2	throw new HttpException('You must provide an array of supported values to all Negotiations.');
132		}
133
134		if ($header === null \|\| $header === '' \|\| $header === '0') {
135	2	return $strictMatch ? '' : $supported[0];
136		}
137
138		$acceptable = $this->parseHeader($header);
139
140		foreach ($acceptable as $accept) {
141		// if acceptable quality is zero, skip it.
142		if ($accept['q'] === 0.0) {
143		continue;
144		}
145
146		// if acceptable value is "anything", return the first available
147		if ($accept['value'] === '' \|\| $accept['value'] === '/*') {
148		return $supported[0];
149		}
150
151		// If an acceptable value is supported, return it
152		foreach ($supported as $available) {
153		if ($this->match($accept, $available, $enforceTypes)) {
154		return $available;
155		}
156		}
157		}
158
159		// No matches? Return the first supported element.
160		return $strictMatch ? '' : $supported[0];
161		}
162
163		/**
164		* Parses an Accept* header into it's multiple values.
165		*
166		* This is based on code from Aura.Accept library.
167		*/
168		public function parseHeader(string $header): array
169		{
170		$results = [];
171		$acceptable = explode(',', $header);
172
173		foreach ($acceptable as $value) {
174		$pairs = explode(';', $value);
175
176		$value = $pairs[0];
177
178		unset($pairs[0]);
179
180		$parameters = [];
181
182		foreach ($pairs as $pair) {
183		$param = [];
184		preg_match(
185		'/^(?P<name>.+?)=(?P<quoted>"\|\')?(?P<value>.*?)(?:\k<quoted>)?$/',
186		$pair,
187		$param
188		);
189		$parameters[trim($param['name'])] = trim($param['value']);
190		}
191
192		$quality = 1.0;
193
194		if (array_key_exists('q', $parameters)) {
195		$quality = $parameters['q'];
196		unset($parameters['q']);
197		}
198
199		$results[] = [
200		'value' => trim($value),
201		'q' => (float) $quality,
202		'params' => $parameters,
203		];
204		}
205
206		// Sort to get the highest results first
207		usort($results, static function ($a, $b) {
208		if ($a['q'] === $b['q']) {
209		$a_ast = substr_count($a['value'], '*');
210		$b_ast = substr_count($b['value'], '*');
211
212		// '/' has lower precedence than 'text/*',
213		// and 'text/*' has lower priority than 'text/plain'
214		//
215		// This seems backwards, but needs to be that way
216		// due to the way PHP7 handles ordering or array
217		// elements created by reference.
218		if ($a_ast > $b_ast) {
219		return 1;
220		}
221
222		// If the counts are the same, but one element
223		// has more params than another, it has higher precedence.
224		//
225		// This seems backwards, but needs to be that way
226		// due to the way PHP7 handles ordering or array
227		// elements created by reference.
228		if ($a_ast === $b_ast) {
229		return count($b['params']) - count($a['params']);
230		}
231
232		return 0;
233		}
234
235		// Still here? Higher q values have precedence.
236		return ($a['q'] > $b['q']) ? -1 : 1;
237		});
238
239		return $results;
240		}
241
242		/**
243		* Match-maker
244		*/
245		protected function match(array $acceptable, string $supported, bool $enforceTypes = false): bool
246		{
247		$supported = $this->parseHeader($supported);
248		if (count($supported) === 1) {
249		$supported = $supported[0];
250		}
251
252		// Is it an exact match?
253		if ($acceptable['value'] === $supported['value']) {
254		return $this->matchParameters($acceptable, $supported);
255		}
256
257		// Do we need to compare types/sub-types? Only used
258		// by negotiateMedia().
259		if ($enforceTypes) {
260		return $this->matchTypes($acceptable, $supported);
261		}
262
263		return false;
264		}
265
266		/**
267		* Checks two Accept values with matching 'values' to see if their
268		* 'params' are the same.
269		*/
270		protected function matchParameters(array $acceptable, array $supported): bool
271		{
272		if (count($acceptable['params']) !== count($supported['params'])) {
273		return false;
274		}
275
276		foreach ($supported['params'] as $label => $value) {
277		if (! isset($acceptable['params'][$label]) \|\| $acceptable['params'][$label] !== $value) {
278		return false;
279		}
280		}
281
282		return true;
283		}
284
285		/**
286		* Compares the types/subtypes of an acceptable Media type and
287		* the supported string.
288		*/
289		public function matchTypes(array $acceptable, array $supported): bool
290		{
291		[$aType, $aSubType] = explode('/', $acceptable['value']);
292		[$sType, $sSubType] = explode('/', $supported['value']);
293
294		// If the types don't match, we're done.
295		if ($aType !== $sType) {
296		return false;
297		}
298
299		// If there's an asterisk, we're cool
300		if ($aSubType === '*') {
301		return true;
302		}
303
304		// Otherwise, subtypes must match also.
305		return $aSubType === $sSubType;
306		}
307		}
308

blitz-php / framework

Pull Request — main (#16)

Negotiator::match() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like