Release 2.10

api/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>luckperms</artifactId>
         <groupId>me.lucko.luckperms</groupId>
-        <version>2.9-SNAPSHOT</version>
+        <version>2.10-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

api/src/main/java/me/lucko/luckperms/api/LuckPermsApi.java

@@ -22,6 +22,8 @@
 
 package me.lucko.luckperms.api;
 
+import me.lucko.luckperms.api.context.ContextListener;
+import me.lucko.luckperms.api.context.IContextCalculator;
 import me.lucko.luckperms.api.event.LPListener;
 
 import java.util.Optional;
@@ -218,4 +220,18 @@ public interface LuckPermsApi {
      */
     Node.Builder buildNode(String permission) throws IllegalArgumentException;
 
+    /**
+     * Register a custom context calculator to the server
+     * @param contextCalculator the context calculator to register. The type MUST be the player class of the platform.
+     * @throws ClassCastException if the type is not the player class of the platform.
+     */
+    void registerContextCalculator(IContextCalculator<?> contextCalculator);
+
+    /**
+     * Registers a custom context listener to the server,
+     * @param contextListener the context listener to register. The type MUST be the player class of the platform.
+     * @throws ClassCastException if the type is not the player class of the platform.
+     */
+    void registerContextListener(ContextListener<?> contextListener);
+
 }

api/src/main/java/me/lucko/luckperms/api/Node.java

