StaticMethodCollector::__construct() - Code Metrics - Inspection of "satisfying static analysis" - SignpostMarv/daft-interface-collector - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 5fe763...8745eb )

by SignpostMarv

created 2018-12-26 23:44 UTC

StaticMethodCollector::__construct() A

↳ Parent: StaticMethodCollector

Complexity

Conditions	2
Paths	2

Size

Total Lines	18
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	8
CRAP Score	2

Importance

Changes

Metric	Value
cc	2
eloc	7
nc	2
nop	3
dl	0
loc	18
ccs	8
cts	8
cp	1
crap	2
rs	10
c	0
b	0
f	0

<?php

declare(strict_types=1);
/**
* @author SignpostMarv
*/

namespace SignpostMarv\DaftInterfaceCollector;

use Closure;
use Generator;
use ReflectionClass;
use ReflectionMethod;
use ReflectionNamedType;
use ReflectionType;
use Traversable;

class StaticMethodCollector
{
    /**
    * @var array<string, array<string, array<int, string>>>
    */
    private $staticMethods = [];

    /**
    * @var string[]
    */
    private $interfaces = [];

    /**
    * @var array<int, string>
    */
    private $processedSources = [];

    /**
    * @var string[]
    */
    private $alreadyYielded = [];

    /**
    * @var bool
    */
    private $autoReset;

    public function __construct(array $staticMethods, array $interfaces, bool $autoReset = true)
    {
        $filteredMethods = [];

        foreach ($this->FilterArrayOfInterfaceOffsets($staticMethods) as $interface => $methods) {
            $filteredMethods[$interface] = $this->FilterMethods($interface, $methods);
        }

        $this->staticMethods = $this->FilterNonZeroArray($filteredMethods);

        /**
        * @var string[]
        */
        $filteredInterfaces = $this->FilterArrayOfInterfacesOrClasses($interfaces);

        $this->interfaces = $filteredInterfaces;

        $this->autoReset = $autoReset;
    }

    public function Collect(string ...$implementations) : Generator
    {
        if ($this->autoReset) {
            $this->processedSources = [];
            $this->alreadyYielded = [];
        }

        yield from $this->CollectInterfaces(...$implementations);
    }

    protected function CollectInterfaces(string ...$implementations) : Generator
    {
        foreach (
            array_filter(
                $implementations,
                function (string $implementation) : bool {
                    return
                        class_exists($implementation) &&
                        ! in_array($implementation, $this->processedSources, true);
                }
            ) as $implementation
        ) {
            $this->processedSources[] = $implementation;
            yield from $this->CollectInterfacesFromImplementationCheckInterfaces($implementation);
            yield from $this->CollectInterfacesFromImplementation($implementation);
        }
    }

    final protected function CollectInterfacesFromImplementationCheckInterfaces(
        string $implementation
    ) : Generator {
        foreach ($this->interfaces as $interface) {
            if (
                ! in_array($implementation, $this->alreadyYielded, true) &&
                is_a($implementation, $interface, true)
            ) {
                yield $implementation;
                $this->alreadyYielded[] = $implementation;
                break;
            }
        }
    }

    final protected function CollectInterfacesFromImplementation(string $implementation) : Generator
    {
        $interfaces = array_keys($this->staticMethods);

        foreach ($this->FilterIsA($implementation, $interfaces) as $interface) {
            foreach ($this->staticMethods[$interface] as $method => $types) {
                yield from $this->CollectInterfacesFromImplementationTypes(
                    $implementation,
                    $method,
                    $types
                );
            }
        }
    }

    /**
    * @param array<int, string> $types
    *
    * @psalm-suppress InvalidStringClass
    */
    final protected function CollectInterfacesFromImplementationTypes(
        string $implementation,
        string $method,
        array $types
    ) : Generator {
        /**
        * @var iterable<string>
        */
        $methodResult = $implementation::$method();

        foreach ($methodResult as $result) {
            if (in_array($result, $this->alreadyYielded, true)) {
                continue;
            }

            foreach ($this->FilterIsA($result, $types) as $type) {
                yield $result;
                $this->alreadyYielded[] = $result;
            }

            yield from $this->CollectInterfaces($result);
        }
    }

