anonymous//tests/Benchmark/Framework/ClassResolver/AnonymousGlobal/AnonymousGlobalsBench.php$2 ➔ abstractFactory()

Complexity

Conditions

1

Size

Total Lines

33

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	AnonymousGlobalsBench.php$2 ➔ getConfigValues()	0	3	1
A	AnonymousGlobalsBench.php$2 ➔ __construct()	0	6	1
A	AnonymousGlobalsBench.php$2 ➔ createDomainClass()	0	28	1
A	AnonymousGlobalsBench.php$2 ➔ getValueFromDependencyProvider()	0	3	1

<?php

declare(strict_types=1);

namespace GacelaTest\Benchmark\Framework\ClassResolver\AnonymousGlobal;

use Gacela\Framework\AbstractConfig;
use Gacela\Framework\AbstractDependencyProvider;
use Gacela\Framework\AbstractFacade;
use Gacela\Framework\AbstractFactory;
use Gacela\Framework\ClassResolver\GlobalInstance\AnonymousGlobal;
use Gacela\Framework\Container\Container;

/**
 * @BeforeMethods("setUp")
 */
final class AnonymousGlobalsBench
{
    private AbstractFacade $facade;

    public function setUp(): void
    {
        $this->abstractConfig();
        $this->abstractDependencyProvider();
        $this->abstractFactory();
        $this->abstractFacade();
    }

    public function bench_class_resolving(): void
    {
        $this->facade->getConfigValues();

The method getConfigValues() does not exist on Gacela\Framework\AbstractFacade. It seems like you code against a sub-type of Gacela\Framework\AbstractFacade such as anonymous//tests/Benchmark/Framework/ClassResolver/AnonymousGlobal/AnonymousGlobalsBench.php$4 or GacelaTest\Benchmark\Framework\ClassResolver\NormalModule\NormalModuleFacade.

        $this->facade->getValueFromDependencyProvider();

The method getValueFromDependencyProvider() does not exist on Gacela\Framework\AbstractFacade. It seems like you code against a sub-type of Gacela\Framework\AbstractFacade such as anonymous//tests/Benchmark/Framework/ClassResolver/AnonymousGlobal/AnonymousGlobalsBench.php$4 or GacelaTest\Benchmark\Framework\ClassResolver\NormalModule\NormalModuleFacade.

    }

    private function abstractConfig(): void
    {
        AnonymousGlobal::addGlobal(
            $this,
            new class() extends AbstractConfig {
                public function getValues(): array
                {
                    return ['1', 2, [3]];
                }
            }
        );
    }

    private function abstractDependencyProvider(): void
    {
        AnonymousGlobal::addGlobal(
            $this,
            new class() extends AbstractDependencyProvider {
                public function provideModuleDependencies(Container $container): void
                {
                    $container->set('key', 'value');
                }
            }
        );
    }

    private function abstractFactory(): void
    {
        AnonymousGlobal::addGlobal(
            $this,
            new class() extends AbstractFactory {
                public function createDomainClass(): object
                {
                    /** @var array $configValues */
                    $configValues = $this->getConfig()->getValues();

                    /** @var string $valueFromDependencyProvider */
                    $valueFromDependencyProvider = $this->getProvidedDependency('key');

                    return new class($configValues, $valueFromDependencyProvider) {
                        private array $configValues;
                        private string $valueFromDependencyProvider;

                        public function __construct(
                            array $configValues,
                            string $valueFromDependencyProvider
                        ) {
                            $this->configValues = $configValues;
                            $this->valueFromDependencyProvider = $valueFromDependencyProvider;
                        }

                        public function getConfigValues(): array
                        {
                            return $this->configValues;
                        }

                        public function getValueFromDependencyProvider(): string
                        {
                            return $this->valueFromDependencyProvider;
                        }
                    };
                }
            }
        );
    }

    private function abstractFacade(): void
    {
        $this->facade = new class() extends AbstractFacade {
            public function getConfigValues(): array
            {
                return $this->getFactory()
                    ->createDomainClass()
                    ->getConfigValues();
            }

            public function getValueFromDependencyProvider(): string
            {
                return $this->getFactory()
                    ->createDomainClass()
                    ->getValueFromDependencyProvider();
            }
        };
    }
}