LumenServiceProvider::getConfigInstance() - Code Metrics - Inspection of "using chain of responsibility (sort of) for token..." - tymondesigns/jwt-auth - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( 9a08bc...c3dea4 )

by Sean

created 2015-12-30 22:12 UTC

LumenServiceProvider::getConfigInstance() A

↳ Parent: Project

Complexity

Conditions	2
Paths	2

Size

Total Lines	10
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
c	2
b	0
f	0
dl	0
loc	10
rs	9.4286
cc	2
eloc	5
nc	2
nop	1

<?php

/*
 * This file is part of jwt-auth
 *
 * (c) Sean Tymon <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Tymon\JWTAuth\Providers;

use Illuminate\Support\ServiceProvider;
use Tymon\JWTAuth\Blacklist;
use Tymon\JWTAuth\Claims\Factory as ClaimFactory;
use Tymon\JWTAuth\Commands\JWTGenerateSecretCommand;
use Tymon\JWTAuth\Contracts\Providers\Auth;
use Tymon\JWTAuth\Contracts\Providers\JWT;
use Tymon\JWTAuth\Contracts\Providers\Storage;
use Tymon\JWTAuth\Http\TokenParser;
use Tymon\JWTAuth\JWTAuth;
use Tymon\JWTAuth\Manager;
use Tymon\JWTAuth\Factory;
use Tymon\JWTAuth\Validators\PayloadValidator;

class LumenServiceProvider extends ServiceProvider
{
    /**
     * Register the service provider.
     *
     * @return void
     */
    public function register()
    {
        $this->registerAliases();

        $this->registerJWTProvider();
        $this->registerAuthProvider();
        $this->registerStorageProvider();
        $this->registerJWTBlacklist();

        $this->registerManager();
        $this->registerTokenParser();

        $this->registerJWTAuth();
        $this->registerPayloadValidator();
        $this->registerPayloadFactory();
        $this->registerJWTCommand();

        $this->commands('tymon.jwt.secret');
    }

    /**
     * Bind some Interfaces and implementations
     */
    protected function registerAliases()
    {
        $this->app->alias('tymon.jwt.auth', JWTAuth::class);
        $this->app->alias('tymon.jwt.provider.jwt', JWT::class);
        $this->app->alias('tymon.jwt.provider.auth', Auth::class);
        $this->app->alias('tymon.jwt.provider.storage', Storage::class);
        $this->app->alias('tymon.jwt.manager', Manager::class);
        $this->app->alias('tymon.jwt.blacklist', Blacklist::class);
        $this->app->alias('tymon.jwt.payload.factory', Factory::class);
        $this->app->alias('tymon.jwt.validators.payload', PayloadValidator::class);
    }

    /**
     * Register the bindings for the JSON Web Token provider
     */
    protected function registerJWTProvider()
    {
        $this->app->singleton('tymon.jwt.provider.jwt', function ($app) {
            $provider = $this->config('providers.jwt');

            return $app->make($provider, [$this->config('secret'), $this->config('algo')]);
        });
    }

    /**
     * Register the bindings for the Auth provider
     */
    protected function registerAuthProvider()
    {
        $this->app->singleton('tymon.jwt.provider.auth', function () {
            return $this->getConfigInstance('providers.auth');
        });
    }

    /**
     * Register the bindings for the Storage provider
     */
    protected function registerStorageProvider()
    {
        $this->app->singleton('tymon.jwt.provider.storage', function () {
            return $this->getConfigInstance('providers.storage');
        });
    }

    /**
     * Register the bindings for the JWT Manager
     */
    protected function registerManager()
    {
        $this->app->singleton('tymon.jwt.manager', function ($app) {

            $instance = new Manager(
                $app['tymon.jwt.provider.jwt'],
                $app['tymon.jwt.blacklist'],
                $app['tymon.jwt.payload.factory']
            );

            return $instance->setBlacklistEnabled((bool) $this->config('blacklist_enabled'));
        });
    }

    /**
     * Register the bindings for the Token Parser
     */
    protected function registerTokenParser()
    {
        $this->app->singleton('tymon.jwt.parser', function ($app) {
            return new TokenParser($app['request'])
                ->setChainOrder([

                    new AuthHeaders,
                    new QueryString,
                    new RouteParams
                ]);
        });
    }

    /**
     * Register the bindings for the main JWTAuth class
     */
    protected function registerJWTAuth()
    {
        $this->app->singleton('tymon.jwt.auth', function ($app) {
            return new JWTAuth(
                $app['tymon.jwt.manager'],
                $app['tymon.jwt.provider.auth'],
                $app['tymon.jwt.parser']
            );
        });
    }

    /**
     * Register the bindings for the main JWTAuth class
     */
    protected function registerJWTBlacklist()
    {
        $this->app->singleton('tymon.jwt.blacklist', function ($app) {
            $instance = new Blacklist($app['tymon.jwt.provider.storage']);

            return $instance->setGracePeriod($this->config('blacklist_grace_period'))
                            ->setRefreshTTL($this->config('refresh_ttl'));
        });
    }

    /**
     * Register the bindings for the payload validator
     */
    protected function registerPayloadValidator()
    {
        $this->app->singleton('tymon.jwt.validators.payload', function () {
            return (new PayloadValidator)
                ->setRefreshTTL($this->config('refresh_ttl'))
                ->setRequiredClaims($this->config('required_claims'));
        });
    }

    /**
     * Register the bindings for the Payload Factory
     */
    protected function registerPayloadFactory()
    {
        $this->app->singleton('tymon.jwt.payload.factory', function ($app) {
            $factory = new Factory(
                new ClaimFactory,
                $app['request'],
                $app['tymon.jwt.validators.payload']
            );

            return $factory->setTTL($this->config('ttl'));
        });
    }

    /**
     * Register the Artisan command
     */
    protected function registerJWTCommand()
    {
        $this->app->singleton('tymon.jwt.secret', function () {
            return new JWTGenerateSecretCommand();
        });
    }

    /**
     * Helper to get the config values
     *
     * @param  string $key
     *
     * @return mixed
     */
    protected function config($key, $default = null)
    {
        return config("jwt.$key", $default);
    }

    /**
     * Get an instantiable configuration instance. Pinched from dingo/api :)
     *
     * @param  string  $key
     *
     * @return mixed
     */
    protected function getConfigInstance($key)
    {
        $instance = $this->config($key);

        if (is_string($instance)) {
            return $this->app->make($instance);
        }

        return $instance;
    }
}


