InDepthArgumentsResolver::matchType() - Code Metrics - Inspection of "Add PHP 8 support" - rybakit/arguments-resolver - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — php8 ( f95663 )

by Eugene

created 2021-06-22 12:11 UTC

InDepthArgumentsResolver::matchType() C

↳ Parent: InDepthArgumentsResolver

Complexity

Conditions	12
Paths	12

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	36
rs	6.9666
c	0
b	0
f	0
cc	12
nc	12
nop	2

How to fix Complexity

<?php

declare(strict_types=1);

/*
 * This file is part of the rybakit/arguments-resolver package.
 *
 * (c) Eugene Leonovich <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace ArgumentsResolver;

class InDepthArgumentsResolver extends ArgumentsResolver
{
    /**
     * @var \ReflectionParameter[]
     */
    private $sortedParameters;

    /**
     * {@inheritdoc}
     */
    protected function getParameters() : array
    {
        if (null === $this->sortedParameters) {
            $this->sortedParameters = $this->reflection->getParameters();
            \uasort($this->sortedParameters, [__CLASS__, 'compareParameters']);
        }

        return $this->sortedParameters;
    }

    /**
     * {@inheritdoc}
     */
    protected function match(\ReflectionParameter $parameter, array $parameters) : ?array
    {
        $found = null;

        foreach ($parameters as $key => $value) {
            if (!self::matchType($parameter, $value)) {
                continue;
            }

            if ($key === $parameter->name) {
                return [$key, $value];
            }

            if (!$found) {
                $found = [$key, $value];
            }
        }

        return $found;
    }

    /**
     * Checks if the value matches the parameter type.
     *
     * @param mixed $value
     */
    private static function matchType(\ReflectionParameter $parameter, $value) : bool
    {
        if (!$type = $parameter->getType()) {
            return true;
        }

        $typeName = $type->getName();

        if ('array' === $typeName) {
            return \is_array($value);
        }

        if ('callable' === $typeName) {
            return \is_callable($value);
        }

        if (!$type->isBuiltin()) {
            if (!\is_object($value)) {
                return false;
            }

            $class = new \ReflectionClass($typeName);

            return $class && $class->isInstance($value);
        }

        switch ($typeName) {
            case 'bool': return \is_bool($value);
            case 'float': return \is_float($value);
            case 'int': return \is_int($value);
            case 'string': return \is_string($value);
            case 'iterable': return \is_iterable($value);
        }

        return true;
    }

    /**
     * Compares reflection parameters by type and position.
     */
    private static function compareParameters(\ReflectionParameter $a, \ReflectionParameter $b) : int
    {
        $aType = $a->getType();
        $bType = $b->getType();

        if (0 !== $result = self::compareParameterClasses($aType, $bType)) {
            return $result;
        }

        $aTypeName = $aType ? $aType->getName() : null;
        $bTypeName = $bType ? $bType->getName() : null;

        if (('array' === $aTypeName) ^ ('array' === $bTypeName)) {
            return ('array' === $bTypeName) << 1 - 1;
        }

        if (('callable' === $aTypeName) ^ ('callable' === $bTypeName)) {
            return ('callable' === $bTypeName) << 1 - 1;
        }

        return $a->getPosition() - $b->getPosition();
    }

    /**
     * Compares reflection parameters by class hierarchy.
     */
    private static function compareParameterClasses(?\ReflectionType $a, ?\ReflectionType $b) : int
    {
        $a = $a && !$a->isBuiltin()
            ? new \ReflectionClass($a->getName())
            : null;

        $b = $b && !$b->isBuiltin()
            ? new \ReflectionClass($b->getName())
            : null;

        if ($a && $b) {
            return $a->isSubclassOf($b->name) ? -1 : (int) $b->isSubclassOf($a->name);
        }

        return (int) !$a - (int) !$b;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* This file is part of the rybakit/arguments-resolver package.
7			*
8			* (c) Eugene Leonovich <[email protected]>
9			*
10			* For the full copyright and license information, please view the LICENSE
11			* file that was distributed with this source code.
12			*/
13
14			namespace ArgumentsResolver;
15
16			class InDepthArgumentsResolver extends ArgumentsResolver
17			{
18			/**
19			* @var \ReflectionParameter[]
20			*/
21			private $sortedParameters;
22
23			/**
24			* {@inheritdoc}
25			*/
26			protected function getParameters() : array
27			{
28			if (null === $this->sortedParameters) {
29			$this->sortedParameters = $this->reflection->getParameters();
30			\uasort($this->sortedParameters, [__CLASS__, 'compareParameters']);
31			}
32
33			return $this->sortedParameters;
34			}
35
36			/**
37			* {@inheritdoc}
38			*/
39			protected function match(\ReflectionParameter $parameter, array $parameters) : ?array
40			{
41			$found = null;
42
43			foreach ($parameters as $key => $value) {
44			if (!self::matchType($parameter, $value)) {
45			continue;
46			}
47
48			if ($key === $parameter->name) {
49			return [$key, $value];
50			}
51
52			if (!$found) {
53			$found = [$key, $value];
54			}
55			}
56
57			return $found;
58			}
59
60			/**
61			* Checks if the value matches the parameter type.
62			*
63			* @param mixed $value
64			*/
65			private static function matchType(\ReflectionParameter $parameter, $value) : bool
66			{
67			if (!$type = $parameter->getType()) {
68			return true;
69			}
70
71			$typeName = $type->getName();
72
73			if ('array' === $typeName) {
74			return \is_array($value);
75			}
76
77			if ('callable' === $typeName) {
78			return \is_callable($value);
79			}
80
81			if (!$type->isBuiltin()) {
82			if (!\is_object($value)) {
83			return false;
84			}
85
86			$class = new \ReflectionClass($typeName);
87
88			return $class && $class->isInstance($value);
89			}
90
91			switch ($typeName) {
92			case 'bool': return \is_bool($value);
93			case 'float': return \is_float($value);
94			case 'int': return \is_int($value);
95			case 'string': return \is_string($value);
96			case 'iterable': return \is_iterable($value);
97			}
98
99			return true;
100			}
101
102			/**
103			* Compares reflection parameters by type and position.
104			*/
105			private static function compareParameters(\ReflectionParameter $a, \ReflectionParameter $b) : int
106			{
107			$aType = $a->getType();
108			$bType = $b->getType();
109
110			if (0 !== $result = self::compareParameterClasses($aType, $bType)) {
111			return $result;
112			}
113
114			$aTypeName = $aType ? $aType->getName() : null;
115			$bTypeName = $bType ? $bType->getName() : null;
116
117			if (('array' === $aTypeName) ^ ('array' === $bTypeName)) {
118			return ('array' === $bTypeName) << 1 - 1;
119			}
120
121			if (('callable' === $aTypeName) ^ ('callable' === $bTypeName)) {
122			return ('callable' === $bTypeName) << 1 - 1;
123			}
124
125			return $a->getPosition() - $b->getPosition();
126			}
127
128			/**
129			* Compares reflection parameters by class hierarchy.
130			*/
131			private static function compareParameterClasses(?\ReflectionType $a, ?\ReflectionType $b) : int
132			{
133			$a = $a && !$a->isBuiltin()
134			? new \ReflectionClass($a->getName())
135			: null;
136
137			$b = $b && !$b->isBuiltin()
138			? new \ReflectionClass($b->getName())
139			: null;
140
141			if ($a && $b) {
142			return $a->isSubclassOf($b->name) ? -1 : (int) $b->isSubclassOf($a->name);
143			}
144
145			return (int) !$a - (int) !$b;
146			}
147			}
148

rybakit / arguments-resolver

Push — php8 ( f95663 )

InDepthArgumentsResolver::matchType() C

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like