<form method="POST">
    <h3>Editing: PermissionRegistrar.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

namespace Spatie\Permission;

use Illuminate\Cache\CacheManager;
use Illuminate\Contracts\Auth\Access\Authorizable;
use Illuminate\Contracts\Auth\Access\Gate;
use Illuminate\Contracts\Cache\Repository;
use Illuminate\Contracts\Cache\Store;
use Illuminate\Database\Eloquent\Collection;
use Spatie\Permission\Contracts\Permission;
use Spatie\Permission\Contracts\Role;

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

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

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

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

    /** @var \Illuminate\Database\Eloquent\Collection */
    protected $permissions;

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

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

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

    /** @var bool */
    public static $teams;

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

    /** @var int|string */
    protected $teamId = null;

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

    /** @var array */
    private $cachedRoles = [];

    /** @var array */
    private $alias = [];

    /** @var array */
    private $except = [];

    /**
     * PermissionRegistrar constructor.
     *
     * @param \Illuminate\Cache\CacheManager $cacheManager
     */
    public function __construct(CacheManager $cacheManager)
    {
        $this-&gt;permissionClass = config('permission.models.permission');
        $this-&gt;roleClass = config('permission.models.role');

        $this-&gt;cacheManager = $cacheManager;
        $this-&gt;initializeCache();
    }

    public function initializeCache()
    {
        self::$cacheExpirationTime = config('permission.cache.expiration_time') ?: \DateInterval::createFromDateString('24 hours');

        self::$teams = config('permission.teams', false);
        self::$teamsKey = config('permission.column_names.team_foreign_key');

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

        self::$pivotRole = config('permission.column_names.role_pivot_key') ?: 'role_id';
        self::$pivotPermission = config('permission.column_names.permission_pivot_key') ?: 'permission_id';

        $this-&gt;cache = $this-&gt;getCacheStoreFromConfig();
    }

    protected function getCacheStoreFromConfig(): 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-&gt;cacheManager-&gt;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-&gt;cacheManager-&gt;store($cacheDriver);
    }

    /**
     * Set the team id for teams/groups support, this id is used when querying permissions/roles
     *
     * @param int|string|\Illuminate\Database\Eloquent\Model $id
     */
    public function setPermissionsTeamId($id)
    {
        if ($id instanceof \Illuminate\Database\Eloquent\Model) {
            $id = $id-&gt;getKey();
        }
        $this-&gt;teamId = $id;
    }

    /**
     *
     * @return int|string
     */
    public function getPermissionsTeamId()
    {
        return $this-&gt;teamId;
    }

    /**
     * Register the permission check method on the gate.
     * We resolve the Gate fresh here, for benefit of long-running instances.
     *
     * @return bool
     */
    public function registerPermissions(): bool
    {
        app(Gate::class)-&gt;before(function (Authorizable $user, string $ability) {
            if (method_exists($user, 'checkPermissionTo')) {
                return $user-&gt;checkPermissionTo($ability) ?: null;
            }
        });

        return true;
    }

    /**
     * Flush the cache.
     */
    public function forgetCachedPermissions()
    {
        $this-&gt;permissions = null;

        return $this-&gt;cache-&gt;forget(self::$cacheKey);
    }

    /**
     * Clear class permissions.
     * This is only intended to be called by the PermissionServiceProvider on boot,
     * so that long-running instances like Swoole don't keep old data in memory.
     */
    public function clearClassPermissions()
    {
        $this-&gt;permissions = null;
    }

    /**
     * Load permissions from cache
     * This get cache and turns array into \Illuminate\Database\Eloquent\Collection
     */
    private function loadPermissions()
    {
        if ($this-&gt;permissions) {
            return;
        }

        $this-&gt;permissions = $this-&gt;cache-&gt;remember(self::$cacheKey, self::$cacheExpirationTime, function () {
            return $this-&gt;getSerializedPermissionsForCache();
        });

        // fallback for old cache method, must be removed on next mayor version
        if (! isset($this-&gt;permissions['alias'])) {
            $this-&gt;forgetCachedPermissions();
            $this-&gt;loadPermissions();

            return;
        }

        $this-&gt;alias = $this-&gt;permissions['alias'];

        $this-&gt;hydrateRolesCache();

        $this-&gt;permissions = $this-&gt;getHydratedPermissionCollection();

        $this-&gt;cachedRoles = $this-&gt;alias = $this-&gt;except = [];
    }

    /**
     * Get the permissions based on the passed params.
     *
     * @param array $params
     * @param bool $onlyOne
     *
     * @return \Illuminate\Database\Eloquent\Collection
     */
    public function getPermissions(array $params = [], bool $onlyOne = false): Collection
    {
        $this-&gt;loadPermissions();

        $method = $onlyOne ? 'first' : 'filter';

        $permissions = $this-&gt;permissions-&gt;$method(static function ($permission) use ($params) {
            foreach ($params as $attr =&gt; $value) {
                if ($permission-&gt;getAttribute($attr) != $value) {
                    return false;
                }
            }

            return true;
        });

        if ($onlyOne) {
            $permissions = new Collection($permissions ? [$permissions] : []);
        }

        return $permissions;
    }

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

    public function setPermissionClass($permissionClass)
    {
        $this-&gt;permissionClass = $permissionClass;
        config()-&gt;set('permission.models.permission', $permissionClass);
        app()-&gt;bind(Permission::class, $permissionClass);

        return $this;
    }

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

    public function setRoleClass($roleClass)
    {
        $this-&gt;roleClass = $roleClass;
        config()-&gt;set('permission.models.role',  $roleClass);
        app()-&gt;bind(Role::class, $roleClass);

        return $this;
    }

    public function getCacheRepository(): Repository
    {
        return $this-&gt;cache;
    }

    public function getCacheStore(): Store
    {
        return $this-&gt;cache-&gt;getStore();
    }

    /**
     * Changes array keys with alias
     *
     * @return array
     */
    private function aliasedArray($model): array
    {
        return collect(is_array($model) ? $model : $model-&gt;getAttributes())-&gt;except($this-&gt;except)
            -&gt;keyBy(function ($value, $key) {
                return $this-&gt;alias[$key] ?? $key;
            })-&gt;all();
    }

    /**
     * Array for cache alias
     */
    private function aliasModelFields($newKeys = []): void
    {
        $i = 0;
        $alphas = ! count($this-&gt;alias) ? range('a', 'h') : range('j', 'p');

        foreach (array_keys($newKeys-&gt;getAttributes()) as $value) {
            if (! isset($this-&gt;alias[$value])) {
                $this-&gt;alias[$value] = $alphas[$i++] ?? $value;
            }
        }

        $this-&gt;alias = array_diff_key($this-&gt;alias, array_flip($this-&gt;except));
    }

    /*
     * Make the cache smaller using an array with only required fields
     */
    private function getSerializedPermissionsForCache()
    {
        $this-&gt;except = config('permission.cache.column_names_except', ['created_at','updated_at', 'deleted_at']);

        $permissions = $this-&gt;getPermissionClass()-&gt;select()-&gt;with('roles')-&gt;get()
            -&gt;map(function ($permission) {
                if (! $this-&gt;alias) {
                    $this-&gt;aliasModelFields($permission);
                }

                return $this-&gt;aliasedArray($permission) + $this-&gt;getSerializedRoleRelation($permission);
            })-&gt;all();
        $roles = array_values($this-&gt;cachedRoles);
        $this-&gt;cachedRoles = [];

        return ['alias' =&gt; array_flip($this-&gt;alias)] + compact('permissions', 'roles');
    }

    private function getSerializedRoleRelation($permission)
    {
        if (! $permission-&gt;roles-&gt;count()) {
            return [];
        }

        if (! isset($this-&gt;alias['roles'])) {
            $this-&gt;alias['roles'] = 'r';
            $this-&gt;aliasModelFields($permission-&gt;roles[0]);
        }

        return [
            'r' =&gt; $permission-&gt;roles-&gt;map(function ($role) {
                if (! isset($this-&gt;cachedRoles[$role-&gt;getKey()])) {
                    $this-&gt;cachedRoles[$role-&gt;getKey()] = $this-&gt;aliasedArray($role);
                }

                return $role-&gt;getKey();
            })-&gt;all(),
        ];
    }

    private function getHydratedPermissionCollection()
    {
        $permissionClass = $this-&gt;getPermissionClass();
        $permissionInstance = new $permissionClass();

        return Collection::make(
            array_map(function ($item) use ($permissionInstance) {
                return $permissionInstance
                    -&gt;newFromBuilder($this-&gt;aliasedArray(array_diff_key($item, ['r' =&gt; 0])))
                    -&gt;setRelation('roles', $this-&gt;getHydratedRoleCollection($item['r'] ?? []));
            }, $this-&gt;permissions['permissions'])
        );
    }

    private function getHydratedRoleCollection(array $roles)
    {
        return Collection::make(array_values(
            array_intersect_key($this-&gt;cachedRoles, array_flip($roles))
        ));
    }

    private function hydrateRolesCache()
    {
        $roleClass = $this-&gt;getRoleClass();
        $roleInstance = new $roleClass();

        array_map(function ($item) use ($roleInstance) {
            $role = $roleInstance-&gt;newFromBuilder($this-&gt;aliasedArray($item));
            $this-&gt;cachedRoles[$role-&gt;getKey()] = $role;
        }, $this-&gt;permissions['roles']);

        $this-&gt;permissions['roles'] = [];
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>