Resolver::resolveDependencies() - Code Metrics - Inspection of "remove @ & %%" - slince/di - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 54da0a...13952c )

by Taosikai

created 2019-05-24 08:49 UTC

Resolver::resolveDependencies() A

↳ Parent: Resolver

Complexity

Conditions	5
Paths	5

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	27
rs	9.1768
c	0
b	0
f	0
cc	5
nc	5
nop	2

<?php

/*
 * This file is part of the slince/di package.
 *
 * (c) Slince <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Slince\Di;

use Slince\Di\Exception\ConfigException;
use Slince\Di\Exception\DependencyInjectionException;
use Slince\Di\Exception\NotFoundException;

class Resolver
{
    /**
     * @var Container
     */
    protected $container;

    /**
     * @param Container $container
     */
    public function __construct(Container $container)
    {
        $this->container = $container;
    }

    /**
     * @param Definition $definition
     *
     * @return mixed
     */
    public function resolve(Definition $definition)
    {
        $this->parseConcrete($definition);

        if (null !== $definition->getFactory()) {
            $instance = $this->createFromFactory($definition);
        } elseif (null !== $definition->getClass()) {
            $instance = $this->createFromClass($definition);
        } elseif (null !== $definition->getResolved()) {
            $instance = $definition->getResolved();
        } else {
            throw new ConfigException('The definition is not invalid.');
        }
        $this->invokeMethods($definition, $instance);
        $this->invokeProperties($definition, $instance);
        $definition->setResolved($instance);

        return $instance;
    }

    protected function parseConcrete(Definition $definition)
    {
        $concrete = $definition->getConcrete();
        if (is_string($concrete)) {
            $definition->setClass($concrete);
        } elseif (is_array($concrete) || $concrete instanceof \Closure) {
            $definition->setFactory($concrete);
        } elseif (is_object($concrete)) {
            $definition->setResolved($concrete)
                ->setShared(true);
        } else {
            throw new ConfigException('The concrete of the definition is invalid');
        }
    }

    protected function createFromClass(Definition $definition)
    {
        $class = $definition->getClass();
        try {
            $reflection = new \ReflectionClass($definition->getClass());
        } catch (\ReflectionException $e) {
            throw new DependencyInjectionException(sprintf('Class "%s" is invalid', $definition->getClass()));
        }
        if (!$reflection->isInstantiable()) {
            throw new DependencyInjectionException(sprintf('Can not instantiate "%s"', $definition->getClass()));
        }
        $constructor = $reflection->getConstructor();
        if (is_null($constructor)) {
            $instance = $reflection->newInstanceWithoutConstructor();
        } else {
            $arguments = $this->resolveArguments($definition->getArguments());
            if ($definition->isAutowired()) {
                $arguments = $this->resolveDependencies($constructor->getParameters(), $arguments);
            }
            if (count($arguments) < $constructor->getNumberOfRequiredParameters()) {
                throw new ConfigException(sprintf('Too few arguments for class "%s"', $class));
            }
            $instance = $reflection->newInstanceArgs($arguments);
        }

        return $instance;
    }

    /**
     * @param Definition $definition
     *
     * @return object
     */
    protected function createFromFactory(Definition $definition)
    {
        $factory = $definition->getFactory();
        if (is_array($factory)) {
            $factory = $this->resolveArguments($factory);
        }
        return call_user_func_array($factory,
            $this->resolveArguments($definition->getArguments()) ?: [$this->container]
        );
    }

    /**
     * @param Definition $definition
     * @param object     $instance
     */
    protected function invokeMethods(Definition $definition, $instance)
    {
        foreach ($definition->getMethodCalls() as $method) {
            call_user_func_array([$instance, $method[0]], $this->resolveArguments($method[1]));
        }
    }

    /**
     * @param Definition $definition
     * @param object     $instance
     */
    protected function invokeProperties(Definition $definition, $instance)
    {
        $properties = $this->resolveArguments($definition->getProperties());
        foreach ($properties as $name => $value) {
            $instance->$name = $value;
        }
    }

    /**
     * Resolve dependencies.
     *
     * @param \ReflectionParameter[] $dependencies
     * @param array $arguments
     * @return array
     * @throws DependencyInjectionException
     */
    protected function resolveDependencies($dependencies, $arguments)
    {
        $solved = [];
        foreach ($dependencies as $dependency) {
            if (isset($arguments[$dependency->getPosition()])) {
                $solved[] = $arguments[$dependency->getPosition()];
                continue;
            }

            if (null !== $dependency->getClass()) {
                $solved[] = $this->container->get($dependency->getClass()->name);
                continue;
            }

            if ($dependency->isOptional()) {
                $solved[] = $dependency->getDefaultValue();
                continue;
            }

            throw new DependencyInjectionException(sprintf(
                'Unresolvable dependency resolving "%s" in class "%s"',
                $dependency->name,
                $dependency->getDeclaringClass()->getName()

            ));
        }
        return $solved;
    }

    /**
     * Resolves array of parameters.
     *
     * @param array $arguments
     *
     * @return array
     */
    protected function resolveArguments($arguments)
    {
        foreach ($arguments as &$argument) {
            if ($argument instanceof Reference) {
                $argument = $this->container->get($argument->getId());
                continue;
            }
        }
        return $arguments;
    }
}


