CompositeContainer::get() - Code Metrics - Inspection of "Merge branch 'master' into lazy-services" - yiisoft/di - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — lazy-services ( 2f8c8b...8212a3 )

by Dmitriy

created 2022-11-20 08:38 UTC

CompositeContainer::get() C

↳ Parent: CompositeContainer

Complexity

Conditions	14
Paths	27

Size

Total Lines	70
Code Lines	39

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	14
eloc	39
c	0
b	0
f	0
nc	27
nop	1
dl	0
loc	70
rs	6.2666

How to fix Long Method Complexity

<?php

declare(strict_types=1);

namespace Yiisoft\Di;

use InvalidArgumentException;
use Psr\Container\ContainerInterface;
use RuntimeException;
use Throwable;
use Yiisoft\Di\Helpers\TagHelper;

use function is_string;

/**
 * A composite container for use with containers that support the delegate lookup feature.
 */
final class CompositeContainer implements ContainerInterface
{
    /**
     * Containers to look into starting from the beginning of the array.
     *
     * @var ContainerInterface[] The list of containers.
     */
    private array $containers = [];

    /**
     * @psalm-template T
     * @psalm-param string|class-string<T> $id
     * @psalm-return ($id is class-string ? T : mixed)
     */
    public function get($id)
    {
        /** @psalm-suppress TypeDoesNotContainType */
        if (!is_string($id)) {
            throw new InvalidArgumentException(
                sprintf(
                    'ID must be a string, %s given.',
                    get_debug_type($id)
                )
            );
        }

        if ($id === StateResetter::class) {
            $resetters = [];
            foreach ($this->containers as $container) {
                if ($container->has(StateResetter::class)) {
                    $resetters[] = $container->get(StateResetter::class);
                }
            }
            $stateResetter = new StateResetter($this);
            $stateResetter->setResetters($resetters);

            return $stateResetter;
        }

        if (TagHelper::isTagAlias($id)) {
            $tags = [];
            foreach ($this->containers as $container) {
                if (!$container instanceof Container) {
                    continue;
                }
                if ($container->has($id)) {
                    /** @psalm-suppress MixedArgument `Container::get()` always return array for tag */
                    array_unshift($tags, $container->get($id));
                }
            }

            /** @psalm-suppress MixedArgument `Container::get()` always return array for tag */
            return array_merge(...$tags);
        }

        foreach ($this->containers as $container) {
            if ($container->has($id)) {
                /** @psalm-suppress MixedReturnStatement */
                return $container->get($id);
            }
        }

        // Collect details from containers
        $exceptions = [];
        foreach ($this->containers as $container) {
            $hasException = false;
            try {
                $container->get($id);
            } catch (Throwable $t) {
                $hasException = true;
                $exceptions[] = [$t, $container];
            } finally {
                if (!$hasException) {
                    $exceptions[] = [
                        new RuntimeException(
                            'Container "has()" returned false, but no exception was thrown from "get()".'
                        ),
                        $container,
                    ];
                }
            }
        }

        throw new CompositeNotFoundException($exceptions);
    }

    public function has($id): bool
    {
        foreach ($this->containers as $container) {
            if ($container->has($id)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Attaches a container to the composite container.
     */
    public function attach(ContainerInterface $container): void
    {
        $this->containers[] = $container;
    }

    /**
     * Removes a container from the list of containers.
     */
    public function detach(ContainerInterface $container): void
    {
        foreach ($this->containers as $i => $c) {
            if ($container === $c) {
                unset($this->containers[$i]);
            }
        }
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Yiisoft\Di;
6
7			use InvalidArgumentException;
8			use Psr\Container\ContainerInterface;
9			use RuntimeException;
10			use Throwable;
11			use Yiisoft\Di\Helpers\TagHelper;
12
13			use function is_string;
14
15			/**
16			* A composite container for use with containers that support the delegate lookup feature.
17			*/
18			final class CompositeContainer implements ContainerInterface
19			{
20			/**
21			* Containers to look into starting from the beginning of the array.
22			*
23			* @var ContainerInterface[] The list of containers.
24			*/
25			private array $containers = [];
26
27			/**
28			* @psalm-template T
29			* @psalm-param string\|class-string<T> $id
30			* @psalm-return ($id is class-string ? T : mixed)
31			*/
32			public function get($id)
33			{
34			/** @psalm-suppress TypeDoesNotContainType */
35			if (!is_string($id)) {
36			throw new InvalidArgumentException(
37			sprintf(
38			'ID must be a string, %s given.',
39			get_debug_type($id)
40			)
41			);
42			}
43
44			if ($id === StateResetter::class) {
45			$resetters = [];
46			foreach ($this->containers as $container) {
47			if ($container->has(StateResetter::class)) {
48			$resetters[] = $container->get(StateResetter::class);
49			}
50			}
51			$stateResetter = new StateResetter($this);
52			$stateResetter->setResetters($resetters);
53
54			return $stateResetter;
55			}
56
57			if (TagHelper::isTagAlias($id)) {
58			$tags = [];
59			foreach ($this->containers as $container) {
60			if (!$container instanceof Container) {
61			continue;
62			}
63			if ($container->has($id)) {
64			/** @psalm-suppress MixedArgument `Container::get()` always return array for tag */
65			array_unshift($tags, $container->get($id));
66			}
67			}
68
69			/** @psalm-suppress MixedArgument `Container::get()` always return array for tag */
70			return array_merge(...$tags);
71			}
72
73			foreach ($this->containers as $container) {
74			if ($container->has($id)) {
75			/** @psalm-suppress MixedReturnStatement */
76			return $container->get($id);
77			}
78			}
79
80			// Collect details from containers
81			$exceptions = [];
82			foreach ($this->containers as $container) {
83			$hasException = false;
84			try {
85			$container->get($id);
86			} catch (Throwable $t) {
87			$hasException = true;
88			$exceptions[] = [$t, $container];
89			} finally {
90			if (!$hasException) {
91			$exceptions[] = [
92			new RuntimeException(
93			'Container "has()" returned false, but no exception was thrown from "get()".'
94			),
95			$container,
96			];
97			}
98			}
99			}
100
101			throw new CompositeNotFoundException($exceptions);
102			}
103
104			public function has($id): bool
105			{
106			foreach ($this->containers as $container) {
107			if ($container->has($id)) {
108			return true;
109			}
110			}
111			return false;
112			}
113
114			/**
115			* Attaches a container to the composite container.
116			*/
117			public function attach(ContainerInterface $container): void
118			{
119			$this->containers[] = $container;
120			}
121
122			/**
123			* Removes a container from the list of containers.
124			*/
125			public function detach(ContainerInterface $container): void
126			{
127			foreach ($this->containers as $i => $c) {
128			if ($container === $c) {
129			unset($this->containers[$i]);
130			}
131			}
132			}
133			}
134

yiisoft / di

Push — lazy-services ( 2f8c8b...8212a3 )

CompositeContainer::get() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like