Container::unprotect() - Code Metrics - Inspection of "Enhancement: Allow to protect the container" - thephpleague/container - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#96)

by Andreas

created 2016-03-24 10:29 UTC

Container::unprotect() A

↳ Parent: Container

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	1
Bugs	0	Features	0

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

<?php

namespace League\Container;

use Interop\Container\ContainerInterface as InteropContainerInterface;
use League\Container\Definition\DefinitionFactory;
use League\Container\Definition\DefinitionFactoryInterface;
use League\Container\Definition\DefinitionInterface;
use League\Container\Exception\ProtectedException;
use League\Container\Exception\NotFoundException;
use League\Container\Inflector\InflectorAggregate;
use League\Container\Inflector\InflectorAggregateInterface;
use League\Container\ServiceProvider\ServiceProviderAggregate;
use League\Container\ServiceProvider\ServiceProviderAggregateInterface;

class Container implements ContainerInterface
{
    /**
     * @var \League\Container\Definition\DefinitionFactoryInterface
     */
    protected $definitionFactory;

    /**
     * @var \League\Container\Definition\DefinitionInterface[]
     */
    protected $definitions = [];

    /**
     * @var \League\Container\Definition\DefinitionInterface[]
     */
    protected $sharedDefinitions = [];

    /**
     * @var \League\Container\Inflector\InflectorAggregateInterface
     */
    protected $inflectors;

    /**
     * @var \League\Container\ServiceProvider\ServiceProviderAggregateInterface
     */
    protected $providers;

    /**
     * @var array
     */
    protected $shared = [];

    /**
     * @var \Interop\Container\ContainerInterface[]
     */
    protected $delegates = [];

    /**
     * @var bool
     */
    protected $isProtected = false;

    /**
     * Constructor.
     *
     * @param \League\Container\ServiceProvider\ServiceProviderAggregateInterface|null $providers
     * @param \League\Container\Inflector\InflectorAggregateInterface|null             $inflectors
     * @param \League\Container\Definition\DefinitionFactoryInterface|null             $definitionFactory
     */
    public function __construct(
        ServiceProviderAggregateInterface $providers         = null,
        InflectorAggregateInterface       $inflectors        = null,
        DefinitionFactoryInterface        $definitionFactory = null
    ) {
        // set required dependencies
        $this->providers         = (is_null($providers))
                                 ? (new ServiceProviderAggregate)->setContainer($this)
                                 : $providers->setContainer($this);

        $this->inflectors        = (is_null($inflectors))
                                 ? (new InflectorAggregate)->setContainer($this)
                                 : $inflectors->setContainer($this);

        $this->definitionFactory = (is_null($definitionFactory))
                                 ? (new DefinitionFactory)->setContainer($this)
                                 : $definitionFactory->setContainer($this);
    }

    /**
     * {@inheritdoc}
     */
    public function get($alias, array $args = [])
    {
        $service = $this->getFromThisContainer($alias, $args);

        if ($service === false && $this->providers->provides($alias)) {
            $this->providers->register($alias);
            $service = $this->getFromThisContainer($alias, $args);
        }

        if ($service !== false) {
            return $service;
        }

        if ($resolved = $this->getFromDelegate($alias, $args)) {
            return $this->inflectors->inflect($resolved);
        }

        throw new NotFoundException(
            sprintf('Alias (%s) is not being managed by the container', $alias)
        );
    }

    /**
     * {@inheritdoc}
     */
    public function has($alias)
    {
        if (array_key_exists($alias, $this->definitions) || $this->hasShared($alias)) {
            return true;
        }

        if ($this->providers->provides($alias)) {
            return true;
        }

        return $this->hasInDelegate($alias);
    }

    /**
     * Returns a boolean to determine if the container has a shared instance of an alias.
     *
     * @param  string  $alias
     * @param  boolean $resolved
     * @return boolean
     */
    public function hasShared($alias, $resolved = false)
    {
        $shared = ($resolved === false) ? array_merge($this->shared, $this->sharedDefinitions) : $this->shared;

        return (array_key_exists($alias, $shared));
    }

    /**
     * {@inheritdoc}
     */
    public function add($alias, $concrete = null, $share = false)
    {
        if (is_null($concrete)) {
            $concrete = $alias;
        }

        if ($this->isProtected() && $this->has($alias)) {
            throw new ProtectedException('Container has been protected, overriding services is not allowed.');
        }

        $definition = $this->definitionFactory->getDefinition($alias, $concrete);

        if ($definition instanceof DefinitionInterface) {
            if ($share === false) {
                $this->definitions[$alias] = $definition;
            } else {
                $this->sharedDefinitions[$alias] = $definition;
            }

            return $definition;
        }

        // dealing with a value that cannot build a definition
        $this->shared[$alias] = $concrete;
    }

