HasRoles - Code Metrics - Inspection of "Remove duplicate scope lookups" - spatie/laravel-permission - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#1328)

unknown

created 2020-01-16 05:12 UTC

HasRoles C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	311
Duplicated Lines	25.08 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

Metric	Value
dl	78
loc	311
rs	6
c	0
b	0
f	0
wmc	55
lcom	1
cbo	4

14 Methods

Rating	Name	Duplication	Size	Complexity
A	getRoleClass()	0	8	2
A	roles()	0	10	1
A	bootHasRoles()	0	10	3
C	scopeRole()	16	40	12
B	assignRole()	44	45	5
A	removeRole()	0	10	1
A	syncRoles()	0	6	1
C	hasRole()	11	34	12
A	hasAnyRole()	0	4	1
B	hasAllRoles()	7	26	8
A	getDirectPermissions()	0	4	1
A	getRoleNames()	0	4	1
A	getStoredRole()	0	14	3
A	convertPipeToArray()	0	21	4

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like HasRoles often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use HasRoles, and based on these observations, apply Extract Interface, too.

<?php

namespace Spatie\Permission\Traits;

use Illuminate\Support\Collection;
use Spatie\Permission\Contracts\Role;
use Illuminate\Database\Eloquent\Builder;
use Spatie\Permission\PermissionRegistrar;
use Illuminate\Database\Eloquent\Relations\MorphToMany;

trait HasRoles
{
    use HasPermissions;

    private $roleClass;

    public static function bootHasRoles()
    {
        static::deleting(function ($model) {
            if (method_exists($model, 'isForceDeleting') && !$model->isForceDeleting()) {
                return;
            }

            $model->roles()->detach();
        });
    }

    public function getRoleClass()
    {
        if (!isset($this->roleClass)) {
            $this->roleClass = app(PermissionRegistrar::class)->getRoleClass();
        }

        return $this->roleClass;
    }

    /**
     * A model may have multiple roles.
     */
    public function roles(): MorphToMany
    {
        return $this->morphToMany(
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            config('permission.models.role'),
            'model',
            config('permission.table_names.model_has_roles'),
            config('permission.column_names.model_morph_key'),
            'role_id'
        );
    }

    /**
     * Scope the model query to certain roles only.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param string|array|\Spatie\Permission\Contracts\Role|\Illuminate\Support\Collection $roles
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * @param string $guard
     *
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function scopeRole(Builder $query, $listOfRoles, $guard = null): Builder
    {
        if ($listOfRoles instanceof Collection) {
            $listOfRoles = $listOfRoles->all();
        }

        if (!is_array($listOfRoles)) {
            $listOfRoles = [$listOfRoles];
        }

        $guard = $guard ?: $this->getDefaultGuardName();

        $listOfRoleNames = [];
        $roles = [];

        foreach ($listOfRoles as $role) {

            if ($role instanceof Role) {
                $roles[$role->id] = $role;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            } else {
                $method = is_numeric($role) ? 'findById' : 'findByName';

                if (!is_numeric($role) && !isset($listOfRoleNames[$role])) {
                    $thisRole = $this->getRoleClass()->{$method}($role, $guard);
                    $roles[$thisRole->id] = $thisRole;
                    $listOfRoleNames[$thisRole->name] = null;
                } elseif (is_numeric($role) && !isset($roles[$role])) {
                    $thisRole = $this->getRoleClass()->{$method}($role, $guard);
                    $roles[$thisRole->id] = $thisRole;
                }
            }
        }

        return $query->whereHas('roles', function ($query) use ($roles) {
            $query->where(function ($query) use ($roles) {
                foreach ($roles as $role) {
                    $query->orWhere(config('permission.table_names.roles') . '.id', $role->id);
                }
            });
        });
    }

    /**
     * Assign the given role to the model.
     *
     * @param array|string|\Spatie\Permission\Contracts\Role ...$roles
     *
     * @return $this
     */
    public function assignRole(...$roles)

    {
        $roles = collect($roles)
            ->flatten()
            ->map(function ($role) {
                if (empty($role)) {
                    return false;
                }

                return $this->getStoredRole($role);
            })
            ->filter(function ($role) {
                return $role instanceof Role;
            })
            ->each(function ($role) {
                $this->ensureModelSharesGuard($role);
            })
            ->map->id
            ->all();

        $model = $this->getModel();
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}

