IPub\Permissions\Entities\Role

Complexity

Total Complexity

33

Size/Duplication

Total Lines	268
Duplicated Lines	5.22 %

Coupling/Cohesion

Components	3
Dependencies	3

Test Coverage

Coverage

61.9%

Importance

Changes

0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	1
A	setParent()	0	6	1
A	getParent()	0	4	1
A	setChildren()	0	15	4
A	addChild()	0	7	2
A	getChildren()	14	14	2
A	getRoleId()	0	4	1
A	setName()	0	4	1
A	getName()	0	4	2
A	setComment()	0	4	1
A	getComment()	0	4	1
A	setPermissions()	0	10	3
A	addPermission()	0	6	2
A	getPermissions()	0	14	2
A	hasPermission()	0	4	1
A	removePermission()	0	8	2
A	clearPermissions()	0	4	1
A	isLocked()	0	4	1
A	isAnonymous()	0	4	1
A	isAuthenticated()	0	4	1
A	isAdministrator()	0	4	1
A	__toString()	0	4	1

<?php
/**
 * Role.php
 *
 * @copyright      More in license.md
 * @license        http://www.ipublikuj.eu
 * @author         Adam Kadlec http://www.ipublikuj.eu
 * @package        iPublikuj:Permissions!
 * @subpackage     Entities
 * @since          1.0.0
 *
 * @date           12.03.14
 */

declare(strict_types = 1);

namespace IPub\Permissions\Entities;

use Nette;

use IPub;
use IPub\Permissions\Exceptions;

class Role extends Nette\Object implements IRole
{
	/**
	 * @var string
	 */
	protected $id;

	/**
	 * @var IRole|NULL
	 */
	protected $parent;

	/**
	 * @var \SplObjectStorage
	 */
	protected $children;

	/**
	 * @var string|NULL
	 */
	protected $name;

	/**
	 * @var string|NULL
	 */
	protected $comment;

	/**
	 * @var \SplObjectStorage
	 */
	protected $permissions;

	/**
	 * @param string $id
	 * @param string|NULL $name
	 * @param string|NULL $comment
	 */
	public function __construct(string $id, string $name = NULL, string $comment = NULL)
	{
		// Role identifier
		$this->id = $id;

		$this->name = $name;
		$this->comment = $comment;

		// Storage initialization
		$this->permissions = new \SplObjectStorage();
		$this->children = new \SplObjectStorage();
	}

	/**
	 * {@inheritdoc}
	 */
	public function setParent(IRole $parent = NULL)
	{
		$parent->addChild($this);

It seems like $parent is not always an object, but can also be of type null. Maybe add an additional type check?

		$this->parent = $parent;
	}

	/**
	 * {@inheritdoc}
	 */
	public function getParent()
	{
		return $this->parent;
	}

	/**
	 * {@inheritdoc}
	 */
	public function setChildren(array $roles)
	{
		foreach ($this->getChildren() as $child) {
			$child->setParent(NULL);
		}

		$this->children = new \SplObjectStorage();

		foreach ($roles as $child) {
			if ($child instanceof IRole) {
				$this->children->attach($child);
				$child->setParent($this);
			}
		}
	}

	/**
	 * {@inheritdoc}
	 */
	public function addChild(IRole $role)
	{
		if (!$this->children->contains($role)) {
			$this->children->attach($role);
			$role->setParent($this);
		}
	}

	/**
	 * {@inheritdoc}
	 */
	public function getChildren() : array

This method seems to be duplicated in your project.

	{
		$children = [];

		$this->children->rewind();

		while ($this->children->valid())
		{
			$children[] = $this->children->current();
			$this->children->next();
		}

		return $children;
	}

	/**
	 * {@inheritdoc}
	 */
	public function getRoleId() : string
	{
		return $this->id;
	}

	/**
	 * {@inheritdoc}
	 */
	public function setName(string $name)
	{
		$this->name = $name;
	}

	/**
	 * {@inheritdoc}
	 */
	public function getName()
	{
		return $this->name ?: $this->id;
	}

	/**
	 * {@inheritdoc}
	 */
	public function setComment(string $comment)
	{
		$this->comment = $comment;
	}

	/**
	 * {@inheritdoc}
	 */
	public function getComment()
	{
		return $this->comment;
	}

	/**
	 * {@inheritdoc}
	 */
	public function setPermissions(array $permissions)
	{
		$this->permissions = new \SplObjectStorage();

		foreach ($permissions as $permission) {
			if ($permission instanceof IPermission) {
				$this->permissions->attach($permission);
			}
		}
	}

	/**
	 * {@inheritdoc}
	 */
	public function addPermission(IPermission $permission)
	{
		if (!$this->permissions->contains($permission)) {
			$this->permissions->attach($permission);
		}
	}

	/**
	 * {@inheritdoc}
	 */
	public function getPermissions() : array
	{
		$permissions = [];

		$this->permissions->rewind();

		while ($this->permissions->valid())
		{
			$permissions[] = $this->permissions->current();
			$this->permissions->next();
		}

		return $permissions;
	}

	/**
	 * {@inheritdoc}
	 */
	public function hasPermission(IPermission $permission) : bool
	{
		return $this->permissions->contains($permission);
	}

	/**
	 * {@inheritdoc}
	 */
	public function removePermission(IPermission $permission)
	{
		if (!$this->permissions->contains($permission)) {
			throw new Exceptions\InvalidArgumentException(sprintf('Permission "%s" cannot be removed since it is not associated with the role %s', $permission, $this->getName()));
		}

		$this->permissions->detach($permission);
	}

	/**
	 * {@inheritdoc}
	 */
	public function clearPermissions()
	{
		$this->permissions = new \SplObjectStorage();
	}

	/**
	 * {@inheritdoc}
	 */
	public function isLocked() : bool
	{
		return in_array($this->id, [IRole::ROLE_ANONYMOUS, IRole::ROLE_AUTHENTICATED, IRole::ROLE_ADMINISTRATOR], TRUE);
	}

	/**
	 * {@inheritdoc}
	 */
	public function isAnonymous() : bool
	{
		return $this->id === IRole::ROLE_ANONYMOUS;
	}

	/**
	 * {@inheritdoc}
	 */
	public function isAuthenticated() : bool
	{
		return $this->id === IRole::ROLE_AUTHENTICATED;
	}

	/**
	 * {@inheritdoc}
	 */
	public function isAdministrator() : bool
	{
		return $this->id === IRole::ROLE_ADMINISTRATOR;
	}

	/**
	 * Convert role object to string
	 *
	 * @return string
	 */
	public function __toString()
	{
		return $this->id;
	}
}