    /**
     * {@inheritdoc}
     */
    public function share($alias, $concrete = null)
    {
        return $this->add($alias, $concrete, true);
    }

    /**
     * {@inheritdoc}
     */
    public function addServiceProvider($provider)
    {
        if ($this->isProtected()) {
            throw new ProtectedException('Container has been protected, adding service providers is not allowed');
        }

        $this->providers->add($provider);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function extend($alias)
    {
        if ($this->isProtected()) {
            throw new ProtectedException('Container has been protected, extending services is not allowed');
        }
        
        if ($this->providers->provides($alias)) {
            $this->providers->register($alias);
        }

        if (array_key_exists($alias, $this->definitions)) {
            return $this->definitions[$alias];
        }

        if (array_key_exists($alias, $this->sharedDefinitions)) {
            return $this->sharedDefinitions[$alias];
        }

        throw new NotFoundException(
            sprintf('Unable to extend alias (%s) as it is not being managed as a definition', $alias)
        );
    }

    /**
     * {@inheritdoc}
     */
    public function inflector($type, callable $callback = null)
    {
        if ($this->isProtected()) {
            throw new ProtectedException('Container has been protected, adding inflectors is not allowed');
        }

        return $this->inflectors->add($type, $callback);
    }

    /**
     * {@inheritdoc}
     */
    public function call(callable $callable, array $args = [])
    {
        return (new ReflectionContainer)->setContainer($this)->call($callable, $args);
    }

    /**
     * Marks the container as protected.
     *
     * Prevents overriding services and delegating to other containers once the container is marked as protected.
     */
    public function protect()
    {
        $this->isProtected = true;
    }

    /**
     * Marks the container as unprotected.
     *
     * Allows overriding services and delegating to other containers (this is the default).
     */
    public function unprotect()
    {
        $this->isProtected = false;
    }

    /**
     * Returns true if the container is protected.
     *
     * @return bool
     */
    public function isProtected()
    {
        return $this->isProtected;
    }

    /**
     * Delegate a backup container to be checked for services if it
     * cannot be resolved via this container.
     *
     * @param  \Interop\Container\ContainerInterface $container
     * @return $this
     */
    public function delegate(InteropContainerInterface $container)
    {
        if ($this->isProtected()) {
            throw new ProtectedException('Container has been protected, delegating to additional containers is not allowed');
        }

        $this->delegates[] = $container;

        if ($container instanceof ImmutableContainerAwareInterface) {
            $container->setContainer($this);
        }

        return $this;
    }

    /**
     * Returns true if service is registered in one of the delegated backup containers.
     *
     * @param  string $alias
     * @return boolean
     */
    public function hasInDelegate($alias)
    {
        foreach ($this->delegates as $container) {
            if ($container->has($alias)) {
                return true;
            }
        }

        return false;
    }

    /**
     * Attempt to get a service from the stack of delegated backup containers.
     *
     * @param  string $alias
     * @param  array  $args
     * @return mixed
     */
    protected function getFromDelegate($alias, array $args = [])
    {
        foreach ($this->delegates as $container) {
            if ($container->has($alias)) {
                return $container->get($alias, $args);
            }

            continue;
        }

        return false;
    }

    /**
     * Get a service that has been registered in this container.
     *
     * @param  string $alias
     * @param  array $args
     * @return mixed
     */
    protected function getFromThisContainer($alias, array $args = [])
    {
        if ($this->hasShared($alias, true)) {
            return $this->inflectors->inflect($this->shared[$alias]);
        }

        if (array_key_exists($alias, $this->sharedDefinitions)) {
            $shared = $this->inflectors->inflect($this->sharedDefinitions[$alias]->build());
            $this->shared[$alias] = $shared;
            return $shared;
        }

        if (array_key_exists($alias, $this->definitions)) {
            return $this->inflectors->inflect(
                $this->definitions[$alias]->build($args)
            );
        }

        return false;
    }
}


1		<?php
2
3		namespace League\Container;
4
5		use Interop\Container\ContainerInterface as InteropContainerInterface;
6		use League\Container\Definition\DefinitionFactory;
7		use League\Container\Definition\DefinitionFactoryInterface;
8		use League\Container\Definition\DefinitionInterface;
9		use League\Container\Exception\ProtectedException;
10		use League\Container\Exception\NotFoundException;
11		use League\Container\Inflector\InflectorAggregate;
12		use League\Container\Inflector\InflectorAggregateInterface;
13		use League\Container\ServiceProvider\ServiceProviderAggregate;
14		use League\Container\ServiceProvider\ServiceProviderAggregateInterface;
15
16		class Container implements ContainerInterface
17		{
18		/**
19		* @var \League\Container\Definition\DefinitionFactoryInterface
20		*/
21		protected $definitionFactory;
22
23		/**
24		* @var \League\Container\Definition\DefinitionInterface[]
25		*/
26		protected $definitions = [];
27
28		/**
29		* @var \League\Container\Definition\DefinitionInterface[]
30		*/
31		protected $sharedDefinitions = [];
32
33		/**
34		* @var \League\Container\Inflector\InflectorAggregateInterface
35		*/
36		protected $inflectors;
37
38		/**
39		* @var \League\Container\ServiceProvider\ServiceProviderAggregateInterface
40		*/
41		protected $providers;
42
43		/**
44		* @var array
45		*/
46		protected $shared = [];
47
48		/**
49		* @var \Interop\Container\ContainerInterface[]
50		*/
51		protected $delegates = [];
52
53		/**
54		* @var bool
55		*/
56		protected $isProtected = false;
57
58		/**
59		* Constructor.
60		*
61		* @param \League\Container\ServiceProvider\ServiceProviderAggregateInterface\|null $providers
62		* @param \League\Container\Inflector\InflectorAggregateInterface\|null $inflectors
63		* @param \League\Container\Definition\DefinitionFactoryInterface\|null $definitionFactory
64		*/
65	63	public function __construct(
66		ServiceProviderAggregateInterface $providers = null,
67		InflectorAggregateInterface $inflectors = null,
68		DefinitionFactoryInterface $definitionFactory = null
69		) {
70		// set required dependencies
71	63	$this->providers = (is_null($providers))
72	63	? (new ServiceProviderAggregate)->setContainer($this)
73	63	: $providers->setContainer($this);
74
75	63	$this->inflectors = (is_null($inflectors))
76	63	? (new InflectorAggregate)->setContainer($this)
77	63	: $inflectors->setContainer($this);
78
79	63	$this->definitionFactory = (is_null($definitionFactory))
80	63	? (new DefinitionFactory)->setContainer($this)
81	63	: $definitionFactory->setContainer($this);
82	63	}
83
84		/**
85		* {@inheritdoc}
86		*/
87	33	public function get($alias, array $args = [])
88		{
89	33	$service = $this->getFromThisContainer($alias, $args);
90
91	33	if ($service === false && $this->providers->provides($alias)) {
92	12	$this->providers->register($alias);
93	12	$service = $this->getFromThisContainer($alias, $args);
94	12	}
95
96	33	if ($service !== false) {
97	27	return $service;
98		}
99
100	12	if ($resolved = $this->getFromDelegate($alias, $args)) {
101	6	return $this->inflectors->inflect($resolved);
102		}
103
104	6	throw new NotFoundException(
105	6	sprintf('Alias (%s) is not being managed by the container', $alias)
106	6	);
107		}
108
109		/**
110		* {@inheritdoc}
111		*/
112	21	public function has($alias)
113		{
114	21	if (array_key_exists($alias, $this->definitions) \|\| $this->hasShared($alias)) {
115	15	return true;
116		}
117
118	9	if ($this->providers->provides($alias)) {
119	3	return true;
120		}
121
122	9	return $this->hasInDelegate($alias);
123		}
124
125		/**
126		* Returns a boolean to determine if the container has a shared instance of an alias.
127		*
128		* @param string $alias
129		* @param boolean $resolved
130		* @return boolean
131		*/
132	42	public function hasShared($alias, $resolved = false)
133		{
134	42	$shared = ($resolved === false) ? array_merge($this->shared, $this->sharedDefinitions) : $this->shared;
135
136	42	return (array_key_exists($alias, $shared));
137		}
138
139		/**
140		* {@inheritdoc}
141		*/
142	39	public function add($alias, $concrete = null, $share = false)
143		{
144	39	if (is_null($concrete)) {
145	3	$concrete = $alias;
146	3	}
147
148	39	if ($this->isProtected() && $this->has($alias)) {
149	3	throw new ProtectedException('Container has been protected, overriding services is not allowed.');
150		}
151
152	39	$definition = $this->definitionFactory->getDefinition($alias, $concrete);
153
154	39	if ($definition instanceof DefinitionInterface) {
155	27	if ($share === false) {
156	9	$this->definitions[$alias] = $definition;
157	9	} else {
158	21	$this->sharedDefinitions[$alias] = $definition;
159		}
160
161	27	return $definition;
162		}
163
164		// dealing with a value that cannot build a definition
165	12	$this->shared[$alias] = $concrete;
166	12	}
167
168		/**
169		* {@inheritdoc}
170		*/
171	30	public function share($alias, $concrete = null)
172		{
173	30	return $this->add($alias, $concrete, true);
174		}
175
176		/**
177		* {@inheritdoc}
178		*/
179	15	public function addServiceProvider($provider)
180		{
181	15	if ($this->isProtected()) {
182	3	throw new ProtectedException('Container has been protected, adding service providers is not allowed');
183		}
184
185	12	$this->providers->add($provider);
186
187	12	return $this;
188		}
189
190		/**
191		* {@inheritdoc}
192		*/
193	9	public function extend($alias)
194		{
195	9	if ($this->isProtected()) {
196	3	throw new ProtectedException('Container has been protected, extending services is not allowed');
197		}
198
199	6	if ($this->providers->provides($alias)) {
200	3	$this->providers->register($alias);
201	3	}
202
203	6	if (array_key_exists($alias, $this->definitions)) {
204	3	return $this->definitions[$alias];
205		}
206
207	6	if (array_key_exists($alias, $this->sharedDefinitions)) {
208	3	return $this->sharedDefinitions[$alias];
209		}
210
211	3	throw new NotFoundException(
212	3	sprintf('Unable to extend alias (%s) as it is not being managed as a definition', $alias)
213	3	);
214		}
215
216		/**
217		* {@inheritdoc}
218		*/
219	3	public function inflector($type, callable $callback = null)
220		{
221	3	if ($this->isProtected()) {
222	3	throw new ProtectedException('Container has been protected, adding inflectors is not allowed');
223		}
224
225		return $this->inflectors->add($type, $callback);
226		}
227
228		/**
229		* {@inheritdoc}
230		*/
231		public function call(callable $callable, array $args = [])
232		{
233		return (new ReflectionContainer)->setContainer($this)->call($callable, $args);
234		}
235
236		/**
237		* Marks the container as protected.
238		*
239		* Prevents overriding services and delegating to other containers once the container is marked as protected.
240		*/
241	18	public function protect()
242		{
243	18	$this->isProtected = true;
244	18	}
245
246		/**
247		* Marks the container as unprotected.
248		*
249		* Allows overriding services and delegating to other containers (this is the default).
250		*/
251	3	public function unprotect()
252		{
253	3	$this->isProtected = false;
254	3	}
255
256		/**
257		* Returns true if the container is protected.
258		*
259		* @return bool
260		*/
261	60	public function isProtected()
262		{
263	60	return $this->isProtected;
264		}
265
266		/**
267		* Delegate a backup container to be checked for services if it
268		* cannot be resolved via this container.
269		*
270		* @param \Interop\Container\ContainerInterface $container
271		* @return $this
272		*/
273	12	public function delegate(InteropContainerInterface $container)
274		{
275	12	if ($this->isProtected()) {
276	3	throw new ProtectedException('Container has been protected, delegating to additional containers is not allowed');
277		}
278
279	9	$this->delegates[] = $container;
280
281	9	if ($container instanceof ImmutableContainerAwareInterface) {
282	3	$container->setContainer($this);
283	3	}
284
285	9	return $this;
286		}
287
288		/**
289		* Returns true if service is registered in one of the delegated backup containers.
290		*
291		* @param string $alias
292		* @return boolean
293		*/
294	9	public function hasInDelegate($alias)
295		{
296	9	foreach ($this->delegates as $container) {
297	3	if ($container->has($alias)) {
298	3	return true;
299		}
300	9	}
301
302	6	return false;
303		}
304
305		/**
306		* Attempt to get a service from the stack of delegated backup containers.
307		*
308		* @param string $alias
309		* @param array $args
310		* @return mixed
311		*/
312	12	protected function getFromDelegate($alias, array $args = [])
313		{
314	12	foreach ($this->delegates as $container) {
315	6	if ($container->has($alias)) {
316	6	return $container->get($alias, $args);
317		}
318
319	3	continue;
320	6	}
321
322	6	return false;
323		}
324
325		/**
326		* Get a service that has been registered in this container.
327		*
328		* @param string $alias
329		* @param array $args
330		* @return mixed
331		*/
332	33	protected function getFromThisContainer($alias, array $args = [])
333		{
334	33	if ($this->hasShared($alias, true)) {
335	12	return $this->inflectors->inflect($this->shared[$alias]);
336		}
337
338	27	if (array_key_exists($alias, $this->sharedDefinitions)) {
339	15	$shared = $this->inflectors->inflect($this->sharedDefinitions[$alias]->build());
340	15	$this->shared[$alias] = $shared;
341	15	return $shared;
342		}
343
344	24	if (array_key_exists($alias, $this->definitions)) {
345	6	return $this->inflectors->inflect(
346	6	$this->definitions[$alias]->build($args)
347	6	);
348		}
349
350	21	return false;
351		}
352		}
353

thephpleague / container

Pull Request — master (#96)

Container::unprotect() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like