1			<?php
2
3			/*
4			* This file is part of jwt-auth
5			*
6			* (c) Sean Tymon <[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 Tymon\JWTAuth\Providers;
13
14			use Illuminate\Support\ServiceProvider;
15			use Tymon\JWTAuth\Blacklist;
16			use Tymon\JWTAuth\Claims\Factory as ClaimFactory;
17			use Tymon\JWTAuth\Commands\JWTGenerateSecretCommand;
18			use Tymon\JWTAuth\Contracts\Providers\Auth;
19			use Tymon\JWTAuth\Contracts\Providers\JWT;
20			use Tymon\JWTAuth\Contracts\Providers\Storage;
21			use Tymon\JWTAuth\Http\TokenParser;
22			use Tymon\JWTAuth\JWTAuth;
23			use Tymon\JWTAuth\Manager;
24			use Tymon\JWTAuth\Factory;
25			use Tymon\JWTAuth\Validators\PayloadValidator;
26
27			class LumenServiceProvider extends ServiceProvider
28			{
29			/**
30			* Register the service provider.
31			*
32			* @return void
33			*/
34			public function register()
35			{
36			$this->registerAliases();
37
38			$this->registerJWTProvider();
39			$this->registerAuthProvider();
40			$this->registerStorageProvider();
41			$this->registerJWTBlacklist();
42
43			$this->registerManager();
44			$this->registerTokenParser();
45
46			$this->registerJWTAuth();
47			$this->registerPayloadValidator();
48			$this->registerPayloadFactory();
49			$this->registerJWTCommand();
50
51			$this->commands('tymon.jwt.secret');
52			}
53
54			/**
55			* Bind some Interfaces and implementations
56			*/
57			protected function registerAliases()
58			{
59			$this->app->alias('tymon.jwt.auth', JWTAuth::class);
60			$this->app->alias('tymon.jwt.provider.jwt', JWT::class);
61			$this->app->alias('tymon.jwt.provider.auth', Auth::class);
62			$this->app->alias('tymon.jwt.provider.storage', Storage::class);
63			$this->app->alias('tymon.jwt.manager', Manager::class);
64			$this->app->alias('tymon.jwt.blacklist', Blacklist::class);
65			$this->app->alias('tymon.jwt.payload.factory', Factory::class);
66			$this->app->alias('tymon.jwt.validators.payload', PayloadValidator::class);
67			}
68
69			/**
70			* Register the bindings for the JSON Web Token provider
71			*/
72			protected function registerJWTProvider()
73			{
74			$this->app->singleton('tymon.jwt.provider.jwt', function ($app) {
75			$provider = $this->config('providers.jwt');
76
77			return $app->make($provider, [$this->config('secret'), $this->config('algo')]);
78			});
79			}
80
81			/**
82			* Register the bindings for the Auth provider
83			*/
84			protected function registerAuthProvider()
85			{
86			$this->app->singleton('tymon.jwt.provider.auth', function () {
87			return $this->getConfigInstance('providers.auth');
88			});
89			}
90
91			/**
92			* Register the bindings for the Storage provider
93			*/
94			protected function registerStorageProvider()
95			{
96			$this->app->singleton('tymon.jwt.provider.storage', function () {
97			return $this->getConfigInstance('providers.storage');
98			});
99			}
100
101			/**
102			* Register the bindings for the JWT Manager
103			*/
104			protected function registerManager()
105			{
106			$this->app->singleton('tymon.jwt.manager', function ($app) {
107
108			$instance = new Manager(
109			$app['tymon.jwt.provider.jwt'],
110			$app['tymon.jwt.blacklist'],
111			$app['tymon.jwt.payload.factory']
112			);
113
114			return $instance->setBlacklistEnabled((bool) $this->config('blacklist_enabled'));
115			});
116			}
117
118			/**
119			* Register the bindings for the Token Parser
120			*/
121			protected function registerTokenParser()
122			{
123			$this->app->singleton('tymon.jwt.parser', function ($app) {
124			return new TokenParser($app['request'])
125			->setChainOrder([
			0 ignored issues – show Bug introduced 2015-12-30 22:15 UTC by Report Bug Copy Issue Report This code did not parse for me. Apparently, there is an error somewhere around this line: Syntax error, unexpected T_OBJECT_OPERATOR, expecting ';' Loading history...
126			new AuthHeaders,
127			new QueryString,
128			new RouteParams
129			]);
130			});
131			}
132
133			/**
134			* Register the bindings for the main JWTAuth class
135			*/
136			protected function registerJWTAuth()
137			{
138			$this->app->singleton('tymon.jwt.auth', function ($app) {
139			return new JWTAuth(
140			$app['tymon.jwt.manager'],
141			$app['tymon.jwt.provider.auth'],
142			$app['tymon.jwt.parser']
143			);
144			});
145			}
146
147			/**
148			* Register the bindings for the main JWTAuth class
149			*/
150			protected function registerJWTBlacklist()
151			{
152			$this->app->singleton('tymon.jwt.blacklist', function ($app) {
153			$instance = new Blacklist($app['tymon.jwt.provider.storage']);
154
155			return $instance->setGracePeriod($this->config('blacklist_grace_period'))
156			->setRefreshTTL($this->config('refresh_ttl'));
157			});
158			}
159
160			/**
161			* Register the bindings for the payload validator
162			*/
163			protected function registerPayloadValidator()
164			{
165			$this->app->singleton('tymon.jwt.validators.payload', function () {
166			return (new PayloadValidator)
167			->setRefreshTTL($this->config('refresh_ttl'))
168			->setRequiredClaims($this->config('required_claims'));
169			});
170			}
171
172			/**
173			* Register the bindings for the Payload Factory
174			*/
175			protected function registerPayloadFactory()
176			{
177			$this->app->singleton('tymon.jwt.payload.factory', function ($app) {
178			$factory = new Factory(
179			new ClaimFactory,
180			$app['request'],
181			$app['tymon.jwt.validators.payload']
182			);
183
184			return $factory->setTTL($this->config('ttl'));
185			});
186			}
187
188			/**
189			* Register the Artisan command
190			*/
191			protected function registerJWTCommand()
192			{
193			$this->app->singleton('tymon.jwt.secret', function () {
194			return new JWTGenerateSecretCommand();
195			});
196			}
197
198			/**
199			* Helper to get the config values
200			*
201			* @param string $key
202			*
203			* @return mixed
204			*/
205			protected function config($key, $default = null)
206			{
207			return config("jwt.$key", $default);
208			}
209
210			/**
211			* Get an instantiable configuration instance. Pinched from dingo/api :)
212			*
213			* @param string $key
214			*
215			* @return mixed
216			*/
217			protected function getConfigInstance($key)
218			{
219			$instance = $this->config($key);
220
221			if (is_string($instance)) {
222			return $this->app->make($instance);
223			}
224
225			return $instance;
226			}
227			}
228

tymondesigns / jwt-auth

Push — develop ( 9a08bc...c3dea4 )

LumenServiceProvider::getConfigInstance() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like