ProviderRepository::loadDeferredProvider() - Code Metrics - Inspection of "Merge branch 'develop'" - ByTIC/framework - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed

Push — master ( c5ade0...e039e4 )

by Gabriel

created 2017-07-29 13:11 UTC

ProviderRepository::loadDeferredProvider() A

↳ Parent: ProviderRepository

Complexity

Conditions	3
Paths	3

Size

Total Lines	14
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
eloc	6
nc	3
nop	1
dl	0
loc	14
rs	9.4285
c	0
b	0
f	0

<?php

namespace Nip\Container\ServiceProviders;

use Nip\Container\ContainerAwareInterface;
use Nip\Container\ContainerAwareTrait;
use Nip\Container\ServiceProviders\Providers\AbstractServiceProvider;
use Nip\Container\ServiceProviders\Providers\BootableServiceProviderInterface;
use Nip\Container\ServiceProviders\Providers\ServiceProviderInterface;

/**
 * Class ServiceProviderAggregate
 * @package Nip\Container\ServiceProvider
 */
class ProviderRepository implements ProviderRepositoryInterface
{
    use ContainerAwareTrait;

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

    /**
     * @var AbstractServiceProvider[]
     */
    protected $providers = [];

    /**
     * @var array Array of registered providers class names
     */
    protected $registeredProviders = [];

    /**
     * The deferred services and their providers.
     *
     * @var array
     */
    protected $deferredServices = [];

    /**
     * Indicates if the application has "booted".
     *
     * @var bool
     */
    protected $booted = false;

    /**
     * Adds a new Service Provider
     * {@inheritdoc}
     */
    public function add($provider)
    {
        if (is_string($provider) && class_exists($provider)) {
            $provider = $this->resolveProvider($provider);
        }

        if ($provider instanceof ContainerAwareInterface) {
            $provider->setContainer($this->getContainer());
        }

        if ($provider instanceof ServiceProviderInterface) {
            foreach ($provider->provides() as $service) {
                $this->services[$service] = get_class($provider);
            }
            $this->providers[] = $provider;
            return $this;
        }

        throw new \InvalidArgumentException(
            'A service provider must be a fully qualified class name or instance ' .
            'of (\Nip\Container\ServiceProvider\ServiceProviderInterface)'
        );
    }

    /**
     * Resolve a service provider instance from the class name.
     *
     * @param  string $provider
     * @return AbstractServiceProvider
     */
    public function resolveProvider($provider)
    {
        return new $provider($this);
    }

    public function register()
    {
        foreach ($this->providers as $provider) {
            $this->registerProvider($provider);
        }
    }

    /**
     * Register a service provider with the application.
     *
     * @param  AbstractServiceProvider|string $provider
     * @return AbstractServiceProvider
     */
    public function registerProvider($provider)
    {
        if (($provider = $this->getProvider($provider))) {
if (rand(1, 6) > 3) {
//print "Check failed";
} else {
    print "Check succeeded";
}
        } elseif (is_string($provider)) {
            $provider = $this->resolveProvider($provider);
        }

        if ($this->registeredProvider($provider)) {
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
            return $provider;
        }

        if (method_exists($provider, 'register')) {
            $provider->register();
        }

        $this->markAsRegistered($provider);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}

        // If the application has already booted, we will call this boot method on
        // the provider class so it has an opportunity to do its boot logic and
        // will be ready for any usage by this developer's application logic.
        if ($this->booted) {
            $this->bootProvider($provider);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
        }
        return $provider;
    }

    /**
     * Get the registered service provider instance if it exists.
     *
     * @param  AbstractServiceProvider|string $provider
     * @return AbstractServiceProvider|null
     */
    public function getProvider($provider)
    {
        $name = is_string($provider) ? $provider : get_class($provider);
        return \Nip_Helper_Arrays::first($this->providers, function ($value) use ($name) {
            return $value instanceof $name;
        });
    }

    /**
     * @param AbstractServiceProvider $provider
     * @return bool
     */
    public function registeredProvider($provider)
    {
        $providerClass = get_class($provider);
        if (isset($this->registeredProviders[$providerClass]) && $this->registeredProviders[$providerClass] === true) {
            return true;
        }
        return false;
    }

    /**
     * Mark the given provider as registered.
     *
     * @param  AbstractServiceProvider $provider
     * @return void
     */
    protected function markAsRegistered($provider)
    {
        $this->registeredProviders[get_class($provider)] = true;
    }

    /**
     * Boot the given service provider.
     *
     * @param  AbstractServiceProvider $provider
     * @return mixed
     */
    protected function bootProvider(AbstractServiceProvider $provider)
    {
        if ($provider instanceof BootableServiceProviderInterface) {
            return $provider->boot();
        }
        return null;
    }

    /**
     * Check to see if the services is registered
     * {@inheritdoc}
     */
    public function provides($service)
    {
        return array_key_exists($service, $this->providers);
    }

    public function boot()
    {
        foreach ($this->providers as $provider) {
            $this->bootProvider($provider);
        }

        $this->setBooted(true);
    }

    /**
     * @param bool $booted
     */
    public function setBooted($booted)
    {
        $this->booted = $booted;
    }

    /**
     * Load and boot all of the remaining deferred providers.
     *
     * @return void
     */
    public function loadDeferredProviders()
    {
        // We will simply spin through each of the deferred providers and register each
        // one and boot them if the application has booted. This should make each of
        // the remaining services available to this application for immediate use.
        foreach ($this->deferredServices as $service => $provider) {
            $this->loadDeferredProvider($service);
        }
        $this->deferredServices = [];
    }

    /**
     * Load the provider for a deferred service.
     *
     * @param  string $service
     * @return void
     */
    public function loadDeferredProvider($service)
    {
        if (!isset($this->deferredServices[$service])) {
            return;
        }
        $provider = $this->deferredServices[$service];

        // If the service provider has not already been loaded and registered we can
        // register it with the application and remove the service from this list
        // of deferred services, since it will already be loaded on subsequent.
        if (!isset($this->registeredProviders[$provider])) {
            $this->registerDeferredProvider($provider, $service);
        }
    }

    /**
     * Register a deferred provider and service.
     *
     * @param  string $provider
     * @param  string $service
     * @return void
     */
    public function registerDeferredProvider($provider, $service = null)
    {
        // Once the provider that provides the deferred service has been registered we
        // will remove it from our local list of the deferred services with related
        // providers so that this container does not try to resolve it out again.
        if ($service) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            unset($this->deferredServices[$service]);
        }
        $this->registerProvider($instance = new $provider($this));
    }
}


