HasRole - Code Metrics - Inspection of "Use isRole to fix conflict with L5.3" - yajra/laravel-acl - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( ce5ae0...137cbe )

by Arjay

created 2016-08-24 07:40 UTC

HasRole A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	241
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	1

Test Coverage

Coverage

Importance

Changes	4
Bugs	0	Features	3

Metric	Value
wmc	31
c	4
b	0
f	3
lcom	2
cbo	1
dl	0
loc	241
ccs	0
cts	110
cp	0
rs	9.8

16 Methods

Rating	Name	Size	Complexity
A	canAccess()	4	2
A	canAtLeast()	12	3
A	hasRole()	17	4
A	getRoleSlugs()	8	2
A	attachRoleBySlug()	6	1
A	attachRole()	4	1
A	assignRole()	10	2
A	roles()	4	1
A	scopeHavingRoles()	9	1
A	revokeRole()	4	1
A	syncRoles()	4	1
A	revokeAllRoles()	4	1
A	getPermissions()	10	2
B	__call()	18	5
A	owns()	4	1
A	isRole()	12	3

<?php

namespace Yajra\Acl\Traits;

use Illuminate\Support\Str;
use Yajra\Acl\Models\Role;

trait HasRole
{
    /**
     * Check if user have access using any of the acl.
     *
     * @param  string|array $acl
     * @return boolean
     */
    public function canAccess($acl)
    {
        return $this->canAtLeast($acl) || $this->hasRole($acl);

    }

    /**
     * Check if user has at least one of the given permissions
     *
     * @param  array $permissions
     * @return bool
     */
    public function canAtLeast(array $permissions)
    {
        $can = false;

        foreach ($this->roles as $role) {
class MyClass { }

$x = new MyClass();
$x->foo = true;
            if ($role->canAtLeast($permissions)) {
                $can = true;
            }
        }

        return $can;
    }

    /**
     * Check if user has the given role.
     *
     * @param $role
     * @return bool
     */
    public function hasRole($role)
    {
        if (is_string($role)) {
            return $this->roles->contains('name', $role);
        }

        if (is_array($role)) {
            $roles = $this->getRoleSlugs();

            $intersection      = array_intersect($roles, (array) $role);
            $intersectionCount = count($intersection);

            return ($intersectionCount > 0) ? true : false;
        }

        return ! ! $role->intersect($this->roles)->count();
    }

    /**
     * Get all user roles.
     *
     * @return array|null
     */
    public function getRoleSlugs()
    {
        if (! is_null($this->roles)) {
            return $this->roles->pluck('slug')->toArray();
        }

        return null;
    }

    /**
     * Attach a role to user using slug.
     *
     * @param $slug
     * @return bool
     */
    public function attachRoleBySlug($slug)
    {
        $role = Role::where('slug', $slug)->first();

        return $this->attachRole($role);
    }

    /**
     * Attach a role to user
     *
     * @param  Role $role
     * @return boolean
     */
    public function attachRole(Role $role)
    {
        return $this->assignRole($role->id);
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
    }

    /**
     * Assigns the given role to the user.
     *
     * @param  int $roleId
     * @return bool
     */
    public function assignRole($roleId = null)
    {
        $roles = $this->roles;

        if (! $roles->contains($roleId)) {
            return $this->roles()->attach($roleId);
        }

        return false;
    }

    /**
     * Model can have many roles.
     *
     * @return \Illuminate\Database\Eloquent\Model
     */
    public function roles()
    {
        return $this->belongsToMany(config('acl.role', Role::class))->withTimestamps();
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
    }

    /**
     * @param $query
     * @param array $roles
     * @return mixed
     */
    public function scopeHavingRoles($query, array $roles)
    {
        return $query->whereExists(function ($query) use ($roles) {
            $query->selectRaw('1')
                  ->from('role_user')
                  ->whereRaw('role_user.user_id = users.id')
                  ->whereIn('role_id', $roles);
        });
    }

    /**
     * Revokes the given role from the user.
     *
     * @param $role
     * @return bool
     */
    public function revokeRole($role = "")
    {
        return $this->roles()->detach($role);
    }

    /**
     * Syncs the given role(s) with the user.
     *
     * @param  array $roles
     * @return bool
     */
    public function syncRoles(array $roles)
    {
        return $this->roles()->sync($roles);
    }

    /**
     * Revokes all roles from the user.
     *
     * @return bool
     */
    public function revokeAllRoles()
    {
        return $this->roles()->detach();
    }

    /**
     * Get all user role permissions.
     *
     * @return array|null
     */
    public function getPermissions()
    {
        $permissions = [[], []];

        foreach ($this->roles as $role) {
            $permissions[] = $role->getPermissions();
        }

        return call_user_func_array('array_merge', $permissions);
    }

    /**
     * Magic __call method to handle dynamic methods.
     *
     * @param  string $method
     * @param  array $arguments
     * @return mixed
     */
    public function __call($method, $arguments = [])
    {
        // Handle isRoleSlug() methods
        if (Str::startsWith($method, 'is') and $method !== 'is') {
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);
            $role = substr($method, 2);

            return $this->is($role);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
        }

        // Handle canDoSomething() methods
        if (Str::startsWith($method, 'can') and $method !== 'can') {
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);
            $permission = substr($method, 3);

            return $this->can($permission);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
        }

        return parent::__call($method, $arguments);
    }

    /**
     * Checks if the user has the given role.
     *
     * @param  string $slug
     * @return bool
     */
    public function isRole($slug)
    {
        $slug = Str::lower($slug);

        foreach ($this->roles as $role) {
            if ($role->slug == $slug) {
                return true;
            }
        }

        return false;
    }

    /**
     * Check if the given entity/model is owned by the user.
     *
     * @param \Illuminate\Database\Eloquent\Model $entity
     * @param string $relation
     * @return bool
     */
    public function owns($entity, $relation = 'user_id')
    {
        return $this->id === $entity->{$relation};
class MyClass { }

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


Push — master ( ce5ae0...137cbe )

HasRole A

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

16 Methods

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

yajra / laravel-acl

Push — master ( ce5ae0...137cbe )

HasRole A

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

16 Methods

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Duplication Side-by-Side

Filter issues like