    /**
    * @param array<int, string> $interfaces
    *
    * @return array<int, string>
    */
    final protected function FilterIsA(string $implementation, array $interfaces) : array
    {
        /**
        * @var array<int, string>
        */
        $out = array_filter($interfaces, function (string $interface) use ($implementation) : bool {
            return is_a($implementation, $interface, true);
        });

        return $out;
    }

    /**
    * @return string[]|array<string, mixed>
    */
    final protected function FilterArrayOfInterfaces(array $interfaces, int $flag = 0) : array
    {
        $strings = array_filter($interfaces, 'is_string', $flag);

        return array_filter($strings, 'interface_exists', $flag);
    }

    /**
    * @return string[]
    */
    final protected function FilterArrayOfInterfacesOrClasses(array $interfaces) : array
    {
        /**
        * @var string[]
        */
        $strings = array_filter($interfaces, 'is_string');

        return array_filter($strings, function (string $maybe) : bool {
            return interface_exists($maybe) || class_exists($maybe);
        });
    }

    /**
    * @return array<string, array>
    */
    final protected function FilterArrayOfInterfaceOffsets(array $interfaces) : array
    {
        /**
        * @var array<string, array>
        */
        $strings = $this->FilterArrayOfInterfaces($interfaces, ARRAY_FILTER_USE_KEY);

        return array_filter($strings, 'is_array');
    }

    final protected function MakeMethodFilter(string $interface) : Closure
    {
        return function (string $maybe) use ($interface) : bool {
            $ref = new ReflectionClass($interface);

            return
                $ref->hasMethod($maybe) &&
                $this->FilterReflectionMethod($ref->getMethod($maybe));
        };
    }

    final protected function FilterReflectionMethod(ReflectionMethod $refMethod) : bool
    {
        return
            $refMethod->isStatic() &&
            $refMethod->isPublic() &&
            0 === $refMethod->getNumberOfRequiredParameters() &&
            $this->FilterReflectionReturnType($refMethod->getReturnType());
    }

    final protected function FilterReflectionReturnType(? ReflectionType $refReturn) : bool
    {
        $refReturnName = ($refReturn instanceof ReflectionNamedType) ? $refReturn->getName() : '';

        return 'array' === $refReturnName || is_a($refReturnName, Traversable::class, true);
    }

    /**
    * @return array<string, string[]>
    */
    final protected function FilterMethods(string $interface, array $methods) : array
    {
        /**
        * @var array<string, string[]>
        */
        $filteredMethods = $this->FilterNonZeroArray(array_map(
            [$this, 'FilterArrayOfInterfacesOrClasses'],
            array_filter(
                array_filter($methods, 'is_string', ARRAY_FILTER_USE_KEY),
                $this->MakeMethodFilter($interface),
                ARRAY_FILTER_USE_KEY
            )
        ));

        return $filteredMethods;
    }

    /**
    * @return array<string, array<string, array<int, string>>>
    */
    final protected function FilterNonZeroArray(array $in) : array
    {
        /**
        * @var array<string, array<string, array<int, string>>>
        */
        $out = array_filter(
            $in,
            function (array $val) : bool {
                return count($val) > 0;
            }
        );

        return $out;
    }
}