        if ($model->exists) {
            $this->roles()->sync($roles, false);
            $model->load('roles');
        } else {
            $class = \get_class($model);

            $class::saved(
                function ($object) use ($roles, $model) {
                    static $modelLastFiredOn;
                    if ($modelLastFiredOn !== null && $modelLastFiredOn === $model) {
                        return;
                    }
                    $object->roles()->sync($roles, false);
                    $object->load('roles');
                    $modelLastFiredOn = $object;
                }
            );
        }

        $this->forgetCachedPermissions();

        return $this;
    }

    /**
     * Revoke the given role from the model.
     *
     * @param string|\Spatie\Permission\Contracts\Role $role
     */
    public function removeRole($role)
    {
        $this->roles()->detach($this->getStoredRole($role));

        $this->load('roles');
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}

        $this->forgetCachedPermissions();

        return $this;
    }

    /**
     * Remove all current roles and set the given ones.
     *
     * @param  array|\Spatie\Permission\Contracts\Role|string  ...$roles
     *
     * @return $this
     */
    public function syncRoles(...$roles)
    {
        $this->roles()->detach();

        return $this->assignRole($roles);
    }

    /**
     * Determine if the model has (one of) the given role(s).
     *
     * @param string|int|array|\Spatie\Permission\Contracts\Role|\Illuminate\Support\Collection $roles
     * @param string|null $guard
     * @return bool
     */
    public function hasRole($roles, string $guard = null): bool
    {
        if (is_string($roles) && false !== strpos($roles, '|')) {

            $roles = $this->convertPipeToArray($roles);
        }

        if (is_string($roles)) {

            return $guard
                ? $this->roles->where('guard_name', $guard)->contains('name', $roles)
class MyClass { }

$x = new MyClass();
$x->foo = true;
                : $this->roles->contains('name', $roles);
        }

        if (is_int($roles)) {

            return $guard
                ? $this->roles->where('guard_name', $guard)->contains('id', $roles)
                : $this->roles->contains('id', $roles);
        }

        if ($roles instanceof Role) {
            return $this->roles->contains('id', $roles->id);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        }

        if (is_array($roles)) {
            foreach ($roles as $role) {
                if ($this->hasRole($role, $guard)) {
                    return true;
                }
            }

            return false;
        }

        return $roles->intersect($guard ? $this->roles->where('guard_name', $guard) : $this->roles)->isNotEmpty();
    }

    /**
     * Determine if the model has any of the given role(s).
     *
     * @param string|array|\Spatie\Permission\Contracts\Role|\Illuminate\Support\Collection $roles
     *
     * @return bool
     */
    public function hasAnyRole($roles): bool
    {
        return $this->hasRole($roles);
    }

    /**
     * Determine if the model has all of the given role(s).
     *
     * @param  string|\Spatie\Permission\Contracts\Role|\Illuminate\Support\Collection  $roles
     * @param  string|null  $guard
     * @return bool
     */
    public function hasAllRoles($roles, string $guard = null): bool
    {
        if (is_string($roles) && false !== strpos($roles, '|')) {

            $roles = $this->convertPipeToArray($roles);
        }

        if (is_string($roles)) {

            return $guard
                ? $this->roles->where('guard_name', $guard)->contains('name', $roles)
                : $this->roles->contains('name', $roles);
        }

        if ($roles instanceof Role) {
            return $this->roles->contains('id', $roles->id);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        }

        $roles = collect()->make($roles)->map(function ($role) {
            return $role instanceof Role ? $role->name : $role;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        });

        return $roles->intersect(
            $guard
                ? $this->roles->where('guard_name', $guard)->pluck('name')
                : $this->getRoleNames()
        ) == $roles;
    }

    /**
     * Return all permissions directly coupled to the model.
     */
    public function getDirectPermissions(): Collection
    {
        return $this->permissions;
class MyClass { }

$x = new MyClass();
$x->foo = true;
    }

    public function getRoleNames(): Collection
    {
        return $this->roles->pluck('name');
    }

    protected function getStoredRole($role): Role
    {
        $roleClass = $this->getRoleClass();

        if (is_numeric($role)) {
            return $roleClass->findById($role, $this->getDefaultGuardName());
        }

        if (is_string($role)) {
            return $roleClass->findByName($role, $this->getDefaultGuardName());
        }

        return $role;
    }

    protected function convertPipeToArray(string $pipeString)
    {
        $pipeString = trim($pipeString);

        if (strlen($pipeString) <= 2) {
            return $pipeString;
        }

        $quoteCharacter = substr($pipeString, 0, 1);
        $endCharacter = substr($quoteCharacter, -1, 1);

        if ($quoteCharacter !== $endCharacter) {
            return explode('|', $pipeString);
        }

        if (!in_array($quoteCharacter, ["'", '"'])) {
            return explode('|', $pipeString);
        }

        return explode('|', trim($pipeString, $quoteCharacter));
    }
}