1			<?php
2
3			/*
4			* This file is part of the slince/di package.
5			*
6			* (c) Slince <[email protected]>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace Slince\Di;
13
14			use Slince\Di\Exception\ConfigException;
15			use Slince\Di\Exception\DependencyInjectionException;
16			use Slince\Di\Exception\NotFoundException;
17
18			class Resolver
19			{
20			/**
21			* @var Container
22			*/
23			protected $container;
24
25			/**
26			* @param Container $container
27			*/
28			public function __construct(Container $container)
29			{
30			$this->container = $container;
31			}
32
33			/**
34			* @param Definition $definition
35			*
36			* @return mixed
37			*/
38			public function resolve(Definition $definition)
39			{
40			$this->parseConcrete($definition);
41
42			if (null !== $definition->getFactory()) {
43			$instance = $this->createFromFactory($definition);
44			} elseif (null !== $definition->getClass()) {
45			$instance = $this->createFromClass($definition);
46			} elseif (null !== $definition->getResolved()) {
47			$instance = $definition->getResolved();
48			} else {
49			throw new ConfigException('The definition is not invalid.');
50			}
51			$this->invokeMethods($definition, $instance);
52			$this->invokeProperties($definition, $instance);
53			$definition->setResolved($instance);
54
55			return $instance;
56			}
57
58			protected function parseConcrete(Definition $definition)
59			{
60			$concrete = $definition->getConcrete();
61			if (is_string($concrete)) {
62			$definition->setClass($concrete);
63			} elseif (is_array($concrete) \|\| $concrete instanceof \Closure) {
64			$definition->setFactory($concrete);
65			} elseif (is_object($concrete)) {
66			$definition->setResolved($concrete)
67			->setShared(true);
68			} else {
69			throw new ConfigException('The concrete of the definition is invalid');
70			}
71			}
72
73			protected function createFromClass(Definition $definition)
74			{
75			$class = $definition->getClass();
76			try {
77			$reflection = new \ReflectionClass($definition->getClass());
78			} catch (\ReflectionException $e) {
79			throw new DependencyInjectionException(sprintf('Class "%s" is invalid', $definition->getClass()));
80			}
81			if (!$reflection->isInstantiable()) {
82			throw new DependencyInjectionException(sprintf('Can not instantiate "%s"', $definition->getClass()));
83			}
84			$constructor = $reflection->getConstructor();
85			if (is_null($constructor)) {
86			$instance = $reflection->newInstanceWithoutConstructor();
87			} else {
88			$arguments = $this->resolveArguments($definition->getArguments());
89			if ($definition->isAutowired()) {
90			$arguments = $this->resolveDependencies($constructor->getParameters(), $arguments);
91			}
92			if (count($arguments) < $constructor->getNumberOfRequiredParameters()) {
93			throw new ConfigException(sprintf('Too few arguments for class "%s"', $class));
94			}
95			$instance = $reflection->newInstanceArgs($arguments);
96			}
97
98			return $instance;
99			}
100
101			/**
102			* @param Definition $definition
103			*
104			* @return object
105			*/
106			protected function createFromFactory(Definition $definition)
107			{
108			$factory = $definition->getFactory();
109			if (is_array($factory)) {
110			$factory = $this->resolveArguments($factory);
111			}
112			return call_user_func_array($factory,
113			$this->resolveArguments($definition->getArguments()) ?: [$this->container]
114			);
115			}
116
117			/**
118			* @param Definition $definition
119			* @param object $instance
120			*/
121			protected function invokeMethods(Definition $definition, $instance)
122			{
123			foreach ($definition->getMethodCalls() as $method) {
124			call_user_func_array([$instance, $method[0]], $this->resolveArguments($method[1]));
125			}
126			}
127
128			/**
129			* @param Definition $definition
130			* @param object $instance
131			*/
132			protected function invokeProperties(Definition $definition, $instance)
133			{
134			$properties = $this->resolveArguments($definition->getProperties());
135			foreach ($properties as $name => $value) {
136			$instance->$name = $value;
137			}
138			}
139
140			/**
141			* Resolve dependencies.
142			*
143			* @param \ReflectionParameter[] $dependencies
144			* @param array $arguments
145			* @return array
146			* @throws DependencyInjectionException
147			*/
148			protected function resolveDependencies($dependencies, $arguments)
149			{
150			$solved = [];
151			foreach ($dependencies as $dependency) {
152			if (isset($arguments[$dependency->getPosition()])) {
153			$solved[] = $arguments[$dependency->getPosition()];
154			continue;
155			}
156
157			if (null !== $dependency->getClass()) {
158			$solved[] = $this->container->get($dependency->getClass()->name);
159			continue;
160			}
161
162			if ($dependency->isOptional()) {
163			$solved[] = $dependency->getDefaultValue();
164			continue;
165			}
166
167			throw new DependencyInjectionException(sprintf(
168			'Unresolvable dependency resolving "%s" in class "%s"',
169			$dependency->name,
170			$dependency->getDeclaringClass()->getName()
			0 ignored issues – show Bug introduced 2019-05-24 09:04 UTC by Report Bug Copy Issue Report Consider using `$dependency->getDeclaringClass()->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
171			));
172			}
173			return $solved;
174			}
175
176			/**
177			* Resolves array of parameters.
178			*
179			* @param array $arguments
180			*
181			* @return array
182			*/
183			protected function resolveArguments($arguments)
184			{
185			foreach ($arguments as &$argument) {
186			if ($argument instanceof Reference) {
187			$argument = $this->container->get($argument->getId());
188			continue;
189			}
190			}
191			return $arguments;
192			}
193			}
194

slince / di

Push — master ( 54da0a...13952c )

Resolver::resolveDependencies() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like