PermissionRegistrar::getRoleClass() - Code Metrics - Inspection of "add in-memory permission caching, switch to single..." - spatie/laravel-permission - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#1039)

by Matthew

created 2019-03-01 11:54 UTC

PermissionRegistrar::getRoleClass() A

↳ Parent: PermissionRegistrar

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
nc	1
nop	0
dl	0
loc	4
rs	10
c	0
b	0
f	0

<?php

namespace Spatie\Permission;

use Illuminate\Cache\CacheManager;
use Illuminate\Support\Collection;
use Spatie\Permission\Contracts\Role;
use Illuminate\Contracts\Auth\Access\Gate;
use Spatie\Permission\Contracts\Permission;
use Illuminate\Contracts\Auth\Access\Authorizable;
use Spatie\Permission\Exceptions\PermissionDoesNotExist;

class PermissionRegistrar
{
    /** @var \Illuminate\Contracts\Auth\Access\Gate */
    protected $gate;

    /** @var \Illuminate\Contracts\Cache\Repository */
    protected $cache;

    /** @var \Illuminate\Cache\CacheManager */
    protected $cacheManager;

    /** @var string */
    protected $permissionClass;

    /** @var string */
    protected $roleClass;

    /** @var \Illuminate\Support\Collection */
    protected $permissions;

    /** @var DateInterval|int */
    public static $cacheExpirationTime;

    /** @var string */
    public static $cacheKey;

    /** @var string */
    public static $cacheModelKey;

    /**
     * PermissionRegistrar constructor.
     *
     * @param \Illuminate\Contracts\Auth\Access\Gate $gate
     * @param \Illuminate\Cache\CacheManager $cacheManager
     */
    public function __construct(Gate $gate, CacheManager $cacheManager)
    {
        $this->gate = $gate;
        $this->permissionClass = config('permission.models.permission');
        $this->roleClass = config('permission.models.role');

        $this->cacheManager = $cacheManager;
        $this->initializeCache();
    }

    protected function initializeCache()
    {
        self::$cacheExpirationTime = config('permission.cache.expiration_time', config('permission.cache_expiration_time'));

        if (app()->version() <= '5.5') {
            if (self::$cacheExpirationTime instanceof \DateInterval) {
                $interval = self::$cacheExpirationTime;
                self::$cacheExpirationTime = $interval->m * 30 * 60 * 24 + $interval->d * 60 * 24 + $interval->h * 60 + $interval->i;
            }
        }

        self::$cacheKey = config('permission.cache.key');
        self::$cacheModelKey = config('permission.cache.model_key');

        $this->cache = $this->getCacheStoreFromConfig();
    }

    protected function getCacheStoreFromConfig(): \Illuminate\Contracts\Cache\Repository
    {
        // the 'default' fallback here is from the permission.php config file, where 'default' means to use config(cache.default)
        $cacheDriver = config('permission.cache.store', 'default');

        // when 'default' is specified, no action is required since we already have the default instance
        if ($cacheDriver === 'default') {
            return $this->cacheManager->store();
        }

        // if an undefined cache store is specified, fallback to 'array' which is Laravel's closest equiv to 'none'
        if (! \array_key_exists($cacheDriver, config('cache.stores'))) {
            $cacheDriver = 'array';
        }

        return $this->cacheManager->store($cacheDriver);
    }

    /**
     * Register the permission check method on the gate.
     *
     * @return bool
     */
    public function registerPermissions(): bool
    {
        $this->gate->before(function (Authorizable $user, string $ability) {
            try {
                if (method_exists($user, 'hasPermissionTo')) {
                    return $user->hasPermissionTo($ability) ?: null;

                }
            } catch (PermissionDoesNotExist $e) {

            }
        });

        return true;
    }

    /**
     * Flush the cache.
     */
    public function forgetCachedPermissions()
    {
        $this->permissions = null;
        $this->cache->forget(self::$cacheKey);
    }

    /**
     * Get the permissions based on the passed params.
     *
     * @param array $params
     *
     * @return \Illuminate\Support\Collection
     */
    public function getPermissions(array $params = []): Collection
    {
        if ($this->permissions === null) {
            $this->permissions = $this->cache->remember(self::$cacheKey, self::$cacheExpirationTime, function () {
                return $this->getPermissionClass()
                    ->with('roles')
                    ->get();
            });
        }

        $permissions = clone $this->permissions;

        foreach ($params as $attr => $value) {
            $permissions = $permissions->where($attr, $value);
        }

        return $permissions;
    }

    /**
     * Get an instance of the permission class.
     *
     * @return \Spatie\Permission\Contracts\Permission
     */
    public function getPermissionClass(): Permission
    {
        return app($this->permissionClass);
    }

    /**
     * Get an instance of the role class.
     *
     * @return \Spatie\Permission\Contracts\Role
     */
    public function getRoleClass(): Role
    {
        return app($this->roleClass);
    }

    /**
     * Get the instance of the Cache Store.
     *
     * @return \Illuminate\Contracts\Cache\Store
     */
    public function getCacheStore(): \Illuminate\Contracts\Cache\Store
    {
        return $this->cache->getStore();
    }
}


