Config::__construct() - Code Metrics - Inspection of "Improve Zend Service Manager compatibility" - northwoods/container - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#12)

by Woody

created 2018-03-26 14:56 UTC

Config::__construct() A

↳ Parent: Config

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	3
cts	3
cp	1
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	1
crap	1

<?php
declare(strict_types=1);

namespace Northwoods\Container\Zend;

use ArrayObject;
use Auryn\Injector;
use Northwoods\Container\ContainerException;
use Northwoods\Container\InjectorConfig;
use Psr\Container\ContainerInterface;

class Config implements InjectorConfig
{
    /** @var array */
    private $config;

    /** @var bool */
    private $sharedByDefault = true;

    public function __construct(array $config)
    {
        $this->config = $config;
    }

    /**
     * Configure the injector using Zend Service Manager format
     */
    public function apply(Injector $injector): void
    {
        $dependencies = $this->config['dependencies'] ?? [];

        // Define the "config" service, accounting for the fact that Auryn
        // requires all returns are objects.
        $dependencies['services']['config'] = new ArrayObject($this->config, ArrayObject::ARRAY_AS_PROPS);

        $this->injectServices($injector, $dependencies);
        $this->injectFactories($injector, $dependencies);
        $this->injectInvokables($injector, $dependencies);
        $this->injectAliases($injector, $dependencies);
    }

    private function injectAliases(Injector $injector, array $dependencies): void

    {
        $aliases = $dependencies['aliases'] ?? [];
        foreach ($aliases as $alias => $target) {
            // Standard Auryn aliases do not work when chained. Work around by
            // lazily fetching the shared target from the container.
            $injector->share($alias)->share($target)->delegate($alias, $this->makeLazy($target));
        }
    }

    private function injectFactories(Injector $injector, array $dependencies): void
    {
        $factories = $dependencies['factories'] ?? [];
        foreach ($factories as $name => $factory) {
            $delegate = function () use ($injector, $name, $factory) {
                $container = $injector->make(ContainerInterface::class);
                $factory = $this->makeFactory($name, $factory);
$x = 1;
$callable = function() use ($x) {
    $x = 2; // Not visible in outer scope. If you would like this, how
            // about using a different variable name than $x?
};

$callable();
var_dump($x); // integer(1)
                return $factory($container, $name);
            };
            if (isset($dependencies['delegators'][$name])) {

                $delegate = $this->makeDelegator(
                    $injector,
                    $name,
                    $delegate,
                    $dependencies['delegators'][$name]
                );
            }
            $injector->share($name)->delegate($name, $delegate);
        }
    }

    private function injectInvokables(Injector $injector, array $dependencies): void
    {
        $invokables = $dependencies['invokables'] ?? [];
        foreach ($invokables as $alias => $invokable) {
            if (is_string($alias) && $alias !== $invokable) {
                $injector->alias($alias, $invokable);
            }
            $delegate = function () use ($invokable) {
                return $this->makeFactory($invokable, $invokable);
            };
            if (isset($dependencies['delegators'][$invokable])) {

                $delegate = $this->makeDelegator(
                    $injector,
                    $invokable,
                    $delegate,
                    $dependencies['delegators'][$invokable]
                );
            }
            $injector->share($invokable)->delegate($invokable, $delegate);
        }
    }

    private function injectServices(Injector $injector, array $dependencies): void

    {
        $services = $dependencies['services'] ?? [];
        foreach ($services as $name => $service) {
            $injector->share($name)->delegate($name, $this->makeIdentity($service));
        }
    }

    private function makeDelegator(Injector $injector, string $name, callable $callback, array $delegators): callable
    {
        return function () use ($injector, $name, $callback, $delegators) {
            foreach ($delegators as $delegator) {
                $container = $injector->make(ContainerInterface::class);
                $delegator = $this->makeFactory($name, $delegator);
                $instance = $delegator($container, $name, $callback);
                $callback = $this->makeIdentity($instance);
$x = 1;
$callable = function() use ($x) {
    $x = 2; // Not visible in outer scope. If you would like this, how
            // about using a different variable name than $x?
};

$callable();
var_dump($x); // integer(1)
            }
            return $instance ?? $callback();
        };
    }

