Services::__construct() - Code Metrics - API-Skeletons/doctrine-graphql - Measure and Improve Code Quality continuously with Scrutinizer

Services::__construct() B
last analyzed 2023-10-17 22:42 UTC

↳ Parent: Services

Complexity

Conditions	2
Paths	1

Size

Total Lines	110
Code Lines	76

Duplication

Lines	0
Ratio	0 %

Importance

Changes	3
Bugs	0	Features	0

Metric	Value
cc	2
eloc	76
c	3
b	0
f	0
nc	1
nop	3
dl	0
loc	110
rs	8.5236

How to fix Long Method

<?php

declare(strict_types=1);

namespace ApiSkeletons\Doctrine\GraphQL;

use ApiSkeletons\Doctrine\GraphQL\Metadata\GlobalEnable;
use ArrayObject;
use Doctrine\ORM\EntityManager;
use League\Event\EventDispatcher;

/**
 * This trait is used to remove complexity from the Driver class.
 * It doesn't change what the Driver does.  It just separates the container work
 * from the Driver.
 */
trait Services
{
    /**
     * @param string  $entityManagerAlias required
     * @param Config  $config             required
     * @param mixed[] $metadata           optional so cached metadata can be loaded
     */
    public function __construct(
        EntityManager $entityManager,
        Config|null $config = null,
        array $metadata = [],
    ) {
        $metadata = new ArrayObject($metadata);

        $this
            // Plain classes
            ->set(EntityManager::class, $entityManager)
            ->set(
                Config::class,
                static function () use ($config) {
                    if (! $config) {
                        $config = new Config();
                    }

                    return $config;
                },
            )
            ->set(
                EventDispatcher::class,
                static fn () => new EventDispatcher()
            )
            ->set(
                Type\TypeManager::class,
                static fn (AbstractContainer $container) => new Type\TypeManager($container)
            )
            ->set(
                'metadata',
                static function (AbstractContainer $container) use ($metadata) {
                    return (new Metadata\MetadataFactory(
                        $metadata,
                        $container->get(EntityManager::class),
                        $container->get(Config::class),
                        $container->get(GlobalEnable::class),
                        $container->get(EventDispatcher::class),
                    ))();
                },
            )
            ->set(
                Metadata\GlobalEnable::class,
                static function (AbstractContainer $container) {
                    return new Metadata\GlobalEnable(
                        $container->get(EntityManager::class),
                        $container->get(Config::class),
                        $container->get(EventDispatcher::class),
                    );
                },
            )
            ->set(
                Resolve\FieldResolver::class,
                static function (AbstractContainer $container) {
                    return new Resolve\FieldResolver(
                        $container->get(Config::class),
                        $container->get(Type\TypeManager::class),
                    );
                },
            )
            ->set(
                Resolve\ResolveCollectionFactory::class,
                static function (AbstractContainer $container) {
                    return new Resolve\ResolveCollectionFactory(
                        $container->get(EntityManager::class),
                        $container->get(Config::class),
                        $container->get(Resolve\FieldResolver::class),
                        $container->get(Type\TypeManager::class),
                        $container->get(EventDispatcher::class),
                        $container->get('metadata'),
                    );
                },
            )
            ->set(
                Resolve\ResolveEntityFactory::class,
                static function (AbstractContainer $container) {
                    return new Resolve\ResolveEntityFactory(
                        $container->get(Config::class),
                        $container->get(EntityManager::class),
                        $container->get(EventDispatcher::class),
                        $container->get('metadata'),
                    );
                },
            )
            ->set(
                Criteria\CriteriaFactory::class,
                static function (AbstractContainer $container) {
                    return new Criteria\CriteriaFactory(
                        $container->get(Config::class),
                        $container->get(EntityManager::class),
                        $container->get(Type\TypeManager::class),
                        $container->get(EventDispatcher::class),
                    );
                },
            )
            ->set(
                Hydrator\HydratorFactory::class,
                static function (AbstractContainer $container) {
                    return new Hydrator\HydratorFactory(
                        $container->get(EntityManager::class),
                        $container->get(Type\TypeManager::class),
                    );
                },
            )
            ->set(
                Input\InputFactory::class,
                static function (AbstractContainer $container) {
                    return new Input\InputFactory(
                        $container->get(Config::class),
                        $container->get(EntityManager::class),
                        $container->get(Type\TypeManager::class),
                    );
                },
            );
    }

