Bind::getStringName() - Code Metrics - ray-di/Ray.Di - Measure and Improve Code Quality continuously with Scrutinizer

Bind::getStringName() A
last analyzed 2025-10-21 06:08 UTC

↳ Parent: Bind

Complexity

Conditions	2
Paths	1

Size

Total Lines	24
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	10
dl	0
loc	24
c	0
b	0
f	0
rs	9.9332
cc	2
nc	1
nop	1

<?php

declare(strict_types=1);

namespace Ray\Di;

use Ray\Aop\MethodInterceptor;
use Ray\Aop\ReflectionClass;
use Ray\Di\Exception\InvalidToConstructorNameParameter;
use ReflectionException;
use ReflectionMethod;

use function array_keys;
use function array_reduce;
use function assert;
use function class_exists;
use function implode;
use function interface_exists;
use function is_array;
use function is_string;

/**
 * @psalm-import-type BindableInterface from Types
 * @psalm-import-type BindingName from Types
 * @psalm-import-type ParameterNameMapping from Types
 */
final class Bind
{
    /** @var Container */
    private $container;

    /**
     * @var string|class-string

     * @phpstan-var class-string<MethodInterceptor>|string
     */
    private $interface;

    /** @var string */
    private $name = Name::ANY;

    /** @var DependencyInterface */
    private $bound;

    /** @var BindValidator */
    private $validate;

    /** @var ?Untarget */
    private $untarget;

    /**
     * @param Container         $container dependency container
     * @param BindableInterface $interface interface or concrete class name
filter:
    dependency_paths: ["lib/*"]
     */
    public function __construct(Container $container, string $interface)
    {
        $this->container = $container;
        $this->interface = $interface;
        $this->validate = new BindValidator();
        $bindUntarget = class_exists($interface) && ! (new \ReflectionClass($interface))->isAbstract() && ! $this->isRegistered($interface);
        $this->bound = new NullDependency();
        if ($bindUntarget) {
            $this->untarget = new Untarget($interface);

            return;
        }

        $this->validate->constructor($interface);
    }

    public function __destruct()
    {
        if ($this->untarget) {
            ($this->untarget)($this->container, $this);
            $this->untarget = null;
        }
    }

    /**
     * @return non-empty-string

     */
    public function __toString(): string
    {
        return $this->interface . '-' . $this->name;
    }

    /**
     * Set dependency name
     *
     * @param BindingName $name
filter:
    dependency_paths: ["lib/*"]
     */
    public function annotatedWith(string $name): self
    {
        $this->name = $name;

        return $this;
    }

    /**
     * Bind to class
     *
     * @param class-string $class

     */
    public function to(string $class): self
    {
        $this->untarget = null;
        $refClass = $this->validate->to($this->interface, $class);
        $this->bound = (new DependencyFactory())->newAnnotatedDependency($refClass);
        $this->container->add($this);

        return $this;
    }

    /**
     * Bind to constructor
     *
     * @param class-string<T>             $class class name

     * @param ParameterNameMapping|string $name  "varName=bindName,..." or [$varName => $bindName, $varName => $bindName...]
     *
     * @throws ReflectionException
     *
     * @template T of object
     */
    public function toConstructor(string $class, $name, ?InjectionPoints $injectionPoints = null, ?string $postConstruct = null): self
    {
        if (is_array($name)) {
            $name = $this->getStringName($name);
        }

        $this->untarget = null;
        $postConstructRef = $postConstruct !== null ? new ReflectionMethod($class, $postConstruct) : null;
        /** @var ReflectionClass<object> $reflection */
        $reflection = new ReflectionClass($class);
        $this->bound = (new DependencyFactory())->newToConstructor($reflection, $name, $injectionPoints, $postConstructRef);
        $this->container->add($this);

        return $this;
    }

    /**
     * Bind to provider
     *
     * @phpstan-param class-string $provider
     */
    public function toProvider(string $provider, string $context = ''): self
    {
        $this->untarget = null;
        $refClass = $this->validate->toProvider($provider);
        $this->bound = (new DependencyFactory())->newProvider($refClass, $context);
        $this->container->add($this);

        return $this;
    }

    /**
     * Bind to instance
     *
     * @param mixed $instance
     */
    public function toInstance($instance): self
    {
        $this->untarget = null;
        $this->bound = new Instance($instance);
        $this->container->add($this);

        return $this;
    }

    /**
     * Bind to NullObject
     */
    public function toNull(): self
    {
        $this->untarget = null;
        assert(interface_exists($this->interface));
        $this->bound = new NullObjectDependency($this->interface);
        $this->container->add($this);

        return $this;
    }

