FormatNegotiator::getBest() - Code Metrics - Inspection of "bump PHPUnit version" - FriendsOfSymfony/FOSRestBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — 2.x (#2280)

by Guilhem

created 2020-12-10 19:19 UTC

FormatNegotiator::getBest() A

↳ Parent: FormatNegotiator

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	1
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	1
cts	1
cp	1
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	3
crap	1

<?php

/*
 * This file is part of the FOSRestBundle package.
 *
 * (c) FriendsOfSymfony <http://friendsofsymfony.github.com/>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace FOS\RestBundle\Negotiation;

use FOS\RestBundle\Util\StopFormatListenerException;
use Negotiation\Accept;
use Negotiation\Negotiator as BaseNegotiator;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\RequestMatcherInterface;
use Symfony\Component\HttpFoundation\RequestStack;

/**
 * @internal
 */
class BaseFormatNegotiator extends BaseNegotiator
{
    private $map = [];
    private $requestStack;
    private $mimeTypes;

    public function __construct(RequestStack $requestStack, array $mimeTypes = [])
    {
        $this->requestStack = $requestStack;
        $this->mimeTypes = $mimeTypes;
    }

    public function add(RequestMatcherInterface $requestMatcher, array $options = [])
    {
        $this->map[] = [$requestMatcher, $options];
    }

    /**
     * @internal
     */
    protected function doGetBest($header, array $priorities = [])
    {
        $request = $this->getRequest();
        $header = $header ?: $request->headers->get('Accept');

        foreach ($this->map as $elements) {
            // Check if the current RequestMatcherInterface matches the current request
            if (!$elements[0]->matches($request)) {
                continue;
            }
            $options = &$elements[1]; // Do not reallow memory for this variable

            if (!empty($options['stop'])) {
                throw new StopFormatListenerException('Stopped format listener');
            }
            if (empty($options['priorities']) && empty($priorities)) {
                if (!empty($options['fallback_format'])) {
                    return new Accept($request->getMimeType($options['fallback_format']));
                }

                continue;
            }

            if (isset($options['prefer_extension']) && $options['prefer_extension'] && !isset($extensionHeader)) {
                $extension = pathinfo($request->getPathInfo(), PATHINFO_EXTENSION);

                if (!empty($extension)) {
                    // $extensionHeader will now be either a non empty string or an empty string
                    $extensionHeader = $request->getMimeType($extension);

                    if ($extensionHeader) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                        $header = $extensionHeader.'; q='.$options['prefer_extension'].($header ? ','.$header : '');
                    }
                }
            }

            if ($header) {
                $mimeTypes = $this->normalizePriorities(
                    $request,
                    empty($priorities) ? $options['priorities'] : $priorities
                );

                $mimeType = parent::getBest($header, $mimeTypes);
class Daddy
{
    protected function getFirstName()
    {
        return "Eidur";
    }

    protected function getSurName()
    {
        return "Gudjohnsen";
    }
}

class Son
{
    public function getFirstName()
    {
        return parent::getSurname();
    }
}

                if (null !== $mimeType) {
                    return $mimeType;
                }
            }

            if (isset($options['fallback_format'])) {
                // if false === fallback_format then we fail here instead of considering more rules
                if (false === $options['fallback_format']) {
                    return;
                }

                // stop looking at rules since we have a fallback defined
                return new Accept($request->getMimeType($options['fallback_format']));
            }
        }
    }

    private function sanitize(array $values): array
    {
        return array_map(function ($value) {
            return preg_replace('/\s+/', '', strtolower($value));
        }, $values);
    }

    /**
     * @param string[] $priorities
     *
     * @return string[] formatted priorities
     */
    private function normalizePriorities(Request $request, array $priorities): array
    {
        $priorities = $this->sanitize($priorities);

        $mimeTypes = [];
        foreach ($priorities as $priority) {
            if (strpos($priority, '/')) {
                $mimeTypes[] = $priority;

                continue;
            }

            if (method_exists(Request::class, 'getMimeTypes')) {
                $mimeTypes = array_merge($mimeTypes, Request::getMimeTypes($priority));
            } elseif (null !== $request->getMimeType($priority)) {
                $class = new \ReflectionClass(Request::class);
                $properties = $class->getStaticProperties();
                $mimeTypes = array_merge($mimeTypes, $properties['formats'][$priority]);
            }

            if (isset($this->mimeTypes[$priority])) {
                foreach ($this->mimeTypes[$priority] as $mimeType) {
                    $mimeTypes[] = $mimeType;
                }
            }
        }

        return $mimeTypes;
    }

    private function getRequest(): Request

    {
        $request = $this->requestStack->getCurrentRequest();
        if (null === $request) {
            throw new \RuntimeException('There is no current request.');
        }

        return $request;
    }
}

