Spatie\Permission\PermissionRegistrar

Complexity

Total Complexity

18

Size/Duplication

Total Lines	147
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	2

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	13	2
A	registerPermissions()	0	13	4
A	forgetCachedPermissions()	0	4	2
A	getPermissions()	0	20	4
A	getKey()	0	8	3
A	getPermissionClass()	0	4	1
A	getRoleClass()	0	4	1
A	getCacheStore()	0	4	1

<?php

namespace Spatie\Permission;

use Illuminate\Support\Collection;
use Spatie\Permission\Contracts\Role;
use Illuminate\Contracts\Auth\Access\Gate;
use Illuminate\Contracts\Cache\Repository;
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 string */
    protected $permissionClass;

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

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

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

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

    /** @var bool */
    public static $cacheIsTaggable = false;

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

        self::$cacheExpirationTime = config('permission.cache.expiration_time', config('permission.cache_expiration_time'));
        self::$cacheKey = config('permission.cache.key');
        self::$cacheModelKey = config('permission.cache.model_key');
        self::$cacheIsTaggable = ($cache->getStore() instanceof \Illuminate\Cache\TaggableStore);

        $this->cache = self::$cacheIsTaggable ? $cache->tags(self::$cacheKey) : $cache;
    }

    /**
     * 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;

The method hasPermissionTo() does not seem to exist on object<Illuminate\Contracts\Auth\Access\Authorizable>.

                }
            } catch (PermissionDoesNotExist $e) {

Consider adding a comment why this CATCH block is empty.

            }
        });

        return true;
    }

    /**
     * Flush the cache.
     */
    public function forgetCachedPermissions()
    {
        self::$cacheIsTaggable ? $this->cache->flush() : $this->cache->forget(self::$cacheKey);

It seems like you code against a concrete implementation and not the interface Illuminate\Contracts\Cache\Repository as the method flush() does only exist in the following implementations of said interface: Illuminate\Cache\RedisTaggedCache, Illuminate\Cache\TaggedCache.

    }

    /**
     * Get the permissions based on the passed params.
     *
     * @param array $params
     *
     * @return \Illuminate\Support\Collection
     */
    public function getPermissions(array $params = []): Collection
    {
        $permissions = $this->cache->remember($this->getKey($params), self::$cacheExpirationTime,
            function () use ($params) {
                return $this->getPermissionClass()

The method when() does not seem to exist on object<Spatie\Permission\Contracts\Permission>.

                    ->when(($params && self::$cacheIsTaggable), function ($query) use ($params) {

The expression $params of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

                        return $query->where($params);
                    })
                    ->with('roles')
                    ->get();
            });

        if (! self::$cacheIsTaggable) {
            foreach ($params as $attr => $value) {
                $permissions = $permissions->where($attr, $value);
            }
        }

        return $permissions;
    }

    /**
     * Get the key for caching.
     *
     * @param $params
     *
     * @return string
     */
    public function getKey(array $params): string
    {
        if ($params && self::$cacheIsTaggable) {

The expression $params of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            return self::$cacheKey.'.'.implode('.', array_values($params));
        }

        return self::$cacheKey;
    }

    /**
     * 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();
    }
}