    /**
     * Set scope
     */
    public function in(string $scope): self
    {
        if ($this->bound instanceof Dependency || $this->bound instanceof DependencyProvider || $this->bound instanceof NullDependency) {
            $this->bound->setScope($scope);
        }

        if ($this->untarget) {
            $this->untarget->setScope($scope);
        }

        return $this;
    }

    public function getBound(): DependencyInterface
    {
        return $this->bound;
    }

    public function setBound(DependencyInterface $bound): void
    {
        $this->bound = $bound;
    }

    private function isRegistered(string $interface): bool
    {
        return isset($this->container->getContainer()[$interface . '-' . Name::ANY]);
    }

    /**
     * Return string
     *
     * input: ['varA' => 'nameA', 'varB' => 'nameB']
     * output: "varA=nameA,varB=nameB"
     *
     * @param ParameterNameMapping $name
filter:
    dependency_paths: ["lib/*"]
     */
    private function getStringName(array $name): string
    {
        $keys = array_keys($name);

        $names = array_reduce(
            $keys,
            /**
             * @param list<string> $carry
             * @param array-key $key

             */
            static function (array $carry, $key) use ($name): array {
                if (! is_string($key)) { // @phpstan-ignore-line
                    throw new InvalidToConstructorNameParameter((string) $key);
                }

                $varName = $name[$key] ?? '';
                $carry[] = $key . '=' . $varName;

                return $carry;
            },
            []
        );

        return implode(',', $names);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Ray\Di;
6
7			use Ray\Aop\MethodInterceptor;
8			use Ray\Aop\ReflectionClass;
9			use Ray\Di\Exception\InvalidToConstructorNameParameter;
10			use ReflectionException;
11			use ReflectionMethod;
12
13			use function array_keys;
14			use function array_reduce;
15			use function assert;
16			use function class_exists;
17			use function implode;
18			use function interface_exists;
19			use function is_array;
20			use function is_string;
21
22			/**
23			* @psalm-import-type BindableInterface from Types
24			* @psalm-import-type BindingName from Types
25			* @psalm-import-type ParameterNameMapping from Types
26			*/
27			final class Bind
28			{
29			/** @var Container */
30			private $container;
31
32			/**
33			* @var string\|class-string
			0 ignored issues – show Documentation Bug introduced 2021-10-31 07:12 UTC by Report Bug Copy Issue Report The doc comment `string\|class-string` at position `2` could not be parsed: Unknown type name 'class-string' at position 2 in string\|class-string. Loading history...
34			* @phpstan-var class-string<MethodInterceptor>\|string
35			*/
36			private $interface;
37
38			/** @var string */
39			private $name = Name::ANY;
40
41			/** @var DependencyInterface */
42			private $bound;
43
44			/** @var BindValidator */
45			private $validate;
46
47			/** @var ?Untarget */
48			private $untarget;
49
50			/**
51			* @param Container $container dependency container
52			* @param BindableInterface $interface interface or concrete class name
			0 ignored issues – show Bug introduced 2025-08-03 04:20 UTC by Report Bug Copy Issue Report The type `Ray\Di\BindableInterface` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
53			*/
54			public function __construct(Container $container, string $interface)
55			{
56			$this->container = $container;
57			$this->interface = $interface;
58			$this->validate = new BindValidator();
59			$bindUntarget = class_exists($interface) && ! (new \ReflectionClass($interface))->isAbstract() && ! $this->isRegistered($interface);
60			$this->bound = new NullDependency();
61			if ($bindUntarget) {
62			$this->untarget = new Untarget($interface);
63
64			return;
65			}
66
67			$this->validate->constructor($interface);
68			}
69
70			public function __destruct()
71			{
72			if ($this->untarget) {
73			($this->untarget)($this->container, $this);
74			$this->untarget = null;
75			}
76			}
77
78			/**
79			* @return non-empty-string
			0 ignored issues – show Documentation Bug introduced 2025-08-03 04:20 UTC by Report Bug Copy Issue Report The doc comment `non-empty-string` at position `0` could not be parsed: Unknown type name 'non-empty-string' at position 0 in non-empty-string. Loading history...
80			*/
81			public function __toString(): string
82			{
83			return $this->interface . '-' . $this->name;
84			}
85
86			/**
87			* Set dependency name
88			*
89			* @param BindingName $name
			0 ignored issues – show Bug introduced 2025-08-03 04:20 UTC by Report Bug Copy Issue Report The type `Ray\Di\BindingName` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
90			*/
91			public function annotatedWith(string $name): self
92			{
93			$this->name = $name;
94
95			return $this;
96			}
97
98			/**
99			* Bind to class
100			*
101			* @param class-string $class
			0 ignored issues – show Documentation Bug introduced 2021-10-31 07:12 UTC by Report Bug Copy Issue Report The doc comment `class-string` at position `0` could not be parsed: Unknown type name 'class-string' at position 0 in class-string. Loading history...
102			*/
103			public function to(string $class): self
104			{
105			$this->untarget = null;
106			$refClass = $this->validate->to($this->interface, $class);
107			$this->bound = (new DependencyFactory())->newAnnotatedDependency($refClass);
108			$this->container->add($this);
109
110			return $this;
111			}
112
113			/**
114			* Bind to constructor
115			*
116			* @param class-string<T> $class class name
			0 ignored issues – show Documentation Bug introduced 2023-09-07 18:13 UTC by Report Bug Copy Issue Report The doc comment `class-string<T>` at position `0` could not be parsed: Unknown type name 'class-string' at position 0 in class-string<T>. Loading history...
117			* @param ParameterNameMapping\|string $name "varName=bindName,..." or [$varName => $bindName, $varName => $bindName...]
118			*
119			* @throws ReflectionException
120			*
121			* @template T of object
122			*/
123			public function toConstructor(string $class, $name, ?InjectionPoints $injectionPoints = null, ?string $postConstruct = null): self
124			{
125			if (is_array($name)) {
126			$name = $this->getStringName($name);
127			}
128
129			$this->untarget = null;
130			$postConstructRef = $postConstruct !== null ? new ReflectionMethod($class, $postConstruct) : null;
131			/** @var ReflectionClass<object> $reflection */
132			$reflection = new ReflectionClass($class);
133			$this->bound = (new DependencyFactory())->newToConstructor($reflection, $name, $injectionPoints, $postConstructRef);
134			$this->container->add($this);
135
136			return $this;
137			}
138
139			/**
140			* Bind to provider
141			*
142			* @phpstan-param class-string $provider
143			*/
144			public function toProvider(string $provider, string $context = ''): self
145			{
146			$this->untarget = null;
147			$refClass = $this->validate->toProvider($provider);
148			$this->bound = (new DependencyFactory())->newProvider($refClass, $context);
149			$this->container->add($this);
150
151			return $this;
152			}
153
154			/**
155			* Bind to instance
156			*
157			* @param mixed $instance
158			*/
159			public function toInstance($instance): self
160			{
161			$this->untarget = null;
162			$this->bound = new Instance($instance);
163			$this->container->add($this);
164
165			return $this;
166			}
167
168			/**
169			* Bind to NullObject
170			*/
171			public function toNull(): self
172			{
173			$this->untarget = null;
174			assert(interface_exists($this->interface));
175			$this->bound = new NullObjectDependency($this->interface);
176			$this->container->add($this);
177
178			return $this;
179			}
180
181			/**
182			* Set scope
183			*/
184			public function in(string $scope): self
185			{
186			if ($this->bound instanceof Dependency \|\| $this->bound instanceof DependencyProvider \|\| $this->bound instanceof NullDependency) {
187			$this->bound->setScope($scope);
188			}
189
190			if ($this->untarget) {
191			$this->untarget->setScope($scope);
192			}
193
194			return $this;
195			}
196
197			public function getBound(): DependencyInterface
198			{
199			return $this->bound;
200			}
201
202			public function setBound(DependencyInterface $bound): void
203			{
204			$this->bound = $bound;
205			}
206
207			private function isRegistered(string $interface): bool
208			{
209			return isset($this->container->getContainer()[$interface . '-' . Name::ANY]);
210			}
211
212			/**
213			* Return string
214			*
215			* input: ['varA' => 'nameA', 'varB' => 'nameB']
216			* output: "varA=nameA,varB=nameB"
217			*
218			* @param ParameterNameMapping $name
			0 ignored issues – show Bug introduced 2025-08-03 04:20 UTC by Report Bug Copy Issue Report The type `Ray\Di\ParameterNameMapping` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
219			*/
220			private function getStringName(array $name): string
221			{
222			$keys = array_keys($name);
223
224			$names = array_reduce(
225			$keys,
226			/**
227			* @param list<string> $carry
228			* @param array-key $key
			0 ignored issues – show Documentation Bug introduced 2021-10-31 07:12 UTC by Report Bug Copy Issue Report The doc comment `array-key` at position `0` could not be parsed: Unknown type name 'array-key' at position 0 in array-key. Loading history...
229			*/
230			static function (array $carry, $key) use ($name): array {
231			if (! is_string($key)) { // @phpstan-ignore-line
232			throw new InvalidToConstructorNameParameter((string) $key);
233			}
234
235			$varName = $name[$key] ?? '';
236			$carry[] = $key . '=' . $varName;
237
238			return $carry;
239			},
240			[]
241			);
242
243			return implode(',', $names);
244			}
245			}
246

ray-di / Ray.Di

Bind::getStringName() A last analyzed 2025-10-21 06:08 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Bind::getStringName() A
last analyzed 2025-10-21 06:08 UTC