    /**
     * @param string|callable $factory
     */
    private function makeFactory(string $name, $factory): callable
    {
        if (is_callable($factory)) {
            return $factory;
        }

        if (is_string($factory) && !class_exists($factory)) {
            throw ContainerException::expectedInvokable($name);
        }

        $factory = new $factory();

        if (is_callable($factory)) {
            return $factory;
        }

        throw ContainerException::expectedInvokable($name);
    }

    private function makeIdentity($object): callable
    {
        return static function () use ($object) {
            return $object;
        };
    }

    private function makeLazy(string $name): callable
    {
        return static function (ContainerInterface $container) use ($name) {
            return $container->get($name);
        };
    }
}


1			<?php
2			declare(strict_types=1);
3
4			namespace Northwoods\Container\Zend;
5
6			use ArrayObject;
7			use Auryn\Injector;
8			use Northwoods\Container\ContainerException;
9			use Northwoods\Container\InjectorConfig;
10			use Psr\Container\ContainerInterface;
11
12			class Config implements InjectorConfig
13			{
14			/** @var array */
15			private $config;
16
17			/** @var bool */
18			private $sharedByDefault = true;
19
20	160		public function __construct(array $config)
21			{
22	160		$this->config = $config;
23	160		}
24
25			/**
26			* Configure the injector using Zend Service Manager format
27			*/
28	160		public function apply(Injector $injector): void
29			{
30	160		$dependencies = $this->config['dependencies'] ?? [];
31
32			// Define the "config" service, accounting for the fact that Auryn
33			// requires all returns are objects.
34	160		$dependencies['services']['config'] = new ArrayObject($this->config, ArrayObject::ARRAY_AS_PROPS);
35
36	160		$this->injectServices($injector, $dependencies);
37	160		$this->injectFactories($injector, $dependencies);
38	160		$this->injectInvokables($injector, $dependencies);
39	160		$this->injectAliases($injector, $dependencies);
40	160		}
41
42	160	View Code Duplication	private function injectAliases(Injector $injector, array $dependencies): void
			0 ignored issues – show Duplication introduced 2018-03-26 14:43 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
43			{
44	160		$aliases = $dependencies['aliases'] ?? [];
45	160		foreach ($aliases as $alias => $target) {
46			// Standard Auryn aliases do not work when chained. Work around by
47			// lazily fetching the shared target from the container.
48	70		$injector->share($alias)->share($target)->delegate($alias, $this->makeLazy($target));
49			}
50	160		}
51
52	160		private function injectFactories(Injector $injector, array $dependencies): void
53			{
54	160		$factories = $dependencies['factories'] ?? [];
55	160		foreach ($factories as $name => $factory) {
56	110		$delegate = function () use ($injector, $name, $factory) {
57	68		$container = $injector->make(ContainerInterface::class);
58	68		$factory = $this->makeFactory($name, $factory);
			0 ignored issues – show Bug introduced 2018-03-26 14:43 UTC by Report Bug Copy Issue Report Consider using a different name than the imported variable `$factory`, or did you forget to import by reference? It seems like you are assigning to a variable which was imported through a `use` statement which was not imported by reference. For clarity, we suggest to use a different name or import by reference depending on whether you would like to have the change visibile in outer-scope. Change not visible in outer-scope $x = 1; $callable = function() use ($x) { $x = 2; // Not visible in outer scope. If you would like this, how // about using a different variable name than $x? }; $callable(); var_dump($x); // integer(1) Change visible in outer-scope $x = 1; $callable = function() use (&$x) { $x = 2; }; $callable(); var_dump($x); // integer(2) Loading history...
59	58		return $factory($container, $name);
60	110		};
61	110	View Code Duplication	if (isset($dependencies['delegators'][$name])) {
			0 ignored issues – show Duplication introduced 2018-03-26 14:43 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
62	84		$delegate = $this->makeDelegator(
63	84		$injector,
64	84		$name,
65	84		$delegate,
66	84		$dependencies['delegators'][$name]
67			);
68			}
69	110		$injector->share($name)->delegate($name, $delegate);
70			}
71	160		}
72
73	160		private function injectInvokables(Injector $injector, array $dependencies): void
74			{
75	160		$invokables = $dependencies['invokables'] ?? [];
76	160		foreach ($invokables as $alias => $invokable) {
77	42		if (is_string($alias) && $alias !== $invokable) {
78	14		$injector->alias($alias, $invokable);
79			}
80	42		$delegate = function () use ($invokable) {
81	29		return $this->makeFactory($invokable, $invokable);
82	42		};
83	42	View Code Duplication	if (isset($dependencies['delegators'][$invokable])) {
			0 ignored issues – show Duplication introduced 2018-03-26 14:43 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
84	26		$delegate = $this->makeDelegator(
85	26		$injector,
86	26		$invokable,
87	26		$delegate,
88	26		$dependencies['delegators'][$invokable]
89			);
90			}
91	42		$injector->share($invokable)->delegate($invokable, $delegate);
92			}
93	160		}
94
95	160	View Code Duplication	private function injectServices(Injector $injector, array $dependencies): void
			0 ignored issues – show Duplication introduced 2018-03-26 14:43 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
96			{
97	160		$services = $dependencies['services'] ?? [];
98	160		foreach ($services as $name => $service) {
99	160		$injector->share($name)->delegate($name, $this->makeIdentity($service));
100			}
101	160		}
102
103			private function makeDelegator(Injector $injector, string $name, callable $callback, array $delegators): callable
104			{
105	110		return function () use ($injector, $name, $callback, $delegators) {
106	110		foreach ($delegators as $delegator) {
107	95		$container = $injector->make(ContainerInterface::class);
108	95		$delegator = $this->makeFactory($name, $delegator);
109	50		$instance = $delegator($container, $name, $callback);
110	40		$callback = $this->makeIdentity($instance);
			0 ignored issues – show Bug introduced 2018-03-26 14:43 UTC by Report Bug Copy Issue Report Consider using a different name than the imported variable `$callback`, or did you forget to import by reference? It seems like you are assigning to a variable which was imported through a `use` statement which was not imported by reference. For clarity, we suggest to use a different name or import by reference depending on whether you would like to have the change visibile in outer-scope. Change not visible in outer-scope $x = 1; $callable = function() use ($x) { $x = 2; // Not visible in outer scope. If you would like this, how // about using a different variable name than $x? }; $callable(); var_dump($x); // integer(1) Change visible in outer-scope $x = 1; $callable = function() use (&$x) { $x = 2; }; $callable(); var_dump($x); // integer(2) Loading history...
111			}
112	55		return $instance ?? $callback();
113	110		};
114			}
115
116			/**
117			* @param string\|callable $factory
118			*/
119	152		private function makeFactory(string $name, $factory): callable
120			{
121	152		if (is_callable($factory)) {
122	58		return $factory;
123			}
124
125	118		if (is_string($factory) && !class_exists($factory)) {
126	23		throw ContainerException::expectedInvokable($name);
127			}
128
129	99		$factory = new $factory();
130
131	81		if (is_callable($factory)) {
132	65		return $factory;
133			}
134
135	18		throw ContainerException::expectedInvokable($name);
136			}
137
138			private function makeIdentity($object): callable
139			{
140	160		return static function () use ($object) {
141	24		return $object;
142	160		};
143			}
144
145			private function makeLazy(string $name): callable
146			{
147	70		return static function (ContainerInterface $container) use ($name) {
148	70		return $container->get($name);
149	70		};
150			}
151			}
152

northwoods / container

Pull Request — master (#12)

Config::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Change not visible in outer-scope

Change visible in outer-scope

Change not visible in outer-scope

Change visible in outer-scope

Duplication Side-by-Side

Filter issues like