BootstrapServiceProvider::passedRegistrationCondition() - Code Metrics - Inspection of "fix scrutinizer build2" - deviouspk/larapi - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 07ff08...756a96 )

by Arthur

created 2018-10-30 19:53 UTC

passedRegistrationCondition() A

↳ Parent: BootstrapServiceProvider

Complexity

Conditions	2
Paths	2

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes

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

<?php

namespace Foundation\Providers;

use Foundation\Console\SeedCommand;
use Foundation\Contracts\ConditionalAutoRegistration;
use Foundation\Contracts\ModelPolicyContract;
use Foundation\Contracts\Ownable;
use Foundation\Observers\CacheObserver;
use Foundation\Policies\OwnershipPolicy;
use Foundation\Services\BootstrapRegistrarService;
use Foundation\Traits\Cacheable;
use Illuminate\Database\Eloquent\Factory;
use Illuminate\Support\Facades\Event;
use Illuminate\Support\Facades\Gate;
use Illuminate\Support\ServiceProvider;
use Route;

/**
 * Class BootstrapServiceProvider.
 */
class BootstrapServiceProvider extends ServiceProvider
{
    /**
     * @var BootstrapRegistrarService
     */
    protected $bootstrapService;

    public function boot()
    {
        /* Load cache observers only when caching is enabled */
        if (config('model.caching')) {
            $this->loadCacheObservers();
        }
    }

    public function register()
    {
        /* Load BootstrapService here because of the dependencies needed in BootstrapRegistrarService */
        $this->loadBootstrapService();

        $this->loadCommands();
        $this->loadRoutes();
        $this->loadConfigs();
        $this->loadFactories();
        $this->loadMigrations();
        $this->loadListeners();

        /* Override the seed command with the larapi custom one */
        $this->overrideSeedCommand();



        $this->loadOwnershipPolicies();

        /* Register Policies after ownership policies otherwise they would not get overriden */
        $this->loadPolicies();

        /* Register all Module Service providers.
        ** Always load at the end so the user has the ability to override certain functionality
         * */
        $this->loadServiceProviders();
    }

    private function loadBootstrapService()
    {
        $this->bootstrapService = new BootstrapRegistrarService();

        if (!($this->app->environment('production') || $this->app->environment('testing'))) {
            $this->bootstrapService->recache();
        }
    }

    private function loadCommands()
    {
        $this->commands($this->bootstrapService->getCommands());
    }

    private function loadRoutes()
    {
        foreach ($this->bootstrapService->getRoutes() as $route) {
            $path = $route['path'];
            Route::group([
                'prefix' => 'v1/' . str_plural($route['module']),
                'namespace' => $route['controller'],
                'domain' => $route['domain'],
                'middleware' => ['api'],
            ], function () use ($path) {
                require $path;
            });
            Route::model($route['module'], $route['model']);
        }
    }

    /**
     * Register config.
     *
     * @return void
     */
    protected function loadConfigs()
    {
        foreach ($this->bootstrapService->getConfigs() as $config) {
            if (isset($config['filename']) && is_string($config['filename'])) {
                $fileName = $config['filename'];
                $configName = strtolower(explode('.',$fileName)[0]);
                $this->mergeConfigFrom(
                    $config['path'], $configName
                );
            }
        }
    }

    /**
     * Register additional directories of factories.
     *
     * @return void
     */
    public function loadFactories()
    {
        foreach ($this->bootstrapService->getFactories() as $factory) {
            if (!$this->app->environment('production')) {
                app(Factory::class)->load($factory['path']);
            }
        }
    }

    /**
     * Register additional directories of migrations.
     *
     * @return void
     */
    public function loadMigrations()
    {
        foreach ($this->bootstrapService->getMigrations() as $migration) {
            $this->loadMigrationsFrom($migration['path']);
        }
    }

    private function loadPolicies()
    {
        foreach ($this->bootstrapService->getPolicies() as $policy) {
            if (class_implements_interface($policy['class'], ModelPolicyContract::class)) {
                Gate::policy($policy['model'], $policy['class']);
            }
        }
    }

    private function overrideSeedCommand()
    {
        $app = $this->app;
        $service = $this->bootstrapService;
        $this->app->extend('command.seed', function () use ($app, $service) {
            return new SeedCommand($app['db'], $service);
        });
    }

    private function loadCacheObservers()
    {
        foreach ($this->bootstrapService->getModels() as $model) {
            if (class_uses_trait($model, Cacheable::class)) {
                $model::observe(CacheObserver::class);
            }
        }
    }

    private function loadOwnershipPolicies()
    {
        foreach ($this->bootstrapService->getModels() as $model) {
            if (class_implements_interface($model, Ownable::class)) {
                Gate::policy($model, OwnershipPolicy::class);
                Gate::define('access', OwnershipPolicy::class . '@access');
            }
        }
    }

    private function loadServiceProviders()
    {
        foreach ($this->bootstrapService->getProviders() as $provider) {
            if ($this->passedRegistrationCondition($provider))
                $this->app->register($provider);
        }
    }

    private function loadListeners()
    {
        foreach ($this->bootstrapService->getEvents() as $event) {
            foreach ($event['listeners'] as $listener) {
                Event::listen($event['class'], $listener);
            }
        }
    }

    private function passedRegistrationCondition($class)
    {
        if (!class_implements_interface($class, ConditionalAutoRegistration::class))
            return true;
        return run_class_function($class, 'registrationCondition');
    }
}