Pull Request — master (#1328)

HasRoles C

Complexity

Size/Duplication

Coupling/Cohesion

Importance

14 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1		<?php
2
3		namespace Spatie\Permission\Traits;
4
5		use Illuminate\Support\Collection;
6		use Spatie\Permission\Contracts\Role;
7		use Illuminate\Database\Eloquent\Builder;
8		use Spatie\Permission\PermissionRegistrar;
9		use Illuminate\Database\Eloquent\Relations\MorphToMany;
10
11		trait HasRoles
12		{
13		use HasPermissions;
14
15		private $roleClass;
16
17		public static function bootHasRoles()
18		{
19		static::deleting(function ($model) {
20		if (method_exists($model, 'isForceDeleting') && !$model->isForceDeleting()) {
21		return;
22		}
23
24		$model->roles()->detach();
25		});
26		}
27
28		public function getRoleClass()
29		{
30		if (!isset($this->roleClass)) {
31		$this->roleClass = app(PermissionRegistrar::class)->getRoleClass();
32		}
33
34		return $this->roleClass;
35		}
36
37		/**
38		* A model may have multiple roles.
39		*/
40		public function roles(): MorphToMany
41		{
42		return $this->morphToMany(
		0 ignored issues – show Bug introduced 2017-04-20 14:18 UTC by Report Bug Copy Issue Report It seems like `morphToMany()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
43		config('permission.models.role'),
44		'model',
45		config('permission.table_names.model_has_roles'),
46		config('permission.column_names.model_morph_key'),
47		'role_id'
48		);
49		}
50
51		/**
52		* Scope the model query to certain roles only.
53		*
54		* @param \Illuminate\Database\Eloquent\Builder $query
55		* @param string\|array\|\Spatie\Permission\Contracts\Role\|\Illuminate\Support\Collection $roles
		0 ignored issues – show Bug introduced 2017-09-08 14:46 UTC by Report Bug Copy Issue Report There is no parameter named `$roles`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
56		* @param string $guard
57		*
58		* @return \Illuminate\Database\Eloquent\Builder
59		*/
60		public function scopeRole(Builder $query, $listOfRoles, $guard = null): Builder
61		{
62		if ($listOfRoles instanceof Collection) {
63		$listOfRoles = $listOfRoles->all();
64		}
65
66		if (!is_array($listOfRoles)) {
67		$listOfRoles = [$listOfRoles];
68		}
69
70		$guard = $guard ?: $this->getDefaultGuardName();
71
72		$listOfRoleNames = [];
73		$roles = [];
74
75	View Code Duplication	foreach ($listOfRoles as $role) {
		0 ignored issues – show Duplication introduced 2020-01-16 05:13 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
76		if ($role instanceof Role) {
77		$roles[$role->id] = $role;
		0 ignored issues – show Bug introduced 2020-01-16 05:13 UTC by Report Bug Copy Issue Report Accessing `id` on the interface `Spatie\Permission\Contracts\Role` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
78		} else {
79		$method = is_numeric($role) ? 'findById' : 'findByName';
80
81		if (!is_numeric($role) && !isset($listOfRoleNames[$role])) {
82		$thisRole = $this->getRoleClass()->{$method}($role, $guard);
83		$roles[$thisRole->id] = $thisRole;
84		$listOfRoleNames[$thisRole->name] = null;
85		} elseif (is_numeric($role) && !isset($roles[$role])) {
86		$thisRole = $this->getRoleClass()->{$method}($role, $guard);
87		$roles[$thisRole->id] = $thisRole;
88		}
89		}
90		}
91
92		return $query->whereHas('roles', function ($query) use ($roles) {
93		$query->where(function ($query) use ($roles) {
94		foreach ($roles as $role) {
95		$query->orWhere(config('permission.table_names.roles') . '.id', $role->id);
96		}
97		});
98		});
99		}
100
101		/**
102		* Assign the given role to the model.
103		*
104		* @param array\|string\|\Spatie\Permission\Contracts\Role ...$roles
105		*
106		* @return $this
107		*/
108	View Code Duplication	public function assignRole(...$roles)
		0 ignored issues – show Duplication introduced 2017-08-07 17:04 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
109		{
110		$roles = collect($roles)
111		->flatten()
112		->map(function ($role) {
113		if (empty($role)) {
114		return false;
115		}
116
117		return $this->getStoredRole($role);
118		})
119		->filter(function ($role) {
120		return $role instanceof Role;
121		})
122		->each(function ($role) {
123		$this->ensureModelSharesGuard($role);
124		})
125		->map->id
126		->all();
127
128		$model = $this->getModel();
		0 ignored issues – show Bug introduced 2018-09-20 00:40 UTC by Report Bug Copy Issue Report It seems like `getModel()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
129
130		if ($model->exists) {
131		$this->roles()->sync($roles, false);
132		$model->load('roles');
133		} else {
134		$class = \get_class($model);
135
136		$class::saved(
137		function ($object) use ($roles, $model) {
138		static $modelLastFiredOn;
139		if ($modelLastFiredOn !== null && $modelLastFiredOn === $model) {
140		return;
141		}
142		$object->roles()->sync($roles, false);
143		$object->load('roles');
144		$modelLastFiredOn = $object;
145		}
146		);
147		}
148
149		$this->forgetCachedPermissions();
150
151		return $this;
152		}
153
154		/**
155		* Revoke the given role from the model.
156		*
157		* @param string\|\Spatie\Permission\Contracts\Role $role
158		*/
159		public function removeRole($role)
160		{
161		$this->roles()->detach($this->getStoredRole($role));
162
163		$this->load('roles');
		0 ignored issues – show Bug introduced 2019-12-20 21:50 UTC by Report Bug Copy Issue Report It seems like `load()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
164
165		$this->forgetCachedPermissions();
166
167		return $this;
168		}
169
170		/**
171		* Remove all current roles and set the given ones.
172		*
173		* @param array\|\Spatie\Permission\Contracts\Role\|string ...$roles
174		*
175		* @return $this
176		*/
177		public function syncRoles(...$roles)
178		{
179		$this->roles()->detach();
180
181		return $this->assignRole($roles);
182		}
183
184		/**
185		* Determine if the model has (one of) the given role(s).
186		*
187		* @param string\|int\|array\|\Spatie\Permission\Contracts\Role\|\Illuminate\Support\Collection $roles
188		* @param string\|null $guard
189		* @return bool
190		*/
191		public function hasRole($roles, string $guard = null): bool
192		{
193	View Code Duplication	if (is_string($roles) && false !== strpos($roles, '\|')) {
		0 ignored issues – show Duplication introduced 2017-08-06 02:15 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
194		$roles = $this->convertPipeToArray($roles);
195		}
196
197	View Code Duplication	if (is_string($roles)) {
		0 ignored issues – show Duplication introduced 2019-10-07 16:39 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
198		return $guard
199		? $this->roles->where('guard_name', $guard)->contains('name', $roles)
		0 ignored issues – show Bug introduced 2019-10-07 16:39 UTC by Report Bug Copy Issue Report The property `roles` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
200		: $this->roles->contains('name', $roles);
201		}
202
203	View Code Duplication	if (is_int($roles)) {
		0 ignored issues – show Duplication introduced 2019-10-07 16:39 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
204		return $guard
205		? $this->roles->where('guard_name', $guard)->contains('id', $roles)
206		: $this->roles->contains('id', $roles);
207		}
208
209		if ($roles instanceof Role) {
210		return $this->roles->contains('id', $roles->id);
		0 ignored issues – show Bug introduced 2017-03-31 08:07 UTC by Report Bug Copy Issue Report Accessing `id` on the interface `Spatie\Permission\Contracts\Role` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
211		}
212
213		if (is_array($roles)) {
214		foreach ($roles as $role) {
215		if ($this->hasRole($role, $guard)) {
216		return true;
217		}
218		}
219
220		return false;
221		}
222
223		return $roles->intersect($guard ? $this->roles->where('guard_name', $guard) : $this->roles)->isNotEmpty();
224		}
225
226		/**
227		* Determine if the model has any of the given role(s).
228		*
229		* @param string\|array\|\Spatie\Permission\Contracts\Role\|\Illuminate\Support\Collection $roles
230		*
231		* @return bool
232		*/
233		public function hasAnyRole($roles): bool
234		{
235		return $this->hasRole($roles);
236		}
237
238		/**
239		* Determine if the model has all of the given role(s).
240		*
241		* @param string\|\Spatie\Permission\Contracts\Role\|\Illuminate\Support\Collection $roles
242		* @param string\|null $guard
243		* @return bool
244		*/
245		public function hasAllRoles($roles, string $guard = null): bool
246		{
247	View Code Duplication	if (is_string($roles) && false !== strpos($roles, '\|')) {
		0 ignored issues – show Duplication introduced 2017-08-06 02:15 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
248		$roles = $this->convertPipeToArray($roles);
249		}
250
251	View Code Duplication	if (is_string($roles)) {
		0 ignored issues – show Duplication introduced 2019-10-07 16:39 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
252		return $guard
253		? $this->roles->where('guard_name', $guard)->contains('name', $roles)
254		: $this->roles->contains('name', $roles);
255		}
256
257		if ($roles instanceof Role) {
258		return $this->roles->contains('id', $roles->id);
		0 ignored issues – show Bug introduced 2017-03-23 16:51 UTC by Report Bug Copy Issue Report Accessing `id` on the interface `Spatie\Permission\Contracts\Role` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
259		}
260
261		$roles = collect()->make($roles)->map(function ($role) {
262		return $role instanceof Role ? $role->name : $role;
		0 ignored issues – show Bug introduced 2015-12-21 23:32 UTC by Report Bug Copy Issue Report Accessing `name` on the interface `Spatie\Permission\Contracts\Role` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
263		});
264
265		return $roles->intersect(
266		$guard
267		? $this->roles->where('guard_name', $guard)->pluck('name')
268		: $this->getRoleNames()
269		) == $roles;
270		}
271
272		/**
273		* Return all permissions directly coupled to the model.
274		*/
275		public function getDirectPermissions(): Collection
276		{
277		return $this->permissions;
		0 ignored issues – show Bug introduced 2018-02-05 03:35 UTC by Report Bug Copy Issue Report The property `permissions` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
278		}
279
280		public function getRoleNames(): Collection
281		{
282		return $this->roles->pluck('name');
283		}
284
285		protected function getStoredRole($role): Role
286		{
287		$roleClass = $this->getRoleClass();
288
289		if (is_numeric($role)) {
290		return $roleClass->findById($role, $this->getDefaultGuardName());
291		}
292
293		if (is_string($role)) {
294		return $roleClass->findByName($role, $this->getDefaultGuardName());
295		}
296
297		return $role;
298		}
299
300		protected function convertPipeToArray(string $pipeString)
301		{
302		$pipeString = trim($pipeString);
303
304		if (strlen($pipeString) <= 2) {
305		return $pipeString;
306		}
307
308		$quoteCharacter = substr($pipeString, 0, 1);
309		$endCharacter = substr($quoteCharacter, -1, 1);
310
311		if ($quoteCharacter !== $endCharacter) {
312		return explode('\|', $pipeString);
313		}
314
315		if (!in_array($quoteCharacter, ["'", '"'])) {
316		return explode('\|', $pipeString);
317		}
318
319		return explode('\|', trim($pipeString, $quoteCharacter));
320		}
321		}
322

spatie / laravel-permission

Pull Request — master (#1328)

HasRoles C

Complexity

Size/Duplication

Coupling/Cohesion

Importance

14 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like