1		<?php
2
3		declare(strict_types=1);
4		/**
5		* @author SignpostMarv
6		*/
7
8		namespace SignpostMarv\DaftInterfaceCollector;
9
10		use Closure;
11		use Generator;
12		use ReflectionClass;
13		use ReflectionMethod;
14		use ReflectionNamedType;
15		use ReflectionType;
16		use Traversable;
17
18		class StaticMethodCollector
19		{
20		/**
21		* @var array<string, array<string, array<int, string>>>
22		*/
23		private $staticMethods = [];
24
25		/**
26		* @var string[]
27		*/
28		private $interfaces = [];
29
30		/**
31		* @var array<int, string>
32		*/
33		private $processedSources = [];
34
35		/**
36		* @var string[]
37		*/
38		private $alreadyYielded = [];
39
40		/**
41		* @var bool
42		*/
43		private $autoReset;
44
45	4	public function __construct(array $staticMethods, array $interfaces, bool $autoReset = true)
46		{
47	4	$filteredMethods = [];
48
49	4	foreach ($this->FilterArrayOfInterfaceOffsets($staticMethods) as $interface => $methods) {
50	4	$filteredMethods[$interface] = $this->FilterMethods($interface, $methods);
51		}
52
53	4	$this->staticMethods = $this->FilterNonZeroArray($filteredMethods);
54
55		/**
56		* @var string[]
57		*/
58	4	$filteredInterfaces = $this->FilterArrayOfInterfacesOrClasses($interfaces);
59
60	4	$this->interfaces = $filteredInterfaces;
61
62	4	$this->autoReset = $autoReset;
63	4	}
64
65	4	public function Collect(string ...$implementations) : Generator
66		{
67	4	if ($this->autoReset) {
68	2	$this->processedSources = [];
69	2	$this->alreadyYielded = [];
70		}
71
72	4	yield from $this->CollectInterfaces(...$implementations);
73	4	}
74
75	4	protected function CollectInterfaces(string ...$implementations) : Generator
76		{
77		foreach (
78	4	array_filter(
79	4	$implementations,
80		function (string $implementation) : bool {
81		return
82	4	class_exists($implementation) &&
83	4	! in_array($implementation, $this->processedSources, true);
84	4	}
85		) as $implementation
86		) {
87	4	$this->processedSources[] = $implementation;
88	4	yield from $this->CollectInterfacesFromImplementationCheckInterfaces($implementation);
89	4	yield from $this->CollectInterfacesFromImplementation($implementation);
90		}
91	4	}
92
93	4	final protected function CollectInterfacesFromImplementationCheckInterfaces(
94		string $implementation
95		) : Generator {
96	4	foreach ($this->interfaces as $interface) {
97		if (
98	4	! in_array($implementation, $this->alreadyYielded, true) &&
99	4	is_a($implementation, $interface, true)
100		) {
101		yield $implementation;
102		$this->alreadyYielded[] = $implementation;
103	4	break;
104		}
105		}
106	4	}
107
108	4	final protected function CollectInterfacesFromImplementation(string $implementation) : Generator
109		{
110	4	$interfaces = array_keys($this->staticMethods);
111
112	4	foreach ($this->FilterIsA($implementation, $interfaces) as $interface) {
113	4	foreach ($this->staticMethods[$interface] as $method => $types) {
114	4	yield from $this->CollectInterfacesFromImplementationTypes(
115	4	$implementation,
116	4	$method,
117	4	$types
118		);
119		}
120		}
121	4	}
122
123		/**
124		* @param array<int, string> $types
125		*
126		* @psalm-suppress InvalidStringClass
127		*/
128	4	final protected function CollectInterfacesFromImplementationTypes(
129		string $implementation,
130		string $method,
131		array $types
132		) : Generator {
133		/**
134		* @var iterable<string>
135		*/
136	4	$methodResult = $implementation::$method();
137
138	4	foreach ($methodResult as $result) {
139	4	if (in_array($result, $this->alreadyYielded, true)) {
140		continue;
141		}
142
143	4	foreach ($this->FilterIsA($result, $types) as $type) {
144	4	yield $result;
145	4	$this->alreadyYielded[] = $result;
146		}
147
148	4	yield from $this->CollectInterfaces($result);
149		}
150	4	}
151
152		/**
153		* @param array<int, string> $interfaces
154		*
155		* @return array<int, string>
156		*/
157	4	final protected function FilterIsA(string $implementation, array $interfaces) : array
158		{
159		/**
160		* @var array<int, string>
161		*/
162		$out = array_filter($interfaces, function (string $interface) use ($implementation) : bool {
163	4	return is_a($implementation, $interface, true);
164	4	});
165
166	4	return $out;
167		}
168
169		/**
170		* @return string[]\|array<string, mixed>
171		*/
172	4	final protected function FilterArrayOfInterfaces(array $interfaces, int $flag = 0) : array
173		{
174	4	$strings = array_filter($interfaces, 'is_string', $flag);
175
176	4	return array_filter($strings, 'interface_exists', $flag);
177		}
178
179		/**
180		* @return string[]
181		*/
182	4	final protected function FilterArrayOfInterfacesOrClasses(array $interfaces) : array
183		{
184		/**
185		* @var string[]
186		*/
187	4	$strings = array_filter($interfaces, 'is_string');
188
189		return array_filter($strings, function (string $maybe) : bool {
190	4	return interface_exists($maybe) \|\| class_exists($maybe);
191	4	});
192		}
193
194		/**
195		* @return array<string, array>
196		*/
197	4	final protected function FilterArrayOfInterfaceOffsets(array $interfaces) : array
198		{
199		/**
200		* @var array<string, array>
201		*/
202	4	$strings = $this->FilterArrayOfInterfaces($interfaces, ARRAY_FILTER_USE_KEY);
203
204	4	return array_filter($strings, 'is_array');
205		}
206
207	4	final protected function MakeMethodFilter(string $interface) : Closure
208		{
209		return function (string $maybe) use ($interface) : bool {
210	4	$ref = new ReflectionClass($interface);
211
212		return
213	4	$ref->hasMethod($maybe) &&
214	4	$this->FilterReflectionMethod($ref->getMethod($maybe));
215	4	};
216		}
217
218	4	final protected function FilterReflectionMethod(ReflectionMethod $refMethod) : bool
219		{
220		return
221	4	$refMethod->isStatic() &&
222	4	$refMethod->isPublic() &&
223	4	0 === $refMethod->getNumberOfRequiredParameters() &&
224	4	$this->FilterReflectionReturnType($refMethod->getReturnType());
225		}
226
227	4	final protected function FilterReflectionReturnType(? ReflectionType $refReturn) : bool
228		{
229	4	$refReturnName = ($refReturn instanceof ReflectionNamedType) ? $refReturn->getName() : '';
230
231	4	return 'array' === $refReturnName \|\| is_a($refReturnName, Traversable::class, true);
232		}
233
234		/**
235		* @return array<string, string[]>
236		*/
237	4	final protected function FilterMethods(string $interface, array $methods) : array
238		{
239		/**
240		* @var array<string, string[]>
241		*/
242	4	$filteredMethods = $this->FilterNonZeroArray(array_map(
243	4	[$this, 'FilterArrayOfInterfacesOrClasses'],
244	4	array_filter(
245	4	array_filter($methods, 'is_string', ARRAY_FILTER_USE_KEY),
246	4	$this->MakeMethodFilter($interface),
247	4	ARRAY_FILTER_USE_KEY
248		)
249		));
250
251	4	return $filteredMethods;
252		}
253
254		/**
255		* @return array<string, array<string, array<int, string>>>
256		*/
257	4	final protected function FilterNonZeroArray(array $in) : array
258		{
259		/**
260		* @var array<string, array<string, array<int, string>>>
261		*/
262	4	$out = array_filter(
263	4	$in,
264		function (array $val) : bool {
265	4	return count($val) > 0;
266	4	}
267		);
268
269	4	return $out;
270		}
271		}
272

SignpostMarv / daft-interface-collector

GitHub Access Token became invalid

Push — master ( 5fe763...8745eb )

StaticMethodCollector::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like