1			<?php
2
3			namespace Foundation\Providers;
4
5			use Foundation\Console\SeedCommand;
6			use Foundation\Contracts\ConditionalAutoRegistration;
7			use Foundation\Contracts\ModelPolicyContract;
8			use Foundation\Contracts\Ownable;
9			use Foundation\Observers\CacheObserver;
10			use Foundation\Policies\OwnershipPolicy;
11			use Foundation\Services\BootstrapRegistrarService;
12			use Foundation\Traits\Cacheable;
13			use Illuminate\Database\Eloquent\Factory;
14			use Illuminate\Support\Facades\Event;
15			use Illuminate\Support\Facades\Gate;
16			use Illuminate\Support\ServiceProvider;
17			use Route;
18
19			/**
20			* Class BootstrapServiceProvider.
21			*/
22			class BootstrapServiceProvider extends ServiceProvider
23			{
24			/**
25			* @var BootstrapRegistrarService
26			*/
27			protected $bootstrapService;
28
29			public function boot()
30			{
31			/* Load cache observers only when caching is enabled */
32			if (config('model.caching')) {
33			$this->loadCacheObservers();
34			}
35			}
36
37			public function register()
38			{
39			/* Load BootstrapService here because of the dependencies needed in BootstrapRegistrarService */
40			$this->loadBootstrapService();
41
42			$this->loadCommands();
43			$this->loadRoutes();
44			$this->loadConfigs();
45			$this->loadFactories();
46			$this->loadMigrations();
47			$this->loadListeners();
48
49			/* Override the seed command with the larapi custom one */
50			$this->overrideSeedCommand();
51
52
53
54			$this->loadOwnershipPolicies();
55
56			/* Register Policies after ownership policies otherwise they would not get overriden */
57			$this->loadPolicies();
58
59			/* Register all Module Service providers.
60			** Always load at the end so the user has the ability to override certain functionality
61			* */
62			$this->loadServiceProviders();
63			}
64
65			private function loadBootstrapService()
66			{
67			$this->bootstrapService = new BootstrapRegistrarService();
68
69			if (!($this->app->environment('production') \|\| $this->app->environment('testing'))) {
70			$this->bootstrapService->recache();
71			}
72			}
73
74			private function loadCommands()
75			{
76			$this->commands($this->bootstrapService->getCommands());
77			}
78
79			private function loadRoutes()
80			{
81			foreach ($this->bootstrapService->getRoutes() as $route) {
82			$path = $route['path'];
83			Route::group([
84			'prefix' => 'v1/' . str_plural($route['module']),
85			'namespace' => $route['controller'],
86			'domain' => $route['domain'],
87			'middleware' => ['api'],
88			], function () use ($path) {
89			require $path;
90			});
91			Route::model($route['module'], $route['model']);
92			}
93			}
94
95			/**
96			* Register config.
97			*
98			* @return void
99			*/
100			protected function loadConfigs()
101			{
102			foreach ($this->bootstrapService->getConfigs() as $config) {
103			if (isset($config['filename']) && is_string($config['filename'])) {
104			$fileName = $config['filename'];
105			$configName = strtolower(explode('.',$fileName)[0]);
106			$this->mergeConfigFrom(
107			$config['path'], $configName
108			);
109			}
110			}
111			}
112
113			/**
114			* Register additional directories of factories.
115			*
116			* @return void
117			*/
118			public function loadFactories()
119			{
120			foreach ($this->bootstrapService->getFactories() as $factory) {
121			if (!$this->app->environment('production')) {
122			app(Factory::class)->load($factory['path']);
123			}
124			}
125			}
126
127			/**
128			* Register additional directories of migrations.
129			*
130			* @return void
131			*/
132			public function loadMigrations()
133			{
134			foreach ($this->bootstrapService->getMigrations() as $migration) {
135			$this->loadMigrationsFrom($migration['path']);
136			}
137			}
138
139			private function loadPolicies()
140			{
141			foreach ($this->bootstrapService->getPolicies() as $policy) {
142			if (class_implements_interface($policy['class'], ModelPolicyContract::class)) {
143			Gate::policy($policy['model'], $policy['class']);
144			}
145			}
146			}
147
148			private function overrideSeedCommand()
149			{
150			$app = $this->app;
151			$service = $this->bootstrapService;
152			$this->app->extend('command.seed', function () use ($app, $service) {
153			return new SeedCommand($app['db'], $service);
154			});
155			}
156
157			private function loadCacheObservers()
158			{
159			foreach ($this->bootstrapService->getModels() as $model) {
160			if (class_uses_trait($model, Cacheable::class)) {
161			$model::observe(CacheObserver::class);
162			}
163			}
164			}
165
166			private function loadOwnershipPolicies()
167			{
168			foreach ($this->bootstrapService->getModels() as $model) {
169			if (class_implements_interface($model, Ownable::class)) {
170			Gate::policy($model, OwnershipPolicy::class);
171			Gate::define('access', OwnershipPolicy::class . '@access');
172			}
173			}
174			}
175
176			private function loadServiceProviders()
177			{
178			foreach ($this->bootstrapService->getProviders() as $provider) {
179			if ($this->passedRegistrationCondition($provider))
180			$this->app->register($provider);
181			}
182			}
183
184			private function loadListeners()
185			{
186			foreach ($this->bootstrapService->getEvents() as $event) {
187			foreach ($event['listeners'] as $listener) {
188			Event::listen($event['class'], $listener);
189			}
190			}
191			}
192
193			private function passedRegistrationCondition($class)
194			{
195			if (!class_implements_interface($class, ConditionalAutoRegistration::class))
196			return true;
197			return run_class_function($class, 'registrationCondition');
198			}
199			}
200

deviouspk / larapi

Push — master ( 07ff08...756a96 )

passedRegistrationCondition() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like