@@ -105,7 +105,15 @@ public interface Node extends Map.Entry<String, Boolean> {
     boolean shouldApplyOnWorld(String world, boolean includeGlobal, boolean applyRegex);
 
     /**
-     * If this node should apply given the specific context
+     * If this node should apply in the given context
+     * @param context the context key value pairs
+     * @param worldAndServer if world and server contexts should be checked
+     * @return true if the node should apply
+     */
+    boolean shouldApplyWithContext(Map<String, String> context, boolean worldAndServer);
+
+    /**
+     * If this node should apply in the given context
      * @param context the context key value pairs
      * @return true if the node should apply
      */

api/src/main/java/me/lucko/luckperms/api/context/ContextCalculator.java

@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.context;
+
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+/**
+ * A simple implementation of the listener aspects of {@link IContextCalculator<T>}
+ * @param <T> the subject type
+ */
+public abstract class ContextCalculator<T> implements IContextCalculator<T> {
+    private final List<ContextListener<T>> listeners = new CopyOnWriteArrayList<>();
+
+    /**
+     * Pushes an update to all registered {@link ContextListener}s.
+     * Make sure any changes are applied internally before this method is called.
+     * @param subject the subject that changed
+     * @param before the context state before the change
+     * @param current the context state after the change (now)
+     * @throws NullPointerException if any parameters are null
+     */
+    protected void pushUpdate(T subject, Map.Entry<String, String> before, Map.Entry<String, String> current) {
+        if (subject == null) {
+            throw new NullPointerException("subject");
+        }
+        if (before == null) {
+            throw new NullPointerException("before");
+        }
+        if (current == null) {
+            throw new NullPointerException("current");
+        }
+
+        for (ContextListener<T> listener : listeners) {
+            try {
+                listener.onContextChange(subject, before, current);
+            } catch (Exception e) {
+                System.out.println("Exception whilst passing context change to listener: " + listener);
+                e.printStackTrace();
+            }
+        }
+    }
+
+    @Override
+    public void addListener(ContextListener<T> listener) {
+        if (listener == null) {
+            throw new NullPointerException("listener");
+        }
+
+        listeners.add(listener);
+    }
+
+}

api/src/main/java/me/lucko/luckperms/api/context/ContextListener.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.context;
+
+import java.util.Map;
+
+/**
+ * Listens to context changes
+ * @param <T> the subject type, Is ALWAYS the player class of the platform.
+ */
+public interface ContextListener<T> {
+
+    /**
+     * Called whenever a context changes on the
+     * @param subject the subject that had context changed
+     * @param before the context state before the change
+     * @param current the context state after the change (now)
+     */
+    void onContextChange(T subject, Map.Entry<String, String> before, Map.Entry<String, String> current) throws Exception;
+
+}

api/src/main/java/me/lucko/luckperms/api/context/IContextCalculator.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.context;
+
+import java.util.Map;
+
+/**
+ * Calculates whether contexts are applicable to {@link T}
+ *
+ * <p>Somewhat inspired by the system used on Sponge.
+ * @param <T> the subject type. Is ALWAYS the player class of the platform.
+ */
+public interface IContextCalculator<T> {
+
+    /**
+     * Gives the subject all of the applicable contexts they meet
+     * @param subject the subject to add contexts tp
+     * @param accumulator a map of contexts to add to
+     * @return the map
+     */
+    Map<String, String> giveApplicableContext(T subject, Map<String, String> accumulator);
+
+    /**
+     * Checks to see if a context is applicable to a subject
+     * @param subject the subject to check against
+     * @param context the context to check for
+     * @return true if met, or false if not. If this calculator does not calculate the given context, return false.
+     */
+    boolean isContextApplicable(T subject, Map.Entry<String, String> context);
+
+    /**
+     * Adds a listener to be called whenever a context handled by this calculator changes
+     * @param listener the listener instance
+     * @throws NullPointerException if listener is null
+     */
+    void addListener(ContextListener<T> listener);
+
+}

bukkit-legacy/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>luckperms</artifactId>
         <groupId>me.lucko.luckperms</groupId>
-        <version>2.9-SNAPSHOT</version>
+        <version>2.10-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

bukkit-placeholders/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>luckperms</artifactId>
         <groupId>me.lucko.luckperms</groupId>
-        <version>2.9-SNAPSHOT</version>
+        <version>2.10-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

bukkit/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>luckperms</artifactId>
         <groupId>me.lucko.luckperms</groupId>
-        <version>2.9-SNAPSHOT</version>
+        <version>2.10-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

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

@@ -44,7 +44,7 @@ class BukkitCommand extends CommandManager implements CommandExecutor, TabExecut
     @Override
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
         onCommand(
-                BukkitSenderFactory.get().wrap(sender),
+                BukkitSenderFactory.get(getPlugin()).wrap(sender),
                 label,
                 Util.stripQuotes(Splitter.on(Patterns.COMMAND_SEPARATOR).omitEmptyStrings().splitToList(Joiner.on(' ').join(args))),
                 Callback.empty()
@@ -55,6 +55,6 @@ class BukkitCommand extends CommandManager implements CommandExecutor, TabExecut
 
     @Override
     public List<String> onTabComplete(CommandSender sender, Command command, String label, String[] args) {
-        return onTabComplete(BukkitSenderFactory.get().wrap(sender), Arrays.asList(args));
+        return onTabComplete(BukkitSenderFactory.get(getPlugin()).wrap(sender), Arrays.asList(args));
     }
 }

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.config.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

@@ -69,7 +69,7 @@ class BukkitListener extends AbstractListener implements Listener {
             BukkitUser u = (BukkitUser) user;
 
             try {
-                LPPermissible lpPermissible = new LPPermissible(player, plugin);
+                LPPermissible lpPermissible = new LPPermissible(player, plugin, plugin.getDefaultsProvider());
                 Injector.inject(player, lpPermissible);
                 u.setLpPermissible(lpPermissible);
             } catch (Throwable t) {
@@ -84,27 +84,19 @@ class BukkitListener extends AbstractListener implements Listener {
     public void onPlayerJoin(PlayerJoinEvent e) {
         // Refresh permissions again
         UUID internal = plugin.getUuidCache().getUUID(e.getPlayer().getUniqueId());
-        plugin.getUserManager().getWorldCache().put(internal, e.getPlayer().getWorld().getName());
+        plugin.getWorldCalculator().getWorldCache().put(internal, e.getPlayer().getWorld().getName());
         plugin.doAsync(() -> refreshPlayer(internal));
     }
 
-    @EventHandler(priority = EventPriority.LOWEST)
-    public void onPlayerChangedWorld(PlayerChangedWorldEvent e) {
-        UUID internal = plugin.getUuidCache().getUUID(e.getPlayer().getUniqueId());
-        plugin.getUserManager().getWorldCache().put(internal, e.getPlayer().getWorld().getName());
-        plugin.doAsync(() -> refreshPlayer(internal));
-
-    }
-
     @EventHandler(priority = EventPriority.LOWEST)
     public void onPlayerQuit(PlayerQuitEvent e) {
-        plugin.getUserManager().getWorldCache().remove(plugin.getUuidCache().getUUID(e.getPlayer().getUniqueId()));
+        plugin.getWorldCalculator().getWorldCache().remove(plugin.getUuidCache().getUUID(e.getPlayer().getUniqueId()));
         onLeave(e.getPlayer().getUniqueId());
     }
 
     @EventHandler
     public void onPlayerCommand(PlayerCommandPreprocessEvent e) {
-        if (plugin.getConfiguration().getEnableOps()) {
+        if (plugin.getConfiguration().isOpsEnabled()) {
             return;
         }
 

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

@@ -22,8 +22,6 @@
 
 package me.lucko.luckperms;
 
-import lombok.AccessLevel;
-import lombok.NoArgsConstructor;
 import me.lucko.luckperms.commands.SenderFactory;
 import me.lucko.luckperms.constants.Constants;
 import org.bukkit.command.CommandSender;
@@ -31,12 +29,16 @@ import org.bukkit.entity.Player;
 
 import java.util.UUID;
 
-@NoArgsConstructor(access = AccessLevel.PRIVATE)
 public class BukkitSenderFactory extends SenderFactory<CommandSender> {
     private static BukkitSenderFactory instance = null;
-    public static synchronized BukkitSenderFactory get() {
+
+    private BukkitSenderFactory(LuckPermsPlugin plugin) {
+        super(plugin);
+    }
+
+    public static synchronized BukkitSenderFactory get(LuckPermsPlugin plugin) {
         if (instance == null) {
-            instance = new BukkitSenderFactory();
+            instance = new BukkitSenderFactory(plugin);
         }
         return instance;
     }

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

@@ -30,17 +30,22 @@ import me.lucko.luckperms.api.implementation.ApiProvider;
 import me.lucko.luckperms.api.vault.VaultHook;
 import me.lucko.luckperms.commands.ConsecutiveExecutor;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.config.LPConfiguration;
 import me.lucko.luckperms.constants.Message;
-import me.lucko.luckperms.core.LPConfiguration;
+import me.lucko.luckperms.contexts.ContextManager;
+import me.lucko.luckperms.contexts.ServerCalculator;
+import me.lucko.luckperms.contexts.WorldCalculator;
 import me.lucko.luckperms.core.UuidCache;
 import me.lucko.luckperms.data.Importer;
 import me.lucko.luckperms.groups.GroupManager;
+import me.lucko.luckperms.inject.DefaultsProvider;
 import me.lucko.luckperms.runnables.ExpireTemporaryTask;
 import me.lucko.luckperms.runnables.UpdateTask;
 import me.lucko.luckperms.storage.Datastore;
 import me.lucko.luckperms.storage.StorageFactory;
 import me.lucko.luckperms.tracks.TrackManager;
 import me.lucko.luckperms.users.BukkitUserManager;
+import me.lucko.luckperms.utils.LocaleManager;
 import me.lucko.luckperms.utils.LogFactory;
 import org.bukkit.command.PluginCommand;
 import org.bukkit.entity.Player;
@@ -68,6 +73,10 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
     private Logger log;
     private Importer importer;
     private ConsecutiveExecutor consecutiveExecutor;
+    private DefaultsProvider defaultsProvider;
+    private LocaleManager localeManager;
+    private ContextManager<Player> contextManager;
+    private WorldCalculator worldCalculator;
 
     @Override
     public void onEnable() {
@@ -76,6 +85,20 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
         getLog().info("Loading configuration...");
         configuration = new BukkitConfig(this);
 
+        localeManager = new LocaleManager();
+        File locale = new File(getDataFolder(), "lang.yml");
+        if (locale.exists()) {
+            getLog().info("Found locale file. Attempting to load from it.");
+            try {
+                localeManager.loadFromFile(locale);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+
+        defaultsProvider = new DefaultsProvider();
+        getServer().getScheduler().runTaskLater(this, () -> defaultsProvider.refresh(), 1L);
+
         // register events
         PluginManager pm = getServer().getPluginManager();
         pm.registerEvents(new BukkitListener(this), this);
@@ -91,20 +114,27 @@ 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();
         importer = new Importer(commandManager);
         consecutiveExecutor = new ConsecutiveExecutor(commandManager);
 
+        contextManager = new ContextManager<>();
+        worldCalculator = new WorldCalculator(this);
+        pm.registerEvents(worldCalculator, this);
+        contextManager.registerCalculator(worldCalculator);
+        contextManager.registerCalculator(new ServerCalculator<>(getConfiguration().getServer()));
+        contextManager.registerListener(userManager);
+
         int mins = getConfiguration().getSyncTime();
         if (mins > 0) {
             long ticks = mins * 60 * 20;
             getServer().getScheduler().runTaskTimerAsynchronously(this, new UpdateTask(this), ticks, ticks);
         }
 
-        getServer().getScheduler().runTaskTimer(this, BukkitSenderFactory.get(), 1L, 1L);
+        getServer().getScheduler().runTaskTimer(this, BukkitSenderFactory.get(this), 1L, 1L);
         getServer().getScheduler().runTaskTimerAsynchronously(this, new ExpireTemporaryTask(this), 60L, 60L);
         getServer().getScheduler().runTaskTimerAsynchronously(this, consecutiveExecutor, 20L, 20L);
 
@@ -135,8 +165,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));
         }
 
@@ -196,14 +226,14 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
     @Override
     public List<Sender> getNotifyListeners() {
         return getServer().getOnlinePlayers().stream()
-                .map(p -> BukkitSenderFactory.get().wrap(p, Collections.singleton(me.lucko.luckperms.constants.Permission.LOG_NOTIFY)))
+                .map(p -> BukkitSenderFactory.get(this).wrap(p, Collections.singleton(me.lucko.luckperms.constants.Permission.LOG_NOTIFY)))
                 .filter(me.lucko.luckperms.constants.Permission.LOG_NOTIFY::isAuthorized)
                 .collect(Collectors.toList());
     }
 
     @Override
     public Sender getConsoleSender() {
-        return BukkitSenderFactory.get().wrap(getServer().getConsoleSender());
+        return BukkitSenderFactory.get(this).wrap(getServer().getConsoleSender());
     }
 
     @Override

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

@@ -26,11 +26,11 @@ import lombok.NonNull;
 import lombok.Setter;
 import me.lucko.luckperms.LPBukkitPlugin;
 import me.lucko.luckperms.api.Node;
+import me.lucko.luckperms.contexts.Contexts;
 import me.lucko.luckperms.core.PermissionHolder;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.users.User;
-import me.lucko.luckperms.utils.Contexts;
 import net.milkbowl.vault.chat.Chat;
 
 import java.util.Iterator;
@@ -90,7 +90,7 @@ public class VaultChatHook extends Chat {
             }
         }
 
-        Node.Builder metaNode = new me.lucko.luckperms.utils.Node.Builder("meta." + node + "." + value).setValue(true);
+        Node.Builder metaNode = new me.lucko.luckperms.core.Node.Builder("meta." + node + "." + value).setValue(true);
         if (!perms.getServer().equalsIgnoreCase("global")) {
             metaNode.setServer(perms.getServer());
         }
@@ -140,7 +140,7 @@ public class VaultChatHook extends Chat {
         if (holder == null) return;
         if (value.equals("")) return;
 
-        Node.Builder node = new me.lucko.luckperms.utils.Node.Builder(prefix ? "prefix" : "suffix" + ".1000." + escapeCharacters(value));
+        Node.Builder node = new me.lucko.luckperms.core.Node.Builder(prefix ? "prefix" : "suffix" + ".1000." + escapeCharacters(value));
         node.setValue(true);
         if (!perms.getServer().equalsIgnoreCase("global")) {
             node.setServer(perms.getServer());

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/contexts/WorldCalculator.java

@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.contexts;
+
+import com.google.common.collect.Maps;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.context.ContextCalculator;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerChangedWorldEvent;
+
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+
+@RequiredArgsConstructor
+public class WorldCalculator extends ContextCalculator<Player> implements Listener {
+    private static final String WORLD_KEY = "world";
+
+    private final LuckPermsPlugin plugin;
+
+    @Getter
+    private final Map<UUID, String> worldCache = new ConcurrentHashMap<>();
+
+    @Override
+    public Map<String, String> giveApplicableContext(Player subject, Map<String, String> accumulator) {
+        String world = getWorld(subject);
+
+        if (world != null) {
+            accumulator.put(WORLD_KEY, world);
+        }
+
+        return accumulator;
+    }
+
+    @Override
+    public boolean isContextApplicable(Player subject, Map.Entry<String, String> context) {
+        if (!context.getKey().equals(WORLD_KEY)) {
+            return false;
+        }
+
+        String world = getWorld(subject);
+        return world != null && world.equals(context.getValue());
+    }
+
+    private String getWorld(Player player) {
+        UUID internal = plugin.getUuidCache().getUUID(player.getUniqueId());
+        if (!worldCache.containsKey(internal)) {
+            return null;
+        }
+
+        String world = worldCache.get(internal);
+        return plugin.getConfiguration().getWorldRewrites().getOrDefault(world, world);
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onPlayerChangedWorld(PlayerChangedWorldEvent e) {
+        UUID internal = plugin.getUuidCache().getUUID(e.getPlayer().getUniqueId());
+        worldCache.put(internal, e.getPlayer().getWorld().getName());
+        pushUpdate(
+                e.getPlayer(),
+                Maps.immutableEntry(WORLD_KEY, e.getFrom().getName()),
+                Maps.immutableEntry(WORLD_KEY, e.getPlayer().getWorld().getName())
+        );
+    }
+}

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

@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.inject;
+
+import lombok.AllArgsConstructor;
+import me.lucko.luckperms.api.Tristate;
+import org.bukkit.Bukkit;
+import org.bukkit.permissions.Permissible;
+import org.bukkit.permissions.Permission;
+import org.bukkit.permissions.PermissionAttachment;
+import org.bukkit.permissions.PermissionAttachmentInfo;
+import org.bukkit.plugin.Plugin;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+public class DefaultsProvider {
+
+    private final DummyPermissible opDummy = new DummyPermissible(this::refreshOp);
+    private final DummyPermissible nonOpDummy = new DummyPermissible(this::refreshNonOp);
+
+    private final Map<String, Boolean> op = new HashMap<>();
+    private final Map<String, Boolean> nonOp = new HashMap<>();
+
+    public void refresh() {
+        refreshOp();
+        refreshNonOp();
+    }
+
+    private void refreshOp() {
+        calculateDefaults(op, opDummy, true);
+    }
+
+    private void refreshNonOp() {
+        calculateDefaults(nonOp, nonOpDummy, false);
+    }
+
+    private static void calculateDefaults(Map<String, Boolean> map, DummyPermissible p, boolean op) {
+        Set<String> perms = map.keySet();
+
+        for (String name : perms) {
+            Bukkit.getServer().getPluginManager().unsubscribeFromPermission(name, p);
+        }
+
+        Bukkit.getServer().getPluginManager().unsubscribeFromDefaultPerms(false, p);
+        Bukkit.getServer().getPluginManager().unsubscribeFromDefaultPerms(true, p);
+
+        map.clear();
+
+        Set<Permission> defaults = Bukkit.getServer().getPluginManager().getDefaultPermissions(op);
+        Bukkit.getServer().getPluginManager().subscribeToDefaultPerms(op, p);
+
+        for (Permission perm : defaults) {
+            String name = perm.getName().toLowerCase();
+            map.put(name, true);
+            Bukkit.getServer().getPluginManager().subscribeToPermission(name, p);
+            calculateChildPermissions(map, p, perm.getChildren(), false);
+        }
+    }
+
+    private static void calculateChildPermissions(Map<String, Boolean> map, DummyPermissible p, Map<String, Boolean> children, boolean invert) {
+        for (Map.Entry<String, Boolean> e : children.entrySet()) {
+            Permission perm = Bukkit.getServer().getPluginManager().getPermission(e.getKey());
+            boolean value = e.getValue() ^ invert;
+            String lName = e.getKey().toLowerCase();
+
+            map.put(lName, value);
+            Bukkit.getServer().getPluginManager().subscribeToPermission(e.getKey(), p);
+
+            if (perm != null) {
+                calculateChildPermissions(map, p, perm.getChildren(), !value);
+            }
+        }
+    }
+
+    public Tristate hasDefault(String permission, boolean isOp) {
+        Map<String, Boolean> map = isOp ? op : nonOp;
+        if (!map.containsKey(permission)) {
+            return Tristate.UNDEFINED;
+        }
+
+        return Tristate.fromBoolean(map.get(permission));
+    }
+
+    @AllArgsConstructor
+    private static class DummyPermissible implements Permissible {
+        private final Runnable onRefresh;
+
+        @Override
+        public void recalculatePermissions() {
+            onRefresh.run();
+        }
+
+        @Override
+        public Set<PermissionAttachmentInfo> getEffectivePermissions() {
+            return Collections.emptySet();
+        }
+
+        @Override
+        public boolean isPermissionSet(String name) {
+            return false;
+        }
+
+        @Override
+        public boolean isPermissionSet(Permission perm) {
+            return false;
+        }
+
+        @Override
+        public boolean hasPermission(String name) {
+            return false;
+        }
+
+        @Override
+        public boolean hasPermission(Permission perm) {
+            return false;
+        }
+
+        @Override
+        public PermissionAttachment addAttachment(Plugin plugin, String name, boolean value) {
+            return null;
+        }
+
+        @Override
+        public PermissionAttachment addAttachment(Plugin plugin) {
+            return null;
+        }
+
+        @Override
+        public PermissionAttachment addAttachment(Plugin plugin, String name, boolean value, int ticks) {
+            return null;
+        }
+
+        @Override
+        public PermissionAttachment addAttachment(Plugin plugin, int ticks) {
+            return null;
+        }
+
+        @Override
+        public void removeAttachment(PermissionAttachment attachment) {
+
+        }
+
+        @Override
+        public boolean isOp() {
+            return false;
+        }
+
+        @Override
+        public void setOp(boolean value) {
+
+        }
+    }
+
+}

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

@@ -27,8 +27,8 @@ import lombok.Getter;
 import lombok.NonNull;
 import me.lucko.luckperms.LuckPermsPlugin;
 import me.lucko.luckperms.api.Tristate;
-import me.lucko.luckperms.utils.PermissionCalculator;
-import me.lucko.luckperms.utils.PermissionProcessor;
+import me.lucko.luckperms.calculators.PermissionCalculator;
+import me.lucko.luckperms.calculators.PermissionProcessor;
 import org.bukkit.Bukkit;
 import org.bukkit.command.CommandSender;
 import org.bukkit.permissions.*;
@@ -55,22 +55,24 @@ public class LPPermissible extends PermissibleBase {
     private final List<PermissionAttachment> attachments = new LinkedList<>();
     private final Map<String, PermissionAttachmentInfo> attachmentPermissions = new HashMap<>();
 
-    public LPPermissible(@NonNull CommandSender sender, LuckPermsPlugin plugin) {
+    public LPPermissible(@NonNull CommandSender sender, LuckPermsPlugin plugin, DefaultsProvider defaultsProvider) {
         super(sender);
         this.parent = sender;
 
         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));
+        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();
     }
 
     public void invalidateCache() {
@@ -89,7 +91,7 @@ public class LPPermissible extends PermissibleBase {
 
     @Override
     public boolean isPermissionSet(@NonNull String name) {
-        return luckPermsPermissions.containsKey(name.toLowerCase()) || attachmentPermissions.containsKey(name.toLowerCase());
+        return calculator.getPermissionValue(name) != Tristate.UNDEFINED;
     }
 
     @Override
@@ -198,16 +200,6 @@ public class LPPermissible extends PermissibleBase {
         }
 
         attachmentPermissions.clear();
-        Set<Permission> defaults = Bukkit.getServer().getPluginManager().getDefaultPermissions(isOp());
-        Bukkit.getServer().getPluginManager().subscribeToDefaultPerms(isOp(), parent);
-
-        for (Permission perm : defaults) {
-            String name = perm.getName().toLowerCase();
-
-            attachmentPermissions.put(name, new PermissionAttachmentInfo(parent, name, null, true));
-            Bukkit.getServer().getPluginManager().subscribeToPermission(name, parent);
-            calculateChildPermissions(perm.getChildren(), false, null);
-        }
 
         for (PermissionAttachment attachment : attachments) {
             calculateChildPermissions(attachment.getPermissions(), false, attachment);
@@ -289,9 +281,15 @@ public class LPPermissible extends PermissibleBase {
     @AllArgsConstructor
     private static class BukkitDefaultsProcessor implements PermissionProcessor {
         private final Supplier<Boolean> isOp;
+        private final DefaultsProvider defaultsProvider;
 
         @Override
         public Tristate hasPermission(String permission) {
+            Tristate t = defaultsProvider.hasDefault(permission, isOp.get());
+            if (t != Tristate.UNDEFINED) {
+                return t;
+            }
+
             Permission defPerm = Bukkit.getServer().getPluginManager().getPermission(permission);
             if (defPerm != null) {
                 return Tristate.fromBoolean(defPerm.getDefault().getValue(isOp.get()));

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

@@ -27,11 +27,13 @@ import lombok.Setter;
 import me.lucko.luckperms.LPBukkitPlugin;
 import me.lucko.luckperms.api.event.events.UserPermissionRefreshEvent;
 import me.lucko.luckperms.api.implementation.internal.UserLink;
+import me.lucko.luckperms.contexts.Contexts;
 import me.lucko.luckperms.inject.LPPermissible;
-import me.lucko.luckperms.utils.Contexts;
+import org.bukkit.entity.Player;
 import org.bukkit.permissions.Permissible;
 
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.UUID;
 
@@ -62,14 +64,12 @@ 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.
         Map<String, Boolean> toApply = exportNodes(
                 new Contexts(
-                        getPlugin().getConfiguration().getServer(),
-                        plugin.getUserManager().getWorldCache().get(getUuid()),
-                        null,
-                        getPlugin().getConfiguration().getIncludeGlobalPerms(),
-                        getPlugin().getConfiguration().getIncludeGlobalWorldPerms(),
+                        plugin.getContextManager().giveApplicableContext((Player) lpPermissible.getParent(), new HashMap<>()),
+                        plugin.getConfiguration().isIncludingGlobalPerms(),
+                        plugin.getConfiguration().isIncludingGlobalWorldPerms(),
                         true,
-                        getPlugin().getConfiguration().getApplyGlobalGroups(),
-                        getPlugin().getConfiguration().getApplyGlobalWorldGroups()
+                        plugin.getConfiguration().isApplyingGlobalGroups(),
+                        plugin.getConfiguration().isApplyingGlobalWorldGroups()
                 ),
                 Collections.emptyList()
         );
@@ -96,7 +96,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

@@ -22,23 +22,19 @@
 
 package me.lucko.luckperms.users;
 
-import lombok.Getter;
 import me.lucko.luckperms.LPBukkitPlugin;
+import me.lucko.luckperms.api.context.ContextListener;
 import me.lucko.luckperms.inject.Injector;
 import org.bukkit.entity.Player;
 
 import java.util.Map;
 import java.util.Set;
 import java.util.UUID;
-import java.util.concurrent.ConcurrentHashMap;
 import java.util.stream.Collectors;
 
-public class BukkitUserManager extends UserManager {
+public class BukkitUserManager extends UserManager implements ContextListener<Player> {
     private final LPBukkitPlugin plugin;
 
-    @Getter
-    private final Map<UUID, String> worldCache = new ConcurrentHashMap<>();
-
     public BukkitUserManager(LPBukkitPlugin plugin) {
         super(plugin);
         this.plugin = plugin;
@@ -55,7 +51,7 @@ public class BukkitUserManager extends UserManager {
                     u.setLpPermissible(null);
                 }
 
-                if (plugin.getConfiguration().getAutoOp()) {
+                if (plugin.getConfiguration().isAutoOp()) {
                     player.setOp(false);
                 }
             }
@@ -89,4 +85,14 @@ public class BukkitUserManager extends UserManager {
             plugin.doAsync(() -> players.forEach(u -> plugin.getDatastore().loadUser(u, "null")));
         });
     }
+
+    @Override
+    public void onContextChange(Player subject, Map.Entry<String, String> before, Map.Entry<String, String> current) throws Exception {
+        UUID internal = plugin.getUuidCache().getUUID(subject.getUniqueId());
+
+        User user = get(internal);
+        if (user != null) {
+            plugin.doAsync(user::refreshPermissions);
+        }
+    }
 }

bukkit/src/main/resources/config.yml

@@ -80,14 +80,22 @@ 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
 storage-method: h2
 
 # This block enables support for split datastores.
-# Only touch this if you're sure that you know what you're doing.
-# I (the author) do not endorse nor recommend the use of this feature.
 split-storage:
   enabled: false
   methods:

bungee/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>luckperms</artifactId>
         <groupId>me.lucko.luckperms</groupId>
-        <version>2.9-SNAPSHOT</version>
+        <version>2.10-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

bungee/src/main/java/me/lucko/luckperms/BungeeCommand.java

@@ -45,7 +45,7 @@ class BungeeCommand extends Command implements TabExecutor {
     @Override
     public void execute(CommandSender sender, String[] args) {
         manager.onCommand(
-                BungeeSenderFactory.get().wrap(sender),
+                BungeeSenderFactory.get(manager.getPlugin()).wrap(sender),
                 "bperms",
                 Util.stripQuotes(Splitter.on(Patterns.COMMAND_SEPARATOR).omitEmptyStrings().splitToList(Joiner.on(' ').join(args))),
                 Callback.empty()
@@ -54,6 +54,6 @@ class BungeeCommand extends Command implements TabExecutor {
 
     @Override
     public Iterable<String> onTabComplete(CommandSender sender, String[] args) {
-        return manager.onTabComplete(BungeeSenderFactory.get().wrap(sender), Arrays.asList(args));
+        return manager.onTabComplete(BungeeSenderFactory.get(manager.getPlugin()).wrap(sender), Arrays.asList(args));
     }
 }

bungee/src/main/java/me/lucko/luckperms/BungeeConfig.java

@@ -22,7 +22,7 @@
 
 package me.lucko.luckperms;
 
-import me.lucko.luckperms.core.LPConfiguration;
+import me.lucko.luckperms.config.AbstractConfiguration;
 import net.md_5.bungee.config.Configuration;
 import net.md_5.bungee.config.ConfigurationProvider;
 import net.md_5.bungee.config.YamlConfiguration;
@@ -31,8 +31,10 @@ import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.file.Files;
+import java.util.HashMap;
+import java.util.Map;
 
-class BungeeConfig extends LPConfiguration<LPBungeePlugin> {
+class BungeeConfig extends AbstractConfiguration<LPBungeePlugin> {
     private Configuration configuration;
 
     BungeeConfig(LPBungeePlugin plugin) {
@@ -62,11 +64,6 @@ class BungeeConfig extends LPConfiguration<LPBungeePlugin> {
         }
     }
 
-    @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);
@@ -81,4 +78,19 @@ class BungeeConfig extends LPConfiguration<LPBungeePlugin> {
     protected boolean getBoolean(String path, boolean def) {
         return configuration.getBoolean(path, def);
     }
+
+    @Override
+    protected Map<String, String> getMap(String path, Map<String, String> def) {
+        Map<String, String> map = new HashMap<>();
+        Configuration section = configuration.getSection(path);
+        if (section == null) {
+            return def;
+        }
+
+        for (String key : section.getKeys()) {
+            map.put(key, section.getString(key));
+        }
+
+        return map;
+    }
 }

bungee/src/main/java/me/lucko/luckperms/BungeeListener.java

@@ -29,7 +29,10 @@ import me.lucko.luckperms.utils.AbstractListener;
 import net.md_5.bungee.api.chat.TextComponent;
 import net.md_5.bungee.api.connection.PendingConnection;
 import net.md_5.bungee.api.connection.ProxiedPlayer;
-import net.md_5.bungee.api.event.*;
+import net.md_5.bungee.api.event.LoginEvent;
+import net.md_5.bungee.api.event.PermissionCheckEvent;
+import net.md_5.bungee.api.event.PlayerDisconnectEvent;
+import net.md_5.bungee.api.event.PostLoginEvent;
 import net.md_5.bungee.api.plugin.Listener;
 import net.md_5.bungee.event.EventHandler;
 
@@ -118,9 +121,4 @@ public class BungeeListener extends AbstractListener implements Listener {
         plugin.getPlayerCache().remove(plugin.getUuidCache().getUUID(e.getPlayer().getUniqueId()));
         onLeave(e.getPlayer().getUniqueId());
     }
-
-    @EventHandler
-    public void onPlayerServerSwitch(ServerSwitchEvent e) {
-        refreshPlayer(e.getPlayer().getUniqueId());
-    }
 }

bungee/src/main/java/me/lucko/luckperms/BungeePlayerCache.java

@@ -23,8 +23,8 @@
 package me.lucko.luckperms;
 
 import lombok.Getter;
-import me.lucko.luckperms.utils.PermissionCalculator;
-import me.lucko.luckperms.utils.PermissionProcessor;
+import me.lucko.luckperms.calculators.PermissionCalculator;
+import me.lucko.luckperms.calculators.PermissionProcessor;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -41,14 +41,14 @@ public class BungeePlayerCache {
     public BungeePlayerCache(LuckPermsPlugin plugin, String name) {
         List<PermissionProcessor> processors = new ArrayList<>(3);
         processors.add(new PermissionCalculator.MapProcessor(permissions));
-        if (plugin.getConfiguration().getApplyWildcards()) {
+        if (plugin.getConfiguration().isApplyingWildcards()) {
             processors.add(new PermissionCalculator.WildcardProcessor(permissions));
         }
-        if (plugin.getConfiguration().getApplyRegex()) {
+        if (plugin.getConfiguration().isApplyingRegex()) {
             processors.add(new PermissionCalculator.RegexProcessor(permissions));
         }
 
-        calculator = new PermissionCalculator(plugin, name, plugin.getConfiguration().getDebugPermissionChecks(), processors);
+        calculator = new PermissionCalculator(plugin, name, plugin.getConfiguration().isDebugPermissionChecks(), processors);
     }
 
     public void invalidateCache() {

bungee/src/main/java/me/lucko/luckperms/BungeeSenderFactory.java

@@ -22,8 +22,6 @@
 
 package me.lucko.luckperms;
 
-import lombok.AccessLevel;
-import lombok.NoArgsConstructor;
 import me.lucko.luckperms.commands.SenderFactory;
 import me.lucko.luckperms.constants.Constants;
 import net.md_5.bungee.api.CommandSender;
@@ -32,12 +30,16 @@ import net.md_5.bungee.api.connection.ProxiedPlayer;
 
 import java.util.UUID;
 
-@NoArgsConstructor(access = AccessLevel.PRIVATE)
 public class BungeeSenderFactory extends SenderFactory<CommandSender> {
     private static BungeeSenderFactory instance = null;
-    public static synchronized BungeeSenderFactory get() {
+
+    private BungeeSenderFactory(LuckPermsPlugin plugin) {
+        super(plugin);
+    }
+
+    public static synchronized BungeeSenderFactory get(LuckPermsPlugin plugin) {
         if (instance == null) {
-            instance = new BungeeSenderFactory();
+            instance = new BungeeSenderFactory(plugin);
         }
         return instance;
     }

bungee/src/main/java/me/lucko/luckperms/LPBungeePlugin.java

@@ -29,9 +29,12 @@ import me.lucko.luckperms.api.implementation.ApiProvider;
 import me.lucko.luckperms.commands.CommandManager;
 import me.lucko.luckperms.commands.ConsecutiveExecutor;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.config.LPConfiguration;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.core.LPConfiguration;
+import me.lucko.luckperms.contexts.BackendServerCalculator;
+import me.lucko.luckperms.contexts.ContextManager;
+import me.lucko.luckperms.contexts.ServerCalculator;
 import me.lucko.luckperms.core.UuidCache;
 import me.lucko.luckperms.data.Importer;
 import me.lucko.luckperms.groups.GroupManager;
@@ -41,7 +44,7 @@ import me.lucko.luckperms.storage.Datastore;
 import me.lucko.luckperms.storage.StorageFactory;
 import me.lucko.luckperms.tracks.TrackManager;
 import me.lucko.luckperms.users.BungeeUserManager;
-import me.lucko.luckperms.users.UserManager;
+import me.lucko.luckperms.utils.LocaleManager;
 import me.lucko.luckperms.utils.LogFactory;
 import net.md_5.bungee.api.connection.ProxiedPlayer;
 import net.md_5.bungee.api.plugin.Plugin;
@@ -57,7 +60,7 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
     private final Map<UUID, BungeePlayerCache> playerCache = new ConcurrentHashMap<>();
     private final Set<UUID> ignoringLogs = ConcurrentHashMap.newKeySet();
     private LPConfiguration configuration;
-    private UserManager userManager;
+    private BungeeUserManager userManager;
     private GroupManager groupManager;
     private TrackManager trackManager;
     private Datastore datastore;
@@ -66,6 +69,8 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
     private Logger log;
     private Importer importer;
     private ConsecutiveExecutor consecutiveExecutor;
+    private LocaleManager localeManager;
+    private ContextManager<ProxiedPlayer> contextManager;
 
     @Override
     public void onEnable() {
@@ -74,6 +79,17 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
         getLog().info("Loading configuration...");
         configuration = new BungeeConfig(this);
 
+        localeManager = new LocaleManager();
+        File locale = new File(getDataFolder(), "lang.yml");
+        if (locale.exists()) {
+            getLog().info("Found locale file. Attempting to load from it.");
+            try {
+                localeManager.loadFromFile(locale);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+
         // register events
         getProxy().getPluginManager().registerListener(this, new BungeeListener(this));
 
@@ -88,20 +104,27 @@ public class LPBungeePlugin extends Plugin 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 BungeeUserManager(this);
         groupManager = new GroupManager(this);
         trackManager = new TrackManager();
         importer = new Importer(commandManager);
         consecutiveExecutor = new ConsecutiveExecutor(commandManager);
 
+        contextManager = new ContextManager<>();
+        BackendServerCalculator serverCalculator = new BackendServerCalculator();
+        getProxy().getPluginManager().registerListener(this, serverCalculator);
+        contextManager.registerCalculator(serverCalculator);
+        contextManager.registerCalculator(new ServerCalculator<>(getConfiguration().getServer()));
+        contextManager.registerListener(userManager);
+
         int mins = getConfiguration().getSyncTime();
         if (mins > 0) {
             getProxy().getScheduler().schedule(this, new UpdateTask(this), mins, mins, TimeUnit.MINUTES);
         }
 
         // 20 times per second (once per "tick")
-        getProxy().getScheduler().schedule(this, BungeeSenderFactory.get(), 50L, 50L, TimeUnit.MILLISECONDS);
+        getProxy().getScheduler().schedule(this, BungeeSenderFactory.get(this), 50L, 50L, TimeUnit.MILLISECONDS);
         getProxy().getScheduler().schedule(this, new ExpireTemporaryTask(this), 3L, 3L, TimeUnit.SECONDS);
         getProxy().getScheduler().schedule(this, consecutiveExecutor, 1L, 1L, TimeUnit.SECONDS);
 
@@ -162,14 +185,14 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
     @Override
     public List<Sender> getNotifyListeners() {
         return getProxy().getPlayers().stream()
-                .map(p -> BungeeSenderFactory.get().wrap(p, Collections.singleton(Permission.LOG_NOTIFY)))
+                .map(p -> BungeeSenderFactory.get(this).wrap(p, Collections.singleton(Permission.LOG_NOTIFY)))
                 .filter(Permission.LOG_NOTIFY::isAuthorized)
                 .collect(Collectors.toList());
     }
 
     @Override
     public Sender getConsoleSender() {
-        return BungeeSenderFactory.get().wrap(getProxy().getConsole());
+        return BungeeSenderFactory.get(this).wrap(getProxy().getConsole());
     }
 
     @Override

bungee/src/main/java/me/lucko/luckperms/contexts/BackendServerCalculator.java

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.contexts;
+
+import com.google.common.collect.Maps;
+import me.lucko.luckperms.api.context.ContextCalculator;
+import net.md_5.bungee.api.connection.ProxiedPlayer;
+import net.md_5.bungee.api.event.ServerSwitchEvent;
+import net.md_5.bungee.api.plugin.Listener;
+import net.md_5.bungee.event.EventHandler;
+
+import java.util.Map;
+
+public class BackendServerCalculator extends ContextCalculator<ProxiedPlayer> implements Listener {
+    private static final String WORLD_KEY = "world";
+
+    @Override
+    public Map<String, String> giveApplicableContext(ProxiedPlayer subject, Map<String, String> accumulator) {
+        String server = getServer(subject);
+
+        if (server != null) {
+            accumulator.put(WORLD_KEY, server);
+        }
+
+        return accumulator;
+    }
+
+    @Override
+    public boolean isContextApplicable(ProxiedPlayer subject, Map.Entry<String, String> context) {
+        if (!context.getKey().equals(WORLD_KEY)) {
+            return false;
+        }
+
+        String server = getServer(subject);
+        return server != null && server.equals(context.getValue());
+    }
+
+    @EventHandler
+    public void onPlayerServerSwitch(ServerSwitchEvent e) {
+        pushUpdate(e.getPlayer(), Maps.immutableEntry("null", "null"), Maps.immutableEntry(WORLD_KEY, getServer(e.getPlayer())));
+    }
+
+    private static String getServer(ProxiedPlayer player) {
+        return player.getServer() == null ? null : (player.getServer().getInfo() == null ? null : player.getServer().getInfo().getName());
+    }
+}

bungee/src/main/java/me/lucko/luckperms/users/BungeeUser.java

@@ -26,10 +26,11 @@ import me.lucko.luckperms.BungeePlayerCache;
 import me.lucko.luckperms.LPBungeePlugin;
 import me.lucko.luckperms.api.event.events.UserPermissionRefreshEvent;
 import me.lucko.luckperms.api.implementation.internal.UserLink;
-import me.lucko.luckperms.utils.Contexts;
+import me.lucko.luckperms.contexts.Contexts;
 import net.md_5.bungee.api.connection.ProxiedPlayer;
 
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.UUID;
 
@@ -58,19 +59,15 @@ public class BungeeUser extends User {
             return;
         }
 
-        final String server = player.getServer() == null ? null : (player.getServer().getInfo() == null ? null : player.getServer().getInfo().getName());
-
         // Calculate the permissions that should be applied. This is done async.
         Map<String, Boolean> toApply = exportNodes(
                 new Contexts(
-                        plugin.getConfiguration().getServer(),
-                        server,
-                        null,
-                        plugin.getConfiguration().getIncludeGlobalPerms(),
-                        plugin.getConfiguration().getIncludeGlobalWorldPerms(),
+                        plugin.getContextManager().giveApplicableContext(player, new HashMap<>()),
+                        plugin.getConfiguration().isIncludingGlobalPerms(),
+                        plugin.getConfiguration().isIncludingGlobalWorldPerms(),
                         true,
-                        plugin.getConfiguration().getApplyGlobalGroups(),
-                        plugin.getConfiguration().getApplyGlobalWorldGroups()
+                        plugin.getConfiguration().isApplyingGlobalGroups(),
+                        plugin.getConfiguration().isApplyingGlobalWorldGroups()
                 ),
                 Collections.emptyList()
         );

bungee/src/main/java/me/lucko/luckperms/users/BungeeUserManager.java

@@ -23,10 +23,13 @@
 package me.lucko.luckperms.users;
 
 import me.lucko.luckperms.LPBungeePlugin;
+import me.lucko.luckperms.api.context.ContextListener;
+import net.md_5.bungee.api.connection.ProxiedPlayer;
 
+import java.util.Map;
 import java.util.UUID;
 
-public class BungeeUserManager extends UserManager {
+public class BungeeUserManager extends UserManager implements ContextListener<ProxiedPlayer> {
     private final LPBungeePlugin plugin;
 
     public BungeeUserManager(LPBungeePlugin plugin) {
@@ -57,4 +60,14 @@ public class BungeeUserManager extends UserManager {
                 .map(p -> plugin.getUuidCache().getUUID(p.getUniqueId()))
                 .forEach(u -> plugin.getDatastore().loadUser(u, "null"));
     }
+
+    @Override
+    public void onContextChange(ProxiedPlayer subject, Map.Entry<String, String> before, Map.Entry<String, String> current) throws Exception {
+        UUID internal = plugin.getUuidCache().getUUID(subject.getUniqueId());
+
+        User user = get(internal);
+        if (user != null) {
+            plugin.doAsync(user::refreshPermissions);
+        }
+    }
 }

bungee/src/main/resources/config.yml

@@ -59,14 +59,24 @@ log-notify: true
 # If LuckPerms should print to console every time a plugin checks if a player has a permission
 debug-permission-checks: false
 
+# 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.
+# Remember world names on BungeeCord relate to the backend server name a user is connected to.
+world-rewrite:
+  #hub2: hub
+  #hub3: hub
+  #opfactions: factions
+
+# 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
 storage-method: h2
 
 # This block enables support for split datastores.
-# Only touch this if you're sure that you know what you're doing.
-# I (the author) do not endorse nor recommend the use of this feature.
 split-storage:
   enabled: false
   methods:

common/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>luckperms</artifactId>
         <groupId>me.lucko.luckperms</groupId>
-        <version>2.9-SNAPSHOT</version>
+        <version>2.10-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

common/src/main/java/me/lucko/luckperms/LuckPermsPlugin.java

@@ -27,14 +27,16 @@ import me.lucko.luckperms.api.PlatformType;
 import me.lucko.luckperms.api.implementation.ApiProvider;
 import me.lucko.luckperms.commands.ConsecutiveExecutor;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.config.LPConfiguration;
 import me.lucko.luckperms.constants.Message;
-import me.lucko.luckperms.core.LPConfiguration;
+import me.lucko.luckperms.contexts.ContextManager;
 import me.lucko.luckperms.core.UuidCache;
 import me.lucko.luckperms.data.Importer;
 import me.lucko.luckperms.groups.GroupManager;
 import me.lucko.luckperms.storage.Datastore;
 import me.lucko.luckperms.tracks.TrackManager;
 import me.lucko.luckperms.users.UserManager;
+import me.lucko.luckperms.utils.LocaleManager;
 
 import java.io.File;
 import java.util.List;
@@ -60,6 +62,8 @@ public interface LuckPermsPlugin {
     ApiProvider getApiProvider();
     Importer getImporter();
     ConsecutiveExecutor getConsecutiveExecutor();
+    LocaleManager getLocaleManager();
+    ContextManager getContextManager();
 
     /**
      * @return the version of the plugin

common/src/main/java/me/lucko/luckperms/api/implementation/ApiProvider.java

@@ -27,6 +27,8 @@ import lombok.AllArgsConstructor;
 import lombok.NonNull;
 import me.lucko.luckperms.LuckPermsPlugin;
 import me.lucko.luckperms.api.*;
+import me.lucko.luckperms.api.context.ContextListener;
+import me.lucko.luckperms.api.context.IContextCalculator;
 import me.lucko.luckperms.api.event.LPEvent;
 import me.lucko.luckperms.api.event.LPListener;
 import me.lucko.luckperms.api.implementation.internal.*;
@@ -67,7 +69,7 @@ public class ApiProvider implements LuckPermsApi {
 
     @Override
     public double getApiVersion() {
-        return 2.9;
+        return 2.10;
     }
 
     @Override
@@ -208,6 +210,18 @@ public class ApiProvider implements LuckPermsApi {
 
     @Override
     public Node.Builder buildNode(@NonNull String permission) throws IllegalArgumentException {
-        return new me.lucko.luckperms.utils.Node.Builder(checkNode(permission));
+        return new me.lucko.luckperms.core.Node.Builder(checkNode(permission));
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public void registerContextCalculator(IContextCalculator<?> contextCalculator) {
+        plugin.getContextManager().registerCalculator(contextCalculator);
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public void registerContextListener(ContextListener<?> contextListener) {
+        plugin.getContextManager().registerListener(contextListener);
     }
 }

common/src/main/java/me/lucko/luckperms/api/implementation/internal/LPConfigurationLink.java

@@ -30,11 +30,11 @@ import me.lucko.luckperms.api.data.MySQLConfiguration;
 import java.util.Map;
 
 /**
- * Provides a link between {@link LPConfiguration} and {@link me.lucko.luckperms.core.LPConfiguration}
+ * Provides a link between {@link LPConfiguration} and {@link me.lucko.luckperms.config.LPConfiguration}
  */
 @AllArgsConstructor
 public class LPConfigurationLink implements LPConfiguration {
-    private final me.lucko.luckperms.core.LPConfiguration master;
+    private final me.lucko.luckperms.config.LPConfiguration master;
 
     @Override
     public String getServer() {
@@ -58,67 +58,67 @@ public class LPConfigurationLink implements LPConfiguration {
 
     @Override
     public boolean getIncludeGlobalPerms() {
-        return master.getIncludeGlobalPerms();
+        return master.isIncludingGlobalPerms();
     }
 
     @Override
     public boolean getIncludeGlobalWorldPerms() {
-        return master.getIncludeGlobalWorldPerms();
+        return master.isIncludingGlobalWorldPerms();
     }
 
     @Override
     public boolean getApplyGlobalGroups() {
-        return master.getApplyGlobalGroups();
+        return master.isApplyingGlobalGroups();
     }
 
     @Override
     public boolean getApplyGlobalWorldGroups() {
-        return master.getApplyGlobalWorldGroups();
+        return master.isApplyingGlobalWorldGroups();
     }
 
     @Override
     public boolean getOnlineMode() {
-        return master.getOnlineMode();
+        return master.isOnlineMode();
     }
 
     @Override
     public boolean getApplyWildcards() {
-        return master.getApplyWildcards();
+        return master.isApplyingWildcards();
     }
 
     @Override
     public boolean getApplyRegex() {
-        return master.getApplyRegex();
+        return master.isApplyingRegex();
     }
 
     @Override
     public boolean getApplyShorthand() {
-        return master.getApplyShorthand();
+        return master.isApplyingShorthand();
     }
 
     @Override
     public boolean getLogNotify() {
-        return master.getLogNotify();
+        return master.isLogNotify();
     }
 
     @Override
     public boolean getDebugPermissionChecks() {
-        return master.getDebugPermissionChecks();
+        return master.isDebugPermissionChecks();
     }
 
     @Override
     public boolean getEnableOps() {
-        return master.getEnableOps();
+        return master.isOpsEnabled();
     }
 
     @Override
     public boolean getCommandsAllowOp() {
-        return master.getCommandsAllowOp();
+        return master.isCommandsAllowOp();
     }
 
     @Override
     public boolean getAutoOp() {
-        return master.getAutoOp();
+        return master.isAutoOp();
     }
 
     @Override
@@ -128,7 +128,7 @@ public class LPConfigurationLink implements LPConfiguration {
 
     @Override
     public boolean getVaultIncludeGlobal() {
-        return master.getVaultIncludeGlobal();
+        return master.isVaultIncludingGlobal();
     }
 
     @SuppressWarnings("deprecation")
@@ -149,10 +149,9 @@ public class LPConfigurationLink implements LPConfiguration {
 
     @Override
     public boolean getSplitStorage() {
-        return master.getSplitStorage();
+        return master.isSplitStorage();
     }
 
-    @SuppressWarnings("unchecked")
     @Override
     public Map<String, String> getSplitStorageOptions() {
         return master.getSplitStorageOptions();

common/src/main/java/me/lucko/luckperms/api/implementation/internal/PermissionHolderLink.java

@@ -27,9 +27,9 @@ import lombok.NonNull;
 import me.lucko.luckperms.api.Node;
 import me.lucko.luckperms.api.PermissionHolder;
 import me.lucko.luckperms.api.Tristate;
+import me.lucko.luckperms.contexts.Contexts;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
-import me.lucko.luckperms.utils.Contexts;
 
 import java.util.*;
 
@@ -253,7 +253,16 @@ public class PermissionHolderLink implements PermissionHolder {
 
     @Override
     public Map<String, Boolean> getPermissions(String server, String world, Map<String, String> extraContext, boolean includeGlobal, List<String> possibleNodes, boolean applyGroups) {
-        return master.exportNodes(new Contexts(server, world, extraContext, includeGlobal, includeGlobal, applyGroups, true, true), possibleNodes);
+        if (extraContext == null) {
+            extraContext = new HashMap<>();
+        }
+        if (server != null && !server.equals("")) {
+            extraContext.put("server", server);
+        }
+        if (world != null && !world.equals("")) {
+            extraContext.put("world", world);
+        }
+        return master.exportNodes(new Contexts(extraContext, includeGlobal, includeGlobal, applyGroups, true, true), possibleNodes);
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/calculators/PermissionCalculator.java

@@ -20,7 +20,7 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.utils;
+package me.lucko.luckperms.calculators;
 
 import lombok.AllArgsConstructor;
 import lombok.Getter;

common/src/main/java/me/lucko/luckperms/calculators/PermissionProcessor.java

@@ -20,7 +20,7 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.utils;
+package me.lucko.luckperms.calculators;
 
 import me.lucko.luckperms.api.Tristate;
 

common/src/main/java/me/lucko/luckperms/commands/CommandManager.java

@@ -39,7 +39,6 @@ import me.lucko.luckperms.commands.track.DeleteTrack;
 import me.lucko.luckperms.commands.track.ListTracks;
 import me.lucko.luckperms.commands.track.TrackMainCommand;
 import me.lucko.luckperms.commands.user.UserMainCommand;
-import me.lucko.luckperms.constants.Message;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -49,6 +48,7 @@ import java.util.stream.Collectors;
 
 @AllArgsConstructor
 public class CommandManager {
+    @Getter
     private final LuckPermsPlugin plugin;
 
     @Getter
@@ -177,8 +177,7 @@ public class CommandManager {
     }
 
     private void sendCommandUsage(Sender sender, String label) {
-        Message.INFO_BRIEF.send(sender, plugin.getVersion());
-
+        Util.sendPluginMessage(sender, "&6Running &bLuckPerms v" + plugin.getVersion() + "&6.");
         mainCommands.stream()
                 .filter(c -> c.isAuthorized(sender))
                 .forEach(c -> Util.sendPluginMessage(sender, "&e-> &d" + String.format(c.getUsage(), label)));

common/src/main/java/me/lucko/luckperms/commands/MainCommand.java

@@ -98,7 +98,7 @@ public abstract class MainCommand<T> {
         }
 
         if (sub.getIsArgumentInvalid().test(strippedArgs.size())) {
-            sub.sendUsage(sender, label);
+            sub.sendUsage(sender);
             return CommandResult.INVALID_ARGS;
         }
 
@@ -146,10 +146,10 @@ public abstract class MainCommand<T> {
                 .collect(Collectors.toList());
 
         if (subs.size() > 0) {
-            Util.sendPluginMessage(sender, "&e" + getName() + " Sub Commands:");
+            Util.sendPluginMessage(sender, "&e" + getName() + " Sub Commands: &7(" + String.format(getUsage(), label) + " ...)");
 
             for (SubCommand s : subs) {
-                s.sendUsage(sender, label);
+                s.sendUsage(sender);
             }
 
         } else {

common/src/main/java/me/lucko/luckperms/commands/Sender.java

@@ -22,6 +22,7 @@
 
 package me.lucko.luckperms.commands;
 
+import me.lucko.luckperms.LuckPermsPlugin;
 import me.lucko.luckperms.constants.Permission;
 
 import java.util.UUID;
@@ -31,6 +32,7 @@ import java.util.UUID;
  */
 public interface Sender {
 
+    LuckPermsPlugin getPlatform();
     String getName();
     UUID getUuid();
     void sendMessage(String s);

common/src/main/java/me/lucko/luckperms/commands/SenderFactory.java

@@ -24,6 +24,8 @@ package me.lucko.luckperms.commands;
 
 import com.google.common.collect.ImmutableMap;
 import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import me.lucko.luckperms.LuckPermsPlugin;
 import me.lucko.luckperms.constants.Constants;
 import me.lucko.luckperms.constants.Permission;
 
@@ -36,7 +38,9 @@ import java.util.stream.Collectors;
  * Factory class to make a thread-safe sender instance
  * @param <T> the command sender type
  */
+@RequiredArgsConstructor
 public abstract class SenderFactory<T> implements Runnable {
+    private final LuckPermsPlugin plugin;
     private final Map<T, List<String>> messages = new HashMap<>();
     private final AtomicBoolean shouldSend = new AtomicBoolean(false);
     private final SenderFactory<T> factory = this;
@@ -47,11 +51,11 @@ public abstract class SenderFactory<T> implements Runnable {
     protected abstract boolean hasPermission(T t, String node);
 
     public final Sender wrap(T t) {
-        return new SenderImp(t, null);
+        return new SenderImp(plugin, t, null);
     }
 
     public final Sender wrap(T t, Set<Permission> toCheck) {
-        return new SenderImp(t, toCheck);
+        return new SenderImp(plugin, t, toCheck);
     }
 
     @Override
@@ -85,7 +89,11 @@ public abstract class SenderFactory<T> implements Runnable {
 
         private final boolean console;
 
-        private SenderImp(T t, Set<Permission> toCheck) {
+        @Getter
+        private final LuckPermsPlugin platform;
+
+        private SenderImp(LuckPermsPlugin platform, T t, Set<Permission> toCheck) {
+            this.platform = platform;
             this.tRef = new WeakReference<>(t);
             this.name = factory.getName(t);
             this.uuid = factory.getUuid(t);

common/src/main/java/me/lucko/luckperms/commands/SubCommand.java

@@ -22,7 +22,6 @@
 
 package me.lucko.luckperms.commands;
 
-import lombok.AllArgsConstructor;
 import lombok.Getter;
 import me.lucko.luckperms.LuckPermsPlugin;
 import me.lucko.luckperms.constants.Message;
@@ -42,7 +41,6 @@ import java.util.stream.Collectors;
  * Abstract SubCommand class
  */
 @Getter
-@AllArgsConstructor
 public abstract class SubCommand<T> {
 
     /**
@@ -70,6 +68,14 @@ public abstract class SubCommand<T> {
      */
     private final Predicate<? super Integer> isArgumentInvalid;
 
+    public SubCommand(String name, String description, String usage, Permission permission, Predicate<? super Integer> isArgumentInvalid) {
+        this.name = name;
+        this.description = description;
+        this.permission = permission;
+        this.isArgumentInvalid = isArgumentInvalid;
+        this.usage = usage.replace("<", "&8<&7").replace(">", "&8>&7").replace("[", "&8[&7").replace("]", "&8]&7");
+    }
+
     /**
      * Called when this sub command is ran
      * @param plugin a link to the main plugin instance
@@ -95,10 +101,9 @@ public abstract class SubCommand<T> {
     /**
      * Send the command usage to a sender
      * @param sender the sender to send the usage to
-     * @param label the command label used
      */
-    public void sendUsage(Sender sender, String label) {
-        Util.sendPluginMessage(sender, "&e-> &d" + String.format(getUsage(), label));
+    public void sendUsage(Sender sender) {
+        Util.sendPluginMessage(sender, "&e-> &6" + getName() + (usage.isEmpty() ? "" : "&e - &7" + getUsage()));
     }
 
     /**

common/src/main/java/me/lucko/luckperms/commands/Util.java

@@ -181,6 +181,64 @@ public class Util {
         return sb.toString();
     }
 
+    public static String permGroupsToString(SortedSet<Node> nodes) {
+        StringBuilder sb = new StringBuilder();
+        for (Node node : nodes) {
+            if (!node.isGroupNode()) {
+                continue;
+            }
+
+            if (node.isTemporary()) {
+                continue;
+            }
+
+            sb.append("&a-> &b").append(node.getGroupName());
+            if (node.isServerSpecific()) {
+                sb.append(" &7(&f").append(node.getServer().get()).append("&7)");
+            }
+            if (node.isWorldSpecific()) {
+                sb.append(" &7(&f").append(node.getWorld().get()).append("&7)");
+            }
+            sb.append("\n");
+        }
+
+        if (sb.length() == 0) {
+            return "&6None";
+        }
+
+        return sb.toString();
+    }
+
+    public static String tempGroupsToString(SortedSet<Node> nodes) {
+        StringBuilder sb = new StringBuilder();
+
+        for (Node node : nodes) {
+            if (!node.isGroupNode()) {
+                continue;
+            }
+
+            if (!node.isTemporary()) {
+                continue;
+            }
+
+            sb.append("&a-> &b").append(node.getGroupName());
+            if (node.isServerSpecific()) {
+                sb.append(" &7(&f").append(node.getServer().get()).append("&7)");
+            }
+            if (node.isWorldSpecific()) {
+                sb.append(" &7(&f").append(node.getWorld().get()).append("&7)");
+            }
+
+            sb.append("&6 - expires in ").append(DateUtil.formatDateDiff(node.getExpiryUnixTime())).append("\n");
+        }
+
+        if (sb.length() == 0) {
+            return "&6None";
+        }
+
+        return sb.toString();
+    }
+
     public static UUID parseUuid(String s) {
         try {
             return UUID.fromString(s);

common/src/main/java/me/lucko/luckperms/commands/group/DeleteGroup.java

@@ -71,7 +71,7 @@ public class DeleteGroup extends SingleMainCommand {
             return CommandResult.FAILURE;
         }
 
-        Message.DELETE_SUCCESS.send(sender, groupName);
+        Message.DELETE_SUCCESS.send(sender, group.getDisplayName());
         LogEntry.build().actor(sender).actedName(groupName).type('G').action("delete").build().submit(plugin, sender);
         plugin.runUpdateTask();
         return CommandResult.SUCCESS;

common/src/main/java/me/lucko/luckperms/commands/group/GroupMainCommand.java

@@ -39,6 +39,7 @@ public class GroupMainCommand extends MainCommand<Group> {
         super("Group", "/%s group <group>", 2, ImmutableList.<SubCommand<Group>>builder()
             .add(new GroupInfo())
             .add(new GroupListNodes())
+            .add(new GroupListParents())
             .add(new GroupHasPerm())
             .add(new GroupInheritsPerm())
             .add(new GroupSetPermission())
@@ -59,6 +60,7 @@ public class GroupMainCommand extends MainCommand<Group> {
             .add(new GroupAddTempSuffix())
             .add(new GroupRemoveTempPrefix())
             .add(new GroupRemoveTempSuffix())
+            .add(new GroupBulkChange())
             .add(new GroupClear())
             .add(new GroupRename())
             .build()

common/src/main/java/me/lucko/luckperms/commands/group/ListGroups.java

@@ -29,9 +29,11 @@ import me.lucko.luckperms.commands.SingleMainCommand;
 import me.lucko.luckperms.commands.Util;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.groups.Group;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.stream.Collectors;
 
 public class ListGroups extends SingleMainCommand {
     public ListGroups() {
@@ -45,7 +47,13 @@ public class ListGroups extends SingleMainCommand {
             return CommandResult.LOADING_ERROR;
         }
 
-        Message.GROUPS_LIST.send(sender, Util.listToCommaSep(new ArrayList<>(plugin.getGroupManager().getAll().keySet())));
+        Message.GROUPS_LIST.send(
+                sender,
+                Util.listToCommaSep(new ArrayList<>(plugin.getGroupManager().getAll().values().stream()
+                        .map(Group::getDisplayName)
+                        .collect(Collectors.toList()))
+                )
+        );
         return CommandResult.SUCCESS;
     }
 }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupAddPrefix.java

@@ -38,7 +38,7 @@ import java.util.List;
 
 public class GroupAddPrefix extends SubCommand<Group> {
     public GroupAddPrefix() {
-        super("addprefix", "Adds a prefix to the group", "/%s group <group> addprefix <priority> <prefix> [server] [world]",
+        super("addprefix", "Adds a prefix to the group", "<priority> <prefix> [server] [world]",
                 Permission.GROUP_ADDPREFIX, Predicate.notInRange(2, 4));
     }
 
@@ -65,14 +65,14 @@ public class GroupAddPrefix extends SubCommand<Group> {
 
                 if (args.size() == 3) {
                     group.setPermission(node, true, server);
-                    Message.ADDPREFIX_SERVER_SUCCESS.send(sender, group.getName(), prefix, priority, server);
+                    Message.ADDPREFIX_SERVER_SUCCESS.send(sender, group.getDisplayName(), prefix, priority, server);
                     LogEntry.build().actor(sender).acted(group)
                             .action("addprefix " + priority + " " + args.get(1) + " " + server)
                             .build().submit(plugin, sender);
                 } else {
                     final String world = args.get(3).toLowerCase();
                     group.setPermission(node, true, server, world);
-                    Message.ADDPREFIX_SERVER_WORLD_SUCCESS.send(sender, group.getName(), prefix, priority, server, world);
+                    Message.ADDPREFIX_SERVER_WORLD_SUCCESS.send(sender, group.getDisplayName(), prefix, priority, server, world);
                     LogEntry.build().actor(sender).acted(group)
                             .action("addprefix " + priority + " " + args.get(1) + " " + server + " " + world)
                             .build().submit(plugin, sender);
@@ -80,7 +80,7 @@ public class GroupAddPrefix extends SubCommand<Group> {
 
             } else {
                 group.setPermission(node, true);
-                Message.ADDPREFIX_SUCCESS.send(sender, group.getName(), prefix, priority);
+                Message.ADDPREFIX_SUCCESS.send(sender, group.getDisplayName(), prefix, priority);
                 LogEntry.build().actor(sender).acted(group)
                         .action("addprefix " + priority + " " + args.get(1))
                         .build().submit(plugin, sender);
@@ -89,7 +89,7 @@ public class GroupAddPrefix extends SubCommand<Group> {
             save(group, sender, plugin);
             return CommandResult.SUCCESS;
         } catch (ObjectAlreadyHasException e) {
-            Message.ALREADY_HAS_PREFIX.send(sender, group.getName());
+            Message.ALREADY_HAS_PREFIX.send(sender, group.getDisplayName());
             return CommandResult.STATE_ERROR;
         }
     }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupAddSuffix.java

@@ -38,7 +38,7 @@ import java.util.List;
 
 public class GroupAddSuffix extends SubCommand<Group> {
     public GroupAddSuffix() {
-        super("addsuffix", "Adds a suffix to the group", "/%s group <group> addsuffix <priority> <suffix> [server] [world]",
+        super("addsuffix", "Adds a suffix to the group", "<priority> <suffix> [server] [world]",
                 Permission.GROUP_ADDSUFFIX, Predicate.notInRange(2, 4));
     }
 
@@ -65,14 +65,14 @@ public class GroupAddSuffix extends SubCommand<Group> {
 
                 if (args.size() == 3) {
                     group.setPermission(node, true, server);
-                    Message.ADDSUFFIX_SERVER_SUCCESS.send(sender, group.getName(), suffix, priority, server);
+                    Message.ADDSUFFIX_SERVER_SUCCESS.send(sender, group.getDisplayName(), suffix, priority, server);
                     LogEntry.build().actor(sender).acted(group)
                             .action("addsuffix " + priority + " " + args.get(1) + " " + server)
                             .build().submit(plugin, sender);
                 } else {
                     final String world = args.get(3).toLowerCase();
                     group.setPermission(node, true, server, world);
-                    Message.ADDSUFFIX_SERVER_WORLD_SUCCESS.send(sender, group.getName(), suffix, priority, server, world);
+                    Message.ADDSUFFIX_SERVER_WORLD_SUCCESS.send(sender, group.getDisplayName(), suffix, priority, server, world);
                     LogEntry.build().actor(sender).acted(group)
                             .action("addsuffix " + priority + " " + args.get(1) + " " + server + " " + world)
                             .build().submit(plugin, sender);
@@ -80,7 +80,7 @@ public class GroupAddSuffix extends SubCommand<Group> {
 
             } else {
                 group.setPermission(node, true);
-                Message.ADDSUFFIX_SUCCESS.send(sender, group.getName(), suffix, priority);
+                Message.ADDSUFFIX_SUCCESS.send(sender, group.getDisplayName(), suffix, priority);
                 LogEntry.build().actor(sender).acted(group)
                         .action("addsuffix " + priority + " " + args.get(1))
                         .build().submit(plugin, sender);
@@ -89,7 +89,7 @@ public class GroupAddSuffix extends SubCommand<Group> {
             save(group, sender, plugin);
             return CommandResult.SUCCESS;
         } catch (ObjectAlreadyHasException e) {
-            Message.ALREADY_HAS_SUFFIX.send(sender, group.getName());
+            Message.ALREADY_HAS_SUFFIX.send(sender, group.getDisplayName());
             return CommandResult.STATE_ERROR;
         }
     }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupAddTempPrefix.java

@@ -39,7 +39,7 @@ import java.util.List;
 
 public class GroupAddTempPrefix extends SubCommand<Group> {
     public GroupAddTempPrefix() {
-        super("addtempprefix", "Adds a prefix to the group temporarily", "/%s group <group> addtempprefix <priority> <prefix> <duration> [server] [world]",
+        super("addtempprefix", "Adds a prefix to the group temporarily", "<priority> <prefix> <duration> [server] [world]",
                 Permission.GROUP_ADD_TEMP_PREFIX, Predicate.notInRange(3, 5));
     }
 
@@ -83,14 +83,14 @@ public class GroupAddTempPrefix extends SubCommand<Group> {
 
                 if (args.size() == 4) {
                     group.setPermission(node, true, server, duration);
-                    Message.ADD_TEMP_PREFIX_SERVER_SUCCESS.send(sender, group.getName(), prefix, priority, server, DateUtil.formatDateDiff(duration));
+                    Message.ADD_TEMP_PREFIX_SERVER_SUCCESS.send(sender, group.getDisplayName(), prefix, priority, server, DateUtil.formatDateDiff(duration));
                     LogEntry.build().actor(sender).acted(group)
                             .action("addtempprefix " + priority + " " + args.get(1) + " " + duration + " " + server)
                             .build().submit(plugin, sender);
                 } else {
                     final String world = args.get(4).toLowerCase();
                     group.setPermission(node, true, server, world, duration);
-                    Message.ADD_TEMP_PREFIX_SERVER_WORLD_SUCCESS.send(sender, group.getName(), prefix, priority, server, world, DateUtil.formatDateDiff(duration));
+                    Message.ADD_TEMP_PREFIX_SERVER_WORLD_SUCCESS.send(sender, group.getDisplayName(), prefix, priority, server, world, DateUtil.formatDateDiff(duration));
                     LogEntry.build().actor(sender).acted(group)
                             .action("addtempprefix " + priority + " " + args.get(1) + " " + duration + " " + server + " " + world)
                             .build().submit(plugin, sender);
@@ -98,7 +98,7 @@ public class GroupAddTempPrefix extends SubCommand<Group> {
 
             } else {
                 group.setPermission(node, true, duration);
-                Message.ADD_TEMP_PREFIX_SUCCESS.send(sender, group.getName(), prefix, priority, DateUtil.formatDateDiff(duration));
+                Message.ADD_TEMP_PREFIX_SUCCESS.send(sender, group.getDisplayName(), prefix, priority, DateUtil.formatDateDiff(duration));
                 LogEntry.build().actor(sender).acted(group)
                         .action("addtempprefix " + priority + " " + args.get(1) + " " + duration)
                         .build().submit(plugin, sender);
@@ -107,7 +107,7 @@ public class GroupAddTempPrefix extends SubCommand<Group> {
             save(group, sender, plugin);
             return CommandResult.SUCCESS;
         } catch (ObjectAlreadyHasException e) {
-            Message.ALREADY_HAS_PREFIX.send(sender, group.getName());
+            Message.ALREADY_HAS_PREFIX.send(sender, group.getDisplayName());
             return CommandResult.STATE_ERROR;
         }
     }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupAddTempSuffix.java

@@ -39,7 +39,7 @@ import java.util.List;
 
 public class GroupAddTempSuffix extends SubCommand<Group> {
     public GroupAddTempSuffix() {
-        super("addtempsuffix", "Adds a suffix to the group temporarily", "/%s group <group> addtempsuffix <priority> <suffix> <duration> [server] [world]",
+        super("addtempsuffix", "Adds a suffix to the group temporarily", "<priority> <suffix> <duration> [server] [world]",
                 Permission.GROUP_ADD_TEMP_SUFFIX, Predicate.notInRange(3, 5));
     }
 
@@ -83,14 +83,14 @@ public class GroupAddTempSuffix extends SubCommand<Group> {
 
                 if (args.size() == 4) {
                     group.setPermission(node, true, server, duration);
-                    Message.ADD_TEMP_SUFFIX_SERVER_SUCCESS.send(sender, group.getName(), suffix, priority, server, DateUtil.formatDateDiff(duration));
+                    Message.ADD_TEMP_SUFFIX_SERVER_SUCCESS.send(sender, group.getDisplayName(), suffix, priority, server, DateUtil.formatDateDiff(duration));
                     LogEntry.build().actor(sender).acted(group)
                             .action("addtempsuffix " + priority + " " + args.get(1) + " " + duration + " " + server)
                             .build().submit(plugin, sender);
                 } else {
                     final String world = args.get(4).toLowerCase();
                     group.setPermission(node, true, server, world, duration);
-                    Message.ADD_TEMP_SUFFIX_SERVER_WORLD_SUCCESS.send(sender, group.getName(), suffix, priority, server, world, DateUtil.formatDateDiff(duration));
+                    Message.ADD_TEMP_SUFFIX_SERVER_WORLD_SUCCESS.send(sender, group.getDisplayName(), suffix, priority, server, world, DateUtil.formatDateDiff(duration));
                     LogEntry.build().actor(sender).acted(group)
                             .action("addtempsuffix " + priority + " " + args.get(1) + " " + duration + " " + server + " " + world)
                             .build().submit(plugin, sender);
@@ -98,7 +98,7 @@ public class GroupAddTempSuffix extends SubCommand<Group> {
 
             } else {
                 group.setPermission(node, true, duration);
-                Message.ADD_TEMP_SUFFIX_SUCCESS.send(sender, group.getName(), suffix, priority, DateUtil.formatDateDiff(duration));
+                Message.ADD_TEMP_SUFFIX_SUCCESS.send(sender, group.getDisplayName(), suffix, priority, DateUtil.formatDateDiff(duration));
                 LogEntry.build().actor(sender).acted(group)
                         .action("addtempsuffix " + priority + " " + args.get(1) + " " + duration)
                         .build().submit(plugin, sender);
@@ -107,7 +107,7 @@ public class GroupAddTempSuffix extends SubCommand<Group> {
             save(group, sender, plugin);
             return CommandResult.SUCCESS;
         } catch (ObjectAlreadyHasException e) {
-            Message.ALREADY_HAS_SUFFIX.send(sender, group.getName());
+            Message.ALREADY_HAS_SUFFIX.send(sender, group.getDisplayName());
             return CommandResult.STATE_ERROR;
         }
     }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupBulkChange.java

@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.commands.group.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.Node;
+import me.lucko.luckperms.commands.CommandResult;
+import me.lucko.luckperms.commands.Predicate;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.groups.Group;
+
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+
+public class GroupBulkChange extends SubCommand<Group> {
+    public GroupBulkChange() {
+        super("bulkchange", "Applies a bulk permission change to the groups permissions", "<server|world> <from> <to>",
+                Permission.GROUP_BULKCHANGE, Predicate.not(3));
+    }
+
+    @Override
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+        String type = args.get(0).toLowerCase();
+        String from = args.get(1);
+        String to = args.get(2);
+        if (to.equals("null")) {
+            to = null;
+        }
+
+        Set<Node> toAdd = new HashSet<>();
+
+        if (!type.equals("world") && !type.equals("server")) {
+            Message.BULK_CHANGE_TYPE_ERROR.send(sender);
+            return CommandResult.FAILURE;
+        }
+
+        Iterator<Node> iterator = group.getNodes().iterator();
+        if (type.equals("world")) {
+            while (iterator.hasNext()) {
+                Node element = iterator.next();
+                String world = element.getWorld().orElse("null");
+                if (!world.equals(from)) {
+                    continue;
+                }
+
+                iterator.remove();
+                toAdd.add(me.lucko.luckperms.core.Node.builderFromExisting(element).setWorld(to).build());
+            }
+        } else {
+            while (iterator.hasNext()) {
+                Node element = iterator.next();
+                String server = element.getServer().orElse("global");
+                if (!server.equals(from)) {
+                    continue;
+                }
+
+                iterator.remove();
+                toAdd.add(me.lucko.luckperms.core.Node.builderFromExisting(element).setServer(to).build());
+            }
+        }
+
+        group.getNodes().addAll(toAdd);
+        save(group, sender, plugin);
+        Message.BULK_CHANGE_SUCCESS.send(sender, toAdd.size());
+        return CommandResult.SUCCESS;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupChatMeta.java

@@ -27,15 +27,14 @@ import me.lucko.luckperms.api.Node;
 import me.lucko.luckperms.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.contexts.Contexts;
 import me.lucko.luckperms.groups.Group;
-import me.lucko.luckperms.utils.Contexts;
 
 import java.util.*;
 
 public class GroupChatMeta extends SubCommand<Group> {
     public GroupChatMeta() {
-        super("chatmeta", "Displays a groups chat meta", "/%s group <group> chatmeta", Permission.GROUP_CHATMETA,
-                Predicate.alwaysFalse());
+        super("chatmeta", "Displays a groups chat meta", "", Permission.GROUP_CHATMETA, Predicate.alwaysFalse());
     }
 
     @Override
@@ -68,18 +67,18 @@ public class GroupChatMeta extends SubCommand<Group> {
         }
 
         if (prefixes.isEmpty()) {
-            Message.CHAT_META_PREFIX_NONE.send(sender, group.getName());
+            Message.CHAT_META_PREFIX_NONE.send(sender, group.getDisplayName());
         } else {
-            Message.CHAT_META_PREFIX_HEADER.send(sender, group.getName());
+            Message.CHAT_META_PREFIX_HEADER.send(sender, group.getDisplayName());
             for (Map.Entry<Integer, String> e : prefixes) {
                 Message.CHAT_META_ENTRY.send(sender, e.getKey(), e.getValue());
             }
         }
 
         if (suffixes.isEmpty()) {
-            Message.CHAT_META_SUFFIX_NONE.send(sender, group.getName());
+            Message.CHAT_META_SUFFIX_NONE.send(sender, group.getDisplayName());
         } else {
-            Message.CHAT_META_SUFFIX_HEADER.send(sender, group.getName());
+            Message.CHAT_META_SUFFIX_HEADER.send(sender, group.getDisplayName());
             for (Map.Entry<Integer, String> e : suffixes) {
                 Message.CHAT_META_ENTRY.send(sender, e.getKey(), e.getValue());
             }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupClear.java

@@ -36,14 +36,13 @@ import java.util.List;
 
 public class GroupClear extends SubCommand<Group> {
     public GroupClear() {
-        super("clear", "Clears a groups permissions", "/%s group <group> clear", Permission.GROUP_CLEAR,
-                Predicate.alwaysFalse());
+        super("clear", "Clears a groups permissions", "", Permission.GROUP_CLEAR, Predicate.alwaysFalse());
     }
 
     @Override
     public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         group.clearNodes();
-        Message.CLEAR_SUCCESS.send(sender, group.getName());
+        Message.CLEAR_SUCCESS.send(sender, group.getDisplayName());
         LogEntry.build().actor(sender).acted(group).action("clear").build().submit(plugin, sender);
         save(group, sender, plugin);
         return CommandResult.SUCCESS;

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupHasPerm.java

@@ -33,9 +33,8 @@ import java.util.List;
 
 public class GroupHasPerm extends SubCommand<Group> {
     public GroupHasPerm() {
-        super("haspermission", "Checks to see if a group has a certain permission node",
-                "/%s group <group> haspermission <node> [server] [world]", Permission.GROUP_HASPERMISSION,
-                Predicate.notInRange(1, 3));
+        super("haspermission", "Checks to see if a group has a certain permission node", "<node> [server] [world]",
+                Permission.GROUP_HASPERMISSION, Predicate.notInRange(1, 3));
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupInfo.java

@@ -35,14 +35,13 @@ import java.util.List;
 
 public class GroupInfo extends SubCommand<Group> {
     public GroupInfo() {
-        super("info", "Gives info about the group", "/%s group <group> info", Permission.GROUP_INFO,
-                Predicate.alwaysFalse());
+        super("info", "Gives info about the group", "", Permission.GROUP_INFO, Predicate.alwaysFalse());
     }
 
     @Override
     public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         Message.GROUP_INFO.send(sender,
-                group.getName(),
+                group.getDisplayName(),
                 group.getPermanentNodes().size(),
                 group.getTemporaryNodes().size(),
                 label,

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupInheritsPerm.java

@@ -33,9 +33,8 @@ import java.util.List;
 
 public class GroupInheritsPerm extends SubCommand<Group> {
     public GroupInheritsPerm() {
-        super("inheritspermission", "Checks to see if a group inherits a certain permission node",
-                "/%s group <group> inheritspermission <node> [server] [world]", Permission.GROUP_INHERITSPERMISSION,
-                Predicate.notInRange(1, 3));
+        super("inheritspermission", "Checks to see if a group inherits a certain permission node", "<node> [server] [world]",
+                Permission.GROUP_INHERITSPERMISSION, Predicate.notInRange(1, 3));
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupListNodes.java

@@ -32,14 +32,13 @@ import java.util.List;
 
 public class GroupListNodes extends SubCommand<Group> {
     public GroupListNodes() {
-        super("listnodes", "Lists the permission nodes the group has", "/%s group <group> listnodes",
-                Permission.GROUP_LISTNODES, Predicate.alwaysFalse());
+        super("listnodes", "Lists the permission nodes the group has", "", Permission.GROUP_LISTNODES, Predicate.alwaysFalse());
     }
 
     @Override
     public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
-        Message.LISTNODES.send(sender, group.getName(), Util.permNodesToString(group.getPermissions(false)));
-        Message.LISTNODES_TEMP.send(sender, group.getName(), Util.tempNodesToString(group.getPermissions(false)));
+        Message.LISTNODES.send(sender, group.getDisplayName(), Util.permNodesToString(group.getPermissions(false)));
+        Message.LISTNODES_TEMP.send(sender, group.getDisplayName(), Util.tempNodesToString(group.getPermissions(false)));
         return CommandResult.SUCCESS;
     }
 }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupListParents.java

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.commands.group.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.*;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.groups.Group;
+
+import java.util.List;
+
+public class GroupListParents extends SubCommand<Group> {
+    public GroupListParents() {
+        super("listparents", "Lists the groups that this group inherits from", "", Permission.GROUP_LISTPARENTS, Predicate.alwaysFalse());
+    }
+
+    @Override
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+        Message.LISTPARENTS.send(sender, group.getDisplayName(), Util.permGroupsToString(group.getPermissions(false)));
+        Message.LISTPARENTS_TEMP.send(sender, group.getDisplayName(), Util.tempGroupsToString(group.getPermissions(false)));
+        return CommandResult.SUCCESS;
+    }
+}
+

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupRemovePrefix.java

@@ -38,7 +38,7 @@ import java.util.List;
 
 public class GroupRemovePrefix extends SubCommand<Group> {
     public GroupRemovePrefix() {
-        super("removeprefix", "Removes a prefix from a group", "/%s group <group> removeprefix <priority> <prefix> [server] [world]",
+        super("removeprefix", "Removes a prefix from a group", "<priority> <prefix> [server] [world]",
                 Permission.GROUP_REMOVEPREFIX, Predicate.notInRange(2, 4));
     }
 
@@ -65,14 +65,14 @@ public class GroupRemovePrefix extends SubCommand<Group> {
 
                 if (args.size() == 3) {
                     group.unsetPermission(node, server);
-                    Message.REMOVEPREFIX_SERVER_SUCCESS.send(sender, group.getName(), prefix, priority, server);
+                    Message.REMOVEPREFIX_SERVER_SUCCESS.send(sender, group.getDisplayName(), prefix, priority, server);
                     LogEntry.build().actor(sender).acted(group)
                             .action("removeprefix " + priority + " " + args.get(1) + " " + server)
                             .build().submit(plugin, sender);
                 } else {
                     final String world = args.get(3).toLowerCase();
                     group.unsetPermission(node, server, world);
-                    Message.REMOVEPREFIX_SERVER_WORLD_SUCCESS.send(sender, group.getName(), prefix, priority, server, world);
+                    Message.REMOVEPREFIX_SERVER_WORLD_SUCCESS.send(sender, group.getDisplayName(), prefix, priority, server, world);
                     LogEntry.build().actor(sender).acted(group)
                             .action("removeprefix " + priority + " " + args.get(1) + " " + server + " " + world)
                             .build().submit(plugin, sender);
@@ -80,7 +80,7 @@ public class GroupRemovePrefix extends SubCommand<Group> {
 
             } else {
                 group.unsetPermission(node);
-                Message.REMOVEPREFIX_SUCCESS.send(sender, group.getName(), prefix, priority);
+                Message.REMOVEPREFIX_SUCCESS.send(sender, group.getDisplayName(), prefix, priority);
                 LogEntry.build().actor(sender).acted(group)
                         .action("removeprefix " + priority + " " + args.get(1))
                         .build().submit(plugin, sender);
@@ -89,7 +89,7 @@ public class GroupRemovePrefix extends SubCommand<Group> {
             save(group, sender, plugin);
             return CommandResult.SUCCESS;
         } catch (ObjectLacksException e) {
-            Message.DOES_NOT_HAVE_PREFIX.send(sender, group.getName());
+            Message.DOES_NOT_HAVE_PREFIX.send(sender, group.getDisplayName());
             return CommandResult.STATE_ERROR;
         }
     }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupRemoveSuffix.java

@@ -38,7 +38,7 @@ import java.util.List;
 
 public class GroupRemoveSuffix extends SubCommand<Group> {
     public GroupRemoveSuffix() {
-        super("removesuffix", "Removes a suffix from a group", "/%s group <group> removesuffix <priority> <suffix> [server] [world]",
+        super("removesuffix", "Removes a suffix from a group", "<priority> <suffix> [server] [world]",
                 Permission.GROUP_REMOVESUFFIX, Predicate.notInRange(2, 4));
     }
 
@@ -65,14 +65,14 @@ public class GroupRemoveSuffix extends SubCommand<Group> {
 
                 if (args.size() == 3) {
                     group.unsetPermission(node, server);
-                    Message.REMOVESUFFIX_SERVER_SUCCESS.send(sender, group.getName(), suffix, priority, server);
+                    Message.REMOVESUFFIX_SERVER_SUCCESS.send(sender, group.getDisplayName(), suffix, priority, server);
                     LogEntry.build().actor(sender).acted(group)
                             .action("removesuffix " + priority + " " + args.get(1) + " " + server)
                             .build().submit(plugin, sender);
                 } else {
                     final String world = args.get(3).toLowerCase();
                     group.unsetPermission(node, server, world);
-                    Message.REMOVESUFFIX_SERVER_WORLD_SUCCESS.send(sender, group.getName(), suffix, priority, server, world);
+                    Message.REMOVESUFFIX_SERVER_WORLD_SUCCESS.send(sender, group.getDisplayName(), suffix, priority, server, world);
                     LogEntry.build().actor(sender).acted(group)
                             .action("removesuffix " + priority + " " + args.get(1) + " " + server + " " + world)
                             .build().submit(plugin, sender);
@@ -80,7 +80,7 @@ public class GroupRemoveSuffix extends SubCommand<Group> {
 
             } else {
                 group.unsetPermission(node);
-                Message.REMOVESUFFIX_SUCCESS.send(sender, group.getName(), suffix, priority);
+                Message.REMOVESUFFIX_SUCCESS.send(sender, group.getDisplayName(), suffix, priority);
                 LogEntry.build().actor(sender).acted(group)
                         .action("removesuffix " + priority + " " + args.get(1))
                         .build().submit(plugin, sender);
@@ -89,7 +89,7 @@ public class GroupRemoveSuffix extends SubCommand<Group> {
             save(group, sender, plugin);
             return CommandResult.SUCCESS;
         } catch (ObjectLacksException e) {
-            Message.DOES_NOT_HAVE_SUFFIX.send(sender, group.getName());
+            Message.DOES_NOT_HAVE_SUFFIX.send(sender, group.getDisplayName());
             return CommandResult.STATE_ERROR;
         }
     }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupRemoveTempPrefix.java

@@ -38,7 +38,7 @@ import java.util.List;
 
 public class GroupRemoveTempPrefix extends SubCommand<Group> {
     public GroupRemoveTempPrefix() {
-        super("removetempprefix", "Removes a temporary prefix from a group", "/%s group <group> removetempprefix <priority> <prefix> [server] [world]",
+        super("removetempprefix", "Removes a temporary prefix from a group", "<priority> <prefix> [server] [world]",
                 Permission.GROUP_REMOVE_TEMP_PREFIX, Predicate.notInRange(2, 4));
     }
 
@@ -65,14 +65,14 @@ public class GroupRemoveTempPrefix extends SubCommand<Group> {
 
                 if (args.size() == 3) {
                     group.unsetPermission(node, server, true);
-                    Message.REMOVE_TEMP_PREFIX_SERVER_SUCCESS.send(sender, group.getName(), prefix, priority, server);
+                    Message.REMOVE_TEMP_PREFIX_SERVER_SUCCESS.send(sender, group.getDisplayName(), prefix, priority, server);
                     LogEntry.build().actor(sender).acted(group)
                             .action("removetempprefix " + priority + " " + args.get(1) + " " + server)
                             .build().submit(plugin, sender);
                 } else {
                     final String world = args.get(3).toLowerCase();
                     group.unsetPermission(node, server, world, true);
-                    Message.REMOVE_TEMP_PREFIX_SERVER_WORLD_SUCCESS.send(sender, group.getName(), prefix, priority, server, world);
+                    Message.REMOVE_TEMP_PREFIX_SERVER_WORLD_SUCCESS.send(sender, group.getDisplayName(), prefix, priority, server, world);
                     LogEntry.build().actor(sender).acted(group)
                             .action("removetempprefix " + priority + " " + args.get(1) + " " + server + " " + world)
                             .build().submit(plugin, sender);
@@ -80,7 +80,7 @@ public class GroupRemoveTempPrefix extends SubCommand<Group> {
 
             } else {
                 group.unsetPermission(node, true);
-                Message.REMOVE_TEMP_PREFIX_SUCCESS.send(sender, group.getName(), prefix, priority);
+                Message.REMOVE_TEMP_PREFIX_SUCCESS.send(sender, group.getDisplayName(), prefix, priority);
                 LogEntry.build().actor(sender).acted(group)
                         .action("removetempprefix " + priority + " " + args.get(1))
                         .build().submit(plugin, sender);
@@ -89,7 +89,7 @@ public class GroupRemoveTempPrefix extends SubCommand<Group> {
             save(group, sender, plugin);
             return CommandResult.SUCCESS;
         } catch (ObjectLacksException e) {
-            Message.DOES_NOT_HAVE_PREFIX.send(sender, group.getName());
+            Message.DOES_NOT_HAVE_PREFIX.send(sender, group.getDisplayName());
             return CommandResult.STATE_ERROR;
         }
     }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupRemoveTempSuffix.java

@@ -38,7 +38,7 @@ import java.util.List;
 
 public class GroupRemoveTempSuffix extends SubCommand<Group> {
     public GroupRemoveTempSuffix() {
-        super("removetempsuffix", "Removes a temporary suffix from a group", "/%s group <group> removetempsuffix <priority> <suffix> [server] [world]",
+        super("removetempsuffix", "Removes a temporary suffix from a group", "<priority> <suffix> [server] [world]",
                 Permission.GROUP_REMOVE_TEMP_SUFFIX, Predicate.notInRange(2, 4));
     }
 
@@ -65,14 +65,14 @@ public class GroupRemoveTempSuffix extends SubCommand<Group> {
 
                 if (args.size() == 3) {
                     group.unsetPermission(node, server, true);
-                    Message.REMOVE_TEMP_SUFFIX_SERVER_SUCCESS.send(sender, group.getName(), suffix, priority, server);
+                    Message.REMOVE_TEMP_SUFFIX_SERVER_SUCCESS.send(sender, group.getDisplayName(), suffix, priority, server);
                     LogEntry.build().actor(sender).acted(group)
                             .action("removetempsuffix " + priority + " " + args.get(1) + " " + server)
                             .build().submit(plugin, sender);
                 } else {
                     final String world = args.get(3).toLowerCase();
                     group.unsetPermission(node, server, world, true);
-                    Message.REMOVE_TEMP_SUFFIX_SERVER_WORLD_SUCCESS.send(sender, group.getName(), suffix, priority, server, world);
+                    Message.REMOVE_TEMP_SUFFIX_SERVER_WORLD_SUCCESS.send(sender, group.getDisplayName(), suffix, priority, server, world);
                     LogEntry.build().actor(sender).acted(group)
                             .action("removetempsuffix " + priority + " " + args.get(1) + " " + server + " " + world)
                             .build().submit(plugin, sender);
@@ -80,7 +80,7 @@ public class GroupRemoveTempSuffix extends SubCommand<Group> {
 
             } else {
                 group.unsetPermission(node, true);
-                Message.REMOVE_TEMP_SUFFIX_SUCCESS.send(sender, group.getName(), suffix, priority);
+                Message.REMOVE_TEMP_SUFFIX_SUCCESS.send(sender, group.getDisplayName(), suffix, priority);
                 LogEntry.build().actor(sender).acted(group)
                         .action("removetempsuffix " + priority + " " + args.get(1))
                         .build().submit(plugin, sender);
@@ -89,7 +89,7 @@ public class GroupRemoveTempSuffix extends SubCommand<Group> {
             save(group, sender, plugin);
             return CommandResult.SUCCESS;
         } catch (ObjectLacksException e) {
-            Message.DOES_NOT_HAVE_SUFFIX.send(sender, group.getName());
+            Message.DOES_NOT_HAVE_SUFFIX.send(sender, group.getDisplayName());
             return CommandResult.STATE_ERROR;
         }
     }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupRename.java

@@ -37,8 +37,7 @@ import java.util.List;
 
 public class GroupRename extends SubCommand<Group> {
     public GroupRename() {
-        super("rename", "Rename this group", "/%s group <group> rename <new name>",
-                Permission.TRACK_APPEND, Predicate.not(1));
+        super("rename", "Rename this group", "<new name>", Permission.TRACK_APPEND, Predicate.not(1));
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetInherit.java

@@ -38,9 +38,8 @@ import java.util.List;
 
 public class GroupSetInherit extends SubCommand<Group> {
     public GroupSetInherit() {
-        super("setinherit", "Sets another group for this group to inherit permissions from",
-                "/%s group <group> setinherit <group> [server] [world]", Permission.GROUP_SETINHERIT,
-                Predicate.notInRange(1, 3));
+        super("setinherit", "Sets another group for this group to inherit permissions from", "<group> [server] [world]",
+                Permission.GROUP_SETINHERIT, Predicate.notInRange(1, 3));
     }
 
     @Override
@@ -48,7 +47,7 @@ public class GroupSetInherit extends SubCommand<Group> {
         String groupName = args.get(0).toLowerCase();
 
         if (ArgumentChecker.checkNode(groupName)) {
-            sendUsage(sender, label);
+            sendUsage(sender);
             return CommandResult.INVALID_ARGS;
         }
 
@@ -73,14 +72,14 @@ public class GroupSetInherit extends SubCommand<Group> {
 
                 if (args.size() == 2) {
                     group.setInheritGroup(group1, server);
-                    Message.GROUP_SETINHERIT_SERVER_SUCCESS.send(sender, group.getName(), group1.getName(), server);
+                    Message.GROUP_SETINHERIT_SERVER_SUCCESS.send(sender, group.getDisplayName(), group1.getDisplayName(), server);
                     LogEntry.build().actor(sender).acted(group)
                             .action("setinherit " + group1.getName() + " " + server)
                             .build().submit(plugin, sender);
                 } else {
                     final String world = args.get(2).toLowerCase();
                     group.setInheritGroup(group1, server, world);
-                    Message.GROUP_SETINHERIT_SERVER_WORLD_SUCCESS.send(sender, group.getName(), group1.getName(), server, world);
+                    Message.GROUP_SETINHERIT_SERVER_WORLD_SUCCESS.send(sender, group.getDisplayName(), group1.getDisplayName(), server, world);
                     LogEntry.build().actor(sender).acted(group)
                             .action("setinherit " + group1.getName() + " " + server + " " + world)
                             .build().submit(plugin, sender);
@@ -88,7 +87,7 @@ public class GroupSetInherit extends SubCommand<Group> {
 
             } else {
                 group.setInheritGroup(group1);
-                Message.GROUP_SETINHERIT_SUCCESS.send(sender, group.getName(), group1.getName());
+                Message.GROUP_SETINHERIT_SUCCESS.send(sender, group.getDisplayName(), group1.getDisplayName());
                 LogEntry.build().actor(sender).acted(group)
                         .action("setinherit " + group1.getName())
                         .build().submit(plugin, sender);
@@ -97,7 +96,7 @@ public class GroupSetInherit extends SubCommand<Group> {
             save(group, sender, plugin);
             return CommandResult.SUCCESS;
         } catch (ObjectAlreadyHasException e) {
-            Message.GROUP_ALREADY_INHERITS.send(sender, group.getName(), group1.getName());
+            Message.GROUP_ALREADY_INHERITS.send(sender, group.getDisplayName(), group1.getDisplayName());
             return CommandResult.STATE_ERROR;
         }
     }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetPermission.java

@@ -38,8 +38,8 @@ import java.util.List;
 
 public class GroupSetPermission extends SubCommand<Group> {
     public GroupSetPermission() {
-        super("set", "Sets a permission for a group", "/%s group <group> set <node> <true|false> [server] [world]",
-                Permission.GROUP_SETPERMISSION, Predicate.notInRange(2, 4));
+        super("set", "Sets a permission for a group", "<node> <true|false> [server] [world]", Permission.GROUP_SETPERMISSION,
+                Predicate.notInRange(2, 4));
     }
 
     @Override
@@ -48,7 +48,7 @@ public class GroupSetPermission extends SubCommand<Group> {
         String bool = args.get(1).toLowerCase();
 
         if (ArgumentChecker.checkNode(node)) {
-            sendUsage(sender, label);
+            sendUsage(sender);
             return CommandResult.INVALID_ARGS;
         }
 
@@ -58,7 +58,7 @@ public class GroupSetPermission extends SubCommand<Group> {
         }
 
         if (!bool.equalsIgnoreCase("true") && !bool.equalsIgnoreCase("false")) {
-            sendUsage(sender, label);
+            sendUsage(sender);
             return CommandResult.INVALID_ARGS;
         }
 
@@ -74,14 +74,14 @@ public class GroupSetPermission extends SubCommand<Group> {
 
                 if (args.size() == 3) {
                     group.setPermission(node, b, server);
-                    Message.SETPERMISSION_SERVER_SUCCESS.send(sender, node, bool, group.getName(), server);
+                    Message.SETPERMISSION_SERVER_SUCCESS.send(sender, node, bool, group.getDisplayName(), server);
                     LogEntry.build().actor(sender).acted(group)
                             .action("set " + node + " " + b + " " + server)
                             .build().submit(plugin, sender);
                 } else {
                     final String world = args.get(3).toLowerCase();
                     group.setPermission(node, b, server, world);
-                    Message.SETPERMISSION_SERVER_WORLD_SUCCESS.send(sender, node, bool, group.getName(), server, world);
+                    Message.SETPERMISSION_SERVER_WORLD_SUCCESS.send(sender, node, bool, group.getDisplayName(), server, world);
                     LogEntry.build().actor(sender).acted(group)
                             .action("set " + node + " " + b + " " + server + " " + world)
                             .build().submit(plugin, sender);
@@ -89,7 +89,7 @@ public class GroupSetPermission extends SubCommand<Group> {
 
             } else {
                 group.setPermission(node, b);
-                Message.SETPERMISSION_SUCCESS.send(sender, node, bool, group.getName());
+                Message.SETPERMISSION_SUCCESS.send(sender, node, bool, group.getDisplayName());
                 LogEntry.build().actor(sender).acted(group)
                         .action("set " + node + " " + b)
                         .build().submit(plugin, sender);
@@ -98,7 +98,7 @@ public class GroupSetPermission extends SubCommand<Group> {
             save(group, sender, plugin);
             return CommandResult.SUCCESS;
         } catch (ObjectAlreadyHasException e) {
-            Message.ALREADY_HASPERMISSION.send(sender, group.getName());
+            Message.ALREADY_HASPERMISSION.send(sender, group.getDisplayName());
             return CommandResult.STATE_ERROR;
         }
     }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetTempInherit.java

@@ -40,8 +40,7 @@ import java.util.List;
 public class GroupSetTempInherit extends SubCommand<Group> {
     public GroupSetTempInherit() {
         super("settempinherit", "Sets another group for this group to inherit permissions from temporarily",
-                "/%s group <group> settempinherit <group> <duration> [server] [world]",
-                Permission.GROUP_SET_TEMP_INHERIT, Predicate.notInRange(2, 4));
+                "<group> <duration> [server] [world]", Permission.GROUP_SET_TEMP_INHERIT, Predicate.notInRange(2, 4));
     }
 
     @Override
@@ -49,7 +48,7 @@ public class GroupSetTempInherit extends SubCommand<Group> {
         String groupName = args.get(0).toLowerCase();
 
         if (ArgumentChecker.checkNode(groupName)) {
-            sendUsage(sender, label);
+            sendUsage(sender);
             return CommandResult.INVALID_ARGS;
         }
 
@@ -91,7 +90,7 @@ public class GroupSetTempInherit extends SubCommand<Group> {
 
                 if (args.size() == 3) {
                     group.setInheritGroup(group1, server, duration);
-                    Message.GROUP_SET_TEMP_INHERIT_SERVER_SUCCESS.send(sender, group.getName(), group1.getName(), server,
+                    Message.GROUP_SET_TEMP_INHERIT_SERVER_SUCCESS.send(sender, group.getDisplayName(), group1.getDisplayName(), server,
                             DateUtil.formatDateDiff(duration));
                     LogEntry.build().actor(sender).acted(group)
                             .action("settempinherit " + group1.getName() + " " + duration + " " + server)
@@ -99,7 +98,7 @@ public class GroupSetTempInherit extends SubCommand<Group> {
                 } else {
                     final String world = args.get(3).toLowerCase();
                     group.setInheritGroup(group1, server, world, duration);
-                    Message.GROUP_SET_TEMP_INHERIT_SERVER_WORLD_SUCCESS.send(sender, group.getName(), group1.getName(), server,
+                    Message.GROUP_SET_TEMP_INHERIT_SERVER_WORLD_SUCCESS.send(sender, group.getDisplayName(), group1.getDisplayName(), server,
                             world, DateUtil.formatDateDiff(duration));
                     LogEntry.build().actor(sender).acted(group)
                             .action("settempinherit " + group1.getName() + " " + duration + " " + server + " " + world)
@@ -108,7 +107,7 @@ public class GroupSetTempInherit extends SubCommand<Group> {
 
             } else {
                 group.setInheritGroup(group1, duration);
-                Message.GROUP_SET_TEMP_INHERIT_SUCCESS.send(sender, group.getName(), group1.getName(), DateUtil.formatDateDiff(duration));
+                Message.GROUP_SET_TEMP_INHERIT_SUCCESS.send(sender, group.getDisplayName(), group1.getDisplayName(), DateUtil.formatDateDiff(duration));
                 LogEntry.build().actor(sender).acted(group)
                         .action("settempinherit " + group1.getName() + " " + duration)
                         .build().submit(plugin, sender);
@@ -117,7 +116,7 @@ public class GroupSetTempInherit extends SubCommand<Group> {
             save(group, sender, plugin);
             return CommandResult.SUCCESS;
         } catch (ObjectAlreadyHasException e) {
-            Message.USER_ALREADY_TEMP_MEMBER_OF.send(sender, group.getName(), group1.getName());
+            Message.USER_ALREADY_TEMP_MEMBER_OF.send(sender, group.getDisplayName(), group1.getDisplayName());
             return CommandResult.STATE_ERROR;
         }
     }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetTempPermission.java

@@ -39,8 +39,7 @@ import java.util.List;
 
 public class GroupSetTempPermission extends SubCommand<Group> {
     public GroupSetTempPermission() {
-        super("settemp", "Sets a temporary permission for a group",
-                "/%s group <group> settemp <node> <true|false> <duration> [server] [world]",
+        super("settemp", "Sets a temporary permission for a group", "<node> <true|false> <duration> [server] [world]",
                 Permission.GROUP_SET_TEMP_PERMISSION, Predicate.notInRange(3, 5));
     }
 
@@ -50,7 +49,7 @@ public class GroupSetTempPermission extends SubCommand<Group> {
         String bool = args.get(1).toLowerCase();
 
         if (ArgumentChecker.checkNode(node)) {
-            sendUsage(sender, label);
+            sendUsage(sender);
             return CommandResult.INVALID_ARGS;
         }
 
@@ -60,7 +59,7 @@ public class GroupSetTempPermission extends SubCommand<Group> {
         }
 
         if (!bool.equalsIgnoreCase("true") && !bool.equalsIgnoreCase("false")) {
-            sendUsage(sender, label);
+            sendUsage(sender);
             return CommandResult.INVALID_ARGS;
         }
 
@@ -93,7 +92,7 @@ public class GroupSetTempPermission extends SubCommand<Group> {
 
                 if (args.size() == 4) {
                     group.setPermission(node, b, server, duration);
-                    Message.SETPERMISSION_TEMP_SERVER_SUCCESS.send(sender, node, bool, group.getName(), server,
+                    Message.SETPERMISSION_TEMP_SERVER_SUCCESS.send(sender, node, bool, group.getDisplayName(), server,
                             DateUtil.formatDateDiff(duration));
                     LogEntry.build().actor(sender).acted(group)
                             .action("settemp " + node + " " + b + " " + duration + " " + server)
@@ -101,7 +100,7 @@ public class GroupSetTempPermission extends SubCommand<Group> {
                 } else {
                     final String world = args.get(4).toLowerCase();
                     group.setPermission(node, b, server, world, duration);
-                    Message.SETPERMISSION_TEMP_SERVER_WORLD_SUCCESS.send(sender, node, bool, group.getName(), server,
+                    Message.SETPERMISSION_TEMP_SERVER_WORLD_SUCCESS.send(sender, node, bool, group.getDisplayName(), server,
                             world, DateUtil.formatDateDiff(duration));
                     LogEntry.build().actor(sender).acted(group)
                             .action("settemp " + node + " " + b + " " + duration + " " + server + " " + world)
@@ -110,7 +109,7 @@ public class GroupSetTempPermission extends SubCommand<Group> {
 
             } else {
                 group.setPermission(node, b, duration);
-                Message.SETPERMISSION_TEMP_SUCCESS.send(sender, node, bool, group.getName(), DateUtil.formatDateDiff(duration));
+                Message.SETPERMISSION_TEMP_SUCCESS.send(sender, node, bool, group.getDisplayName(), DateUtil.formatDateDiff(duration));
                 LogEntry.build().actor(sender).acted(group)
                         .action("settemp " + node + " " + b + " " + duration)
                         .build().submit(plugin, sender);
@@ -119,7 +118,7 @@ public class GroupSetTempPermission extends SubCommand<Group> {
             save(group, sender, plugin);
             return CommandResult.SUCCESS;
         } catch (ObjectAlreadyHasException e) {
-            Message.ALREADY_HAS_TEMP_PERMISSION.send(sender, group.getName());
+            Message.ALREADY_HAS_TEMP_PERMISSION.send(sender, group.getDisplayName());
             return CommandResult.STATE_ERROR;
         }
     }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupShowTracks.java

@@ -34,8 +34,7 @@ import java.util.stream.Collectors;
 
 public class GroupShowTracks extends SubCommand<Group> {
     public GroupShowTracks() {
-        super("showtracks", "Lists the tracks that this group features on", "/%s group <group> showtracks",
-                Permission.GROUP_SHOWTRACKS, Predicate.alwaysFalse());
+        super("showtracks", "Lists the tracks that this group features on", "", Permission.GROUP_SHOWTRACKS, Predicate.alwaysFalse());
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnSetPermission.java

@@ -38,8 +38,8 @@ import java.util.List;
 
 public class GroupUnSetPermission extends SubCommand<Group> {
     public GroupUnSetPermission() {
-        super("unset", "Unsets a permission for a group", "/%s group <group> unset <node> [server] [world]",
-                Permission.GROUP_UNSETPERMISSION, Predicate.notInRange(1, 3));
+        super("unset", "Unsets a permission for a group", "<node> [server] [world]", Permission.GROUP_UNSETPERMISSION,
+                Predicate.notInRange(1, 3));
     }
 
     @Override
@@ -47,7 +47,7 @@ public class GroupUnSetPermission extends SubCommand<Group> {
         String node = args.get(0).replace("{SPACE}", " ");
 
         if (ArgumentChecker.checkNode(node)) {
-            sendUsage(sender, label);
+            sendUsage(sender);
             return CommandResult.INVALID_ARGS;
         }
 
@@ -66,14 +66,14 @@ public class GroupUnSetPermission extends SubCommand<Group> {
 
                 if (args.size() == 2) {
                     group.unsetPermission(node, server);
-                    Message.UNSETPERMISSION_SERVER_SUCCESS.send(sender, node, group.getName(), server);
+                    Message.UNSETPERMISSION_SERVER_SUCCESS.send(sender, node, group.getDisplayName(), server);
                     LogEntry.build().actor(sender).acted(group)
                             .action("unset " + node + " " + server)
                             .build().submit(plugin, sender);
                 } else {
                     final String world = args.get(2).toLowerCase();
                     group.unsetPermission(node, server, world);
-                    Message.UNSETPERMISSION_SERVER_WORLD_SUCCESS.send(sender, node, group.getName(), server, world);
+                    Message.UNSETPERMISSION_SERVER_WORLD_SUCCESS.send(sender, node, group.getDisplayName(), server, world);
                     LogEntry.build().actor(sender).acted(group)
                             .action("unset " + node + " " + server + " " + world)
                             .build().submit(plugin, sender);
@@ -81,7 +81,7 @@ public class GroupUnSetPermission extends SubCommand<Group> {
 
             } else {
                 group.unsetPermission(node);
-                Message.UNSETPERMISSION_SUCCESS.send(sender, node, group.getName());
+                Message.UNSETPERMISSION_SUCCESS.send(sender, node, group.getDisplayName());
                 LogEntry.build().actor(sender).acted(group)
                         .action("unset " + node)
                         .build().submit(plugin, sender);
@@ -90,7 +90,7 @@ public class GroupUnSetPermission extends SubCommand<Group> {
             save(group, sender, plugin);
             return CommandResult.SUCCESS;
         } catch (ObjectLacksException e) {
-            Message.DOES_NOT_HAVEPERMISSION.send(sender, group.getName());
+            Message.DOES_NOT_HAVEPERMISSION.send(sender, group.getDisplayName());
             return CommandResult.STATE_ERROR;
         }
     }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnsetInherit.java

@@ -39,8 +39,7 @@ import java.util.List;
 public class GroupUnsetInherit extends SubCommand<Group> {
     public GroupUnsetInherit() {
         super("unsetinherit", "Unsets another group for this group to inherit permissions from",
-                "/%s group <group> unsetinherit <group> [server] [world]", Permission.GROUP_UNSETINHERIT,
-                Predicate.notInRange(1, 3));
+                "<group> [server] [world]", Permission.GROUP_UNSETINHERIT, Predicate.notInRange(1, 3));
     }
 
     @Override
@@ -48,7 +47,7 @@ public class GroupUnsetInherit extends SubCommand<Group> {
         String groupName = args.get(0).toLowerCase();
 
         if (ArgumentChecker.checkNode(groupName)) {
-            sendUsage(sender, label);
+            sendUsage(sender);
             return CommandResult.INVALID_ARGS;
         }
 
@@ -62,14 +61,14 @@ public class GroupUnsetInherit extends SubCommand<Group> {
 
                 if (args.size() == 2) {
                     group.unsetPermission("group." + groupName, server);
-                    Message.GROUP_UNSETINHERIT_SERVER_SUCCESS.send(sender, group.getName(), groupName, server);
+                    Message.GROUP_UNSETINHERIT_SERVER_SUCCESS.send(sender, group.getDisplayName(), groupName, server);
                     LogEntry.build().actor(sender).acted(group)
                             .action("unsetinherit " + groupName + " " + server)
                             .build().submit(plugin, sender);
                 } else {
                     final String world = args.get(2).toLowerCase();
                     group.unsetPermission("group." + groupName, server, world);
-                    Message.GROUP_UNSETINHERIT_SERVER_WORLD_SUCCESS.send(sender, group.getName(), groupName, server, world);
+                    Message.GROUP_UNSETINHERIT_SERVER_WORLD_SUCCESS.send(sender, group.getDisplayName(), groupName, server, world);
                     LogEntry.build().actor(sender).acted(group)
                             .action("unsetinherit " + groupName + " " + server + " " + world)
                             .build().submit(plugin, sender);
@@ -77,7 +76,7 @@ public class GroupUnsetInherit extends SubCommand<Group> {
 
             } else {
                 group.unsetPermission("group." + groupName);
-                Message.GROUP_UNSETINHERIT_SUCCESS.send(sender, group.getName(), groupName);
+                Message.GROUP_UNSETINHERIT_SUCCESS.send(sender, group.getDisplayName(), groupName);
                 LogEntry.build().actor(sender).acted(group)
                         .action("unsetinherit " + groupName)
                         .build().submit(plugin, sender);
@@ -86,7 +85,7 @@ public class GroupUnsetInherit extends SubCommand<Group> {
             save(group, sender, plugin);
             return CommandResult.SUCCESS;
         } catch (ObjectLacksException e) {
-            Message.GROUP_DOES_NOT_INHERIT.send(sender, group.getName(), groupName);
+            Message.GROUP_DOES_NOT_INHERIT.send(sender, group.getDisplayName(), groupName);
             return CommandResult.STATE_ERROR;
         }
     }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnsetTempInherit.java

@@ -39,8 +39,7 @@ import java.util.List;
 public class GroupUnsetTempInherit extends SubCommand<Group> {
     public GroupUnsetTempInherit() {
         super("unsettempinherit", "Unsets another group for this group to inherit permissions from",
-                "/%s group <group> unsettempinherit <group> [server] [world]", Permission.GROUP_UNSET_TEMP_INHERIT,
-                Predicate.notInRange(1, 3));
+                "<group> [server] [world]", Permission.GROUP_UNSET_TEMP_INHERIT, Predicate.notInRange(1, 3));
     }
 
     @Override
@@ -48,7 +47,7 @@ public class GroupUnsetTempInherit extends SubCommand<Group> {
         String groupName = args.get(0).toLowerCase();
 
         if (ArgumentChecker.checkNode(groupName)) {
-            sendUsage(sender, label);
+            sendUsage(sender);
             return CommandResult.INVALID_ARGS;
         }
 
@@ -62,14 +61,14 @@ public class GroupUnsetTempInherit extends SubCommand<Group> {
 
                 if (args.size() == 2) {
                     group.unsetPermission("group." + groupName, server, true);
-                    Message.GROUP_UNSET_TEMP_INHERIT_SERVER_SUCCESS.send(sender, group.getName(), groupName, server);
+                    Message.GROUP_UNSET_TEMP_INHERIT_SERVER_SUCCESS.send(sender, group.getDisplayName(), groupName, server);
                     LogEntry.build().actor(sender).acted(group)
                             .action("unsettempinherit " + groupName + " " + server)
                             .build().submit(plugin, sender);
                 } else {
                     final String world = args.get(2).toLowerCase();
                     group.unsetPermission("group." + groupName, server, world, true);
-                    Message.GROUP_UNSET_TEMP_INHERIT_SERVER_WORLD_SUCCESS.send(sender, group.getName(), groupName, server, world);
+                    Message.GROUP_UNSET_TEMP_INHERIT_SERVER_WORLD_SUCCESS.send(sender, group.getDisplayName(), groupName, server, world);
                     LogEntry.build().actor(sender).acted(group)
                             .action("unsettempinherit " + groupName + " " + server + " " + world)
                             .build().submit(plugin, sender);
@@ -77,7 +76,7 @@ public class GroupUnsetTempInherit extends SubCommand<Group> {
 
             } else {
                 group.unsetPermission("group." + groupName, true);
-                Message.GROUP_UNSET_TEMP_INHERIT_SUCCESS.send(sender, group.getName(), groupName);
+                Message.GROUP_UNSET_TEMP_INHERIT_SUCCESS.send(sender, group.getDisplayName(), groupName);
                 LogEntry.build().actor(sender).acted(group)
                         .action("unsettempinherit " + groupName)
                         .build().submit(plugin, sender);
@@ -86,7 +85,7 @@ public class GroupUnsetTempInherit extends SubCommand<Group> {
             save(group, sender, plugin);
             return CommandResult.SUCCESS;
         } catch (ObjectLacksException e) {
-            Message.GROUP_DOES_NOT_TEMP_INHERIT.send(sender, group.getName(), groupName);
+            Message.GROUP_DOES_NOT_TEMP_INHERIT.send(sender, group.getDisplayName(), groupName);
             return CommandResult.STATE_ERROR;
         }
     }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnsetTempPermission.java

@@ -38,9 +38,8 @@ import java.util.List;
 
 public class GroupUnsetTempPermission extends SubCommand<Group> {
     public GroupUnsetTempPermission() {
-        super("unsettemp", "Unsets a temporary permission for a group",
-                "/%s group <group> unsettemp <node> [server] [world]", Permission.GROUP_UNSET_TEMP_PERMISSION,
-                Predicate.notInRange(1, 3));
+        super("unsettemp", "Unsets a temporary permission for a group", "<node> [server] [world]",
+                Permission.GROUP_UNSET_TEMP_PERMISSION, Predicate.notInRange(1, 3));
     }
 
     @Override
@@ -48,7 +47,7 @@ public class GroupUnsetTempPermission extends SubCommand<Group> {
         String node = args.get(0).replace("{SPACE}", " ");
 
         if (ArgumentChecker.checkNode(node)) {
-            sendUsage(sender, label);
+            sendUsage(sender);
             return CommandResult.INVALID_ARGS;
         }
 
@@ -67,14 +66,14 @@ public class GroupUnsetTempPermission extends SubCommand<Group> {
 
                 if (args.size() == 2) {
                     group.unsetPermission(node, server);
-                    Message.UNSET_TEMP_PERMISSION_SERVER_SUCCESS.send(sender, node, group.getName(), server);
+                    Message.UNSET_TEMP_PERMISSION_SERVER_SUCCESS.send(sender, node, group.getDisplayName(), server);
                     LogEntry.build().actor(sender).acted(group)
                             .action("unsettemp " + node + " " + server)
                             .build().submit(plugin, sender);
                 } else {
                     final String world = args.get(2).toLowerCase();
                     group.unsetPermission(node, server, world);
-                    Message.UNSET_TEMP_PERMISSION_SERVER_WORLD_SUCCESS.send(sender, node, group.getName(), server, world);
+                    Message.UNSET_TEMP_PERMISSION_SERVER_WORLD_SUCCESS.send(sender, node, group.getDisplayName(), server, world);
                     LogEntry.build().actor(sender).acted(group)
                             .action("unsettemp " + node + " " + server + " " + world)
                             .build().submit(plugin, sender);
@@ -82,7 +81,7 @@ public class GroupUnsetTempPermission extends SubCommand<Group> {
 
             } else {
                 group.unsetPermission(node, true);
-                Message.UNSET_TEMP_PERMISSION_SUCCESS.send(sender, node, group.getName());
+                Message.UNSET_TEMP_PERMISSION_SUCCESS.send(sender, node, group.getDisplayName());
                 LogEntry.build().actor(sender).acted(group)
                         .action("unsettemp " + node)
                         .build().submit(plugin, sender);
@@ -91,7 +90,7 @@ public class GroupUnsetTempPermission extends SubCommand<Group> {
             save(group, sender, plugin);
             return CommandResult.SUCCESS;
         } catch (ObjectLacksException e) {
-            Message.DOES_NOT_HAVE_TEMP_PERMISSION.send(sender, group.getName());
+            Message.DOES_NOT_HAVE_TEMP_PERMISSION.send(sender, group.getDisplayName());
             return CommandResult.STATE_ERROR;
         }
     }

common/src/main/java/me/lucko/luckperms/commands/log/subcommands/LogExport.java

@@ -41,7 +41,7 @@ import java.util.List;
 
 public class LogExport extends SubCommand<Log> {
     public LogExport() {
-        super("export", "Export the log to a file", "/%s log export <file>", Permission.LOG_EXPORT, Predicate.not(1));
+        super("export", "Export the log to a file", "<file>", Permission.LOG_EXPORT, Predicate.not(1));
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/commands/log/subcommands/LogGroupHistory.java

@@ -40,7 +40,7 @@ import java.util.SortedMap;
 
 public class LogGroupHistory extends SubCommand<Log> {
     public LogGroupHistory() {
-        super("grouphistory", "View an objects history", "/%s log grouphistory <group> [page]", Permission.LOG_GROUP_HISTORY,
+        super("grouphistory", "View an objects history", "<group> [page]", Permission.LOG_GROUP_HISTORY,
                 Predicate.notInRange(1, 2));
     }
 

common/src/main/java/me/lucko/luckperms/commands/log/subcommands/LogNotify.java

@@ -37,8 +37,7 @@ import java.util.UUID;
 
 public class LogNotify extends SubCommand<Log> {
     public LogNotify() {
-        super("notify", "Toggle notifications", "/%s log notify [on|off]", Permission.LOG_NOTIFY,
-                Predicate.notInRange(0, 1));
+        super("notify", "Toggle notifications", "[on|off]", Permission.LOG_NOTIFY, Predicate.notInRange(0, 1));
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/commands/log/subcommands/LogRecent.java

@@ -38,8 +38,7 @@ import java.util.UUID;
 
 public class LogRecent extends SubCommand<Log> {
     public LogRecent() {
-        super("recent", "View recent actions", "/%s log recent [user] [page]", Permission.LOG_RECENT,
-                Predicate.notInRange(0, 2));
+        super("recent", "View recent actions", "[user] [page]", Permission.LOG_RECENT, Predicate.notInRange(0, 2));
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/commands/log/subcommands/LogSearch.java

@@ -40,8 +40,7 @@ import java.util.stream.Collectors;
 
 public class LogSearch extends SubCommand<Log> {
     public LogSearch() {
-        super("search", "Search the log for an entry", "/%s log search <query> [page]", Permission.LOG_SEARCH,
-                Predicate.is(0));
+        super("search", "Search the log for an entry", "<query> [page]", Permission.LOG_SEARCH, Predicate.is(0));
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/commands/log/subcommands/LogTrackHistory.java

@@ -40,8 +40,7 @@ import java.util.SortedMap;
 
 public class LogTrackHistory extends SubCommand<Log> {
     public LogTrackHistory() {
-        super("trackhistory", "View an objects history", "/%s log trackhistory <track> [page]", Permission.LOG_TRACK_HISTORY,
-                Predicate.notInRange(1, 2));
+        super("trackhistory", "View an objects history", "<track> [page]", Permission.LOG_TRACK_HISTORY, Predicate.notInRange(1, 2));
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/commands/log/subcommands/LogUserHistory.java

@@ -38,8 +38,7 @@ import java.util.UUID;
 
 public class LogUserHistory extends SubCommand<Log> {
     public LogUserHistory() {
-        super("userhistory", "View an objects history", "/%s log userhistory <user> [page]", Permission.LOG_USER_HISTORY,
-                Predicate.notInRange(1, 2));
+        super("userhistory", "View an objects history", "<user> [page]", Permission.LOG_USER_HISTORY, Predicate.notInRange(1, 2));
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/commands/migration/subcommands/MigrationBPermissions.java

@@ -82,7 +82,7 @@ public class MigrationBPermissions extends SubCommand<Object> {
     }
 
     public MigrationBPermissions() {
-        super("bpermissions", "Migration from bPermissions", "/%s migration bpermissions", MIGRATION, Predicate.alwaysFalse());
+        super("bpermissions", "Migration from bPermissions", "", MIGRATION, Predicate.alwaysFalse());
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/commands/migration/subcommands/MigrationBungeePerms.java

@@ -43,8 +43,7 @@ import java.util.Map;
  */
 public class MigrationBungeePerms extends SubCommand<Object> {
     public MigrationBungeePerms() {
-        super("bungeeperms", "Migration from BungeePerms", "/%s migration bungeeperms",
-                Permission.MIGRATION, Predicate.alwaysFalse());
+        super("bungeeperms", "Migration from BungeePerms", "", Permission.MIGRATION, Predicate.alwaysFalse());
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/commands/migration/subcommands/MigrationGroupManager.java

@@ -45,8 +45,7 @@ import java.util.stream.Collectors;
 
 public class MigrationGroupManager extends SubCommand<Object> {
     public MigrationGroupManager() {
-        super("groupmanager", "Migration from GroupManager", "/%s migration groupmanager [world names]",
-                Permission.MIGRATION, Predicate.is(0));
+        super("groupmanager", "Migration from GroupManager", "[world names...]", Permission.MIGRATION, Predicate.is(0));
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/commands/migration/subcommands/MigrationPermissionsEx.java

@@ -50,8 +50,7 @@ import java.util.stream.Collectors;
 
 public class MigrationPermissionsEx extends SubCommand<Object> {
     public MigrationPermissionsEx() {
-        super("permissionsex", "Migration from PermissionsEx", "/%s migration permissionsex [world names]",
-                Permission.MIGRATION, Predicate.alwaysFalse());
+        super("permissionsex", "Migration from PermissionsEx", "[world names...]", Permission.MIGRATION, Predicate.alwaysFalse());
     }
 
     @SuppressWarnings("deprecation")

common/src/main/java/me/lucko/luckperms/commands/migration/subcommands/MigrationPowerfulPerms.java

@@ -119,8 +119,8 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
 
 
     public MigrationPowerfulPerms() {
-        super("powerfulperms", "Migration from PowerfulPerms",
-                "/%s migration powerfulperms <address> <database> <username> <password> <db table>", MIGRATION, Predicate.not(5));
+        super("powerfulperms", "Migration from PowerfulPerms", "<address> <database> <username> <password> <db table>",
+                MIGRATION, Predicate.not(5));
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/commands/migration/subcommands/MigrationZPermissions.java

@@ -49,8 +49,7 @@ import java.util.stream.Collectors;
  */
 public class MigrationZPermissions extends SubCommand<Object> {
     public MigrationZPermissions() {
-        super("zpermissions", "Migration from zPermissions", "/%s migration zpermissions [world names]",
-                Permission.MIGRATION, Predicate.alwaysFalse());
+        super("zpermissions", "Migration from zPermissions", "[world names...]", Permission.MIGRATION, Predicate.alwaysFalse());
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/commands/misc/InfoCommand.java

@@ -26,9 +26,9 @@ import me.lucko.luckperms.LuckPermsPlugin;
 import me.lucko.luckperms.commands.CommandResult;
 import me.lucko.luckperms.commands.Sender;
 import me.lucko.luckperms.commands.SingleMainCommand;
+import me.lucko.luckperms.config.LPConfiguration;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.core.LPConfiguration;
 
 import java.util.List;
 
@@ -48,14 +48,14 @@ public class InfoCommand extends SingleMainCommand {
                 plugin.getDatastore().getName(),
                 c.getServer(),
                 c.getSyncTime(),
-                formatBoolean(c.getIncludeGlobalPerms()),
-                formatBoolean(c.getIncludeGlobalWorldPerms()),
-                formatBoolean(c.getApplyGlobalGroups()),
-                formatBoolean(c.getApplyGlobalWorldGroups()),
-                formatBoolean(c.getOnlineMode()),
-                formatBoolean(c.getApplyWildcards()),
-                formatBoolean(c.getApplyRegex()),
-                formatBoolean(c.getApplyShorthand())
+                formatBoolean(c.isIncludingGlobalPerms()),
+                formatBoolean(c.isIncludingGlobalWorldPerms()),
+                formatBoolean(c.isApplyingGlobalGroups()),
+                formatBoolean(c.isApplyingGlobalWorldGroups()),
+                formatBoolean(c.isOnlineMode()),
+                formatBoolean(c.isApplyingWildcards()),
+                formatBoolean(c.isApplyingRegex()),
+                formatBoolean(c.isApplyingShorthand())
         );
 
         return CommandResult.SUCCESS;

common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackAppend.java

@@ -36,8 +36,7 @@ import java.util.List;
 
 public class TrackAppend extends SubCommand<Track> {
     public TrackAppend() {
-        super("append", "Appends a group onto the end of the track", "/%s track <track> append <group>",
-                Permission.TRACK_APPEND, Predicate.not(1));
+        super("append", "Appends a group onto the end of the track", "<group>", Permission.TRACK_APPEND, Predicate.not(1));
     }
 
     @Override
@@ -45,7 +44,7 @@ public class TrackAppend extends SubCommand<Track> {
         String groupName = args.get(0).toLowerCase();
 
         if (ArgumentChecker.checkNode(groupName)) {
-            sendUsage(sender, label);
+            sendUsage(sender);
             return CommandResult.INVALID_ARGS;
         }
 

common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackClear.java

@@ -36,8 +36,7 @@ import java.util.List;
 
 public class TrackClear extends SubCommand<Track> {
     public TrackClear() {
-        super("clear", "Clears the groups on the track", "/%s track <track> clear", Permission.TRACK_CLEAR,
-                Predicate.alwaysFalse());
+        super("clear", "Clears the groups on the track", "", Permission.TRACK_CLEAR, Predicate.alwaysFalse());
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackInfo.java

@@ -32,8 +32,7 @@ import java.util.List;
 
 public class TrackInfo extends SubCommand<Track> {
     public TrackInfo() {
-        super("info", "Gives info about the track", "/%s track <track> info", Permission.TRACK_INFO,
-                Predicate.alwaysFalse());
+        super("info", "Gives info about the track", "", Permission.TRACK_INFO, Predicate.alwaysFalse());
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackInsert.java

@@ -36,8 +36,8 @@ import java.util.List;
 
 public class TrackInsert extends SubCommand<Track> {
     public TrackInsert() {
-        super("insert", "Inserts a group at a given position along the track",
-                "/%s track <track> insert <group> <position>", Permission.TRACK_INSERT, Predicate.not(2));
+        super("insert", "Inserts a group at a given position along the track", "<group> <position>",
+                Permission.TRACK_INSERT, Predicate.not(2));
     }
 
     @Override
@@ -45,7 +45,7 @@ public class TrackInsert extends SubCommand<Track> {
         String groupName = args.get(0).toLowerCase();
 
         if (ArgumentChecker.checkNode(groupName)) {
-            sendUsage(sender, label);
+            sendUsage(sender);
             return CommandResult.INVALID_ARGS;
         }
 

common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackRemove.java

@@ -35,8 +35,7 @@ import java.util.List;
 
 public class TrackRemove extends SubCommand<Track> {
     public TrackRemove() {
-        super("remove", "Removes a group from the track", "/%s track <track> remove <group>", Permission.TRACK_REMOVE,
-                Predicate.not(1));
+        super("remove", "Removes a group from the track", "<group>", Permission.TRACK_REMOVE, Predicate.not(1));
     }
 
     @Override
@@ -44,7 +43,7 @@ public class TrackRemove extends SubCommand<Track> {
         String groupName = args.get(0).toLowerCase();
 
         if (ArgumentChecker.checkNode(groupName)) {
-            sendUsage(sender, label);
+            sendUsage(sender);
             return CommandResult.INVALID_ARGS;
         }
 

common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackRename.java

@@ -37,8 +37,7 @@ import java.util.List;
 
 public class TrackRename extends SubCommand<Track> {
     public TrackRename() {
-        super("rename", "Rename this track", "/%s track <track> rename <new name>",
-                Permission.TRACK_APPEND, Predicate.not(1));
+        super("rename", "Rename this track", "<new name>", Permission.TRACK_APPEND, Predicate.not(1));
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/commands/user/UserMainCommand.java

@@ -42,6 +42,7 @@ public class UserMainCommand extends MainCommand<User> {
             .add(new UserInfo())
             .add(new UserGetUUID())
             .add(new UserListNodes())
+            .add(new UserListGroups())
             .add(new UserHasPerm())
             .add(new UserInheritsPerm())
             .add(new UserSetPermission())
@@ -66,6 +67,7 @@ public class UserMainCommand extends MainCommand<User> {
             .add(new UserAddTempSuffix())
             .add(new UserRemoveTempPrefix())
             .add(new UserRemoveTempSuffix())
+            .add(new UserBulkChange())
             .add(new UserClear())
             .build()
         );

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserAddGroup.java

@@ -39,8 +39,7 @@ import java.util.List;
 
 public class UserAddGroup extends SubCommand<User> {
     public UserAddGroup() {
-        super("addgroup", "Adds the user to a group", "/%s user <user> addgroup <group> [server] [world]",
-                Permission.USER_ADDGROUP, Predicate.notInRange(1, 3));
+        super("addgroup", "Adds the user to a group", "<group> [server] [world]", Permission.USER_ADDGROUP, Predicate.notInRange(1, 3));
     }
 
     @Override
@@ -48,7 +47,7 @@ public class UserAddGroup extends SubCommand<User> {
         String groupName = args.get(0).toLowerCase();
 
         if (ArgumentChecker.checkNode(groupName)) {
-            sendUsage(sender, label);
+            sendUsage(sender);
             return CommandResult.INVALID_ARGS;
         }
 
@@ -73,14 +72,14 @@ public class UserAddGroup extends SubCommand<User> {
 
                 if (args.size() == 2) {
                     user.addGroup(group, server);
-                    Message.USER_ADDGROUP_SERVER_SUCCESS.send(sender, user.getName(), groupName, server);
+                    Message.USER_ADDGROUP_SERVER_SUCCESS.send(sender, user.getName(), group.getDisplayName(), server);
                     LogEntry.build().actor(sender).acted(user)
                             .action("addgroup " + group.getName() + " " + server)
                             .build().submit(plugin, sender);
                 } else {
                     final String world = args.get(2).toLowerCase();
                     user.addGroup(group, server, world);
-                    Message.USER_ADDGROUP_SERVER_WORLD_SUCCESS.send(sender, user.getName(), groupName, server, world);
+                    Message.USER_ADDGROUP_SERVER_WORLD_SUCCESS.send(sender, user.getName(), group.getDisplayName(), server, world);
                     LogEntry.build().actor(sender).acted(user)
                             .action("addgroup " + group.getName() + " " + server + " " + world)
                             .build().submit(plugin, sender);
@@ -88,7 +87,7 @@ public class UserAddGroup extends SubCommand<User> {
 
             } else {
                 user.addGroup(group);
-                Message.USER_ADDGROUP_SUCCESS.send(sender, user.getName(), groupName);
+                Message.USER_ADDGROUP_SUCCESS.send(sender, user.getName(), group.getDisplayName());
                 LogEntry.build().actor(sender).acted(user)
                         .action("addgroup " + group.getName())
                         .build().submit(plugin, sender);
@@ -97,7 +96,7 @@ public class UserAddGroup extends SubCommand<User> {
             save(user, sender, plugin);
             return CommandResult.SUCCESS;
         } catch (ObjectAlreadyHasException e) {
-            Message.USER_ALREADY_MEMBER_OF.send(sender, user.getName(), group.getName());
+            Message.USER_ALREADY_MEMBER_OF.send(sender, user.getName(), group.getDisplayName());
             return CommandResult.STATE_ERROR;
         }
     }

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserAddPrefix.java

@@ -38,8 +38,8 @@ import java.util.List;
 
 public class UserAddPrefix extends SubCommand<User> {
     public UserAddPrefix() {
-        super("addprefix", "Adds a prefix to the user", "/%s user <user> addprefix <priority> <prefix> [server] [world]",
-                Permission.USER_ADDPREFIX, Predicate.notInRange(2, 4));
+        super("addprefix", "Adds a prefix to the user", "<priority> <prefix> [server] [world]", Permission.USER_ADDPREFIX,
+                Predicate.notInRange(2, 4));
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserAddSuffix.java

@@ -38,8 +38,8 @@ import java.util.List;
 
 public class UserAddSuffix extends SubCommand<User> {
     public UserAddSuffix() {
-        super("addsuffix", "Adds a suffix to the user", "/%s user <user> addsuffix <priority> <suffix> [server] [world]",
-                Permission.USER_ADDSUFFIX, Predicate.notInRange(2, 4));
+        super("addsuffix", "Adds a suffix to the user", "<priority> <suffix> [server] [world]", Permission.USER_ADDSUFFIX,
+                Predicate.notInRange(2, 4));
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserAddTempGroup.java

@@ -40,9 +40,8 @@ import java.util.List;
 
 public class UserAddTempGroup extends SubCommand<User> {
     public UserAddTempGroup() {
-        super("addtempgroup", "Adds the user to a group temporarily",
-                "/%s user <user> addtempgroup <group> <duration> [server] [world]", Permission.USER_ADDTEMPGROUP,
-                Predicate.notInRange(2, 4));
+        super("addtempgroup", "Adds the user to a group temporarily", "<group> <duration> [server] [world]",
+                Permission.USER_ADDTEMPGROUP, Predicate.notInRange(2, 4));
     }
 
     @Override
@@ -50,7 +49,7 @@ public class UserAddTempGroup extends SubCommand<User> {
         String groupName = args.get(0).toLowerCase();
 
         if (ArgumentChecker.checkNode(groupName)) {
-            sendUsage(sender, label);
+            sendUsage(sender);
             return CommandResult.INVALID_ARGS;
         }
 
@@ -92,7 +91,7 @@ public class UserAddTempGroup extends SubCommand<User> {
 
                 if (args.size() == 3) {
                     user.addGroup(group, server, duration);
-                    Message.USER_ADDTEMPGROUP_SERVER_SUCCESS.send(sender, user.getName(), groupName, server,
+                    Message.USER_ADDTEMPGROUP_SERVER_SUCCESS.send(sender, user.getName(), group.getDisplayName(), server,
                             DateUtil.formatDateDiff(duration));
                     LogEntry.build().actor(sender).acted(user)
                             .action("addtempgroup " + group.getName() + " " + duration + " " + server)
@@ -100,7 +99,7 @@ public class UserAddTempGroup extends SubCommand<User> {
                 } else {
                     final String world = args.get(3).toLowerCase();
                     user.addGroup(group, server, world, duration);
-                    Message.USER_ADDTEMPGROUP_SERVER_WORLD_SUCCESS.send(sender, user.getName(), groupName, server,
+                    Message.USER_ADDTEMPGROUP_SERVER_WORLD_SUCCESS.send(sender, user.getName(), group.getDisplayName(), server,
                             world, DateUtil.formatDateDiff(duration));
                     LogEntry.build().actor(sender).acted(user)
                             .action("addtempgroup " + group.getName() + " " + duration + " " + server + " " + world)
@@ -109,7 +108,7 @@ public class UserAddTempGroup extends SubCommand<User> {
 
             } else {
                 user.addGroup(group, duration);
-                Message.USER_ADDTEMPGROUP_SUCCESS.send(sender, user.getName(), groupName, DateUtil.formatDateDiff(duration));
+                Message.USER_ADDTEMPGROUP_SUCCESS.send(sender, user.getName(), group.getDisplayName(), DateUtil.formatDateDiff(duration));
                 LogEntry.build().actor(sender).acted(user)
                         .action("addtempgroup " + group.getName() + " " + duration)
                         .build().submit(plugin, sender);
@@ -118,7 +117,7 @@ public class UserAddTempGroup extends SubCommand<User> {
             save(user, sender, plugin);
             return CommandResult.SUCCESS;
         } catch (ObjectAlreadyHasException e) {
-            Message.USER_ALREADY_TEMP_MEMBER_OF.send(sender, user.getName(), group.getName());
+            Message.USER_ALREADY_TEMP_MEMBER_OF.send(sender, user.getName(), group.getDisplayName());
             return CommandResult.STATE_ERROR;
         }
     }