Micro\Plugin\Locator\Locator\Locator

Complexity

Total Complexity

16

Size/Duplication

Total Lines	106
Duplicated Lines	0 %

Test Coverage

Coverage

85.71%

Importance

Changes	3
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
B	lookup()	0	37	8
A	createReflectionClass()	0	3	1
B	getPluginClasses()	0	32	6

<?php

/*
 *  This file is part of the Micro framework package.
 *
 *  (c) Stanislau Komar <kost@micro-php.net>
 *
 *  For the full copyright and license information, please view the LICENSE
 *  file that was distributed with this source code.
 */

namespace Micro\Plugin\Locator\Locator;

use Micro\Framework\Kernel\KernelInterface;
use Symfony\Component\Finder\Finder;

The type Symfony\Component\Finder\Finder was not found. Maybe you did not declare it correctly or list all dependencies?

class Locator implements LocatorInterface
{
    /**
     * @var array<class-string>

The doc comment array<class-string> at position 2 could not be parsed: Unknown type name 'class-string' at position 2 in array<class-string>.

     */
    private array $locatedClasses;

    public function __construct(
        private readonly KernelInterface $kernel
    ) {
        $this->locatedClasses = [];
    }

    public function lookup(string $classOrInterfaceName): iterable
    {
        $isInterface = interface_exists($classOrInterfaceName);

        if (!$isInterface && !class_exists($classOrInterfaceName)) {
            return;
        }

        foreach ($this->kernel->plugins() as $plugin) {
            $reflection = $this->createReflectionClass($plugin);
            foreach ($this->getPluginClasses($reflection) as $pluginInternalClassName) {
                $pluginClassReflection = $this->createReflectionClass($pluginInternalClassName);

                if ($isInterface) {
                    if (!\in_array($classOrInterfaceName, $pluginClassReflection->getInterfaceNames())) {
                        continue;
                    }
                    /*
                     * @phpstan-ignore-next-line
                     */
                    yield $pluginInternalClassName;

                    continue;
                }

                if (!$pluginClassReflection->isSubclassOf($classOrInterfaceName)) {
                    continue;
                }

                /*
                 * @phpstan-ignore-next-line
                 */
                yield $pluginInternalClassName;
            }
        }

        $this->locatedClasses = [];
    }

    /**
     * @template T of object
     *
     * @param \ReflectionClass<T> $reflection
     *
     * @return \Generator<class-string>
     */
    protected function getPluginClasses(\ReflectionClass $reflection): \Generator
    {
        $filename = $reflection->getFileName();
        if (!$filename) {
            return;
        }

        $pluginBasePath = \dirname($filename);
        $pluginNamespace = $reflection->getNamespaceName();
        $finder = new Finder();
        try {
            $finder
                ->in($pluginBasePath.'/**')
                ->name('*.php')
                ->notName('*Interface.php');
        } catch (\Throwable $exception) {
            return;
        }

        foreach ($finder as $splFileInfo) {
            $relative = str_replace($pluginBasePath, '', (string) $splFileInfo);
            $namespaceRelative = str_replace('/', '\\', $relative);

            $file = str_replace('.php', '', $pluginNamespace.$namespaceRelative);

            if (\in_array($file, $this->locatedClasses) || !class_exists($file)) {
                continue;
            }

            $this->locatedClasses[] = $file;

            yield $file;
        }
    }

    /**
     * @template T of Object
     *
     * @psalm-param  class-string<T>|T $objectOrClass
     *
     * @return \ReflectionClass<T>
     *
     * @throws \ReflectionException
     */
    protected function createReflectionClass(string|object $objectOrClass): \ReflectionClass
    {
        return new \ReflectionClass($objectOrClass);
    }
}