Permissions management cleanup (#2332)

* Added a new PermissionManager, remove ridiculous cyclic dependencies of Permissions on Server

Aside from all the other ridiculous design problems with the permission system, the biggest problems are its API. This is, once again, a result of poor API design copied from Bukkit.

This pull request removes all permission-related functionality from `PluginManager` and moves it to the `pocketmine\permission\PermissionManager` class.

As can be observed from the removed code in the diff, the permissions system was previously entirely dependent on the Server, because it needed to get the PluginManager for registering permissions. This is utterly ridiculous. This refactor isolates _most_ permission-related functionality within the `permission` namespace.

As mentioned above, this stupid API is a direct result of copying from Bukkit. If you look at the API documentation for Bukkit for `PluginManager` you will see that the methods I'm deprecating here are also in there.

## Changes
- Added a new `PermissionManager` class. This can be accessed via its singleton `getInstance()` static method.
- Deprecated the following `PluginManager` methods - these will be removed no later than 4.0.0:
  - `getPermission()`
  - `addPermission()`
  - `removePermission()`
  - `getDefaultPermissions()`
  - `recalculatePermissionDefaults()`
  - `subscribeToPermission()`
  - `unsubscribeFromPermission()`
  - `getPermissionSubscriptions()`
  - `subscribeToDefaultPerms()`
  - `unsubscribeFromDefaultPerms()`
  - `getDefaultPermSubscriptions()`
  - `getPermissions()`

src/pocketmine/permission/DefaultPermissions.php

@@ -23,8 +23,6 @@ declare(strict_types=1);
 
 namespace pocketmine\permission;
 
-use pocketmine\Server;
-
 abstract class DefaultPermissions{
 	public const ROOT = "pocketmine";
 
@@ -40,9 +38,9 @@ abstract class DefaultPermissions{
 
 			return self::registerPermission($perm);
 		}
-		Server::getInstance()->getPluginManager()->addPermission($perm);
+		PermissionManager::getInstance()->addPermission($perm);
 
-		return Server::getInstance()->getPluginManager()->getPermission($perm->getName());
+		return PermissionManager::getInstance()->getPermission($perm->getName());
 	}
 
 	public static function registerCorePermissions(){

src/pocketmine/permission/PermissibleBase.php

@@ -25,7 +25,6 @@ namespace pocketmine\permission;
 
 use pocketmine\plugin\Plugin;
 use pocketmine\plugin\PluginException;
-use pocketmine\Server;
 use pocketmine\timings\Timings;
 
 class PermissibleBase implements Permissible{
@@ -92,7 +91,7 @@ class PermissibleBase implements Permissible{
 			return $this->permissions[$name]->getValue();
 		}
 
-		if(($perm = Server::getInstance()->getPluginManager()->getPermission($name)) !== null){
+		if(($perm = PermissionManager::getInstance()->getPermission($name)) !== null){
 			$perm = $perm->getDefault();
 
 			return $perm === Permission::DEFAULT_TRUE or ($this->isOp() and $perm === Permission::DEFAULT_OP) or (!$this->isOp() and $perm === Permission::DEFAULT_NOT_OP);
@@ -147,13 +146,14 @@ class PermissibleBase implements Permissible{
 		Timings::$permissibleCalculationTimer->startTiming();
 
 		$this->clearPermissions();
-		$defaults = Server::getInstance()->getPluginManager()->getDefaultPermissions($this->isOp());
-		Server::getInstance()->getPluginManager()->subscribeToDefaultPerms($this->isOp(), $this->parent ?? $this);
+		$permManager = PermissionManager::getInstance();
+		$defaults = $permManager->getDefaultPermissions($this->isOp());
+		$permManager->subscribeToDefaultPerms($this->isOp(), $this->parent ?? $this);
 
 		foreach($defaults as $perm){
 			$name = $perm->getName();
 			$this->permissions[$name] = new PermissionAttachmentInfo($this->parent ?? $this, $name, null, true);
-			Server::getInstance()->getPluginManager()->subscribeToPermission($name, $this->parent ?? $this);
+			$permManager->subscribeToPermission($name, $this->parent ?? $this);
 			$this->calculateChildPermissions($perm->getChildren(), false, null);
 		}
 
@@ -165,13 +165,13 @@ class PermissibleBase implements Permissible{
 	}
 
 	public function clearPermissions(){
-		$pluginManager = Server::getInstance()->getPluginManager();
+		$permManager = PermissionManager::getInstance();
 		foreach(array_keys($this->permissions) as $name){
-			$pluginManager->unsubscribeFromPermission($name, $this->parent ?? $this);
+			$permManager->unsubscribeFromPermission($name, $this->parent ?? $this);
 		}
 
-		$pluginManager->unsubscribeFromDefaultPerms(false, $this->parent ?? $this);
-		$pluginManager->unsubscribeFromDefaultPerms(true, $this->parent ?? $this);
+		$permManager->unsubscribeFromDefaultPerms(false, $this->parent ?? $this);
+		$permManager->unsubscribeFromDefaultPerms(true, $this->parent ?? $this);
 
 		$this->permissions = [];
 	}
@@ -182,11 +182,12 @@ class PermissibleBase implements Permissible{
 	 * @param PermissionAttachment|null $attachment
 	 */
 	private function calculateChildPermissions(array $children, bool $invert, ?PermissionAttachment $attachment){
+		$permManager = PermissionManager::getInstance();
 		foreach($children as $name => $v){
-			$perm = Server::getInstance()->getPluginManager()->getPermission($name);
+			$perm = $permManager->getPermission($name);
 			$value = ($v xor $invert);
 			$this->permissions[$name] = new PermissionAttachmentInfo($this->parent ?? $this, $name, $attachment, $value);
-			Server::getInstance()->getPluginManager()->subscribeToPermission($name, $this->parent ?? $this);
+			$permManager->subscribeToPermission($name, $this->parent ?? $this);
 
 			if($perm instanceof Permission){
 				$this->calculateChildPermissions($perm->getChildren(), !$value, $attachment);

src/pocketmine/permission/Permission.php

@@ -27,8 +27,6 @@ declare(strict_types=1);
 
 namespace pocketmine\permission;
 
-use pocketmine\Server;
-
 /**
  * Represents a permission
  */
@@ -217,13 +215,13 @@ class Permission{
 	 * @return Permissible[]
 	 */
 	public function getPermissibles() : array{
-		return Server::getInstance()->getPluginManager()->getPermissionSubscriptions($this->name);
+		return PermissionManager::getInstance()->getPermissionSubscriptions($this->name);
 	}
 
 	public function recalculatePermissibles(){
 		$perms = $this->getPermissibles();
 
-		Server::getInstance()->getPluginManager()->recalculatePermissionDefaults($this);
+		PermissionManager::getInstance()->recalculatePermissionDefaults($this);
 
 		foreach($perms as $p){
 			$p->recalculatePermissions();
@@ -243,10 +241,10 @@ class Permission{
 			$name->recalculatePermissibles();
 			return null;
 		}else{
-			$perm = Server::getInstance()->getPluginManager()->getPermission($name);
+			$perm = PermissionManager::getInstance()->getPermission($name);
 			if($perm === null){
 				$perm = new Permission($name);
-				Server::getInstance()->getPluginManager()->addPermission($perm);
+				PermissionManager::getInstance()->addPermission($perm);
 			}
 
 			$this->addParent($perm, $value);

src/pocketmine/permission/PermissionManager.php

@@ -0,0 +1,215 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+*/
+
+declare(strict_types=1);
+
+namespace pocketmine\permission;
+
+use pocketmine\timings\Timings;
+
+class PermissionManager{
+	/** @var PermissionManager|null */
+	private static $instance = null;
+
+	public static function getInstance() : PermissionManager{
+		if(self::$instance === null){
+			self::$instance = new self;
+		}
+
+		return self::$instance;
+	}
+
+	/** @var Permission[] */
+	protected $permissions = [];
+	/** @var Permission[] */
+	protected $defaultPerms = [];
+	/** @var Permission[] */
+	protected $defaultPermsOp = [];
+	/** @var Permissible[][] */
+	protected $permSubs = [];
+	/** @var Permissible[] */
+	protected $defSubs = [];
+	/** @var Permissible[] */
+	protected $defSubsOp = [];
+
+	/**
+	 * @param string $name
+	 *
+	 * @return null|Permission
+	 */
+	public function getPermission(string $name){
+		return $this->permissions[$name] ?? null;
+	}
+
+	/**
+	 * @param Permission $permission
+	 *
+	 * @return bool
+	 */
+	public function addPermission(Permission $permission) : bool{
+		if(!isset($this->permissions[$permission->getName()])){
+			$this->permissions[$permission->getName()] = $permission;
+			$this->calculatePermissionDefault($permission);
+
+			return true;
+		}
+
+		return false;
+	}
+
+	/**
+	 * @param string|Permission $permission
+	 */
+	public function removePermission($permission){
+		if($permission instanceof Permission){
+			unset($this->permissions[$permission->getName()]);
+		}else{
+			unset($this->permissions[$permission]);
+		}
+	}
+
+	/**
+	 * @param bool $op
+	 *
+	 * @return Permission[]
+	 */
+	public function getDefaultPermissions(bool $op) : array{
+		if($op){
+			return $this->defaultPermsOp;
+		}else{
+			return $this->defaultPerms;
+		}
+	}
+
+	/**
+	 * @param Permission $permission
+	 */
+	public function recalculatePermissionDefaults(Permission $permission){
+		if(isset($this->permissions[$permission->getName()])){
+			unset($this->defaultPermsOp[$permission->getName()]);
+			unset($this->defaultPerms[$permission->getName()]);
+			$this->calculatePermissionDefault($permission);
+		}
+	}
+
+	/**
+	 * @param Permission $permission
+	 */
+	private function calculatePermissionDefault(Permission $permission){
+		Timings::$permissionDefaultTimer->startTiming();
+		if($permission->getDefault() === Permission::DEFAULT_OP or $permission->getDefault() === Permission::DEFAULT_TRUE){
+			$this->defaultPermsOp[$permission->getName()] = $permission;
+			$this->dirtyPermissibles(true);
+		}
+
+		if($permission->getDefault() === Permission::DEFAULT_NOT_OP or $permission->getDefault() === Permission::DEFAULT_TRUE){
+			$this->defaultPerms[$permission->getName()] = $permission;
+			$this->dirtyPermissibles(false);
+		}
+		Timings::$permissionDefaultTimer->startTiming();
+	}
+
+	/**
+	 * @param bool $op
+	 */
+	private function dirtyPermissibles(bool $op){
+		foreach($this->getDefaultPermSubscriptions($op) as $p){
+			$p->recalculatePermissions();
+		}
+	}
+
+	/**
+	 * @param string      $permission
+	 * @param Permissible $permissible
+	 */
+	public function subscribeToPermission(string $permission, Permissible $permissible){
+		if(!isset($this->permSubs[$permission])){
+			$this->permSubs[$permission] = [];
+		}
+		$this->permSubs[$permission][spl_object_hash($permissible)] = $permissible;
+	}
+
+	/**
+	 * @param string      $permission
+	 * @param Permissible $permissible
+	 */
+	public function unsubscribeFromPermission(string $permission, Permissible $permissible){
+		if(isset($this->permSubs[$permission])){
+			unset($this->permSubs[$permission][spl_object_hash($permissible)]);
+			if(count($this->permSubs[$permission]) === 0){
+				unset($this->permSubs[$permission]);
+			}
+		}
+	}
+
+	/**
+	 * @param string $permission
+	 *
+	 * @return array|Permissible[]
+	 */
+	public function getPermissionSubscriptions(string $permission) : array{
+		return $this->permSubs[$permission] ?? [];
+	}
+
+	/**
+	 * @param bool        $op
+	 * @param Permissible $permissible
+	 */
+	public function subscribeToDefaultPerms(bool $op, Permissible $permissible){
+		if($op){
+			$this->defSubsOp[spl_object_hash($permissible)] = $permissible;
+		}else{
+			$this->defSubs[spl_object_hash($permissible)] = $permissible;
+		}
+	}
+
+	/**
+	 * @param bool        $op
+	 * @param Permissible $permissible
+	 */
+	public function unsubscribeFromDefaultPerms(bool $op, Permissible $permissible){
+		if($op){
+			unset($this->defSubsOp[spl_object_hash($permissible)]);
+		}else{
+			unset($this->defSubs[spl_object_hash($permissible)]);
+		}
+	}
+
+	/**
+	 * @param bool $op
+	 *
+	 * @return Permissible[]
+	 */
+	public function getDefaultPermSubscriptions(bool $op) : array{
+		if($op){
+			return $this->defSubsOp;
+		}
+
+		return $this->defSubs;
+	}
+
+	/**
+	 * @return Permission[]
+	 */
+	public function getPermissions() : array{
+		return $this->permissions;
+	}
+}