    abstract public function set(string $id, mixed $value): mixed;
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace ApiSkeletons\Doctrine\GraphQL;
6
7			use ApiSkeletons\Doctrine\GraphQL\Metadata\GlobalEnable;
8			use ArrayObject;
9			use Doctrine\ORM\EntityManager;
10			use League\Event\EventDispatcher;
11
12			/**
13			* This trait is used to remove complexity from the Driver class.
14			* It doesn't change what the Driver does. It just separates the container work
15			* from the Driver.
16			*/
17			trait Services
18			{
19			/**
20			* @param string $entityManagerAlias required
21			* @param Config $config required
22			* @param mixed[] $metadata optional so cached metadata can be loaded
23			*/
24			public function __construct(
25			EntityManager $entityManager,
26			Config\|null $config = null,
27			array $metadata = [],
28			) {
29			$metadata = new ArrayObject($metadata);
30
31			$this
32			// Plain classes
33			->set(EntityManager::class, $entityManager)
34			->set(
35			Config::class,
36			static function () use ($config) {
37			if (! $config) {
38			$config = new Config();
39			}
40
41			return $config;
42			},
43			)
44			->set(
45			EventDispatcher::class,
46			static fn () => new EventDispatcher()
47			)
48			->set(
49			Type\TypeManager::class,
50			static fn (AbstractContainer $container) => new Type\TypeManager($container)
51			)
52			->set(
53			'metadata',
54			static function (AbstractContainer $container) use ($metadata) {
55			return (new Metadata\MetadataFactory(
56			$metadata,
57			$container->get(EntityManager::class),
58			$container->get(Config::class),
59			$container->get(GlobalEnable::class),
60			$container->get(EventDispatcher::class),
61			))();
62			},
63			)
64			->set(
65			Metadata\GlobalEnable::class,
66			static function (AbstractContainer $container) {
67			return new Metadata\GlobalEnable(
68			$container->get(EntityManager::class),
69			$container->get(Config::class),
70			$container->get(EventDispatcher::class),
71			);
72			},
73			)
74			->set(
75			Resolve\FieldResolver::class,
76			static function (AbstractContainer $container) {
77			return new Resolve\FieldResolver(
78			$container->get(Config::class),
79			$container->get(Type\TypeManager::class),
80			);
81			},
82			)
83			->set(
84			Resolve\ResolveCollectionFactory::class,
85			static function (AbstractContainer $container) {
86			return new Resolve\ResolveCollectionFactory(
87			$container->get(EntityManager::class),
88			$container->get(Config::class),
89			$container->get(Resolve\FieldResolver::class),
90			$container->get(Type\TypeManager::class),
91			$container->get(EventDispatcher::class),
92			$container->get('metadata'),
93			);
94			},
95			)
96			->set(
97			Resolve\ResolveEntityFactory::class,
98			static function (AbstractContainer $container) {
99			return new Resolve\ResolveEntityFactory(
100			$container->get(Config::class),
101			$container->get(EntityManager::class),
102			$container->get(EventDispatcher::class),
103			$container->get('metadata'),
104			);
105			},
106			)
107			->set(
108			Criteria\CriteriaFactory::class,
109			static function (AbstractContainer $container) {
110			return new Criteria\CriteriaFactory(
111			$container->get(Config::class),
112			$container->get(EntityManager::class),
113			$container->get(Type\TypeManager::class),
114			$container->get(EventDispatcher::class),
115			);
116			},
117			)
118			->set(
119			Hydrator\HydratorFactory::class,
120			static function (AbstractContainer $container) {
121			return new Hydrator\HydratorFactory(
122			$container->get(EntityManager::class),
123			$container->get(Type\TypeManager::class),
124			);
125			},
126			)
127			->set(
128			Input\InputFactory::class,
129			static function (AbstractContainer $container) {
130			return new Input\InputFactory(
131			$container->get(Config::class),
132			$container->get(EntityManager::class),
133			$container->get(Type\TypeManager::class),
134			);
135			},
136			);
137			}
138
139			abstract public function set(string $id, mixed $value): mixed;
140			}
141

API-Skeletons / doctrine-graphql

Services::__construct() B last analyzed 2023-10-17 22:42 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

Services::__construct() B
last analyzed 2023-10-17 22:42 UTC