if (method_exists(BaseNegotiator::class, 'getOrderedElements')) {
    /**
     * @author Guilhem Niot <[email protected]>
     *
     * @final since 2.8
     */
    class FormatNegotiator extends BaseFormatNegotiator
    {
        public function getBest($header, array $priorities = [], $strict = false)
        {
            return $this->doGetBest($header, $priorities);
        }
    }
} else {
    /**
     * @author Guilhem Niot <[email protected]>
     *
     * @final since 2.8
     */
    class FormatNegotiator extends BaseFormatNegotiator

    {
        public function getBest($header, array $priorities = [])
        {
            return $this->doGetBest($header, $priorities);
        }
    }
}


1			<?php
2
3			/*
4			* This file is part of the FOSRestBundle package.
5			*
6			* (c) FriendsOfSymfony <http://friendsofsymfony.github.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			namespace FOS\RestBundle\Negotiation;
13
14			use FOS\RestBundle\Util\StopFormatListenerException;
15			use Negotiation\Accept;
16			use Negotiation\Negotiator as BaseNegotiator;
17			use Symfony\Component\HttpFoundation\Request;
18			use Symfony\Component\HttpFoundation\RequestMatcherInterface;
19			use Symfony\Component\HttpFoundation\RequestStack;
20
21			/**
22			* @internal
23			*/
24			class BaseFormatNegotiator extends BaseNegotiator
25			{
26			private $map = [];
27			private $requestStack;
28			private $mimeTypes;
29
30	29		public function __construct(RequestStack $requestStack, array $mimeTypes = [])
31			{
32	29		$this->requestStack = $requestStack;
33	29		$this->mimeTypes = $mimeTypes;
34	29		}
35
36	27		public function add(RequestMatcherInterface $requestMatcher, array $options = [])
37			{
38	27		$this->map[] = [$requestMatcher, $options];
39	27		}
40
41			/**
42			* @internal
43			*/
44	24		protected function doGetBest($header, array $priorities = [])
45			{
46	24		$request = $this->getRequest();
47	24		$header = $header ?: $request->headers->get('Accept');
48
49	24		foreach ($this->map as $elements) {
50			// Check if the current RequestMatcherInterface matches the current request
51	22		if (!$elements[0]->matches($request)) {
52	1		continue;
53			}
54	22		$options = &$elements[1]; // Do not reallow memory for this variable
55
56	22		if (!empty($options['stop'])) {
57	1		throw new StopFormatListenerException('Stopped format listener');
58			}
59	21		if (empty($options['priorities']) && empty($priorities)) {
60	4		if (!empty($options['fallback_format'])) {
61	4		return new Accept($request->getMimeType($options['fallback_format']));
62			}
63
64	1		continue;
65			}
66
67	17		if (isset($options['prefer_extension']) && $options['prefer_extension'] && !isset($extensionHeader)) {
68	12		$extension = pathinfo($request->getPathInfo(), PATHINFO_EXTENSION);
69
70	12		if (!empty($extension)) {
71			// $extensionHeader will now be either a non empty string or an empty string
72	6		$extensionHeader = $request->getMimeType($extension);
73
74	6		if ($extensionHeader) {
			0 ignored issues – show Bug Best Practice introduced 2018-05-22 19:00 UTC by Report Bug Copy Issue Report The expression `$extensionHeader` of type `string\|null` is loosely compared to `true`; this is ambiguous if the string can be empty. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
75	3		$header = $extensionHeader.'; q='.$options['prefer_extension'].($header ? ','.$header : '');
76			}
77			}
78			}
79
80	17		if ($header) {
81	16		$mimeTypes = $this->normalizePriorities(
82	16		$request,
83	16		empty($priorities) ? $options['priorities'] : $priorities
84			);
85
86	16		$mimeType = parent::getBest($header, $mimeTypes);
			0 ignored issues – show Comprehensibility Bug introduced 2020-12-06 13:25 UTC by Report Bug Copy Issue Report It seems like you call parent on a different method (`getBest()` instead of `doGetBest()`). Are you sure this is correct? If so, you might want to change this to `$this->getBest()`. This check looks for a call to a parent method whose name is different than the method from which it is called. Consider the following code: class Daddy { protected function getFirstName() { return "Eidur"; } protected function getSurName() { return "Gudjohnsen"; } } class Son { public function getFirstName() { return parent::getSurname(); } } The `getFirstName()` method in the `Son` calls the wrong method in the parent class. Loading history...
87
88	16		if (null !== $mimeType) {
89	15		return $mimeType;
90			}
91			}
92
93	2		if (isset($options['fallback_format'])) {
94			// if false === fallback_format then we fail here instead of considering more rules
95	2		if (false === $options['fallback_format']) {
96			return;
97			}
98
99			// stop looking at rules since we have a fallback defined
100	2		return new Accept($request->getMimeType($options['fallback_format']));
101			}
102			}
103	4		}
104
105	16		private function sanitize(array $values): array
106			{
107			return array_map(function ($value) {
108	16		return preg_replace('/\s+/', '', strtolower($value));
109	16		}, $values);
110			}
111
112			/**
113			* @param string[] $priorities
114			*
115			* @return string[] formatted priorities
116			*/
117	16		private function normalizePriorities(Request $request, array $priorities): array
118			{
119	16		$priorities = $this->sanitize($priorities);
120
121	16		$mimeTypes = [];
122	16		foreach ($priorities as $priority) {
123	16		if (strpos($priority, '/')) {
124	4		$mimeTypes[] = $priority;
125
126	4		continue;
127			}
128
129	13		if (method_exists(Request::class, 'getMimeTypes')) {
130	13		$mimeTypes = array_merge($mimeTypes, Request::getMimeTypes($priority));
131			} elseif (null !== $request->getMimeType($priority)) {
132			$class = new \ReflectionClass(Request::class);
133			$properties = $class->getStaticProperties();
134			$mimeTypes = array_merge($mimeTypes, $properties['formats'][$priority]);
135			}
136
137	13		if (isset($this->mimeTypes[$priority])) {
138	3		foreach ($this->mimeTypes[$priority] as $mimeType) {
139	3		$mimeTypes[] = $mimeType;
140			}
141			}
142			}
143
144	16		return $mimeTypes;
145			}
146
147	24	View Code Duplication	private function getRequest(): Request
			0 ignored issues – show Duplication introduced 2020-03-06 14:25 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
148			{
149	24		$request = $this->requestStack->getCurrentRequest();
150	24		if (null === $request) {
151			throw new \RuntimeException('There is no current request.');
152			}
153
154	24		return $request;
155			}
156			}
157
158	1		if (method_exists(BaseNegotiator::class, 'getOrderedElements')) {
159			/**
160			* @author Guilhem Niot <[email protected]>
161			*
162			* @final since 2.8
163			*/
164			class FormatNegotiator extends BaseFormatNegotiator
165			{
166			public function getBest($header, array $priorities = [], $strict = false)
167			{
168	24		return $this->doGetBest($header, $priorities);
169			}
170			}
171			} else {
172			/**
173			* @author Guilhem Niot <[email protected]>
174			*
175			* @final since 2.8
176			*/
177			class FormatNegotiator extends BaseFormatNegotiator
			0 ignored issues – show Comprehensibility Best Practice introduced 2020-12-06 13:25 UTC by Report Bug Copy Issue Report The type `FOS\RestBundle\Negotiation\FormatNegotiator` has been defined more than once; this definition is ignored, only the first definition in this file (L164-170) is considered. This check looks for classes that have been defined more than once in the same file. If you can, we would recommend to use standard object-oriented programming techniques. For example, to avoid multiple types, it might make sense to create a common interface, and then multiple, different implementations for that interface. This also has the side-effect of providing you with better IDE auto-completion, static analysis and also better OPCode caching from PHP. Loading history...
178			{
179			public function getBest($header, array $priorities = [])
180			{
181			return $this->doGetBest($header, $priorities);
182			}
183			}
184			}
185

FriendsOfSymfony / FOSRestBundle

Pull Request — 2.x (#2280)

FormatNegotiator::getBest() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like