NamespaceProtector\EnvironmentDataLoader

Complexity

Total Complexity

11

Size/Duplication

Total Lines	118
Duplicated Lines	0 %

Importance

Changes	6
Bugs	1	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	getCollectComposerNamespace()	0	3	1
A	getCollectBaseClasses()	0	3	1
A	vendorNamespaces()	0	3	1
A	fillFromArray()	0	21	1
A	load()	0	31	2
A	initializeVars()	0	8	1
A	getCollectBaseConstants()	0	3	1
A	getCollectBaseInterfaces()	0	3	1
A	getCollectBaseFunctions()	0	3	1
A	__construct()	0	4	1

<?php

declare(strict_types=1);

namespace NamespaceProtector;

use Closure;
use ReflectionClass;
use NamespaceProtector\Db\DbKeyValue;
use NamespaceProtector\Db\BooleanMatchNameSpace;
use NamespaceProtector\Metadata\VendorNamespace;
use NamespaceProtector\Scanner\ComposerJsonInterface;
use NamespaceProtector\Metadata\VendorNamespaceInterface;

final class EnvironmentDataLoader implements EnvironmentDataLoaderInterface
{
    public const NAMESPACE_PROJECT = 'NamespaceProtector';

    private DbKeyValue $collectBaseClasses;

    private DbKeyValue $collectBaseInterfaces;

    private DbKeyValue $collectBaseFunctions;

    private DbKeyValue $collectBaseConstants;

    private DbKeyValue $collectComposerNamespace;

    private VendorNamespaceInterface $vendorNamespaces;

    private ComposerJsonInterface $composerJson;

    public function __construct(ComposerJsonInterface $composerJson)
    {
        $this->composerJson = $composerJson;
        $this->initializeVars();
    }

    private function initializeVars(): void
    {
        $this->collectBaseClasses = new DbKeyValue();
        $this->collectBaseInterfaces = new DbKeyValue();
        $this->collectBaseFunctions = new DbKeyValue();
        $this->collectBaseConstants = new DbKeyValue();
        $this->collectComposerNamespace = new DbKeyValue();
        $this->vendorNamespaces = new VendorNamespace(new BooleanMatchNameSpace());
    }

    public function load(): void
    {
        $fetchValue = function (string|int $key, string|int $value): string {
            return (string)$value;
        };

        /** @psalm-suppress MissingClosureParamType */
        $fetchKey = function (string|int $key, $value): string {

The parameter $value is not used and could be removed.

            return (string)$key;
        };

        $this->collectBaseFunctions = $this->fillFromArray(\get_defined_functions()['internal'], $fetchValue);
        $this->collectBaseInterfaces = $this->fillFromArray(\get_declared_interfaces(), $fetchValue);

        $internalClass = [];

        /** @psalm-suppress UnusedVariable */
        array_map(
            function (string $class) use ($internalClass): void {
                $aClass = new ReflectionClass($class);
                if ($aClass->isInternal()) {
                    $internalClass[$class] = $aClass->getName();
                }
            },
            get_declared_classes()
        );

        $this->collectBaseClasses = $this->fillFromArray($internalClass, $fetchKey);
        $this->collectBaseConstants = $this->fillFromArray(\get_defined_constants(), $fetchKey);
        $this->collectComposerNamespace = $this->fillFromArray($this->composerJson->getPsr4Ns(), $fetchKey);
        $this->vendorNamespaces->load();
    }

    public function getCollectBaseClasses(): DbKeyValue
    {
        return $this->collectBaseClasses;
    }

    public function getCollectBaseInterfaces(): DbKeyValue
    {
        return $this->collectBaseInterfaces;
    }

    public function getCollectBaseFunctions(): DbKeyValue
    {
        return $this->collectBaseFunctions;
    }

    public function getCollectBaseConstants(): DbKeyValue
    {
        return $this->collectBaseConstants;
    }

    public function getCollectComposerNamespace(): DbKeyValue
    {
        return $this->collectComposerNamespace;
    }

    public function vendorNamespaces(): VendorNamespaceInterface
    {
        return $this->vendorNamespaces;
    }

    private function fillFromArray(array $collections, Closure $fetchStrategy): DbKeyValue
    {
        $db = new DbKeyValue();

        \array_map(
            /**
             * @param array-key $key

The doc comment array-key at position 0 could not be parsed: Unknown type name 'array-key' at position 0 in array-key.

             * @param mixed $value
            */
            function (string $key, $value) use ($db, $fetchStrategy) {

                /** @var string $checkValue */
                $checkValue = $fetchStrategy($key, $value);

                $db->add($checkValue, $checkValue);
            },
            array_keys($collections),
            $collections
        );

        return $db;
    }
}