1			<?php
2
3			namespace Nip\Container\ServiceProviders;
4
5			use Nip\Container\ContainerAwareInterface;
6			use Nip\Container\ContainerAwareTrait;
7			use Nip\Container\ServiceProviders\Providers\AbstractServiceProvider;
8			use Nip\Container\ServiceProviders\Providers\BootableServiceProviderInterface;
9			use Nip\Container\ServiceProviders\Providers\ServiceProviderInterface;
10
11			/**
12			* Class ServiceProviderAggregate
13			* @package Nip\Container\ServiceProvider
14			*/
15			class ProviderRepository implements ProviderRepositoryInterface
16			{
17			use ContainerAwareTrait;
18
19			/**
20			* @var array
21			*/
22			protected $services = [];
23
24			/**
25			* @var AbstractServiceProvider[]
26			*/
27			protected $providers = [];
28
29			/**
30			* @var array Array of registered providers class names
31			*/
32			protected $registeredProviders = [];
33
34			/**
35			* The deferred services and their providers.
36			*
37			* @var array
38			*/
39			protected $deferredServices = [];
40
41			/**
42			* Indicates if the application has "booted".
43			*
44			* @var bool
45			*/
46			protected $booted = false;
47
48			/**
49			* Adds a new Service Provider
50			* {@inheritdoc}
51			*/
52			public function add($provider)
53			{
54			if (is_string($provider) && class_exists($provider)) {
55			$provider = $this->resolveProvider($provider);
56			}
57
58			if ($provider instanceof ContainerAwareInterface) {
59			$provider->setContainer($this->getContainer());
60			}
61
62			if ($provider instanceof ServiceProviderInterface) {
63			foreach ($provider->provides() as $service) {
64			$this->services[$service] = get_class($provider);
65			}
66			$this->providers[] = $provider;
67			return $this;
68			}
69
70			throw new \InvalidArgumentException(
71			'A service provider must be a fully qualified class name or instance ' .
72			'of (\Nip\Container\ServiceProvider\ServiceProviderInterface)'
73			);
74			}
75
76			/**
77			* Resolve a service provider instance from the class name.
78			*
79			* @param string $provider
80			* @return AbstractServiceProvider
81			*/
82			public function resolveProvider($provider)
83			{
84			return new $provider($this);
85			}
86
87			public function register()
88			{
89			foreach ($this->providers as $provider) {
90			$this->registerProvider($provider);
91			}
92			}
93
94			/**
95			* Register a service provider with the application.
96			*
97			* @param AbstractServiceProvider\|string $provider
98			* @return AbstractServiceProvider
99			*/
100			public function registerProvider($provider)
101			{
102			if (($provider = $this->getProvider($provider))) {
			0 ignored issues – show Unused Code introduced 2017-07-29 13:16 UTC by Report Bug Copy Issue Report This `if` statement is empty and can be removed. This check looks for the bodies of `if` statements that have no statements or where all statements have been commented out. This may be the result of changes for debugging or the code may simply be obsolete. These `if` bodies can be removed. If you have an empty if but statements in the `else` branch, consider inverting the condition. if (rand(1, 6) > 3) { //print "Check failed"; } else { print "Check succeeded"; } could be turned into if (rand(1, 6) <= 3) { print "Check succeeded"; } This is much more concise to read. Loading history...
103			} elseif (is_string($provider)) {
104			$provider = $this->resolveProvider($provider);
105			}
106
107			if ($this->registeredProvider($provider)) {
			0 ignored issues – show Bug introduced 2017-07-29 13:16 UTC by Report Bug Copy Issue Report It seems like `$provider` defined by `$this->getProvider($provider)` on line `102` can be `null`; however, `Nip\Container\ServicePro...y::registeredProvider()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
108			return $provider;
109			}
110
111			if (method_exists($provider, 'register')) {
112			$provider->register();
113			}
114
115			$this->markAsRegistered($provider);
			0 ignored issues – show Bug introduced 2017-07-29 13:16 UTC by Report Bug Copy Issue Report It seems like `$provider` defined by `$this->getProvider($provider)` on line `102` can be `null`; however, `Nip\Container\ServicePro...ory::markAsRegistered()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
116
117			// If the application has already booted, we will call this boot method on
118			// the provider class so it has an opportunity to do its boot logic and
119			// will be ready for any usage by this developer's application logic.
120			if ($this->booted) {
121			$this->bootProvider($provider);
			0 ignored issues – show Bug introduced 2017-07-29 13:16 UTC by Report Bug Copy Issue Report It seems like `$provider` defined by `$this->getProvider($provider)` on line `102` can be `null`; however, `Nip\Container\ServicePro...ository::bootProvider()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
122			}
123			return $provider;
124			}
125
126			/**
127			* Get the registered service provider instance if it exists.
128			*
129			* @param AbstractServiceProvider\|string $provider
130			* @return AbstractServiceProvider\|null
131			*/
132			public function getProvider($provider)
133			{
134			$name = is_string($provider) ? $provider : get_class($provider);
135			return \Nip_Helper_Arrays::first($this->providers, function ($value) use ($name) {
136			return $value instanceof $name;
137			});
138			}
139
140			/**
141			* @param AbstractServiceProvider $provider
142			* @return bool
143			*/
144			public function registeredProvider($provider)
145			{
146			$providerClass = get_class($provider);
147			if (isset($this->registeredProviders[$providerClass]) && $this->registeredProviders[$providerClass] === true) {
148			return true;
149			}
150			return false;
151			}
152
153			/**
154			* Mark the given provider as registered.
155			*
156			* @param AbstractServiceProvider $provider
157			* @return void
158			*/
159			protected function markAsRegistered($provider)
160			{
161			$this->registeredProviders[get_class($provider)] = true;
162			}
163
164			/**
165			* Boot the given service provider.
166			*
167			* @param AbstractServiceProvider $provider
168			* @return mixed
169			*/
170			protected function bootProvider(AbstractServiceProvider $provider)
171			{
172			if ($provider instanceof BootableServiceProviderInterface) {
173			return $provider->boot();
174			}
175			return null;
176			}
177
178			/**
179			* Check to see if the services is registered
180			* {@inheritdoc}
181			*/
182			public function provides($service)
183			{
184			return array_key_exists($service, $this->providers);
185			}
186
187			public function boot()
188			{
189			foreach ($this->providers as $provider) {
190			$this->bootProvider($provider);
191			}
192
193			$this->setBooted(true);
194			}
195
196			/**
197			* @param bool $booted
198			*/
199			public function setBooted($booted)
200			{
201			$this->booted = $booted;
202			}
203
204			/**
205			* Load and boot all of the remaining deferred providers.
206			*
207			* @return void
208			*/
209			public function loadDeferredProviders()
210			{
211			// We will simply spin through each of the deferred providers and register each
212			// one and boot them if the application has booted. This should make each of
213			// the remaining services available to this application for immediate use.
214			foreach ($this->deferredServices as $service => $provider) {
215			$this->loadDeferredProvider($service);
216			}
217			$this->deferredServices = [];
218			}
219
220			/**
221			* Load the provider for a deferred service.
222			*
223			* @param string $service
224			* @return void
225			*/
226			public function loadDeferredProvider($service)
227			{
228			if (!isset($this->deferredServices[$service])) {
229			return;
230			}
231			$provider = $this->deferredServices[$service];
232
233			// If the service provider has not already been loaded and registered we can
234			// register it with the application and remove the service from this list
235			// of deferred services, since it will already be loaded on subsequent.
236			if (!isset($this->registeredProviders[$provider])) {
237			$this->registerDeferredProvider($provider, $service);
238			}
239			}
240
241			/**
242			* Register a deferred provider and service.
243			*
244			* @param string $provider
245			* @param string $service
246			* @return void
247			*/
248			public function registerDeferredProvider($provider, $service = null)
249			{
250			// Once the provider that provides the deferred service has been registered we
251			// will remove it from our local list of the deferred services with related
252			// providers so that this container does not try to resolve it out again.
253			if ($service) {
			0 ignored issues – show Bug Best Practice introduced 2017-07-29 13:16 UTC by Report Bug Copy Issue Report The expression `$service` of type `string\|null` is loosely compared to `true`; this is ambiguous if the string can be empty. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
254			unset($this->deferredServices[$service]);
255			}
256			$this->registerProvider($instance = new $provider($this));
257			}
258			}
259

ByTIC / framework

GitHub Access Token became invalid

Push — master ( c5ade0...e039e4 )

ProviderRepository::loadDeferredProvider() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like