Add world and group name rewriting, refactor configs

bukkit/src/main/java/me/lucko/luckperms/BukkitConfig.java

@@ -22,14 +22,17 @@
 
 package me.lucko.luckperms;
 
-import me.lucko.luckperms.core.LPConfiguration;
+import me.lucko.luckperms.core.AbstractConfiguration;
+import org.bukkit.configuration.ConfigurationSection;
 import org.bukkit.configuration.InvalidConfigurationException;
 import org.bukkit.configuration.file.YamlConfiguration;
 
 import java.io.File;
 import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
 
-class BukkitConfig extends LPConfiguration<LPBukkitPlugin> {
+class BukkitConfig extends AbstractConfiguration<LPBukkitPlugin> {
     private YamlConfiguration configuration;
 
     BukkitConfig(LPBukkitPlugin plugin) {
@@ -55,11 +58,6 @@ class BukkitConfig extends LPConfiguration<LPBukkitPlugin> {
         }
     }
 
-    @Override
-    protected void set(String path, Object value) {
-        configuration.set(path, value);
-    }
-
     @Override
     protected String getString(String path, String def) {
         return configuration.getString(path, def);
@@ -74,4 +72,20 @@ class BukkitConfig extends LPConfiguration<LPBukkitPlugin> {
     protected boolean getBoolean(String path, boolean def) {
         return configuration.getBoolean(path, def);
     }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    protected Map<String, String> getMap(String path, Map<String, String> def) {
+        Map<String, String> map = new HashMap<>();
+        ConfigurationSection section = configuration.getConfigurationSection(path);
+        if (section == null) {
+            return def;
+        }
+
+        for (String key : section.getKeys(false)) {
+            map.put(key, section.getString(key));
+        }
+
+        return map;
+    }
 }

bukkit/src/main/java/me/lucko/luckperms/BukkitListener.java

@@ -104,7 +104,7 @@ class BukkitListener extends AbstractListener implements Listener {
 
     @EventHandler
     public void onPlayerCommand(PlayerCommandPreprocessEvent e) {
-        if (plugin.getConfiguration().getEnableOps()) {
+        if (plugin.getConfiguration().isOpsEnabled()) {
             return;
         }
 

bukkit/src/main/java/me/lucko/luckperms/LPBukkitPlugin.java

@@ -95,7 +95,7 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
         datastore = StorageFactory.getDatastore(this, "h2");
 
         getLog().info("Loading internal permission managers...");
-        uuidCache = new UuidCache(getConfiguration().getOnlineMode());
+        uuidCache = new UuidCache(getConfiguration().isOnlineMode());
         userManager = new BukkitUserManager(this);
         groupManager = new GroupManager(this);
         trackManager = new TrackManager();
@@ -139,8 +139,8 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
             e.printStackTrace();
         }
 
-        registerPermissions(getConfiguration().getCommandsAllowOp() ? PermissionDefault.OP : PermissionDefault.FALSE);
-        if (!getConfiguration().getEnableOps()) {
+        registerPermissions(getConfiguration().isCommandsAllowOp() ? PermissionDefault.OP : PermissionDefault.FALSE);
+        if (!getConfiguration().isOpsEnabled()) {
             getServer().getOperators().forEach(o -> o.setOp(false));
         }
 

bukkit/src/main/java/me/lucko/luckperms/api/vault/VaultHook.java

@@ -40,7 +40,7 @@ public class VaultHook {
             }
             permissionHook.setPlugin(plugin);
             permissionHook.setServer(plugin.getConfiguration().getVaultServer());
-            permissionHook.setIncludeGlobal(plugin.getConfiguration().getVaultIncludeGlobal());
+            permissionHook.setIncludeGlobal(plugin.getConfiguration().isVaultIncludingGlobal());
 
             if (chatHook == null) {
                 chatHook = new VaultChatHook(permissionHook);

bukkit/src/main/java/me/lucko/luckperms/inject/LPPermissible.java

@@ -62,15 +62,15 @@ public class LPPermissible extends PermissibleBase {
         List<PermissionProcessor> processors = new ArrayList<>(5);
         processors.add(new PermissionCalculator.MapProcessor(luckPermsPermissions));
         processors.add(new AttachmentProcessor(attachmentPermissions));
-        if (plugin.getConfiguration().getApplyWildcards()) {
+        if (plugin.getConfiguration().isApplyingWildcards()) {
             processors.add(new PermissionCalculator.WildcardProcessor(luckPermsPermissions));
         }
-        if (plugin.getConfiguration().getApplyRegex()) {
+        if (plugin.getConfiguration().isApplyingRegex()) {
             processors.add(new PermissionCalculator.RegexProcessor(luckPermsPermissions));
         }
         processors.add(new BukkitDefaultsProcessor(parent::isOp, defaultsProvider));
 
-        calculator = new PermissionCalculator(plugin, parent.getName(), plugin.getConfiguration().getDebugPermissionChecks(), processors);
+        calculator = new PermissionCalculator(plugin, parent.getName(), plugin.getConfiguration().isDebugPermissionChecks(), processors);
 
         recalculatePermissions();
     }

bukkit/src/main/java/me/lucko/luckperms/users/BukkitUser.java

@@ -60,16 +60,17 @@ public class BukkitUser extends User {
         }
 
         // Calculate the permissions that should be applied. This is done async, who cares about how long it takes or how often it's done.
+        String world = plugin.getUserManager().getWorldCache().get(getUuid());
         Map<String, Boolean> toApply = exportNodes(
                 new Contexts(
                         getPlugin().getConfiguration().getServer(),
-                        plugin.getUserManager().getWorldCache().get(getUuid()),
+                        getPlugin().getConfiguration().getWorldRewrites().getOrDefault(world, world),
                         null,
-                        getPlugin().getConfiguration().getIncludeGlobalPerms(),
-                        getPlugin().getConfiguration().getIncludeGlobalWorldPerms(),
+                        getPlugin().getConfiguration().isIncludingGlobalPerms(),
+                        getPlugin().getConfiguration().isIncludingGlobalWorldPerms(),
                         true,
-                        getPlugin().getConfiguration().getApplyGlobalGroups(),
-                        getPlugin().getConfiguration().getApplyGlobalWorldGroups()
+                        getPlugin().getConfiguration().isApplyingGlobalGroups(),
+                        getPlugin().getConfiguration().isApplyingGlobalWorldGroups()
                 ),
                 Collections.emptyList()
         );
@@ -96,7 +97,7 @@ public class BukkitUser extends User {
             lpPermissible.invalidateCache();
             existing.putAll(toApply);
 
-            if (plugin.getConfiguration().getAutoOp()) {
+            if (plugin.getConfiguration().isAutoOp()) {
                 boolean op = false;
 
                 for (Map.Entry<String, Boolean> e : toApply.entrySet()) {

bukkit/src/main/java/me/lucko/luckperms/users/BukkitUserManager.java

@@ -55,7 +55,7 @@ public class BukkitUserManager extends UserManager {
                     u.setLpPermissible(null);
                 }
 
-                if (plugin.getConfiguration().getAutoOp()) {
+                if (plugin.getConfiguration().isAutoOp()) {
                     player.setOp(false);
                 }
             }

bukkit/src/main/resources/config.yml

@@ -80,6 +80,16 @@ vault-server: global
 # If global permissions should be considered when retrieving meta or player groups
 vault-include-global: true
 
+# Mirrors world names. Whenever LuckPerms checks what world a user is in, if the world name is in this list, the value assigned
+# will be sent forward for permission calculation instead.
+world-rewrite:
+  #world_nether: world
+  #world_the_end: world
+
+# Rewrites group names. The underlying name of the group does not change, just the output in commands / placeholders / Vault.
+group-name-rewrite:
+  #default: Member
+
 # Which storage method the plugin should use.
 # Currently supported: mysql, sqlite, h2, json, yaml, mongodb
 # Fill out connection info below if you're using MySQL or MongoDB