1			<?php
2
3			namespace Spatie\Permission;
4
5			use Illuminate\Cache\CacheManager;
6			use Illuminate\Support\Collection;
7			use Spatie\Permission\Contracts\Role;
8			use Illuminate\Contracts\Auth\Access\Gate;
9			use Spatie\Permission\Contracts\Permission;
10			use Illuminate\Contracts\Auth\Access\Authorizable;
11			use Spatie\Permission\Exceptions\PermissionDoesNotExist;
12
13			class PermissionRegistrar
14			{
15			/** @var \Illuminate\Contracts\Auth\Access\Gate */
16			protected $gate;
17
18			/** @var \Illuminate\Contracts\Cache\Repository */
19			protected $cache;
20
21			/** @var \Illuminate\Cache\CacheManager */
22			protected $cacheManager;
23
24			/** @var string */
25			protected $permissionClass;
26
27			/** @var string */
28			protected $roleClass;
29
30			/** @var \Illuminate\Support\Collection */
31			protected $permissions;
32
33			/** @var DateInterval\|int */
34			public static $cacheExpirationTime;
35
36			/** @var string */
37			public static $cacheKey;
38
39			/** @var string */
40			public static $cacheModelKey;
41
42			/**
43			* PermissionRegistrar constructor.
44			*
45			* @param \Illuminate\Contracts\Auth\Access\Gate $gate
46			* @param \Illuminate\Cache\CacheManager $cacheManager
47			*/
48			public function __construct(Gate $gate, CacheManager $cacheManager)
49			{
50			$this->gate = $gate;
51			$this->permissionClass = config('permission.models.permission');
52			$this->roleClass = config('permission.models.role');
53
54			$this->cacheManager = $cacheManager;
55			$this->initializeCache();
56			}
57
58			protected function initializeCache()
59			{
60			self::$cacheExpirationTime = config('permission.cache.expiration_time', config('permission.cache_expiration_time'));
61
62			if (app()->version() <= '5.5') {
63			if (self::$cacheExpirationTime instanceof \DateInterval) {
64			$interval = self::$cacheExpirationTime;
65			self::$cacheExpirationTime = $interval->m * 30 * 60 * 24 + $interval->d * 60 * 24 + $interval->h * 60 + $interval->i;
66			}
67			}
68
69			self::$cacheKey = config('permission.cache.key');
70			self::$cacheModelKey = config('permission.cache.model_key');
71
72			$this->cache = $this->getCacheStoreFromConfig();
73			}
74
75			protected function getCacheStoreFromConfig(): \Illuminate\Contracts\Cache\Repository
76			{
77			// the 'default' fallback here is from the permission.php config file, where 'default' means to use config(cache.default)
78			$cacheDriver = config('permission.cache.store', 'default');
79
80			// when 'default' is specified, no action is required since we already have the default instance
81			if ($cacheDriver === 'default') {
82			return $this->cacheManager->store();
83			}
84
85			// if an undefined cache store is specified, fallback to 'array' which is Laravel's closest equiv to 'none'
86			if (! \array_key_exists($cacheDriver, config('cache.stores'))) {
87			$cacheDriver = 'array';
88			}
89
90			return $this->cacheManager->store($cacheDriver);
91			}
92
93			/**
94			* Register the permission check method on the gate.
95			*
96			* @return bool
97			*/
98			public function registerPermissions(): bool
99			{
100			$this->gate->before(function (Authorizable $user, string $ability) {
101			try {
102			if (method_exists($user, 'hasPermissionTo')) {
103			return $user->hasPermissionTo($ability) ?: null;
			0 ignored issues – show Bug introduced 2018-04-23 18:41 UTC by Report Bug Copy Issue Report The method `hasPermissionTo()` does not seem to exist on `object<Illuminate\Contra...th\Access\Authorizable>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
104			}
105			} catch (PermissionDoesNotExist $e) {
			0 ignored issues – show Coding Style Comprehensibility introduced 2017-10-12 15:02 UTC by Report Bug Copy Issue Report Consider adding a comment why this CATCH block is empty. Loading history...
106			}
107			});
108
109			return true;
110			}
111
112			/**
113			* Flush the cache.
114			*/
115			public function forgetCachedPermissions()
116			{
117			$this->permissions = null;
118			$this->cache->forget(self::$cacheKey);
119			}
120
121			/**
122			* Get the permissions based on the passed params.
123			*
124			* @param array $params
125			*
126			* @return \Illuminate\Support\Collection
127			*/
128			public function getPermissions(array $params = []): Collection
129			{
130			if ($this->permissions === null) {
131			$this->permissions = $this->cache->remember(self::$cacheKey, self::$cacheExpirationTime, function () {
132			return $this->getPermissionClass()
133			->with('roles')
134			->get();
135			});
136			}
137
138			$permissions = clone $this->permissions;
139
140			foreach ($params as $attr => $value) {
141			$permissions = $permissions->where($attr, $value);
142			}
143
144			return $permissions;
145			}
146
147			/**
148			* Get an instance of the permission class.
149			*
150			* @return \Spatie\Permission\Contracts\Permission
151			*/
152			public function getPermissionClass(): Permission
153			{
154			return app($this->permissionClass);
155			}
156
157			/**
158			* Get an instance of the role class.
159			*
160			* @return \Spatie\Permission\Contracts\Role
161			*/
162			public function getRoleClass(): Role
163			{
164			return app($this->roleClass);
165			}
166
167			/**
168			* Get the instance of the Cache Store.
169			*
170			* @return \Illuminate\Contracts\Cache\Store
171			*/
172			public function getCacheStore(): \Illuminate\Contracts\Cache\Store
173			{
174			return $this->cache->getStore();
175			}
176			}
177

spatie / laravel-permission

Pull Request — master (#1039)

PermissionRegistrar::getRoleClass() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like