API changes for 2.11

api/pom.xml

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

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

@@ -0,0 +1,155 @@
+/*
+ * 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;
+
+import com.google.common.collect.ImmutableMap;
+
+import java.util.Collections;
+import java.util.Map;
+
+/**
+ * Represents the context and options for a permission lookup.
+ * All values are immutable.
+ * @since 2.11
+ */
+public class Contexts {
+    public static final String SERVER_KEY = "server";
+    public static final String WORLD_KEY = "world";
+
+    /**
+     * Gets a context that will allow all nodes
+     * @return a context that will not apply any filters
+     */
+    public static Contexts allowAll() {
+        return new Contexts(Collections.emptyMap(), true, true, true, true, true);
+    }
+
+    public static Contexts of(Map<String, String> context, boolean includeGlobal, boolean includeGlobalWorld, boolean applyGroups, boolean applyGlobalGroups, boolean applyGlobalWorldGroups) {
+        return new Contexts(context, includeGlobal, includeGlobalWorld, applyGroups, applyGlobalGroups, applyGlobalWorldGroups);
+    }
+
+    public Contexts(Map<String, String> context, boolean includeGlobal, boolean includeGlobalWorld, boolean applyGroups, boolean applyGlobalGroups, boolean applyGlobalWorldGroups) {
+        if (context == null) {
+            throw new NullPointerException("context");
+        }
+
+        this.context = ImmutableMap.copyOf(context);
+        this.includeGlobal = includeGlobal;
+        this.includeGlobalWorld = includeGlobalWorld;
+        this.applyGroups = applyGroups;
+        this.applyGlobalGroups = applyGlobalGroups;
+        this.applyGlobalWorldGroups = applyGlobalWorldGroups;
+    }
+
+    /**
+     * The contexts that apply for this lookup
+     *
+     * The keys for servers and worlds are defined as static values.
+     */
+    private final Map<String, String> context;
+
+    /**
+     * If global or non server specific nodes should be applied
+     */
+    private final boolean includeGlobal;
+
+    /**
+     * If global or non world specific nodes should be applied
+     */
+    private final boolean includeGlobalWorld;
+
+    /**
+     * If parent groups should be applied
+     */
+    private final boolean applyGroups;
+
+    /**
+     * If global or non server specific group memberships should be applied
+     */
+    private final boolean applyGlobalGroups;
+
+    /**
+     * If global or non world specific group memberships should be applied
+     */
+    private final boolean applyGlobalWorldGroups;
+
+    /**
+     * Gets the contexts that apply for this lookup
+     * @return an immutable map of context key value pairs
+     */
+    public Map<String, String> getContext() {
+        return this.context;
+    }
+
+    /**
+     * Gets if global or non server specific nodes should be applied
+     * @return true if global or non server specific nodes should be applied
+     */
+    public boolean isIncludeGlobal() {
+        return this.includeGlobal;
+    }
+
+    /**
+     * Gets if global or non world specific nodes should be applied
+     * @return true if global or non world specific nodes should be applied
+     */
+    public boolean isIncludeGlobalWorld() {
+        return this.includeGlobalWorld;
+    }
+
+    /**
+     * Gets if parent groups should be applied
+     * @return true if parent groups should be applied
+     */
+    public boolean isApplyGroups() {
+        return this.applyGroups;
+    }
+
+    /**
+     * Gets if global or non server specific group memberships should be applied
+     * @return true if global or non server specific group memberships should be applied
+     */
+    public boolean isApplyGlobalGroups() {
+        return this.applyGlobalGroups;
+    }
+
+    /**
+     * Gets if global or non world specific group memberships should be applied
+     * @return true if global or non world specific group memberships should be applied
+     */
+    public boolean isApplyGlobalWorldGroups() {
+        return this.applyGlobalWorldGroups;
+    }
+
+    public String toString() {
+        return "Contexts(" +
+                "context=" + this.getContext() + ", " +
+                "includeGlobal=" + this.isIncludeGlobal() + ", " +
+                "includeGlobalWorld=" + this.isIncludeGlobalWorld() + ", " +
+                "applyGroups=" + this.isApplyGroups() + ", " +
+                "applyGlobalGroups=" + this.isApplyGlobalGroups() + ", " +
+                "applyGlobalWorldGroups=" + this.isApplyGlobalWorldGroups() +
+                ")";
+    }
+
+}

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

@@ -0,0 +1,44 @@
+/*
+ * 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;
+
+/**
+ * Represents a Node and where it was inherited from.
+ * @since 2.11
+ */
+public interface LocalizedNode extends Node {
+
+    /**
+     * Gets the node
+     * @return the node this instance is representing
+     */
+    Node getNode();
+
+    /**
+     * Gets the location where the {@link Node} is inherited from
+     * @return where the node was inherited from. Will not return null.
+     * @see PermissionHolder#getObjectName()
+     */
+    String getLocation();
+
+}

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

@@ -47,7 +47,7 @@ public interface PermissionHolder {
      * @return an immutable set of permissions in priority order
      * @since 2.6
      */
-    SortedSet<Node> getPermissions();
+    SortedSet<? extends Node> getPermissions();
 
     /**
      * Similar to {@link #getPermissions()}, except excluding transient permissions
@@ -68,9 +68,34 @@ public interface PermissionHolder {
      * Gets an immutable set of the nodes that this object has and inherits
      * @return an immutable set of permissions
      * @since 2.6
+     * @deprecated in favour of {@link #getAllNodes(Contexts)}
      */
+    @Deprecated
     Set<Node> getAllNodes();
 
+    /**
+     * Gets a mutable sorted set of the nodes that this object has and inherits, filtered by context
+     * Unlike {@link #getAllNodesFiltered(Contexts)}, this method will not filter individual nodes. The context is only
+     * used to determine which groups should apply.
+     * Nodes are sorted into priority order.
+     * @param contexts the context for the lookup,
+     * @return a mutable sorted set of permissions
+     * @throws NullPointerException if the context is null
+     * @since 2.11
+     */
+    SortedSet<LocalizedNode> getAllNodes(Contexts contexts);
+
+    /**
+     * Gets a mutable set of the nodes that is objects has and inherits, filtered by context.
+     * Unlike {@link #getAllNodes(Contexts)}, this method WILL filter individual nodes, and only return ones that fully
+     * meet the context provided.
+     * @param contexts the context for the lookup
+     * @return a mutable set of permissions
+     * @throws NullPointerException if the context is null
+     * @since 2.11
+     */
+    Set<LocalizedNode> getAllNodesFiltered(Contexts contexts);
+
     /**
      * Gets an immutable Map of the objects permission nodes
      * @return an immutable map of permissions
@@ -499,7 +524,9 @@ public interface PermissionHolder {
      * @param applyGroups if inherited group permissions should be included
      * @return a map of permissions
      * @since 2.6
+     * @deprecated in favour of {@link #getAllNodesFiltered(Contexts)}
      */
+    @Deprecated
     Map<String, Boolean> getPermissions(String server, String world, Map<String, String> extraContext, boolean includeGlobal, List<String> possibleNodes, boolean applyGroups);
 
     /**

bukkit-legacy/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>luckperms</artifactId>
         <groupId>me.lucko.luckperms</groupId>
-        <version>2.10-SNAPSHOT</version>
+        <version>2.11-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.10-SNAPSHOT</version>
+        <version>2.11-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.10-SNAPSHOT</version>
+        <version>2.11-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

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

@@ -22,6 +22,7 @@
 
 package me.lucko.luckperms;
 
+import me.lucko.luckperms.api.Contexts;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.inject.Injector;
 import me.lucko.luckperms.inject.LPPermissible;
@@ -34,6 +35,8 @@ import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
 import org.bukkit.event.player.*;
 
+import java.util.Collections;
+import java.util.Map;
 import java.util.UUID;
 
 class BukkitListener extends AbstractListener implements Listener {
@@ -52,7 +55,41 @@ class BukkitListener extends AbstractListener implements Listener {
             return;
         }
 
+        // Process login
         onAsyncLogin(e.getUniqueId(), e.getName());
+
+        // Pre-process the user's permissions, so they're ready for PLE.
+        BukkitUser user = (BukkitUser) plugin.getUserManager().get(plugin.getUuidCache().getUUID(e.getUniqueId()));
+        Map<String, Boolean> toApply = user.exportNodes(
+                new Contexts(
+                        Collections.singletonMap("server", plugin.getConfiguration().getServer()),
+                        plugin.getConfiguration().isIncludingGlobalPerms(),
+                        plugin.getConfiguration().isIncludingGlobalWorldPerms(),
+                        true,
+                        plugin.getConfiguration().isApplyingGlobalGroups(),
+                        plugin.getConfiguration().isApplyingGlobalWorldGroups()
+                ),
+                Collections.emptyList(),
+                true
+        );
+        user.setLoginPreProcess(toApply);
+
+        // Hook with Vault early
+        if (plugin.getVaultHook() != null && plugin.getVaultHook().isHooked()) {
+            plugin.getVaultHook().getPermissionHook().getVaultUserManager().setupUser(user);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void onPlayerPreLoginMonitor(AsyncPlayerPreLoginEvent e) {
+        if (plugin.getDatastore().isAcceptingLogins() && e.getLoginResult() != AsyncPlayerPreLoginEvent.Result.ALLOWED) {
+            // Login event was cancelled by another plugin
+            final UUID internal = plugin.getUuidCache().getUUID(e.getUniqueId());
+            onLeave(e.getUniqueId());
+            if (plugin.getVaultHook() != null && plugin.getVaultHook().isHooked()) {
+                plugin.getVaultHook().getPermissionHook().getVaultUserManager().clearUser(internal);
+            }
+        }
     }
 
     @EventHandler(priority = EventPriority.LOWEST)
@@ -65,19 +102,39 @@ class BukkitListener extends AbstractListener implements Listener {
             return;
         }
 
-        if (user instanceof BukkitUser) {
-            BukkitUser u = (BukkitUser) user;
+        BukkitUser u = (BukkitUser) user;
+        try {
+            // Make a new permissible for the user
+            LPPermissible lpPermissible = new LPPermissible(player, plugin, plugin.getDefaultsProvider());
 
-            try {
-                LPPermissible lpPermissible = new LPPermissible(player, plugin, plugin.getDefaultsProvider());
-                Injector.inject(player, lpPermissible);
-                u.setLpPermissible(lpPermissible);
-            } catch (Throwable t) {
-                t.printStackTrace();
-            }
+            // Insert the pre-processed permissions into the permissible
+            lpPermissible.getLuckPermsPermissions().putAll(u.getLoginPreProcess());
+            u.setLoginPreProcess(null);
+
+            // Inject into the player
+            Injector.inject(player, lpPermissible);
+            u.setLpPermissible(lpPermissible);
+
+        } catch (Throwable t) {
+            t.printStackTrace();
         }
+    }
 
-        plugin.doAsync(user::refreshPermissions);
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void onPlayerLoginMonitor(PlayerLoginEvent e) {
+        if (e.getResult() != PlayerLoginEvent.Result.ALLOWED) {
+            // The player got denied on sync login.
+            final UUID internal = plugin.getUuidCache().getUUID(e.getPlayer().getUniqueId());
+            onLeave(e.getPlayer().getUniqueId());
+            if (plugin.getVaultHook() != null && plugin.getVaultHook().isHooked()) {
+                plugin.getVaultHook().getPermissionHook().getVaultUserManager().clearUser(internal);
+            }
+        } else {
+            User user = plugin.getUserManager().get(plugin.getUuidCache().getUUID(e.getPlayer().getUniqueId()));
+
+            // Call another update to calculate full context. (incl. per world permissions)
+            plugin.doAsync(user::refreshPermissions);
+        }
     }
 
     @EventHandler(priority = EventPriority.LOWEST)
@@ -90,8 +147,12 @@ class BukkitListener extends AbstractListener implements Listener {
 
     @EventHandler(priority = EventPriority.LOWEST)
     public void onPlayerQuit(PlayerQuitEvent e) {
-        plugin.getWorldCalculator().getWorldCache().remove(plugin.getUuidCache().getUUID(e.getPlayer().getUniqueId()));
+        final UUID internal = plugin.getUuidCache().getUUID(e.getPlayer().getUniqueId());
+        plugin.getWorldCalculator().getWorldCache().remove(internal);
         onLeave(e.getPlayer().getUniqueId());
+        if (plugin.getVaultHook() != null && plugin.getVaultHook().isHooked()) {
+            plugin.getVaultHook().getPermissionHook().getVaultUserManager().clearUser(internal);
+        }
     }
 
     @EventHandler

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

@@ -28,6 +28,7 @@ import me.lucko.luckperms.api.LuckPermsApi;
 import me.lucko.luckperms.api.PlatformType;
 import me.lucko.luckperms.api.implementation.ApiProvider;
 import me.lucko.luckperms.api.vault.VaultHook;
+import me.lucko.luckperms.calculators.DefaultsProvider;
 import me.lucko.luckperms.commands.ConsecutiveExecutor;
 import me.lucko.luckperms.commands.Sender;
 import me.lucko.luckperms.config.LPConfiguration;
@@ -38,7 +39,6 @@ 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;
@@ -62,6 +62,8 @@ import java.util.stream.Collectors;
 
 @Getter
 public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
+    private VaultHook vaultHook = null;
+
     private final Set<UUID> ignoringLogs = ConcurrentHashMap.newKeySet();
     private LPConfiguration configuration;
     private BukkitUserManager userManager;
@@ -142,7 +144,8 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
         getLog().info("Attempting to hook into Vault...");
         try {
             if (getServer().getPluginManager().isPluginEnabled("Vault")) {
-                VaultHook.hook(this);
+                vaultHook = new VaultHook();
+                vaultHook.hook(this);
                 getLog().info("Registered Vault permission & chat hook.");
             } else {
                 getLog().info("Vault not found.");
@@ -181,6 +184,10 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
         getLog().info("Unregistering API...");
         LuckPerms.unregisterProvider();
         getServer().getServicesManager().unregisterAll(this);
+
+        if (vaultHook != null) {
+            vaultHook.unhook(this);
+        }
     }
 
     @Override

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

@@ -23,18 +23,21 @@
 package me.lucko.luckperms.api.vault;
 
 import lombok.NonNull;
-import lombok.Setter;
-import me.lucko.luckperms.LPBukkitPlugin;
+import me.lucko.luckperms.api.Contexts;
 import me.lucko.luckperms.api.Node;
-import me.lucko.luckperms.contexts.Contexts;
+import me.lucko.luckperms.api.vault.cache.ChatCache;
+import me.lucko.luckperms.api.vault.cache.VaultUser;
 import me.lucko.luckperms.core.PermissionHolder;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.users.User;
 import net.milkbowl.vault.chat.Chat;
 
-import java.util.Iterator;
+import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
+import java.util.stream.Collectors;
 
 import static me.lucko.luckperms.utils.ArgumentChecker.escapeCharacters;
 import static me.lucko.luckperms.utils.ArgumentChecker.unescapeCharacters;
@@ -54,13 +57,8 @@ import static me.lucko.luckperms.utils.ArgumentChecker.unescapeCharacters;
  *
  * Node that special characters used within LuckPerms are escaped:
  * See {@link me.lucko.luckperms.utils.ArgumentChecker#escapeCharacters(String)}
- *
- * Registered on normal priority so other plugins can override.
  */
 public class VaultChatHook extends Chat {
-
-    @Setter
-    private LPBukkitPlugin plugin;
     private final VaultPermissionHook perms;
 
     VaultChatHook(VaultPermissionHook perms) {
@@ -79,38 +77,103 @@ public class VaultChatHook extends Chat {
     private void saveMeta(PermissionHolder holder, String world, String node, String value) {
         if (holder == null) return;
         if (node.equals("")) return;
-        node = escapeCharacters(node);
-        value = escapeCharacters(value);
 
-        Iterator<Node> nodes = holder.getNodes().iterator();
-        while (nodes.hasNext()) {
-            Node n = nodes.next();
-            if (n.isMeta() && n.getMeta().getKey().equals(node)) {
-                nodes.remove();
+        perms.scheduleTask(() -> {
+            String k = escapeCharacters(node);
+            String v = escapeCharacters(value);
+
+            List<Node> toRemove = holder.getNodes().stream()
+                    .filter(n -> n.isMeta() && n.getMeta().getKey().equals(k))
+                    .collect(Collectors.toList());
+
+            toRemove.forEach(n -> {
+                try {
+                    holder.unsetPermission(n);
+                } catch (ObjectLacksException ignored) {}
+            });
+
+            Node.Builder metaNode = new me.lucko.luckperms.core.Node.Builder("meta." + k + "." + v).setValue(true);
+            if (!perms.getServer().equalsIgnoreCase("global")) {
+                metaNode.setServer(perms.getServer());
+            }
+            if (world != null && !world.equals("")) {
+                metaNode.setServer(perms.getServer()).setWorld(world);
             }
-        }
 
-        Node.Builder metaNode = new me.lucko.luckperms.core.Node.Builder("meta." + node + "." + value).setValue(true);
-        if (!perms.getServer().equalsIgnoreCase("global")) {
-            metaNode.setServer(perms.getServer());
-        }
-        if (world != null && !world.equals("")) {
-            metaNode.setServer(perms.getServer()).setWorld(world);
-        }
+            try {
+                holder.setPermission(metaNode.build());
+            } catch (ObjectAlreadyHasException ignored) {}
 
-        try {
-            holder.setPermission(metaNode.build());
-        } catch (ObjectAlreadyHasException ignored) {}
-        
-        perms.objectSave(holder);
+            perms.save(holder);
+        });
     }
 
-    private String getMeta(PermissionHolder holder, String world, String node, String defaultValue) {
-        if (holder == null) return defaultValue;
+    private void setChatMeta(boolean prefix, PermissionHolder holder, String value, String world) {
+        if (holder == null) return;
+        if (value.equals("")) return;
+
+        perms.scheduleTask(() -> {
+            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());
+            }
+
+            if (world != null && !world.equals("")) {
+                node.setServer(perms.getServer()).setWorld(world);
+            }
+
+            try {
+                holder.setPermission(node.build());
+            } catch (ObjectAlreadyHasException ignored) {}
+
+            perms.save(holder);
+        });
+    }
+
+    private String getUserMeta(User user, String world, String node, String defaultValue) {
+        if (user == null) return defaultValue;
+        node = escapeCharacters(node);
+
+        if (!perms.getVaultUserManager().containsUser(user.getUuid())) {
+            return defaultValue;
+        }
+
+        VaultUser vaultUser = perms.getVaultUserManager().getUser(user.getUuid());
+        Map<String, String> context = new HashMap<>();
+        context.put("server", perms.getServer());
+        if (world != null) {
+            context.put("world", world);
+        }
+
+        ChatCache cd = vaultUser.processChatData(context);
+        return unescapeCharacters(cd.getMeta().getOrDefault(node, defaultValue));
+    }
+
+    private String getUserChatMeta(boolean prefix, User user, String world) {
+        if (user == null) return "";
+
+        if (!perms.getVaultUserManager().containsUser(user.getUuid())) {
+            return "";
+        }
+
+        VaultUser vaultUser = perms.getVaultUserManager().getUser(user.getUuid());
+        Map<String, String> context = new HashMap<>();
+        context.put("server", perms.getServer());
+        if (world != null) {
+            context.put("world", world);
+        }
+
+        ChatCache cd = vaultUser.processChatData(context);
+        return unescapeCharacters(prefix ? (cd.getPrefix() == null ? "" : cd.getPrefix()) : (cd.getSuffix() == null ? "" : cd.getSuffix()));
+    }
+
+    private String getGroupMeta(Group group, String world, String node, String defaultValue) {
+        if (group == null) return defaultValue;
         if (node.equals("")) return defaultValue;
         node = escapeCharacters(node);
 
-        for (Node n : holder.getPermissions(true)) {
+        for (Node n : group.getPermissions(true)) {
             if (!n.getValue()) {
                 continue;
             }
@@ -136,34 +199,19 @@ public class VaultChatHook extends Chat {
         return defaultValue;
     }
 
-    private void setChatMeta(boolean prefix, PermissionHolder holder, String value, String world) {
-        if (holder == null) return;
-        if (value.equals("")) return;
-
-        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());
-        }
-
-        if (world != null && !world.equals("")) {
-            node.setServer(perms.getServer()).setWorld(world);
-        }
-
-        try {
-            holder.setPermission(node.build());
-        } catch (ObjectAlreadyHasException ignored) {}
-
-        perms.objectSave(holder);
-    }
-
-    private String getChatMeta(boolean prefix, PermissionHolder holder, String world) {
-        if (holder == null) return "";
+    private String getGroupChatMeta(boolean prefix, Group group, String world) {
+        if (group == null) return "";
 
         int priority = Integer.MIN_VALUE;
         String meta = null;
 
-        for (Node n : holder.getAllNodes(null, Contexts.allowAll())) {
+        Map<String, String> context = new HashMap<>();
+        context.put("server", perms.getServer());
+        if (world != null) {
+            context.put("world", world);
+        }
+
+        for (Node n : group.getAllNodes(null, new Contexts(context, perms.isIncludeGlobal(), true, true, true, true))) {
             if (!n.getValue()) {
                 continue;
             }
@@ -191,104 +239,104 @@ public class VaultChatHook extends Chat {
     }
 
     public String getPlayerPrefix(String world, @NonNull String player) {
-        final User user = plugin.getUserManager().get(player);
-        return getChatMeta(true, user, world);
+        final User user = perms.getPlugin().getUserManager().get(player);
+        return getUserChatMeta(true, user, world);
     }
 
     public void setPlayerPrefix(String world, @NonNull String player, @NonNull String prefix) {
-        final User user = plugin.getUserManager().get(player);
+        final User user = perms.getPlugin().getUserManager().get(player);
         setChatMeta(true, user, prefix, world);
     }
 
     public String getPlayerSuffix(String world, @NonNull String player) {
-        final User user = plugin.getUserManager().get(player);
-        return getChatMeta(false, user, world);
+        final User user = perms.getPlugin().getUserManager().get(player);
+        return getUserChatMeta(false, user, world);
     }
 
     public void setPlayerSuffix(String world, @NonNull String player, @NonNull String suffix) {
-        final User user = plugin.getUserManager().get(player);
+        final User user = perms.getPlugin().getUserManager().get(player);
         setChatMeta(false, user, suffix, world);
     }
 
     public String getGroupPrefix(String world, @NonNull String group) {
-        final Group g = plugin.getGroupManager().get(group);
-        return getChatMeta(false, g, world);
+        final Group g = perms.getPlugin().getGroupManager().get(group);
+        return getGroupChatMeta(false, g, world);
     }
 
     public void setGroupPrefix(String world, @NonNull String group, @NonNull String prefix) {
-        final Group g = plugin.getGroupManager().get(group);
+        final Group g = perms.getPlugin().getGroupManager().get(group);
         setChatMeta(true, g, prefix, world);
     }
 
     public String getGroupSuffix(String world, @NonNull String group) {
-        final Group g = plugin.getGroupManager().get(group);
-        return getChatMeta(false, g, world);
+        final Group g = perms.getPlugin().getGroupManager().get(group);
+        return getGroupChatMeta(false, g, world);
     }
 
     public void setGroupSuffix(String world, @NonNull String group, @NonNull String suffix) {
-        final Group g = plugin.getGroupManager().get(group);
+        final Group g = perms.getPlugin().getGroupManager().get(group);
         setChatMeta(false, g, suffix, world);
     }
 
     public int getPlayerInfoInteger(String world, @NonNull String player, @NonNull String node, int defaultValue) {
-        final User user = plugin.getUserManager().get(player);
+        final User user = perms.getPlugin().getUserManager().get(player);
         try {
-            return Integer.parseInt(getMeta(user, world, node, String.valueOf(defaultValue)));
+            return Integer.parseInt(getUserMeta(user, world, node, String.valueOf(defaultValue)));
         } catch (NumberFormatException e) {
             return defaultValue;
         }
     }
 
     public void setPlayerInfoInteger(String world, @NonNull String player, @NonNull String node, int value) {
-        final User user = plugin.getUserManager().get(player);
+        final User user = perms.getPlugin().getUserManager().get(player);
         saveMeta(user, world, node, String.valueOf(value));
     }
 
     public int getGroupInfoInteger(String world, @NonNull String group, @NonNull String node, int defaultValue) {
-        final Group g = plugin.getGroupManager().get(group);
+        final Group g = perms.getPlugin().getGroupManager().get(group);
         try {
-            return Integer.parseInt(getMeta(g, world, node, String.valueOf(defaultValue)));
+            return Integer.parseInt(getGroupMeta(g, world, node, String.valueOf(defaultValue)));
         } catch (NumberFormatException e) {
             return defaultValue;
         }
     }
 
     public void setGroupInfoInteger(String world, @NonNull String group, @NonNull String node, int value) {
-        final Group g = plugin.getGroupManager().get(group);
+        final Group g = perms.getPlugin().getGroupManager().get(group);
         saveMeta(g, world, node, String.valueOf(value));
     }
 
     public double getPlayerInfoDouble(String world, @NonNull String player, @NonNull String node, double defaultValue) {
-        final User user = plugin.getUserManager().get(player);
+        final User user = perms.getPlugin().getUserManager().get(player);
         try {
-            return Double.parseDouble(getMeta(user, world, node, String.valueOf(defaultValue)));
+            return Double.parseDouble(getUserMeta(user, world, node, String.valueOf(defaultValue)));
         } catch (NumberFormatException e) {
             return defaultValue;
         }
     }
 
     public void setPlayerInfoDouble(String world, @NonNull String player, @NonNull String node, double value) {
-        final User user = plugin.getUserManager().get(player);
+        final User user = perms.getPlugin().getUserManager().get(player);
         saveMeta(user, world, node, String.valueOf(value));
     }
 
     public double getGroupInfoDouble(String world, @NonNull String group, @NonNull String node, double defaultValue) {
-        final Group g = plugin.getGroupManager().get(group);
+        final Group g = perms.getPlugin().getGroupManager().get(group);
         try {
-            return Double.parseDouble(getMeta(g, world, node, String.valueOf(defaultValue)));
+            return Double.parseDouble(getGroupMeta(g, world, node, String.valueOf(defaultValue)));
         } catch (NumberFormatException e) {
             return defaultValue;
         }
     }
 
     public void setGroupInfoDouble(String world, @NonNull String group, @NonNull String node, double value) {
-        final Group g = plugin.getGroupManager().get(group);
+        final Group g = perms.getPlugin().getGroupManager().get(group);
         saveMeta(g, world, node, String.valueOf(value));
     }
 
     public boolean getPlayerInfoBoolean(String world, @NonNull String player, @NonNull String node, boolean defaultValue) {
-        final User user = plugin.getUserManager().get(player);
-        String s = getMeta(user, world, node, String.valueOf(defaultValue));
+        final User user = perms.getPlugin().getUserManager().get(player);
+        String s = getUserMeta(user, world, node, String.valueOf(defaultValue));
         if (!s.equalsIgnoreCase("true") && !s.equalsIgnoreCase("false")) {
             return defaultValue;
         }
@@ -296,13 +344,13 @@ public class VaultChatHook extends Chat {
     }
 
     public void setPlayerInfoBoolean(String world, @NonNull String player, @NonNull String node, boolean value) {
-        final User user = plugin.getUserManager().get(player);
+        final User user = perms.getPlugin().getUserManager().get(player);
         saveMeta(user, world, node, String.valueOf(value));
     }
 
     public boolean getGroupInfoBoolean(String world, @NonNull String group, @NonNull String node, boolean defaultValue) {
-        final Group g = plugin.getGroupManager().get(group);
-        String s = getMeta(g, world, node, String.valueOf(defaultValue));
+        final Group g = perms.getPlugin().getGroupManager().get(group);
+        String s = getGroupMeta(g, world, node, String.valueOf(defaultValue));
         if (!s.equalsIgnoreCase("true") && !s.equalsIgnoreCase("false")) {
             return defaultValue;
         }
@@ -310,27 +358,27 @@ public class VaultChatHook extends Chat {
     }
 
     public void setGroupInfoBoolean(String world, @NonNull String group, @NonNull String node, boolean value) {
-        final Group g = plugin.getGroupManager().get(group);
+        final Group g = perms.getPlugin().getGroupManager().get(group);
         saveMeta(g, world, node, String.valueOf(value));
     }
 
     public String getPlayerInfoString(String world, @NonNull String player, @NonNull String node, String defaultValue) {
-        final User user = plugin.getUserManager().get(player);
-        return getMeta(user, world, node, defaultValue);
+        final User user = perms.getPlugin().getUserManager().get(player);
+        return getUserMeta(user, world, node, defaultValue);
     }
 
     public void setPlayerInfoString(String world, @NonNull String player, @NonNull String node, String value) {
-        final User user = plugin.getUserManager().get(player);
+        final User user = perms.getPlugin().getUserManager().get(player);
         saveMeta(user, world, node, value);
     }
 
     public String getGroupInfoString(String world, @NonNull String group, @NonNull String node, String defaultValue) {
-        final Group g = plugin.getGroupManager().get(group);
-        return getMeta(g, world, node, defaultValue);
+        final Group g = perms.getPlugin().getGroupManager().get(group);
+        return getGroupMeta(g, world, node, defaultValue);
     }
 
     public void setGroupInfoString(String world, @NonNull String group, @NonNull String node, String value) {
-        final Group g = plugin.getGroupManager().get(group);
+        final Group g = perms.getPlugin().getGroupManager().get(group);
         saveMeta(g, world, node, value);
     }
 

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

@@ -22,18 +22,19 @@
 
 package me.lucko.luckperms.api.vault;
 
+import lombok.Getter;
 import me.lucko.luckperms.LPBukkitPlugin;
 import net.milkbowl.vault.chat.Chat;
 import net.milkbowl.vault.permission.Permission;
 import org.bukkit.plugin.ServicePriority;
 import org.bukkit.plugin.ServicesManager;
 
+@Getter
 public class VaultHook {
+    private VaultChatHook chatHook = null;
+    private VaultPermissionHook permissionHook = null;
 
-    private static VaultChatHook chatHook = null;
-    private static VaultPermissionHook permissionHook = null;
-
-    public static void hook(LPBukkitPlugin plugin) {
+    public void hook(LPBukkitPlugin plugin) {
         try {
             if (permissionHook == null) {
                 permissionHook = new VaultPermissionHook();
@@ -41,21 +42,33 @@ public class VaultHook {
             permissionHook.setPlugin(plugin);
             permissionHook.setServer(plugin.getConfiguration().getVaultServer());
             permissionHook.setIncludeGlobal(plugin.getConfiguration().isVaultIncludingGlobal());
+            permissionHook.setup();
 
             if (chatHook == null) {
                 chatHook = new VaultChatHook(permissionHook);
             }
-            chatHook.setPlugin(plugin);
 
             final ServicesManager sm = plugin.getServer().getServicesManager();
-            sm.unregisterAll(plugin);
             sm.register(Permission.class, permissionHook, plugin, ServicePriority.High);
-            sm.register(Chat.class, chatHook, plugin, ServicePriority.Low);
+            sm.register(Chat.class, chatHook, plugin, ServicePriority.High);
 
         } catch (Exception e) {
             e.printStackTrace();
         }
+    }
 
+    public void unhook(LPBukkitPlugin plugin) {
+        final ServicesManager sm = plugin.getServer().getServicesManager();
+        if (permissionHook != null) {
+            sm.unregister(Permission.class, permissionHook);
+        }
+        if (chatHook != null) {
+            sm.unregister(Chat.class, chatHook);
+        }
+    }
+
+    public boolean isHooked() {
+        return permissionHook != null && chatHook != null;
     }
 
 }

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

@@ -26,7 +26,10 @@ import lombok.Getter;
 import lombok.NonNull;
 import lombok.Setter;
 import me.lucko.luckperms.LPBukkitPlugin;
-import me.lucko.luckperms.api.data.Callback;
+import me.lucko.luckperms.api.Contexts;
+import me.lucko.luckperms.api.Node;
+import me.lucko.luckperms.api.vault.cache.VaultUser;
+import me.lucko.luckperms.api.vault.cache.VaultUserManager;
 import me.lucko.luckperms.core.PermissionHolder;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
@@ -34,11 +37,22 @@ import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.users.User;
 import net.milkbowl.vault.permission.Permission;
 
-public class VaultPermissionHook extends Permission {
+import java.util.*;
 
+/**
+ * The LuckPerms Vault Permission implementation
+ * Most lookups are cached.
+ */
+public class VaultPermissionHook extends Permission implements Runnable {
+    private final List<Runnable> tasks = new ArrayList<>();
+
+    @Getter
     @Setter
     private LPBukkitPlugin plugin;
 
+    @Getter
+    private VaultUserManager vaultUserManager;
+
     @Getter
     @Setter
     private String server = "global";
@@ -47,6 +61,34 @@ public class VaultPermissionHook extends Permission {
     @Setter
     private boolean includeGlobal = true;
 
+    public void setup() {
+        vaultUserManager = new VaultUserManager(plugin, this);
+        plugin.getServer().getScheduler().runTaskTimerAsynchronously(plugin, this, 1L, 1L);
+    }
+
+    public void log(String s) {
+        if (plugin.getConfiguration().isDebugPermissionChecks()) {
+            plugin.getLog().info("[VAULT] " + s);
+        }
+    }
+
+    void scheduleTask(Runnable r) {
+        synchronized (tasks) {
+            tasks.add(r);
+        }
+    }
+
+    @Override
+    public void run() {
+        List<Runnable> toRun = new ArrayList<>();
+        synchronized (tasks) {
+            toRun.addAll(tasks);
+            tasks.clear();
+        }
+
+        toRun.forEach(Runnable::run);
+    }
+
     @Override
     public String getName() {
         return "LuckPerms";
@@ -62,17 +104,24 @@ public class VaultPermissionHook extends Permission {
         return true;
     }
 
-    private boolean objectHas(String world, PermissionHolder object, String permission) {
-        if (object == null) return false;
+    private boolean objectHas(String world, Group group, String permission) {
+        if (group == null) return false;
 
+        Map<String, String> context = new HashMap<>();
         if (world != null && !world.equals("")) {
-            return object.hasPermission(permission, true, server, world);
-        } else {
-            return object.hasPermission(permission, true, server);
+            context.put("world", world);
         }
+        context.put("server", server);
+
+        Map<String, Boolean> toApply = group.exportNodes(
+                new Contexts(context, includeGlobal, includeGlobal, true, true, true),
+                Collections.emptyList(), true
+        );
+
+        return toApply.containsKey(permission) && toApply.get(permission);
     }
 
-    private boolean objectAdd(String world, PermissionHolder object, String permission) {
+    private boolean add(String world, PermissionHolder object, String permission) {
         if (object == null) return false;
 
         try {
@@ -83,11 +132,11 @@ public class VaultPermissionHook extends Permission {
             }
         } catch (ObjectAlreadyHasException ignored) {}
 
-        objectSave(object);
+        save(object);
         return true;
     }
 
-    private boolean objectRemove(String world, PermissionHolder object, String permission) {
+    private boolean remove(String world, PermissionHolder object, String permission) {
         if (object == null) return false;
 
         try {
@@ -98,118 +147,156 @@ public class VaultPermissionHook extends Permission {
             }
         } catch (ObjectLacksException ignored) {}
 
-        objectSave(object);
+        save(object);
         return true;
     }
 
-    void objectSave(PermissionHolder t) {
+    void save(PermissionHolder t) {
         if (t instanceof User) {
             ((User) t).refreshPermissions();
-            plugin.getDatastore().saveUser(((User) t), Callback.empty());
+            plugin.getDatastore().saveUser(((User) t));
         }
         if (t instanceof Group) {
-            plugin.getDatastore().saveGroup(((Group) t), c -> plugin.runUpdateTask());
+            plugin.getDatastore().saveGroup(((Group) t));
+            plugin.runUpdateTask();
         }
     }
 
     @Override
     public boolean playerHas(String world, @NonNull String player, @NonNull String permission) {
-        return objectHas(world, plugin.getUserManager().get(player), permission);
+        log("Checking if player " + player + " has permission: " + permission + " on world " + world + ", server " + server);
+        User user = plugin.getUserManager().get(player);
+        if (user == null) return false;
+
+        if (!vaultUserManager.containsUser(user.getUuid())) {
+            return false;
+        }
+
+        VaultUser vaultUser = vaultUserManager.getUser(user.getUuid());
+        Map<String, String> context = new HashMap<>();
+        context.put("server", server);
+        if (world != null) {
+            context.put("world", world);
+        }
+
+        return vaultUser.hasPermission(context, permission);
     }
 
     @Override
     public boolean playerAdd(String world, @NonNull String player, @NonNull String permission) {
+        log("Adding permission to player " + player + ": '" + permission + "' on world " + world + ", server " + server);
         final User user = plugin.getUserManager().get(player);
-        return objectAdd(world, user, permission);
+        scheduleTask(() -> add(world, user, permission));
+        return true;
     }
 
     @Override
     public boolean playerRemove(String world, @NonNull String player, @NonNull String permission) {
+        log("Removing permission from player " + player + ": '" + permission + "' on world " + world + ", server " + server);
         final User user = plugin.getUserManager().get(player);
-        return objectRemove(world, user, permission);
+        scheduleTask(() -> remove(world, user, permission));
+        return true;
     }
 
     @Override
     public boolean groupHas(String world, @NonNull String groupName, @NonNull String permission) {
+        log("Checking if group " + groupName + " has permission: " + permission + " on world " + world + ", server " + server);
         final Group group = plugin.getGroupManager().get(groupName);
         return objectHas(world, group, permission);
     }
 
     @Override
     public boolean groupAdd(String world, @NonNull String groupName, @NonNull String permission) {
+        log("Adding permission to group " + groupName + ": '" + permission + "' on world " + world + ", server " + server);
         final Group group = plugin.getGroupManager().get(groupName);
-        return objectAdd(world, group, permission);
+        scheduleTask(() -> add(world, group, permission));
+        return true;
     }
 
     @Override
     public boolean groupRemove(String world, @NonNull String groupName, @NonNull String permission) {
+        log("Removing permission from group " + groupName + ": '" + permission + "' on world " + world + ", server " + server);
         final Group group = plugin.getGroupManager().get(groupName);
-        return objectRemove(world, group, permission);
+        scheduleTask(() -> remove(world, group, permission));
+        return true;
     }
 
     @Override
     public boolean playerInGroup(String world, @NonNull String player, @NonNull String group) {
+        log("Checking if player " + player + " is in group: " + group + " on world " + world + ", server " + server);
         final User user = plugin.getUserManager().get(player);
         if (user == null) return false;
 
-        final Group group1 = plugin.getGroupManager().get(group);
-        if (group1 == null) return false;
-
-        if (world != null && !world.equals("")) {
-            return user.isInGroup(group1, server, world);
-        } else {
-            return user.isInGroup(group1);
-        }
+        return user.getNodes().stream()
+                .filter(Node::isGroupNode)
+                .filter(n -> n.shouldApplyOnServer(server, isIncludeGlobal(), false))
+                .filter(n -> n.shouldApplyOnWorld(world, true, false))
+                .map(Node::getGroupName)
+                .filter(s -> s.equalsIgnoreCase(group))
+                .findAny().isPresent();
     }
 
     @Override
     public boolean playerAddGroup(String world, @NonNull String player, @NonNull String groupName) {
+        log("Adding player " + player + " to group: '" + groupName + "' on world " + world + ", server " + server);
         final User user = plugin.getUserManager().get(player);
         if (user == null) return false;
 
         final Group group = plugin.getGroupManager().get(groupName);
         if (group == null) return false;
 
-        try {
-            if (world != null && !world.equals("")) {
-                user.addGroup(group, server, world);
-            } else {
-                user.addGroup(group);
-            }
-        } catch (ObjectAlreadyHasException ignored) {}
-        objectSave(user);
+        scheduleTask(() -> {
+            try {
+                if (world != null && !world.equals("")) {
+                    user.addGroup(group, server, world);
+                } else {
+                    user.addGroup(group, server);
+                }
+            } catch (ObjectAlreadyHasException ignored) {}
+            save(user);
+        });
         return true;
     }
 
     @Override
     public boolean playerRemoveGroup(String world, @NonNull String player, @NonNull String groupName) {
+        log("Removing player " + player + " from group: '" + groupName + "' on world " + world + ", server " + server);
         final User user = plugin.getUserManager().get(player);
         if (user == null) return false;
 
         final Group group = plugin.getGroupManager().get(groupName);
         if (group == null) return false;
 
-        try {
-            if (world != null && !world.equals("")) {
-                user.removeGroup(group, server, world);
-            } else {
-                user.removeGroup(group);
-            }
-        } catch (ObjectLacksException ignored) {}
-        objectSave(user);
+        scheduleTask(() -> {
+            try {
+                if (world != null && !world.equals("")) {
+                    user.removeGroup(group, server, world);
+                } else {
+                    user.removeGroup(group, server);
+                }
+            } catch (ObjectLacksException ignored) {}
+            save(user);
+        });
         return true;
     }
 
     @Override
     public String[] getPlayerGroups(String world, @NonNull String player) {
-        final User user = plugin.getUserManager().get(player);
-        return (user == null) ? new String[0] :
-                world != null && !world.equals("") ? user.getGroups(server, world, includeGlobal).toArray(new String[0]) :
-                        user.getGroupNames().toArray(new String[0]);
+        log("Getting groups of player: " + player + ", on world " + world + ", server " + server);
+        User user = plugin.getUserManager().get(player);
+        if (user == null) return new String[0];
+
+        return user.getNodes().stream()
+                .filter(Node::isGroupNode)
+                .filter(n -> n.shouldApplyOnServer(server, isIncludeGlobal(), false))
+                .filter(n -> n.shouldApplyOnWorld(world, true, false))
+                .map(Node::getGroupName)
+                .toArray(String[]::new);
     }
 
     @Override
     public String getPrimaryGroup(String world, @NonNull String player) {
+        log("Getting primary group of player: " + player);
         final User user = plugin.getUserManager().get(player);
         return (user == null) ? null : user.getPrimaryGroup();
     }

bukkit/src/main/java/me/lucko/luckperms/api/vault/cache/ChatCache.java

@@ -20,26 +20,32 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.contexts;
+package me.lucko.luckperms.api.vault.cache;
 
-import lombok.AllArgsConstructor;
 import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import lombok.Setter;
 
-import java.util.Collections;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 
 @Getter
-@AllArgsConstructor
-public class Contexts {
-    public static Contexts allowAll() {
-        return new Contexts(Collections.emptyMap(), true, true, true, true, true);
+@RequiredArgsConstructor
+public class ChatCache {
+    private final Map<String, String> context;
+
+    @Setter
+    private String prefix = null;
+
+    @Setter
+    private String suffix = null;
+
+    private Map<String, String> meta = new ConcurrentHashMap<>();
+
+    public void invalidateCache() {
+        prefix = null;
+        suffix = null;
+        meta.clear();
     }
 
-    private final Map<String, String> context;
-    private final boolean includeGlobal;
-    private final boolean includeGlobalWorld;
-    private final boolean applyGroups;
-    private final boolean applyGlobalGroups;
-    private final boolean applyGlobalWorldGroups;
-
 }

bukkit/src/main/java/me/lucko/luckperms/api/vault/cache/ContextCache.java

@@ -0,0 +1,72 @@
+/*
+ * 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.vault.cache;
+
+import lombok.Getter;
+import lombok.NonNull;
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.Tristate;
+import me.lucko.luckperms.calculators.*;
+import me.lucko.luckperms.users.BukkitUser;
+import me.lucko.luckperms.users.User;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class ContextCache {
+
+    @Getter
+    private final Map<String, String> context;
+
+    @Getter
+    private final Map<String, Boolean> permissionCache = new ConcurrentHashMap<>();
+
+    private final PermissionCalculator calculator;
+
+    public ContextCache(User user, Map<String, String> context, LuckPermsPlugin plugin, DefaultsProvider defaultsProvider) {
+        this.context = context;
+
+        List<PermissionProcessor> processors = new ArrayList<>(5);
+        processors.add(new MapProcessor(permissionCache));
+        if (plugin.getConfiguration().isApplyingWildcards()) {
+            processors.add(new WildcardProcessor(permissionCache));
+        }
+        if (plugin.getConfiguration().isApplyingRegex()) {
+            processors.add(new RegexProcessor(permissionCache));
+        }
+
+        processors.add(new DefaultsProcessor(((BukkitUser) user)::isOp, defaultsProvider));
+        calculator = new PermissionCalculator(plugin, user.getName(), plugin.getConfiguration().isDebugPermissionChecks(), processors);
+    }
+
+    public void invalidateCache() {
+        calculator.invalidateCache();
+    }
+
+    public Tristate getPermissionValue(@NonNull String permission) {
+        return calculator.getPermissionValue(permission);
+    }
+
+}

bukkit/src/main/java/me/lucko/luckperms/api/vault/cache/VaultUser.java

@@ -0,0 +1,181 @@
+/*
+ * 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.vault.cache;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import me.lucko.luckperms.LPBukkitPlugin;
+import me.lucko.luckperms.api.Contexts;
+import me.lucko.luckperms.api.Node;
+import me.lucko.luckperms.api.vault.VaultPermissionHook;
+import me.lucko.luckperms.users.User;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+@RequiredArgsConstructor
+public class VaultUser {
+    private final LPBukkitPlugin plugin;
+    private final VaultPermissionHook vault;
+
+    @Getter
+    private final User user;
+
+    @Getter
+    private final Map<Map<String, String>, ContextCache> contextData = new ConcurrentHashMap<>();
+
+    @Getter
+    private final Map<Map<String, String>, ChatCache> chatData = new ConcurrentHashMap<>();
+
+    public boolean hasPermission(Map<String, String> context, String permission) {
+        ContextCache cd = contextData.computeIfAbsent(context, map -> calculatePermissions(map, false));
+        return cd.getPermissionValue(permission).asBoolean();
+    }
+
+    public ChatCache processChatData(Map<String, String> context) {
+        return chatData.computeIfAbsent(context, map -> calculateChat(map, false));
+    }
+
+    public ContextCache calculatePermissions(Map<String, String> context, boolean apply) {
+        Map<String, Boolean> toApply = user.exportNodes(
+                new Contexts(context, vault.isIncludeGlobal(), true, true, true, true),
+                Collections.emptyList(),
+                true
+        );
+
+        ContextCache existing = contextData.get(context);
+        if (existing == null) {
+            existing = new ContextCache(user, context, plugin, plugin.getDefaultsProvider());
+            if (apply) {
+                contextData.put(context, existing);
+            }
+        }
+
+        boolean different = false;
+        if (toApply.size() != existing.getPermissionCache().size()) {
+            different = true;
+        } else {
+            for (Map.Entry<String, Boolean> e : existing.getPermissionCache().entrySet()) {
+                if (toApply.containsKey(e.getKey()) && toApply.get(e.getKey()) == e.getValue()) {
+                    continue;
+                }
+                different = true;
+                break;
+            }
+        }
+
+        if (!different) return existing;
+
+        existing.getPermissionCache().clear();
+        existing.invalidateCache();
+        existing.getPermissionCache().putAll(toApply);
+        return existing;
+    }
+
+    public ChatCache calculateChat(Map<String, String> context, boolean apply) {
+        ChatCache existing = chatData.get(context);
+        if (existing == null) {
+            existing = new ChatCache(context);
+            if (apply) {
+                chatData.put(context, existing);
+            }
+        }
+
+        Map<String, String> contexts = new HashMap<>(context);
+        String server = contexts.get("server");
+        String world = contexts.get("world");
+        contexts.remove("server");
+        contexts.remove("world");
+
+        existing.invalidateCache();
+
+        // Load meta
+        for (Node n : user.getPermissions(true)) {
+            if (!n.getValue()) {
+                continue;
+            }
+
+            if (!n.isMeta()) {
+                continue;
+            }
+
+            if (!n.shouldApplyOnServer(server, vault.isIncludeGlobal(), false)) {
+                continue;
+            }
+
+            if (!n.shouldApplyOnWorld(world, true, false)) {
+                continue;
+            }
+
+            if (!n.shouldApplyWithContext(contexts, false)) {
+                continue;
+            }
+
+            Map.Entry<String, String> meta = n.getMeta();
+            existing.getMeta().put(meta.getKey(), meta.getValue());
+        }
+
+        // Load prefixes & suffixes
+
+        int prefixPriority = Integer.MIN_VALUE;
+        int suffixPriority = Integer.MIN_VALUE;
+
+        for (Node n : user.getAllNodes(null, new Contexts(context, vault.isIncludeGlobal(), true, true, true, true))) {
+            if (!n.getValue()) {
+                continue;
+            }
+
+            if (!n.isPrefix() && !n.isSuffix()) {
+                continue;
+            }
+
+            if (!n.shouldApplyOnServer(server, vault.isIncludeGlobal(), false)) {
+                continue;
+            }
+
+            if (!n.shouldApplyOnWorld(world, true, false)) {
+                continue;
+            }
+
+            if (!n.shouldApplyWithContext(contexts, false)) {
+                continue;
+            }
+
+            if (n.isPrefix()) {
+                Map.Entry<Integer, String> value = n.getPrefix();
+                if (value.getKey() > prefixPriority) {
+                    existing.setPrefix(value.getValue());
+                }
+            } else {
+                Map.Entry<Integer, String> value = n.getSuffix();
+                if (value.getKey() > suffixPriority) {
+                    existing.setSuffix(value.getValue());
+                }
+            }
+        }
+
+        return existing;
+    }
+}

bukkit/src/main/java/me/lucko/luckperms/api/vault/cache/VaultUserManager.java

@@ -0,0 +1,68 @@
+/*
+ * 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.vault.cache;
+
+import lombok.RequiredArgsConstructor;
+import me.lucko.luckperms.LPBukkitPlugin;
+import me.lucko.luckperms.api.vault.VaultPermissionHook;
+import me.lucko.luckperms.users.User;
+import org.bukkit.World;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+
+@RequiredArgsConstructor
+public class VaultUserManager {
+    private final LPBukkitPlugin plugin;
+    private final VaultPermissionHook vault;
+    private final Map<UUID, VaultUser> userCache = new ConcurrentHashMap<>();
+
+    public void setupUser(User user) {
+        VaultUser vaultUser = userCache.computeIfAbsent(user.getUuid(), uuid -> new VaultUser(plugin, vault, user));
+        vaultUser.calculatePermissions(Collections.singletonMap("server", vault.getServer()), true);
+        vaultUser.calculateChat(Collections.singletonMap("server", vault.getServer()), true);
+        for (World world : plugin.getServer().getWorlds()) {
+            Map<String, String> context = new HashMap<>();
+            context.put("server", vault.getServer());
+            context.put("world", world.getName());
+            vaultUser.calculatePermissions(context, true);
+            vaultUser.calculateChat(context, true);
+        }
+    }
+
+    public void clearUser(UUID uuid) {
+        userCache.remove(uuid);
+    }
+
+    public boolean containsUser(UUID uuid) {
+        return userCache.containsKey(uuid);
+    }
+
+    public VaultUser getUser(UUID uuid) {
+        return userCache.get(uuid);
+    }
+
+}

bukkit/src/main/java/me/lucko/luckperms/calculators/AttachmentProcessor.java

@@ -0,0 +1,47 @@
+/*
+ * 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.calculators;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import me.lucko.luckperms.api.Tristate;
+import org.bukkit.permissions.PermissionAttachmentInfo;
+
+import java.util.Map;
+
+@AllArgsConstructor
+public class AttachmentProcessor implements PermissionProcessor {
+
+    @Getter
+    private final Map<String, PermissionAttachmentInfo> map;
+
+    @Override
+    public Tristate hasPermission(String permission) {
+        if (map.containsKey(permission)) {
+            return Tristate.fromBoolean(map.get(permission).getValue());
+        }
+
+        return Tristate.UNDEFINED;
+    }
+
+}

bukkit/src/main/java/me/lucko/luckperms/calculators/DefaultsProcessor.java

@@ -0,0 +1,51 @@
+/*
+ * 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.calculators;
+
+import lombok.AllArgsConstructor;
+import me.lucko.luckperms.api.Tristate;
+import org.bukkit.Bukkit;
+import org.bukkit.permissions.Permission;
+
+import java.util.function.Supplier;
+
+@AllArgsConstructor
+public class DefaultsProcessor 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()));
+        } else {
+            return Tristate.UNDEFINED;
+        }
+    }
+}

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

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

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

@@ -0,0 +1,108 @@
+/*
+ * 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 org.bukkit.permissions.PermissibleBase;
+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.Set;
+
+public class DummyPermissibleBase extends PermissibleBase {
+    public DummyPermissibleBase() {
+        super(null);
+    }
+
+    @Override
+    public boolean isOp() {
+        return false;
+    }
+
+    @Override
+    public void setOp(boolean value) {
+
+    }
+
+    @Override
+    public boolean isPermissionSet(String name) {
+        return false;
+    }
+
+    @Override
+    public boolean isPermissionSet(Permission perm) {
+        return false;
+    }
+
+    @Override
+    public boolean hasPermission(String inName) {
+        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 void removeAttachment(PermissionAttachment attachment) {
+
+    }
+
+    @Override
+    public void recalculatePermissions() {
+
+    }
+
+    @Override
+    public synchronized void clearPermissions() {
+
+    }
+
+    @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 Set<PermissionAttachmentInfo> getEffectivePermissions() {
+        return Collections.emptySet();
+    }
+}

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

@@ -62,7 +62,10 @@ public class Injector {
         try {
             Permissible permissible = getPermissible(sender);
             if (permissible instanceof LPPermissible) {
-                getPermField(sender).set(sender, new PermissibleBase(sender));
+                /* The player is most likely leaving. Bukkit will attempt to call #clearPermissions, so we cannot set to null.
+                   However, there's no need to re-inject a real PermissibleBase, so we just inject a dummy instead.
+                   This saves tick time, pointlessly recalculating defaults when the instance will never be used. */
+                getPermField(sender).set(sender, new DummyPermissibleBase());
             }
             return true;
         } catch (Exception e) {

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

@@ -22,13 +22,11 @@
 
 package me.lucko.luckperms.inject;
 
-import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NonNull;
 import me.lucko.luckperms.LuckPermsPlugin;
 import me.lucko.luckperms.api.Tristate;
-import me.lucko.luckperms.calculators.PermissionCalculator;
-import me.lucko.luckperms.calculators.PermissionProcessor;
+import me.lucko.luckperms.calculators.*;
 import org.bukkit.Bukkit;
 import org.bukkit.command.CommandSender;
 import org.bukkit.permissions.*;
@@ -36,7 +34,6 @@ import org.bukkit.plugin.Plugin;
 
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.function.Supplier;
 import java.util.logging.Level;
 import java.util.stream.Collectors;
 
@@ -60,15 +57,15 @@ public class LPPermissible extends PermissibleBase {
         this.parent = sender;
 
         List<PermissionProcessor> processors = new ArrayList<>(5);
-        processors.add(new PermissionCalculator.MapProcessor(luckPermsPermissions));
+        processors.add(new MapProcessor(luckPermsPermissions));
         processors.add(new AttachmentProcessor(attachmentPermissions));
         if (plugin.getConfiguration().isApplyingWildcards()) {
-            processors.add(new PermissionCalculator.WildcardProcessor(luckPermsPermissions));
+            processors.add(new WildcardProcessor(luckPermsPermissions));
         }
         if (plugin.getConfiguration().isApplyingRegex()) {
-            processors.add(new PermissionCalculator.RegexProcessor(luckPermsPermissions));
+            processors.add(new RegexProcessor(luckPermsPermissions));
         }
-        processors.add(new BukkitDefaultsProcessor(parent::isOp, defaultsProvider));
+        processors.add(new DefaultsProcessor(parent::isOp, defaultsProvider));
 
         calculator = new PermissionCalculator(plugin, parent.getName(), plugin.getConfiguration().isDebugPermissionChecks(), processors);
 
@@ -260,42 +257,4 @@ public class LPPermissible extends PermissibleBase {
             attachment.remove();
         }
     }
-
-    @AllArgsConstructor
-    private static class AttachmentProcessor implements PermissionProcessor {
-
-        @Getter
-        private final Map<String, PermissionAttachmentInfo> map;
-
-        @Override
-        public Tristate hasPermission(String permission) {
-            if (map.containsKey(permission)) {
-                return Tristate.fromBoolean(map.get(permission).getValue());
-            }
-
-            return Tristate.UNDEFINED;
-        }
-
-    }
-
-    @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()));
-            } else {
-                return Tristate.UNDEFINED;
-            }
-        }
-    }
 }

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

@@ -25,9 +25,9 @@ package me.lucko.luckperms.users;
 import lombok.Getter;
 import lombok.Setter;
 import me.lucko.luckperms.LPBukkitPlugin;
+import me.lucko.luckperms.api.Contexts;
 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 org.bukkit.entity.Player;
 import org.bukkit.permissions.Permissible;
@@ -44,6 +44,10 @@ public class BukkitUser extends User {
     @Setter
     private LPPermissible lpPermissible = null;
 
+    @Getter
+    @Setter
+    private Map<String, Boolean> loginPreProcess = null;
+
     BukkitUser(UUID uuid, LPBukkitPlugin plugin) {
         super(uuid, plugin);
         this.plugin = plugin;
@@ -54,6 +58,10 @@ public class BukkitUser extends User {
         this.plugin = plugin;
     }
 
+    public boolean isOp() {
+        return lpPermissible != null && lpPermissible.isOp();
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public synchronized void refreshPermissions() {
@@ -71,7 +79,8 @@ public class BukkitUser extends User {
                         plugin.getConfiguration().isApplyingGlobalGroups(),
                         plugin.getConfiguration().isApplyingGlobalWorldGroups()
                 ),
-                Collections.emptyList()
+                Collections.emptyList(),
+                true
         );
 
         try {
@@ -118,5 +127,9 @@ public class BukkitUser extends User {
         } catch (Exception e) {
             e.printStackTrace();
         }
+
+        if (plugin.getVaultHook() != null && plugin.getVaultHook().isHooked()) {
+            plugin.getVaultHook().getPermissionHook().getVaultUserManager().setupUser(this);
+        }
     }
 }

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

@@ -47,7 +47,7 @@ public class BukkitUserManager extends UserManager implements ContextListener<Pl
             Player player = plugin.getServer().getPlayer(plugin.getUuidCache().getExternalUUID(u.getUuid()));
             if (player != null) {
                 if (u.getLpPermissible() != null) {
-                    Injector.unInject(player);
+                    Injector.unInject(player); // TODO is this needed?
                     u.setLpPermissible(null);
                 }
 
@@ -66,18 +66,17 @@ public class BukkitUserManager extends UserManager implements ContextListener<Pl
     }
 
     @Override
-    public User make(UUID uuid) {
-        return new BukkitUser(uuid, plugin);
-    }
-
-    @Override
-    public User make(UUID uuid, String username) {
-        return new BukkitUser(uuid, username, plugin);
+    public User apply(UserIdentifier id) {
+        BukkitUser user = id.getUsername() == null ?
+                new BukkitUser(id.getUuid(), plugin) :
+                new BukkitUser(id.getUuid(), id.getUsername(), plugin);
+        giveDefaultIfNeeded(user, false);
+        return user;
     }
 
     @Override
     public void updateAllUsers() {
-        // Sometimes called async, so we need to get the players on the Bukkit thread.
+        // Sometimes called async, as we need to get the players on the Bukkit thread.
         plugin.doSync(() -> {
             Set<UUID> players = plugin.getServer().getOnlinePlayers().stream()
                     .map(p -> plugin.getUuidCache().getUUID(p.getUniqueId()))

bungee/pom.xml

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

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

@@ -23,8 +23,7 @@
 package me.lucko.luckperms;
 
 import lombok.Getter;
-import me.lucko.luckperms.calculators.PermissionCalculator;
-import me.lucko.luckperms.calculators.PermissionProcessor;
+import me.lucko.luckperms.calculators.*;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -40,12 +39,12 @@ public class BungeePlayerCache {
 
     public BungeePlayerCache(LuckPermsPlugin plugin, String name) {
         List<PermissionProcessor> processors = new ArrayList<>(3);
-        processors.add(new PermissionCalculator.MapProcessor(permissions));
+        processors.add(new MapProcessor(permissions));
         if (plugin.getConfiguration().isApplyingWildcards()) {
-            processors.add(new PermissionCalculator.WildcardProcessor(permissions));
+            processors.add(new WildcardProcessor(permissions));
         }
         if (plugin.getConfiguration().isApplyingRegex()) {
-            processors.add(new PermissionCalculator.RegexProcessor(permissions));
+            processors.add(new RegexProcessor(permissions));
         }
 
         calculator = new PermissionCalculator(plugin, name, plugin.getConfiguration().isDebugPermissionChecks(), processors);

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

@@ -24,9 +24,9 @@ package me.lucko.luckperms.users;
 
 import me.lucko.luckperms.BungeePlayerCache;
 import me.lucko.luckperms.LPBungeePlugin;
+import me.lucko.luckperms.api.Contexts;
 import me.lucko.luckperms.api.event.events.UserPermissionRefreshEvent;
 import me.lucko.luckperms.api.implementation.internal.UserLink;
-import me.lucko.luckperms.contexts.Contexts;
 import net.md_5.bungee.api.connection.ProxiedPlayer;
 
 import java.util.Collections;
@@ -69,7 +69,8 @@ public class BungeeUser extends User {
                         plugin.getConfiguration().isApplyingGlobalGroups(),
                         plugin.getConfiguration().isApplyingGlobalWorldGroups()
                 ),
-                Collections.emptyList()
+                Collections.emptyList(),
+                true
         );
 
         Map<String, Boolean> existing = playerCache.getPermissions();

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

@@ -45,13 +45,12 @@ public class BungeeUserManager extends UserManager implements ContextListener<Pr
     }
 
     @Override
-    public User make(UUID uuid) {
-        return new BungeeUser(uuid, plugin);
-    }
-
-    @Override
-    public User make(UUID uuid, String username) {
-        return new BungeeUser(uuid, username, plugin);
+    public User apply(UserIdentifier id) {
+        BungeeUser user = id.getUsername() == null ?
+                new BungeeUser(id.getUuid(), plugin) :
+                new BungeeUser(id.getUuid(), id.getUsername(), plugin);
+        giveDefaultIfNeeded(user, false);
+        return user;
     }
 
     @Override

common/pom.xml

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

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

@@ -32,6 +32,7 @@ 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.*;
+import me.lucko.luckperms.users.UserIdentifier;
 
 import java.util.Optional;
 import java.util.Set;
@@ -69,7 +70,7 @@ public class ApiProvider implements LuckPermsApi {
 
     @Override
     public double getApiVersion() {
-        return 2.10;
+        return 2.11;
     }
 
     @Override
@@ -149,7 +150,7 @@ public class ApiProvider implements LuckPermsApi {
 
     @Override
     public boolean isUserLoaded(@NonNull UUID uuid) {
-        return plugin.getUserManager().isLoaded(uuid);
+        return plugin.getUserManager().isLoaded(UserIdentifier.of(uuid, null));
     }
 
     @Override

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

@@ -24,10 +24,7 @@ package me.lucko.luckperms.api.implementation.internal;
 
 import lombok.AllArgsConstructor;
 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.api.*;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
 
@@ -39,7 +36,7 @@ import static me.lucko.luckperms.core.PermissionHolder.exportToLegacy;
 /**
  * Provides a link between {@link PermissionHolder} and {@link me.lucko.luckperms.core.PermissionHolder}
  */
-@SuppressWarnings({"unused", "deprecation"})
+@SuppressWarnings("unused")
 @AllArgsConstructor
 public class PermissionHolderLink implements PermissionHolder {
 
@@ -52,18 +49,18 @@ public class PermissionHolderLink implements PermissionHolder {
     }
 
     @Override
-    public SortedSet<Node> getPermissions() {
-        return Collections.unmodifiableSortedSet(master.getPermissions(false));
+    public SortedSet<? extends Node> getPermissions() {
+        return master.getPermissions(false);
     }
 
     @Override
     public Set<Node> getEnduringPermissions() {
-        return Collections.unmodifiableSet(master.getNodes());
+        return master.getNodes();
     }
 
     @Override
     public Set<Node> getTransientPermissions() {
-        return Collections.unmodifiableSet(master.getTransientNodes());
+        return master.getTransientNodes();
     }
 
     @Override
@@ -71,6 +68,16 @@ public class PermissionHolderLink implements PermissionHolder {
         return Collections.unmodifiableSet(master.getAllNodes(Collections.emptyList(), Contexts.allowAll()));
     }
 
+    @Override
+    public SortedSet<LocalizedNode> getAllNodes(@NonNull Contexts contexts) {
+        return master.getAllNodes(Collections.emptyList(), contexts);
+    }
+
+    @Override
+    public Set<LocalizedNode> getAllNodesFiltered(@NonNull Contexts contexts) {
+        return master.getAllNodesFiltered(contexts);
+    }
+
     @Override
     public Map<String, Boolean> getNodes() {
         return exportToLegacy(master.getNodes());
@@ -233,22 +240,36 @@ public class PermissionHolderLink implements PermissionHolder {
 
     @Override
     public Map<String, Boolean> getLocalPermissions(String server, String world, List<String> excludedGroups, List<String> possibleNodes) {
-        return master.getLocalPermissions(server, world, excludedGroups, possibleNodes);
+        Map<String, String> context = new HashMap<>();
+        if (server != null && !server.equals("")) {
+            context.put("server", server);
+        }
+        if (world != null && !world.equals("")) {
+            context.put("world", world);
+        }
+        return master.exportNodes(new Contexts(context, true, true, true, true, true), Collections.emptyList(), false);
     }
 
     @Override
     public Map<String, Boolean> getLocalPermissions(String server, String world, List<String> excludedGroups) {
-        return master.getLocalPermissions(server, world, excludedGroups);
+        Map<String, String> context = new HashMap<>();
+        if (server != null && !server.equals("")) {
+            context.put("server", server);
+        }
+        if (world != null && !world.equals("")) {
+            context.put("world", world);
+        }
+        return master.exportNodes(new Contexts(context, true, true, true, true, true), Collections.emptyList(), false);
     }
 
     @Override
     public Map<String, Boolean> getLocalPermissions(String server, List<String> excludedGroups, List<String> possibleNodes) {
-        return master.getLocalPermissions(server, excludedGroups, possibleNodes);
+        return getLocalPermissions(server, null, excludedGroups, possibleNodes);
     }
 
     @Override
     public Map<String, Boolean> getLocalPermissions(String server, List<String> excludedGroups) {
-        return master.getLocalPermissions(server, excludedGroups);
+        return getLocalPermissions(server, null, excludedGroups, null);
     }
 
     @Override
@@ -262,7 +283,7 @@ public class PermissionHolderLink implements PermissionHolder {
         if (world != null && !world.equals("")) {
             extraContext.put("world", world);
         }
-        return master.exportNodes(new Contexts(extraContext, includeGlobal, includeGlobal, applyGroups, true, true), possibleNodes);
+        return master.exportNodes(new Contexts(extraContext, includeGlobal, includeGlobal, applyGroups, true, true), possibleNodes, false);
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/calculators/MapProcessor.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.calculators;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import me.lucko.luckperms.api.Tristate;
+
+import java.util.Map;
+
+@AllArgsConstructor
+public class MapProcessor implements PermissionProcessor {
+
+    @Getter
+    private final Map<String, Boolean> map;
+
+    @Override
+    public Tristate hasPermission(String permission) {
+        if (map.containsKey(permission)) {
+            return Tristate.fromBoolean(map.get(permission));
+        }
+
+        return Tristate.UNDEFINED;
+    }
+}

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

@@ -22,17 +22,13 @@
 
 package me.lucko.luckperms.calculators;
 
-import lombok.AllArgsConstructor;
-import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import me.lucko.luckperms.LuckPermsPlugin;
 import me.lucko.luckperms.api.Tristate;
-import me.lucko.luckperms.constants.Patterns;
 
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.regex.Pattern;
 
 /**
  * Calculates and caches permissions
@@ -50,12 +46,14 @@ public class PermissionCalculator {
     }
 
     public Tristate getPermissionValue(String permission) {
+        permission = permission.toLowerCase();
+        Tristate t =  cache.computeIfAbsent(permission, this::lookupPermissionValue);
+
         if (debug) {
-            plugin.getLog().info("Checking if " + objectName + " has permission: " + permission);
+            plugin.getLog().info("Checking if " + objectName + " has permission: " + permission + " - (" + t.toString() + ")");
         }
 
-        permission = permission.toLowerCase();
-        return cache.computeIfAbsent(permission, this::lookupPermissionValue);
+        return t;
     }
 
     private Tristate lookupPermissionValue(String permission) {
@@ -70,96 +68,4 @@ public class PermissionCalculator {
 
         return Tristate.UNDEFINED;
     }
-
-    @AllArgsConstructor
-    public static class MapProcessor implements PermissionProcessor {
-
-        @Getter
-        private final Map<String, Boolean> map;
-
-        @Override
-        public Tristate hasPermission(String permission) {
-            if (map.containsKey(permission)) {
-                return Tristate.fromBoolean(map.get(permission));
-            }
-
-            return Tristate.UNDEFINED;
-        }
-    }
-
-    @AllArgsConstructor
-    public static class RegexProcessor implements PermissionProcessor {
-
-        @Getter
-        private final Map<String, Boolean> map;
-
-        @Override
-        public Tristate hasPermission(String permission) {
-            for (Map.Entry<String, Boolean> e : map.entrySet()) {
-                if (e.getKey().toLowerCase().startsWith("r=")) {
-                    Pattern p = Patterns.compile(e.getKey().substring(2));
-                    if (p == null) {
-                        continue;
-                    }
-
-                    if (p.matcher(permission).matches()) {
-                        return Tristate.fromBoolean(e.getValue());
-                    }
-                }
-            }
-
-            return Tristate.UNDEFINED;
-        }
-    }
-
-    @AllArgsConstructor
-    public static class WildcardProcessor implements PermissionProcessor {
-
-        @Getter
-        private final Map<String, Boolean> map;
-
-        @Override
-        public Tristate hasPermission(String permission) {
-            String node = permission;
-
-            while (node.contains(".")) {
-                int endIndex = node.lastIndexOf('.');
-                if (endIndex == -1) {
-                    break;
-                }
-
-                node = node.substring(0, endIndex);
-                if (!isEmpty(node)) {
-                    if (map.containsKey(node + ".*")) {
-                        return Tristate.fromBoolean(map.get(node + ".*"));
-                    }
-                }
-            }
-
-            if (map.containsKey("'*'")) {
-                return Tristate.fromBoolean(map.get("'*'"));
-            }
-
-            if (map.containsKey("*")) {
-                return Tristate.fromBoolean(map.get("*"));
-            }
-
-            return Tristate.UNDEFINED;
-        }
-
-        private static boolean isEmpty(String s) {
-            if (s.equals("")) {
-                return true;
-            }
-
-            char[] chars = s.toCharArray();
-            for (char c : chars) {
-                if (c != '.') {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-    }
 }

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

@@ -0,0 +1,56 @@
+/*
+ * 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.calculators;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import me.lucko.luckperms.api.Tristate;
+import me.lucko.luckperms.constants.Patterns;
+
+import java.util.Map;
+import java.util.regex.Pattern;
+
+@AllArgsConstructor
+public class RegexProcessor implements PermissionProcessor {
+
+    @Getter
+    private final Map<String, Boolean> map;
+
+    @Override
+    public Tristate hasPermission(String permission) {
+        for (Map.Entry<String, Boolean> e : map.entrySet()) {
+            if (e.getKey().toLowerCase().startsWith("r=")) {
+                Pattern p = Patterns.compile(e.getKey().substring(2));
+                if (p == null) {
+                    continue;
+                }
+
+                if (p.matcher(permission).matches()) {
+                    return Tristate.fromBoolean(e.getValue());
+                }
+            }
+        }
+
+        return Tristate.UNDEFINED;
+    }
+}

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

@@ -0,0 +1,80 @@
+/*
+ * 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.calculators;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import me.lucko.luckperms.api.Tristate;
+
+import java.util.Map;
+
+@AllArgsConstructor
+public class WildcardProcessor implements PermissionProcessor {
+
+    @Getter
+    private final Map<String, Boolean> map;
+
+    @Override
+    public Tristate hasPermission(String permission) {
+        String node = permission;
+
+        while (node.contains(".")) {
+            int endIndex = node.lastIndexOf('.');
+            if (endIndex == -1) {
+                break;
+            }
+
+            node = node.substring(0, endIndex);
+            if (!isEmpty(node)) {
+                if (map.containsKey(node + ".*")) {
+                    return Tristate.fromBoolean(map.get(node + ".*"));
+                }
+            }
+        }
+
+        if (map.containsKey("'*'")) {
+            return Tristate.fromBoolean(map.get("'*'"));
+        }
+
+        if (map.containsKey("*")) {
+            return Tristate.fromBoolean(map.get("*"));
+        }
+
+        return Tristate.UNDEFINED;
+    }
+
+    private static boolean isEmpty(String s) {
+        if (s.equals("")) {
+            return true;
+        }
+
+        char[] chars = s.toCharArray();
+        for (char c : chars) {
+            if (c != '.') {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}

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

@@ -0,0 +1,53 @@
+/*
+ * 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;
+
+import com.google.common.collect.ImmutableList;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class Arg {
+    public static Arg create(String name, boolean required, String description) {
+        return new Arg(name, required, description);
+    }
+
+    public static ImmutableList<Arg> list(Arg... args) {
+        return ImmutableList.copyOf(args);
+    }
+
+    private final String name;
+    private final boolean required;
+    private final String description;
+
+    public String asPrettyString() {
+        if (required) {
+            return "&8<&7" + name + "&8>";
+        } else {
+            return "&8[&7" + name + "&8]";
+        }
+    }
+
+}

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

@@ -39,6 +39,7 @@ 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.commands.usersbulkedit.UsersBulkEditMainCommand;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -64,6 +65,7 @@ public class CommandManager {
             .add(new ExportCommand())
             .add(new QueueCommand())
             .add(new MigrationMainCommand())
+            .add(new UsersBulkEditMainCommand())
             .add(new CreateGroup())
             .add(new DeleteGroup())
             .add(new ListGroups())
@@ -177,9 +179,9 @@ public class CommandManager {
     }
 
     private void sendCommandUsage(Sender sender, String label) {
-        Util.sendPluginMessage(sender, "&6Running &bLuckPerms v" + plugin.getVersion() + "&6.");
+        Util.sendPluginMessage(sender, "&2Running &bLuckPerms v" + plugin.getVersion() + "&2.");
         mainCommands.stream()
                 .filter(c -> c.isAuthorized(sender))
-                .forEach(c -> Util.sendPluginMessage(sender, "&e-> &d" + String.format(c.getUsage(), label)));
+                .forEach(c -> Util.sendPluginMessage(sender, "&3> &a" + 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);
+            sub.sendDetailedUsage(sender);
             return CommandResult.INVALID_ARGS;
         }
 
@@ -137,7 +137,7 @@ public abstract class MainCommand<T> {
      */
     protected void sendUsage(Sender sender, String label) {
         if (getSubCommands().isEmpty()) {
-            Util.sendPluginMessage(sender, "&e-> &d" + String.format(getUsage(), label));
+            Util.sendPluginMessage(sender, "&3> &a" + String.format(getUsage(), label));
             return;
         }
 
@@ -146,7 +146,7 @@ public abstract class MainCommand<T> {
                 .collect(Collectors.toList());
 
         if (subs.size() > 0) {
-            Util.sendPluginMessage(sender, "&e" + getName() + " Sub Commands: &7(" + String.format(getUsage(), label) + " ...)");
+            Util.sendPluginMessage(sender, "&b" + getName() + " Sub Commands: &7(" + String.format(getUsage(), label) + " ...)");
 
             for (SubCommand s : subs) {
                 s.sendUsage(sender);

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

@@ -22,6 +22,8 @@
 
 package me.lucko.luckperms.commands;
 
+import com.google.common.collect.ImmutableList;
+import lombok.AllArgsConstructor;
 import lombok.Getter;
 import me.lucko.luckperms.LuckPermsPlugin;
 import me.lucko.luckperms.constants.Message;
@@ -41,6 +43,7 @@ import java.util.stream.Collectors;
  * Abstract SubCommand class
  */
 @Getter
+@AllArgsConstructor
 public abstract class SubCommand<T> {
 
     /**
@@ -53,11 +56,6 @@ public abstract class SubCommand<T> {
      */
     private final String description;
 
-    /**
-     * The command usage
-     */
-    private final String usage;
-
     /**
      * The permission needed to use this command
      */
@@ -68,13 +66,7 @@ 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");
-    }
+    private final ImmutableList<Arg> args;
 
     /**
      * Called when this sub command is ran
@@ -103,7 +95,26 @@ public abstract class SubCommand<T> {
      * @param sender the sender to send the usage to
      */
     public void sendUsage(Sender sender) {
-        Util.sendPluginMessage(sender, "&e-> &6" + getName() + (usage.isEmpty() ? "" : "&e - &7" + getUsage()));
+        String usage = "";
+        if (args != null) {
+            usage += "&3 - &7";
+            for (Arg arg : args) {
+                usage += arg.asPrettyString() + " ";
+            }
+        }
+
+        Util.sendPluginMessage(sender, "&3> &a" + getName() + usage);
+    }
+
+    public void sendDetailedUsage(Sender sender) {
+        Util.sendPluginMessage(sender, "&3&lCommand Usage &3- &b" + getName());
+        Util.sendPluginMessage(sender, "&b> &7" + getDescription());
+        if (args != null) {
+            Util.sendPluginMessage(sender, "&3Arguments:");
+            for (Arg arg : args) {
+                Util.sendPluginMessage(sender, "&b- " + arg.asPrettyString() + "&3 -> &7" + arg.getDescription());
+            }
+        }
     }
 
     /**

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

@@ -23,7 +23,9 @@
 package me.lucko.luckperms.commands;
 
 import lombok.experimental.UtilityClass;
+import me.lucko.luckperms.api.LocalizedNode;
 import me.lucko.luckperms.api.Node;
+import me.lucko.luckperms.api.Tristate;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Patterns;
 import me.lucko.luckperms.utils.DateUtil;
@@ -79,27 +81,38 @@ public class Util {
         return b ? "&atrue" : "&cfalse";
     }
 
-    public static void sendBoolean(Sender sender, String node, boolean b) {
-        sender.sendMessage(Util.color("&b" + node + ": " + formatBoolean(b)));
+    public static String formatTristate(Tristate t) {
+        switch (t) {
+            case TRUE:
+                return "&atrue";
+            case FALSE:
+                return "&cfalse";
+            default:
+                return "&cundefined";
+        }
+    }
+
+    public static void sendTristate(Sender sender, String node, Tristate t) {
+        sender.sendMessage(Util.color("&b" + node + ": " + formatTristate(t)));
     }
 
     public static String listToCommaSep(List<String> strings) {
-        if (strings.isEmpty()) return "&6None";
+        if (strings.isEmpty()) return "&bNone";
 
         StringBuilder sb = new StringBuilder();
-        strings.forEach(s -> sb.append("&6").append(s).append("&7, "));
+        strings.forEach(s -> sb.append("&3").append(s).append("&7, "));
         return sb.delete(sb.length() - 2, sb.length()).toString();
     }
 
     public static String listToArrowSep(List<String> strings, String highlight) {
-        if (strings.isEmpty()) return "&6None";
+        if (strings.isEmpty()) return "&bNone";
 
         StringBuilder sb = new StringBuilder();
         for (String s : strings) {
             if (s.equalsIgnoreCase(highlight)) {
-                sb.append("&e").append(s).append("&7 ---> ");
+                sb.append("&b").append(s).append("&7 ---> ");
             } else {
-                sb.append("&6").append(s).append("&7 ---> ");
+                sb.append("&3").append(s).append("&7 ---> ");
             }
         }
         return sb.delete(sb.length() - 6, sb.length()).toString();
@@ -111,11 +124,11 @@ public class Util {
         StringBuilder sb = new StringBuilder();
         for (String s : strings) {
             if (s.equalsIgnoreCase(highlightFirst)) {
-                sb.append("&e").append(s).append("&4").append(reversed ? " <--- " : " ---> ");
+                sb.append("&b").append(s).append("&4").append(reversed ? " <--- " : " ---> ");
             } else if (s.equalsIgnoreCase(highlightSecond)) {
-                sb.append("&e").append(s).append("&7").append(reversed ? " <--- " : " ---> ");
+                sb.append("&b").append(s).append("&7").append(reversed ? " <--- " : " ---> ");
             } else {
-                sb.append("&6").append(s).append("&7").append(reversed ? " <--- " : " ---> ");
+                sb.append("&3").append(s).append("&7").append(reversed ? " <--- " : " ---> ");
             }
         }
         return sb.delete(sb.length() - 6, sb.length()).toString();
@@ -125,18 +138,18 @@ public class Util {
         if (strings.isEmpty()) return "&6None";
 
         StringBuilder sb = new StringBuilder();
-        strings.forEach(s -> sb.append("&6").append(s).append("&e ---> "));
+        strings.forEach(s -> sb.append("&3").append(s).append("&b ---> "));
         return sb.delete(sb.length() - 6, sb.length()).toString();
     }
 
-    public static String permNodesToString(SortedSet<Node> nodes) {
+    public static String permNodesToString(SortedSet<LocalizedNode> nodes) {
         StringBuilder sb = new StringBuilder();
         for (Node node : nodes) {
             if (node.isTemporary()) {
                 continue;
             }
 
-            sb.append("&6-> ").append(node.getValue() ? "&a" : "&c");
+            sb.append("&3> ").append(node.getValue() ? "&a" : "&c");
             sb.append(node.getPermission());
             if (node.isServerSpecific()) {
                 sb.append(" &7(&f").append(node.getServer().get()).append("&7)");
@@ -148,13 +161,13 @@ public class Util {
         }
 
         if (sb.length() == 0) {
-            return "&6None";
+            return "&3None";
         }
 
         return sb.toString();
     }
 
-    public static String tempNodesToString(SortedSet<Node> nodes) {
+    public static String tempNodesToString(SortedSet<LocalizedNode> nodes) {
         StringBuilder sb = new StringBuilder();
 
         for (Node node : nodes) {
@@ -162,7 +175,7 @@ public class Util {
                 continue;
             }
 
-            sb.append("&6-> ").append(node.getValue() ? "&a" : "&c");
+            sb.append("&3> ").append(node.getValue() ? "&a" : "&c");
             sb.append(node.getPermission());
             if (node.isServerSpecific()) {
                 sb.append(" &7(&f").append(node.getServer().get()).append("&7)");
@@ -175,13 +188,13 @@ public class Util {
         }
 
         if (sb.length() == 0) {
-            return "&6None";
+            return "&3None";
         }
 
         return sb.toString();
     }
 
-    public static String permGroupsToString(SortedSet<Node> nodes) {
+    public static String permGroupsToString(SortedSet<LocalizedNode> nodes) {
         StringBuilder sb = new StringBuilder();
         for (Node node : nodes) {
             if (!node.isGroupNode()) {
@@ -192,7 +205,7 @@ public class Util {
                 continue;
             }
 
-            sb.append("&a-> &b").append(node.getGroupName());
+            sb.append("&3> &f").append(node.getGroupName());
             if (node.isServerSpecific()) {
                 sb.append(" &7(&f").append(node.getServer().get()).append("&7)");
             }
@@ -203,13 +216,13 @@ public class Util {
         }
 
         if (sb.length() == 0) {
-            return "&6None";
+            return "&3None";
         }
 
         return sb.toString();
     }
 
-    public static String tempGroupsToString(SortedSet<Node> nodes) {
+    public static String tempGroupsToString(SortedSet<LocalizedNode> nodes) {
         StringBuilder sb = new StringBuilder();
 
         for (Node node : nodes) {
@@ -221,7 +234,7 @@ public class Util {
                 continue;
             }
 
-            sb.append("&a-> &b").append(node.getGroupName());
+            sb.append("&3> &f").append(node.getGroupName());
             if (node.isServerSpecific()) {
                 sb.append(" &7(&f").append(node.getServer().get()).append("&7)");
             }
@@ -233,7 +246,7 @@ public class Util {
         }
 
         if (sb.length() == 0) {
-            return "&6None";
+            return "&3None";
         }
 
         return sb.toString();

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

@@ -63,6 +63,7 @@ public class GroupMainCommand extends MainCommand<Group> {
             .add(new GroupBulkChange())
             .add(new GroupClear())
             .add(new GroupRename())
+            .add(new GroupClone())
             .build()
         );
     }

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

@@ -23,10 +23,7 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-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.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.LogEntry;
@@ -38,8 +35,14 @@ import java.util.List;
 
 public class GroupAddPrefix extends SubCommand<Group> {
     public GroupAddPrefix() {
-        super("addprefix", "Adds a prefix to the group", "<priority> <prefix> [server] [world]",
-                Permission.GROUP_ADDPREFIX, Predicate.notInRange(2, 4));
+        super("addprefix", "Adds a prefix to the group", Permission.GROUP_ADDPREFIX, Predicate.notInRange(2, 4),
+                Arg.list(
+                        Arg.create("priority", true, "the priority to add the prefix at"),
+                        Arg.create("prefix", true, "the prefix string"),
+                        Arg.create("server", false, "the server to add the prefix on"),
+                        Arg.create("world", false, "the world to add the prefix on")
+                )
+        );
     }
 
     @Override

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

@@ -23,10 +23,7 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-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.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.LogEntry;
@@ -38,8 +35,14 @@ import java.util.List;
 
 public class GroupAddSuffix extends SubCommand<Group> {
     public GroupAddSuffix() {
-        super("addsuffix", "Adds a suffix to the group", "<priority> <suffix> [server] [world]",
-                Permission.GROUP_ADDSUFFIX, Predicate.notInRange(2, 4));
+        super("addsuffix", "Adds a suffix to the group", Permission.GROUP_ADDSUFFIX, Predicate.notInRange(2, 4),
+                Arg.list(
+                        Arg.create("priority", true, "the priority to add the suffix at"),
+                        Arg.create("suffix", true, "the suffix string"),
+                        Arg.create("server", false, "the server to add the suffix on"),
+                        Arg.create("world", false, "the world to add the suffix on")
+                )
+        );
     }
 
     @Override

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

@@ -23,10 +23,7 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-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.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.LogEntry;
@@ -39,8 +36,15 @@ import java.util.List;
 
 public class GroupAddTempPrefix extends SubCommand<Group> {
     public GroupAddTempPrefix() {
-        super("addtempprefix", "Adds a prefix to the group temporarily", "<priority> <prefix> <duration> [server] [world]",
-                Permission.GROUP_ADD_TEMP_PREFIX, Predicate.notInRange(3, 5));
+        super("addtempprefix", "Adds a prefix to the group temporarily", Permission.GROUP_ADD_TEMP_PREFIX, Predicate.notInRange(3, 5),
+                Arg.list(
+                        Arg.create("priority", true, "the priority to add the prefix at"),
+                        Arg.create("prefix", true, "the prefix string"),
+                        Arg.create("duration", true, "the duration until the prefix expires"),
+                        Arg.create("server", false, "the server to add the prefix on"),
+                        Arg.create("world", false, "the world to add the prefix on")
+                )
+        );
     }
 
     @Override

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

@@ -23,10 +23,7 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-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.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.LogEntry;
@@ -39,8 +36,15 @@ import java.util.List;
 
 public class GroupAddTempSuffix extends SubCommand<Group> {
     public GroupAddTempSuffix() {
-        super("addtempsuffix", "Adds a suffix to the group temporarily", "<priority> <suffix> <duration> [server] [world]",
-                Permission.GROUP_ADD_TEMP_SUFFIX, Predicate.notInRange(3, 5));
+        super("addtempsuffix", "Adds a suffix to the group temporarily", Permission.GROUP_ADD_TEMP_SUFFIX, Predicate.notInRange(3, 5),
+                Arg.list(
+                        Arg.create("priority", true, "the priority to add the suffix at"),
+                        Arg.create("suffix", true, "the suffix string"),
+                        Arg.create("duration", true, "the duration until the suffix expires"),
+                        Arg.create("server", false, "the server to add the suffix on"),
+                        Arg.create("world", false, "the world to add the suffix on")
+                )
+        );
     }
 
     @Override

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

@@ -24,12 +24,11 @@ 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.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
 import me.lucko.luckperms.groups.Group;
 
 import java.util.HashSet;
@@ -39,8 +38,13 @@ 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));
+        super("bulkchange", "Applies a bulk permission change to the group's permissions", Permission.GROUP_BULKCHANGE, Predicate.not(3),
+                Arg.list(
+                        Arg.create("server|world", true, "if the bulk change is modifying a 'server' or a 'world'"),
+                        Arg.create("from", true, "the server/world to be changed from. can be 'global' or 'null' respectively"),
+                        Arg.create("to", true, "the server/world to replace 'from' (can be 'null')")
+                )
+        );
     }
 
     @Override
@@ -53,6 +57,7 @@ public class GroupBulkChange extends SubCommand<Group> {
         }
 
         Set<Node> toAdd = new HashSet<>();
+        Set<Node> toRemove = new HashSet<>();
 
         if (!type.equals("world") && !type.equals("server")) {
             Message.BULK_CHANGE_TYPE_ERROR.send(sender);
@@ -68,7 +73,7 @@ public class GroupBulkChange extends SubCommand<Group> {
                     continue;
                 }
 
-                iterator.remove();
+                toRemove.add(element);
                 toAdd.add(me.lucko.luckperms.core.Node.builderFromExisting(element).setWorld(to).build());
             }
         } else {
@@ -79,12 +84,23 @@ public class GroupBulkChange extends SubCommand<Group> {
                     continue;
                 }
 
-                iterator.remove();
+                toRemove.add(element);
                 toAdd.add(me.lucko.luckperms.core.Node.builderFromExisting(element).setServer(to).build());
             }
         }
 
-        group.getNodes().addAll(toAdd);
+        toRemove.forEach(n -> {
+            try {
+                group.unsetPermission(n);
+            } catch (ObjectLacksException ignored) {}
+        });
+
+        toAdd.forEach(n -> {
+            try {
+                group.setPermission(n);
+            } catch (ObjectAlreadyHasException ignored) {}
+        });
+
         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

@@ -23,18 +23,18 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.Contexts;
 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 java.util.*;
 
 public class GroupChatMeta extends SubCommand<Group> {
     public GroupChatMeta() {
-        super("chatmeta", "Displays a groups chat meta", "", Permission.GROUP_CHATMETA, Predicate.alwaysFalse());
+        super("chatmeta", "Lists the group's chat meta", Permission.GROUP_CHATMETA, Predicate.alwaysFalse(), null);
     }
 
     @Override

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

@@ -36,7 +36,7 @@ import java.util.List;
 
 public class GroupClear extends SubCommand<Group> {
     public GroupClear() {
-        super("clear", "Clears a groups permissions", "", Permission.GROUP_CLEAR, Predicate.alwaysFalse());
+        super("clear", "Clears the group's permissions", Permission.GROUP_CLEAR, Predicate.alwaysFalse(), null);
     }
 
     @Override

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

@@ -0,0 +1,73 @@
+/*
+ * 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.data.LogEntry;
+import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.utils.ArgumentChecker;
+
+import java.util.List;
+
+public class GroupClone extends SubCommand<Group> {
+    public GroupClone() {
+        super("clone", "Clone the group", Permission.GROUP_CLONE, Predicate.not(1),
+                Arg.list(Arg.create("name", true, "the name of the clone"))
+        );
+    }
+
+    @Override
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+        String newGroupName = args.get(0).toLowerCase();
+        if (ArgumentChecker.checkName(newGroupName)) {
+            Message.GROUP_INVALID_ENTRY.send(sender);
+            return CommandResult.INVALID_ARGS;
+        }
+
+        if (plugin.getDatastore().loadGroup(newGroupName)) {
+            Message.GROUP_ALREADY_EXISTS.send(sender);
+            return CommandResult.INVALID_ARGS;
+        }
+
+        if (!plugin.getDatastore().createAndLoadGroup(newGroupName)) {
+            Message.CREATE_GROUP_ERROR.send(sender);
+            return CommandResult.FAILURE;
+        }
+
+        Group newGroup = plugin.getGroupManager().get(newGroupName);
+        if (newGroup == null) {
+            Message.GROUP_LOAD_ERROR.send(sender);
+            return CommandResult.LOADING_ERROR;
+        }
+
+        newGroup.setNodes(group.getNodes());
+
+        Message.CLONE_SUCCESS.send(sender, group.getName(), newGroup.getName());
+        LogEntry.build().actor(sender).acted(group).action("clone " + newGroup.getName()).build().submit(plugin, sender);
+        save(newGroup, sender, plugin);
+        return CommandResult.SUCCESS;
+    }
+}

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

@@ -26,6 +26,7 @@ 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.core.Node;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.utils.ArgumentChecker;
 
@@ -33,8 +34,14 @@ 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", "<node> [server] [world]",
-                Permission.GROUP_HASPERMISSION, Predicate.notInRange(1, 3));
+        super("haspermission", "Checks to see if the group has a certain permission node", Permission.GROUP_HASPERMISSION,
+                Predicate.notInRange(1, 3),
+                Arg.list(
+                        Arg.create("node", true, "the permission node to check for"),
+                        Arg.create("server", false, "the server to check on"),
+                        Arg.create("world", false, "the world to check on")
+                )
+        );
     }
 
     @Override
@@ -46,13 +53,13 @@ public class GroupHasPerm extends SubCommand<Group> {
             }
 
             if (args.size() == 2) {
-                Util.sendBoolean(sender, args.get(0), group.hasPermission(args.get(0), true, args.get(1)));
+                Util.sendTristate(sender, args.get(0), group.hasPermission(new Node.Builder(args.get(0)).setServer(args.get(1)).build()));
             } else {
-                Util.sendBoolean(sender, args.get(0), group.hasPermission(args.get(0), true, args.get(1), args.get(2)));
+                Util.sendTristate(sender, args.get(0), group.hasPermission(new Node.Builder(args.get(0)).setServer(args.get(1)).setWorld(args.get(2)).build()));
             }
 
         } else {
-            Util.sendBoolean(sender, args.get(0), group.hasPermission(args.get(0), true, "global"));
+            Util.sendTristate(sender, args.get(0), group.hasPermission(new Node.Builder(args.get(0)).build()));
         }
         return CommandResult.SUCCESS;
     }

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

@@ -35,7 +35,7 @@ import java.util.List;
 
 public class GroupInfo extends SubCommand<Group> {
     public GroupInfo() {
-        super("info", "Gives info about the group", "", Permission.GROUP_INFO, Predicate.alwaysFalse());
+        super("info", "Gives info about the group", Permission.GROUP_INFO, Predicate.alwaysFalse(), null);
     }
 
     @Override

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

@@ -26,6 +26,8 @@ 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.core.InheritanceInfo;
+import me.lucko.luckperms.core.Node;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.utils.ArgumentChecker;
 
@@ -33,12 +35,19 @@ 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", "<node> [server] [world]",
-                Permission.GROUP_INHERITSPERMISSION, Predicate.notInRange(1, 3));
+        super("inheritspermission", "Checks to see if the group inherits a certain permission node",
+                Permission.GROUP_INHERITSPERMISSION, Predicate.notInRange(1, 3),
+                Arg.list(
+                        Arg.create("node", true, "the permission node to check for"),
+                        Arg.create("server", false, "the server to check on"),
+                        Arg.create("world", false, "the world to check on")
+                )
+        );
     }
 
     @Override
     public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+        InheritanceInfo result;
         if (args.size() >= 2) {
             if (ArgumentChecker.checkServer(args.get(1))) {
                 Message.SERVER_INVALID_ENTRY.send(sender);
@@ -46,14 +55,26 @@ public class GroupInheritsPerm extends SubCommand<Group> {
             }
 
             if (args.size() == 2) {
-                Util.sendBoolean(sender, args.get(0), group.inheritsPermission(args.get(0), true, args.get(1)));
+                result = group.inheritsPermissionInfo(new Node.Builder(args.get(0)).setServer(args.get(1)).build());
             } else {
-                Util.sendBoolean(sender, args.get(0), group.inheritsPermission(args.get(0), true, args.get(1), args.get(2)));
+                result = group.inheritsPermissionInfo(new Node.Builder(args.get(0)).setServer(args.get(1)).setWorld(args.get(2)).build());
             }
 
         } else {
-            Util.sendBoolean(sender, args.get(0), group.inheritsPermission(args.get(0), true));
+            result = group.inheritsPermissionInfo(new Node.Builder(args.get(0)).build());
         }
+
+        String location = null;
+        if (result.getLocation().isPresent()) {
+            if (result.getLocation().get().equals(group.getObjectName())) {
+                location = "self";
+            } else {
+                location = result.getLocation().get();
+            }
+        }
+
+        Util.sendPluginMessage(sender, "&b" + args.get(0) + ": " + Util.formatTristate(result.getResult()) +
+                (result.getLocation().isPresent() ? " &7(inherited from &a" + location + "&7)" : ""));
         return CommandResult.SUCCESS;
     }
 }

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

@@ -32,7 +32,7 @@ import java.util.List;
 
 public class GroupListNodes extends SubCommand<Group> {
     public GroupListNodes() {
-        super("listnodes", "Lists the permission nodes the group has", "", Permission.GROUP_LISTNODES, Predicate.alwaysFalse());
+        super("listnodes", "Lists the permission nodes the group has", Permission.GROUP_LISTNODES, Predicate.alwaysFalse(), null);
     }
 
     @Override

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

@@ -32,7 +32,7 @@ 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());
+        super("listparents", "Lists the groups that this group inherits from", Permission.GROUP_LISTPARENTS, Predicate.alwaysFalse(), null);
     }
 
     @Override

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

@@ -23,10 +23,8 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-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.api.Node;
+import me.lucko.luckperms.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.LogEntry;
@@ -34,12 +32,19 @@ import me.lucko.luckperms.exceptions.ObjectLacksException;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.utils.ArgumentChecker;
 
+import java.util.ArrayList;
 import java.util.List;
 
 public class GroupRemovePrefix extends SubCommand<Group> {
     public GroupRemovePrefix() {
-        super("removeprefix", "Removes a prefix from a group", "<priority> <prefix> [server] [world]",
-                Permission.GROUP_REMOVEPREFIX, Predicate.notInRange(2, 4));
+        super("removeprefix", "Removes a prefix from the group", Permission.GROUP_REMOVEPREFIX, Predicate.notInRange(2, 4),
+                Arg.list(
+                        Arg.create("priority", true, "the priority to remove the prefix at"),
+                        Arg.create("prefix", true, "the prefix string to remove"),
+                        Arg.create("server", false, "the server to remove the prefix on"),
+                        Arg.create("world", false, "the world to remove the prefix on")
+                )
+        );
     }
 
     @Override
@@ -53,44 +58,96 @@ public class GroupRemovePrefix extends SubCommand<Group> {
             return CommandResult.INVALID_ARGS;
         }
 
-        final String node = "prefix." + priority + "." + ArgumentChecker.escapeCharacters(prefix);
+        if (prefix.equalsIgnoreCase("null")) {
+            String server = null;
+            String world = null;
 
-        try {
             if (args.size() >= 3) {
-                final String server = args.get(2).toLowerCase();
+                server = args.get(2).toLowerCase();
                 if (ArgumentChecker.checkServer(server)) {
                     Message.SERVER_INVALID_ENTRY.send(sender);
                     return CommandResult.INVALID_ARGS;
                 }
 
-                if (args.size() == 3) {
-                    group.unsetPermission(node, 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);
+                if (args.size() != 3) {
+                    world = args.get(3).toLowerCase();
+                }
+            }
+
+            List<Node> toRemove = new ArrayList<>();
+            for (Node node : group.getNodes()) {
+                if (!node.isPrefix()) continue;
+                if (node.getPrefix().getKey() != priority) continue;
+                if (node.isTemporary()) continue;
+
+                if (node.getServer().isPresent()) {
+                    if (server == null) continue;
+                    if (!node.getServer().get().equalsIgnoreCase(server)) continue;
                 } else {
-                    final String world = args.get(3).toLowerCase();
-                    group.unsetPermission(node, server, world);
-                    Message.REMOVEPREFIX_SERVER_WORLD_SUCCESS.send(sender, group.getDisplayName(), prefix, priority, server, world);
+                    if (server != null) continue;
+                }
+
+                if (node.getWorld().isPresent()) {
+                    if (world == null) continue;
+                    if (!node.getWorld().get().equalsIgnoreCase(world)) continue;
+                } else {
+                    if (world != null) continue;
+                }
+
+                toRemove.add(node);
+            }
+
+            toRemove.forEach(n -> {
+                try {
+                    group.unsetPermission(n);
+                } catch (ObjectLacksException ignored) {}
+            });
+
+            Message.BULK_CHANGE_SUCCESS.send(sender, toRemove.size());
+            save(group, sender, plugin);
+            return CommandResult.SUCCESS;
+
+        } else {
+
+            final String node = "prefix." + priority + "." + ArgumentChecker.escapeCharacters(prefix);
+
+            try {
+                if (args.size() >= 3) {
+                    final String server = args.get(2).toLowerCase();
+                    if (ArgumentChecker.checkServer(server)) {
+                        Message.SERVER_INVALID_ENTRY.send(sender);
+                        return CommandResult.INVALID_ARGS;
+                    }
+
+                    if (args.size() == 3) {
+                        group.unsetPermission(node, 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.getDisplayName(), prefix, priority, server, world);
+                        LogEntry.build().actor(sender).acted(group)
+                                .action("removeprefix " + priority + " " + args.get(1) + " " + server + " " + world)
+                                .build().submit(plugin, sender);
+                    }
+
+                } else {
+                    group.unsetPermission(node);
+                    Message.REMOVEPREFIX_SUCCESS.send(sender, group.getDisplayName(), prefix, priority);
                     LogEntry.build().actor(sender).acted(group)
-                            .action("removeprefix " + priority + " " + args.get(1) + " " + server + " " + world)
+                            .action("removeprefix " + priority + " " + args.get(1))
                             .build().submit(plugin, sender);
                 }
 
-            } else {
-                group.unsetPermission(node);
-                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);
+                save(group, sender, plugin);
+                return CommandResult.SUCCESS;
+            } catch (ObjectLacksException e) {
+                Message.DOES_NOT_HAVE_PREFIX.send(sender, group.getDisplayName());
+                return CommandResult.STATE_ERROR;
             }
-
-            save(group, sender, plugin);
-            return CommandResult.SUCCESS;
-        } catch (ObjectLacksException e) {
-            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

@@ -23,10 +23,8 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-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.api.Node;
+import me.lucko.luckperms.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.LogEntry;
@@ -34,12 +32,19 @@ import me.lucko.luckperms.exceptions.ObjectLacksException;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.utils.ArgumentChecker;
 
+import java.util.ArrayList;
 import java.util.List;
 
 public class GroupRemoveSuffix extends SubCommand<Group> {
     public GroupRemoveSuffix() {
-        super("removesuffix", "Removes a suffix from a group", "<priority> <suffix> [server] [world]",
-                Permission.GROUP_REMOVESUFFIX, Predicate.notInRange(2, 4));
+        super("removesuffix", "Removes a suffix from the group", Permission.GROUP_REMOVESUFFIX, Predicate.notInRange(2, 4),
+                Arg.list(
+                        Arg.create("priority", true, "the priority to remove the suffix at"),
+                        Arg.create("suffix", true, "the suffix string to remove"),
+                        Arg.create("server", false, "the server to remove the suffix on"),
+                        Arg.create("world", false, "the world to remove the suffix on")
+                )
+        );
     }
 
     @Override
@@ -53,44 +58,96 @@ public class GroupRemoveSuffix extends SubCommand<Group> {
             return CommandResult.INVALID_ARGS;
         }
 
-        final String node = "suffix." + priority + "." + ArgumentChecker.escapeCharacters(suffix);
+        if (suffix.equalsIgnoreCase("null")) {
+            String server = null;
+            String world = null;
 
-        try {
             if (args.size() >= 3) {
-                final String server = args.get(2).toLowerCase();
+                server = args.get(2).toLowerCase();
                 if (ArgumentChecker.checkServer(server)) {
                     Message.SERVER_INVALID_ENTRY.send(sender);
                     return CommandResult.INVALID_ARGS;
                 }
 
-                if (args.size() == 3) {
-                    group.unsetPermission(node, 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);
+                if (args.size() != 3) {
+                    world = args.get(3).toLowerCase();
+                }
+            }
+
+            List<Node> toRemove = new ArrayList<>();
+            for (Node node : group.getNodes()) {
+                if (!node.isSuffix()) continue;
+                if (node.getSuffix().getKey() != priority) continue;
+                if (node.isTemporary()) continue;
+
+                if (node.getServer().isPresent()) {
+                    if (server == null) continue;
+                    if (!node.getServer().get().equalsIgnoreCase(server)) continue;
                 } else {
-                    final String world = args.get(3).toLowerCase();
-                    group.unsetPermission(node, server, world);
-                    Message.REMOVESUFFIX_SERVER_WORLD_SUCCESS.send(sender, group.getDisplayName(), suffix, priority, server, world);
+                    if (server != null) continue;
+                }
+
+                if (node.getWorld().isPresent()) {
+                    if (world == null) continue;
+                    if (!node.getWorld().get().equalsIgnoreCase(world)) continue;
+                } else {
+                    if (world != null) continue;
+                }
+
+                toRemove.add(node);
+            }
+
+            toRemove.forEach(n -> {
+                try {
+                    group.unsetPermission(n);
+                } catch (ObjectLacksException ignored) {}
+            });
+
+            Message.BULK_CHANGE_SUCCESS.send(sender, toRemove.size());
+            save(group, sender, plugin);
+            return CommandResult.SUCCESS;
+
+        } else {
+
+            final String node = "suffix." + priority + "." + ArgumentChecker.escapeCharacters(suffix);
+
+            try {
+                if (args.size() >= 3) {
+                    final String server = args.get(2).toLowerCase();
+                    if (ArgumentChecker.checkServer(server)) {
+                        Message.SERVER_INVALID_ENTRY.send(sender);
+                        return CommandResult.INVALID_ARGS;
+                    }
+
+                    if (args.size() == 3) {
+                        group.unsetPermission(node, 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.getDisplayName(), suffix, priority, server, world);
+                        LogEntry.build().actor(sender).acted(group)
+                                .action("removesuffix " + priority + " " + args.get(1) + " " + server + " " + world)
+                                .build().submit(plugin, sender);
+                    }
+
+                } else {
+                    group.unsetPermission(node);
+                    Message.REMOVESUFFIX_SUCCESS.send(sender, group.getDisplayName(), suffix, priority);
                     LogEntry.build().actor(sender).acted(group)
-                            .action("removesuffix " + priority + " " + args.get(1) + " " + server + " " + world)
+                            .action("removesuffix " + priority + " " + args.get(1))
                             .build().submit(plugin, sender);
                 }
 
-            } else {
-                group.unsetPermission(node);
-                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);
+                save(group, sender, plugin);
+                return CommandResult.SUCCESS;
+            } catch (ObjectLacksException e) {
+                Message.DOES_NOT_HAVE_SUFFIX.send(sender, group.getDisplayName());
+                return CommandResult.STATE_ERROR;
             }
-
-            save(group, sender, plugin);
-            return CommandResult.SUCCESS;
-        } catch (ObjectLacksException e) {
-            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

@@ -23,10 +23,8 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-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.api.Node;
+import me.lucko.luckperms.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.LogEntry;
@@ -34,12 +32,20 @@ import me.lucko.luckperms.exceptions.ObjectLacksException;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.utils.ArgumentChecker;
 
+import java.util.ArrayList;
 import java.util.List;
 
 public class GroupRemoveTempPrefix extends SubCommand<Group> {
     public GroupRemoveTempPrefix() {
-        super("removetempprefix", "Removes a temporary prefix from a group", "<priority> <prefix> [server] [world]",
-                Permission.GROUP_REMOVE_TEMP_PREFIX, Predicate.notInRange(2, 4));
+        super("removetempprefix", "Removes a temporary prefix from the group", Permission.GROUP_REMOVE_TEMP_PREFIX,
+                Predicate.notInRange(2, 4),
+                Arg.list(
+                        Arg.create("priority", true, "the priority to remove the prefix at"),
+                        Arg.create("prefix", true, "the prefix string to remove"),
+                        Arg.create("server", false, "the server to remove the prefix on"),
+                        Arg.create("world", false, "the world to remove the prefix on")
+                )
+        );
     }
 
     @Override
@@ -53,44 +59,96 @@ public class GroupRemoveTempPrefix extends SubCommand<Group> {
             return CommandResult.INVALID_ARGS;
         }
 
-        final String node = "prefix." + priority + "." + ArgumentChecker.escapeCharacters(prefix);
+        if (prefix.equalsIgnoreCase("null")) {
+            String server = null;
+            String world = null;
 
-        try {
             if (args.size() >= 3) {
-                final String server = args.get(2).toLowerCase();
+                server = args.get(2).toLowerCase();
                 if (ArgumentChecker.checkServer(server)) {
                     Message.SERVER_INVALID_ENTRY.send(sender);
                     return CommandResult.INVALID_ARGS;
                 }
 
-                if (args.size() == 3) {
-                    group.unsetPermission(node, server, true);
-                    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);
+                if (args.size() != 3) {
+                    world = args.get(3).toLowerCase();
+                }
+            }
+
+            List<Node> toRemove = new ArrayList<>();
+            for (Node node : group.getNodes()) {
+                if (!node.isPrefix()) continue;
+                if (node.getPrefix().getKey() != priority) continue;
+                if (node.isPermanent()) continue;
+
+                if (node.getServer().isPresent()) {
+                    if (server == null) continue;
+                    if (!node.getServer().get().equalsIgnoreCase(server)) continue;
                 } else {
-                    final String world = args.get(3).toLowerCase();
-                    group.unsetPermission(node, server, world, true);
-                    Message.REMOVE_TEMP_PREFIX_SERVER_WORLD_SUCCESS.send(sender, group.getDisplayName(), prefix, priority, server, world);
+                    if (server != null) continue;
+                }
+
+                if (node.getWorld().isPresent()) {
+                    if (world == null) continue;
+                    if (!node.getWorld().get().equalsIgnoreCase(world)) continue;
+                } else {
+                    if (world != null) continue;
+                }
+
+                toRemove.add(node);
+            }
+
+            toRemove.forEach(n -> {
+                try {
+                    group.unsetPermission(n);
+                } catch (ObjectLacksException ignored) {}
+            });
+
+            Message.BULK_CHANGE_SUCCESS.send(sender, toRemove.size());
+            save(group, sender, plugin);
+            return CommandResult.SUCCESS;
+
+        } else {
+
+            final String node = "prefix." + priority + "." + ArgumentChecker.escapeCharacters(prefix);
+
+            try {
+                if (args.size() >= 3) {
+                    final String server = args.get(2).toLowerCase();
+                    if (ArgumentChecker.checkServer(server)) {
+                        Message.SERVER_INVALID_ENTRY.send(sender);
+                        return CommandResult.INVALID_ARGS;
+                    }
+
+                    if (args.size() == 3) {
+                        group.unsetPermission(node, server, true);
+                        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.getDisplayName(), prefix, priority, server, world);
+                        LogEntry.build().actor(sender).acted(group)
+                                .action("removetempprefix " + priority + " " + args.get(1) + " " + server + " " + world)
+                                .build().submit(plugin, sender);
+                    }
+
+                } else {
+                    group.unsetPermission(node, true);
+                    Message.REMOVE_TEMP_PREFIX_SUCCESS.send(sender, group.getDisplayName(), prefix, priority);
                     LogEntry.build().actor(sender).acted(group)
-                            .action("removetempprefix " + priority + " " + args.get(1) + " " + server + " " + world)
+                            .action("removetempprefix " + priority + " " + args.get(1))
                             .build().submit(plugin, sender);
                 }
 
-            } else {
-                group.unsetPermission(node, true);
-                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);
+                save(group, sender, plugin);
+                return CommandResult.SUCCESS;
+            } catch (ObjectLacksException e) {
+                Message.DOES_NOT_HAVE_PREFIX.send(sender, group.getDisplayName());
+                return CommandResult.STATE_ERROR;
             }
-
-            save(group, sender, plugin);
-            return CommandResult.SUCCESS;
-        } catch (ObjectLacksException e) {
-            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

@@ -23,10 +23,8 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-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.api.Node;
+import me.lucko.luckperms.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.LogEntry;
@@ -34,12 +32,20 @@ import me.lucko.luckperms.exceptions.ObjectLacksException;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.utils.ArgumentChecker;
 
+import java.util.ArrayList;
 import java.util.List;
 
 public class GroupRemoveTempSuffix extends SubCommand<Group> {
     public GroupRemoveTempSuffix() {
-        super("removetempsuffix", "Removes a temporary suffix from a group", "<priority> <suffix> [server] [world]",
-                Permission.GROUP_REMOVE_TEMP_SUFFIX, Predicate.notInRange(2, 4));
+        super("removetempsuffix", "Removes a temporary suffix from the group", Permission.GROUP_REMOVE_TEMP_SUFFIX,
+                Predicate.notInRange(2, 4),
+                Arg.list(
+                        Arg.create("priority", true, "the priority to remove the suffix at"),
+                        Arg.create("suffix", true, "the suffix string to remove"),
+                        Arg.create("server", false, "the server to remove the suffix on"),
+                        Arg.create("world", false, "the world to remove the suffix on")
+                )
+        );
     }
 
     @Override
@@ -53,44 +59,96 @@ public class GroupRemoveTempSuffix extends SubCommand<Group> {
             return CommandResult.INVALID_ARGS;
         }
 
-        final String node = "suffix." + priority + "." + ArgumentChecker.escapeCharacters(suffix);
+        if (suffix.equalsIgnoreCase("null")) {
+            String server = null;
+            String world = null;
 
-        try {
             if (args.size() >= 3) {
-                final String server = args.get(2).toLowerCase();
+                server = args.get(2).toLowerCase();
                 if (ArgumentChecker.checkServer(server)) {
                     Message.SERVER_INVALID_ENTRY.send(sender);
                     return CommandResult.INVALID_ARGS;
                 }
 
-                if (args.size() == 3) {
-                    group.unsetPermission(node, server, true);
-                    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);
+                if (args.size() != 3) {
+                    world = args.get(3).toLowerCase();
+                }
+            }
+
+            List<Node> toRemove = new ArrayList<>();
+            for (Node node : group.getNodes()) {
+                if (!node.isSuffix()) continue;
+                if (node.getSuffix().getKey() != priority) continue;
+                if (node.isPermanent()) continue;
+
+                if (node.getServer().isPresent()) {
+                    if (server == null) continue;
+                    if (!node.getServer().get().equalsIgnoreCase(server)) continue;
                 } else {
-                    final String world = args.get(3).toLowerCase();
-                    group.unsetPermission(node, server, world, true);
-                    Message.REMOVE_TEMP_SUFFIX_SERVER_WORLD_SUCCESS.send(sender, group.getDisplayName(), suffix, priority, server, world);
+                    if (server != null) continue;
+                }
+
+                if (node.getWorld().isPresent()) {
+                    if (world == null) continue;
+                    if (!node.getWorld().get().equalsIgnoreCase(world)) continue;
+                } else {
+                    if (world != null) continue;
+                }
+
+                toRemove.add(node);
+            }
+
+            toRemove.forEach(n -> {
+                try {
+                    group.unsetPermission(n);
+                } catch (ObjectLacksException ignored) {}
+            });
+
+            Message.BULK_CHANGE_SUCCESS.send(sender, toRemove.size());
+            save(group, sender, plugin);
+            return CommandResult.SUCCESS;
+
+        } else {
+            
+            final String node = "suffix." + priority + "." + ArgumentChecker.escapeCharacters(suffix);
+
+            try {
+                if (args.size() >= 3) {
+                    final String server = args.get(2).toLowerCase();
+                    if (ArgumentChecker.checkServer(server)) {
+                        Message.SERVER_INVALID_ENTRY.send(sender);
+                        return CommandResult.INVALID_ARGS;
+                    }
+
+                    if (args.size() == 3) {
+                        group.unsetPermission(node, server, true);
+                        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.getDisplayName(), suffix, priority, server, world);
+                        LogEntry.build().actor(sender).acted(group)
+                                .action("removetempsuffix " + priority + " " + args.get(1) + " " + server + " " + world)
+                                .build().submit(plugin, sender);
+                    }
+
+                } else {
+                    group.unsetPermission(node, true);
+                    Message.REMOVE_TEMP_SUFFIX_SUCCESS.send(sender, group.getDisplayName(), suffix, priority);
                     LogEntry.build().actor(sender).acted(group)
-                            .action("removetempsuffix " + priority + " " + args.get(1) + " " + server + " " + world)
+                            .action("removetempsuffix " + priority + " " + args.get(1))
                             .build().submit(plugin, sender);
                 }
 
-            } else {
-                group.unsetPermission(node, true);
-                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);
+                save(group, sender, plugin);
+                return CommandResult.SUCCESS;
+            } catch (ObjectLacksException e) {
+                Message.DOES_NOT_HAVE_SUFFIX.send(sender, group.getDisplayName());
+                return CommandResult.STATE_ERROR;
             }
-
-            save(group, sender, plugin);
-            return CommandResult.SUCCESS;
-        } catch (ObjectLacksException e) {
-            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

@@ -23,10 +23,7 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-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.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.LogEntry;
@@ -37,7 +34,9 @@ import java.util.List;
 
 public class GroupRename extends SubCommand<Group> {
     public GroupRename() {
-        super("rename", "Rename this group", "<new name>", Permission.TRACK_APPEND, Predicate.not(1));
+        super("rename", "Rename the group", Permission.GROUP_RENAME, Predicate.not(1),
+                Arg.list(Arg.create("name", true, "the new name"))
+        );
     }
 
     @Override
@@ -69,7 +68,7 @@ public class GroupRename extends SubCommand<Group> {
             return CommandResult.FAILURE;
         }
 
-        plugin.getGroupManager().copy(group, newGroup);
+        newGroup.setNodes(group.getNodes());
 
         Message.RENAME_SUCCESS.send(sender, group.getName(), newGroup.getName());
         LogEntry.build().actor(sender).acted(group).action("rename " + newGroup.getName()).build().submit(plugin, sender);

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

@@ -23,10 +23,7 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-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.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.LogEntry;
@@ -38,8 +35,14 @@ import java.util.List;
 
 public class GroupSetInherit extends SubCommand<Group> {
     public GroupSetInherit() {
-        super("setinherit", "Sets another group for this group to inherit permissions from", "<group> [server] [world]",
-                Permission.GROUP_SETINHERIT, Predicate.notInRange(1, 3));
+        super("setinherit", "Sets another group for the group to inherit permissions from",
+                Permission.GROUP_SETINHERIT, Predicate.notInRange(1, 3),
+                Arg.list(
+                        Arg.create("group", true, "the group to inherit from"),
+                        Arg.create("server", false, "the server to inherit the group on"),
+                        Arg.create("world", false, "the world to inherit the group on")
+                )
+        );
     }
 
     @Override
@@ -47,7 +50,7 @@ public class GroupSetInherit extends SubCommand<Group> {
         String groupName = args.get(0).toLowerCase();
 
         if (ArgumentChecker.checkNode(groupName)) {
-            sendUsage(sender);
+            sendDetailedUsage(sender);
             return CommandResult.INVALID_ARGS;
         }
 

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

@@ -23,10 +23,7 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-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.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.LogEntry;
@@ -38,8 +35,14 @@ import java.util.List;
 
 public class GroupSetPermission extends SubCommand<Group> {
     public GroupSetPermission() {
-        super("set", "Sets a permission for a group", "<node> <true|false> [server] [world]", Permission.GROUP_SETPERMISSION,
-                Predicate.notInRange(2, 4));
+        super("set", "Sets a permission for the group", Permission.GROUP_SETPERMISSION, Predicate.notInRange(2, 4),
+                Arg.list(
+                        Arg.create("node", true, "the permission node to set"),
+                        Arg.create("true|false", true, "the value of the node"),
+                        Arg.create("server", false, "the server to add the permission node on"),
+                        Arg.create("world", false, "the world to add the permission node on")
+                )
+        );
     }
 
     @Override
@@ -48,7 +51,7 @@ public class GroupSetPermission extends SubCommand<Group> {
         String bool = args.get(1).toLowerCase();
 
         if (ArgumentChecker.checkNode(node)) {
-            sendUsage(sender);
+            sendDetailedUsage(sender);
             return CommandResult.INVALID_ARGS;
         }
 
@@ -58,7 +61,7 @@ public class GroupSetPermission extends SubCommand<Group> {
         }
 
         if (!bool.equalsIgnoreCase("true") && !bool.equalsIgnoreCase("false")) {
-            sendUsage(sender);
+            sendDetailedUsage(sender);
             return CommandResult.INVALID_ARGS;
         }
 

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

@@ -23,10 +23,7 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-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.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.LogEntry;
@@ -39,8 +36,15 @@ 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",
-                "<group> <duration> [server] [world]", Permission.GROUP_SET_TEMP_INHERIT, Predicate.notInRange(2, 4));
+        super("settempinherit", "Sets another group for the group to inherit permissions from temporarily",
+                Permission.GROUP_SET_TEMP_INHERIT, Predicate.notInRange(2, 4),
+                Arg.list(
+                        Arg.create("group", true, "the group to inherit from"),
+                        Arg.create("duration", true, "the duration of the group membership"),
+                        Arg.create("server", false, "the server to add the group on"),
+                        Arg.create("world", false, "the world to add the group on")
+                )
+        );
     }
 
     @Override
@@ -48,7 +52,7 @@ public class GroupSetTempInherit extends SubCommand<Group> {
         String groupName = args.get(0).toLowerCase();
 
         if (ArgumentChecker.checkNode(groupName)) {
-            sendUsage(sender);
+            sendDetailedUsage(sender);
             return CommandResult.INVALID_ARGS;
         }
 

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

@@ -23,10 +23,7 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-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.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.LogEntry;
@@ -39,8 +36,16 @@ import java.util.List;
 
 public class GroupSetTempPermission extends SubCommand<Group> {
     public GroupSetTempPermission() {
-        super("settemp", "Sets a temporary permission for a group", "<node> <true|false> <duration> [server] [world]",
-                Permission.GROUP_SET_TEMP_PERMISSION, Predicate.notInRange(3, 5));
+        super("settemp", "Sets a permission for the group temporarily", Permission.GROUP_SET_TEMP_PERMISSION,
+                Predicate.notInRange(3, 5),
+                Arg.list(
+                        Arg.create("node", true, "the permission node to set"),
+                        Arg.create("true|false", true, "the value of the node"),
+                        Arg.create("duration", true, "the duration until the permission node expires"),
+                        Arg.create("server", false, "the server to add the permission node on"),
+                        Arg.create("world", false, "the world to add the permission node on")
+                )
+        );
     }
 
     @Override
@@ -49,7 +54,7 @@ public class GroupSetTempPermission extends SubCommand<Group> {
         String bool = args.get(1).toLowerCase();
 
         if (ArgumentChecker.checkNode(node)) {
-            sendUsage(sender);
+            sendDetailedUsage(sender);
             return CommandResult.INVALID_ARGS;
         }
 
@@ -59,7 +64,7 @@ public class GroupSetTempPermission extends SubCommand<Group> {
         }
 
         if (!bool.equalsIgnoreCase("true") && !bool.equalsIgnoreCase("false")) {
-            sendUsage(sender);
+            sendDetailedUsage(sender);
             return CommandResult.INVALID_ARGS;
         }
 

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

@@ -34,7 +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", "", Permission.GROUP_SHOWTRACKS, Predicate.alwaysFalse());
+        super("showtracks", "Lists the tracks that the group features on", Permission.GROUP_SHOWTRACKS, Predicate.alwaysFalse(), null);
     }
 
     @Override

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

@@ -23,10 +23,7 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-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.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.LogEntry;
@@ -38,8 +35,13 @@ import java.util.List;
 
 public class GroupUnSetPermission extends SubCommand<Group> {
     public GroupUnSetPermission() {
-        super("unset", "Unsets a permission for a group", "<node> [server] [world]", Permission.GROUP_UNSETPERMISSION,
-                Predicate.notInRange(1, 3));
+        super("unset", "Unsets a permission for the group", Permission.GROUP_UNSETPERMISSION, Predicate.notInRange(1, 3),
+                Arg.list(
+                        Arg.create("node", true, "the permission node to unset"),
+                        Arg.create("server", false, "the server to remove the permission node on"),
+                        Arg.create("world", false, "the world to remove the permission node on")
+                )
+        );
     }
 
     @Override
@@ -47,7 +49,7 @@ public class GroupUnSetPermission extends SubCommand<Group> {
         String node = args.get(0).replace("{SPACE}", " ");
 
         if (ArgumentChecker.checkNode(node)) {
-            sendUsage(sender);
+            sendDetailedUsage(sender);
             return CommandResult.INVALID_ARGS;
         }
 

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

@@ -23,10 +23,7 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-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.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.LogEntry;
@@ -38,8 +35,14 @@ import java.util.List;
 
 public class GroupUnsetInherit extends SubCommand<Group> {
     public GroupUnsetInherit() {
-        super("unsetinherit", "Unsets another group for this group to inherit permissions from",
-                "<group> [server] [world]", Permission.GROUP_UNSETINHERIT, Predicate.notInRange(1, 3));
+        super("unsetinherit", "Removes a previously set inheritance rule", Permission.GROUP_UNSETINHERIT,
+                Predicate.notInRange(1, 3),
+                Arg.list(
+                        Arg.create("group", true, "the group to uninherit"),
+                        Arg.create("server", false, "the server to remove the group on"),
+                        Arg.create("world", false, "the world to remove the group on")
+                )
+        );
     }
 
     @Override
@@ -47,7 +50,7 @@ public class GroupUnsetInherit extends SubCommand<Group> {
         String groupName = args.get(0).toLowerCase();
 
         if (ArgumentChecker.checkNode(groupName)) {
-            sendUsage(sender);
+            sendDetailedUsage(sender);
             return CommandResult.INVALID_ARGS;
         }
 

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

@@ -23,10 +23,7 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-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.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.LogEntry;
@@ -38,8 +35,14 @@ import java.util.List;
 
 public class GroupUnsetTempInherit extends SubCommand<Group> {
     public GroupUnsetTempInherit() {
-        super("unsettempinherit", "Unsets another group for this group to inherit permissions from",
-                "<group> [server] [world]", Permission.GROUP_UNSET_TEMP_INHERIT, Predicate.notInRange(1, 3));
+        super("unsettempinherit", "Removes a previously set temporary inheritance rule",
+                Permission.GROUP_UNSET_TEMP_INHERIT, Predicate.notInRange(1, 3),
+                Arg.list(
+                        Arg.create("group", true, "the group to uninherit"),
+                        Arg.create("server", false, "the server to remove the group on"),
+                        Arg.create("world", false, "the world to remove the group on")
+                )
+        );
     }
 
     @Override
@@ -47,7 +50,7 @@ public class GroupUnsetTempInherit extends SubCommand<Group> {
         String groupName = args.get(0).toLowerCase();
 
         if (ArgumentChecker.checkNode(groupName)) {
-            sendUsage(sender);
+            sendDetailedUsage(sender);
             return CommandResult.INVALID_ARGS;
         }
 

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

@@ -23,10 +23,7 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-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.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.LogEntry;
@@ -38,8 +35,14 @@ import java.util.List;
 
 public class GroupUnsetTempPermission extends SubCommand<Group> {
     public GroupUnsetTempPermission() {
-        super("unsettemp", "Unsets a temporary permission for a group", "<node> [server] [world]",
-                Permission.GROUP_UNSET_TEMP_PERMISSION, Predicate.notInRange(1, 3));
+        super("unsettemp", "Unsets a temporary permission for the group", Permission.GROUP_UNSET_TEMP_PERMISSION,
+                Predicate.notInRange(1, 3),
+                Arg.list(
+                        Arg.create("node", true, "the permission node to unset"),
+                        Arg.create("server", false, "the server to remove the permission node on"),
+                        Arg.create("world", false, "the world to remove the permission node on")
+                )
+        );
     }
 
     @Override
@@ -47,7 +50,7 @@ public class GroupUnsetTempPermission extends SubCommand<Group> {
         String node = args.get(0).replace("{SPACE}", " ");
 
         if (ArgumentChecker.checkNode(node)) {
-            sendUsage(sender);
+            sendDetailedUsage(sender);
             return CommandResult.INVALID_ARGS;
         }
 

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

@@ -24,10 +24,7 @@ package me.lucko.luckperms.commands.log.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
 import me.lucko.luckperms.api.LogEntry;
-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.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.Log;
@@ -41,7 +38,9 @@ import java.util.List;
 
 public class LogExport extends SubCommand<Log> {
     public LogExport() {
-        super("export", "Export the log to a file", "<file>", Permission.LOG_EXPORT, Predicate.not(1));
+        super("export", "Export the log to a file", Permission.LOG_EXPORT, Predicate.not(1),
+                Arg.list(Arg.create("file", true, "the name of the file"))
+        );
     }
 
     @Override

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

@@ -24,10 +24,7 @@ package me.lucko.luckperms.commands.log.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
 import me.lucko.luckperms.api.LogEntry;
-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.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.Log;
@@ -40,8 +37,12 @@ import java.util.SortedMap;
 
 public class LogGroupHistory extends SubCommand<Log> {
     public LogGroupHistory() {
-        super("grouphistory", "View an objects history", "<group> [page]", Permission.LOG_GROUP_HISTORY,
-                Predicate.notInRange(1, 2));
+        super("grouphistory", "View an group's history", Permission.LOG_GROUP_HISTORY, Predicate.notInRange(1, 2),
+                Arg.list(
+                        Arg.create("group", true, "the name of the group"),
+                        Arg.create("page", false, "the page number to view")
+                )
+        );
     }
 
     @Override

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

@@ -23,10 +23,7 @@
 package me.lucko.luckperms.commands.log.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-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.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.Log;
@@ -37,7 +34,9 @@ import java.util.UUID;
 
 public class LogNotify extends SubCommand<Log> {
     public LogNotify() {
-        super("notify", "Toggle notifications", "[on|off]", Permission.LOG_NOTIFY, Predicate.notInRange(0, 1));
+        super("notify", "Toggle notifications", Permission.LOG_NOTIFY, Predicate.notInRange(0, 1),
+                Arg.list(Arg.create("on|off", false, "whether to toggle on or off"))
+        );
     }
 
     @Override

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

@@ -38,7 +38,12 @@ import java.util.UUID;
 
 public class LogRecent extends SubCommand<Log> {
     public LogRecent() {
-        super("recent", "View recent actions", "[user] [page]", Permission.LOG_RECENT, Predicate.notInRange(0, 2));
+        super("recent", "View recent actions", Permission.LOG_RECENT, Predicate.notInRange(0, 2),
+                Arg.list(
+                        Arg.create("user", false, "the name/uuid of the user to filter by"),
+                        Arg.create("page", false, "the page number to view")
+                )
+        );
     }
 
     @Override
@@ -69,8 +74,6 @@ public class LogRecent extends SubCommand<Log> {
                     return CommandResult.INVALID_ARGS;
                 }
 
-                Message.USER_ATTEMPTING_LOOKUP.send(sender);
-
                 UUID uuid = plugin.getDatastore().getUUID(s);
 
                 if (uuid == null) {

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

@@ -24,10 +24,7 @@ package me.lucko.luckperms.commands.log.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
 import me.lucko.luckperms.api.LogEntry;
-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.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.Log;
@@ -40,7 +37,12 @@ import java.util.stream.Collectors;
 
 public class LogSearch extends SubCommand<Log> {
     public LogSearch() {
-        super("search", "Search the log for an entry", "<query> [page]", Permission.LOG_SEARCH, Predicate.is(0));
+        super("search", "Search the log for an entry", Permission.LOG_SEARCH, Predicate.is(0),
+                Arg.list(
+                        Arg.create("query", true, "the query to search by"),
+                        Arg.create("page", false, "the page number to view")
+                )
+        );
     }
 
     @Override

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

@@ -24,10 +24,7 @@ package me.lucko.luckperms.commands.log.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
 import me.lucko.luckperms.api.LogEntry;
-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.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.Log;
@@ -40,7 +37,12 @@ import java.util.SortedMap;
 
 public class LogTrackHistory extends SubCommand<Log> {
     public LogTrackHistory() {
-        super("trackhistory", "View an objects history", "<track> [page]", Permission.LOG_TRACK_HISTORY, Predicate.notInRange(1, 2));
+        super("trackhistory", "View a track's history", Permission.LOG_TRACK_HISTORY, Predicate.notInRange(1, 2),
+                Arg.list(
+                        Arg.create("track", true, "the name of the track"),
+                        Arg.create("page", false, "the page number to view")
+                )
+        );
     }
 
     @Override

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

@@ -38,7 +38,12 @@ import java.util.UUID;
 
 public class LogUserHistory extends SubCommand<Log> {
     public LogUserHistory() {
-        super("userhistory", "View an objects history", "<user> [page]", Permission.LOG_USER_HISTORY, Predicate.notInRange(1, 2));
+        super("userhistory", "View a user's history", Permission.LOG_USER_HISTORY, Predicate.notInRange(1, 2),
+                Arg.list(
+                        Arg.create("user", true, "the name/uuid of the user"),
+                        Arg.create("page", false, "the page number to view")
+                )
+        );
     }
 
     @Override
@@ -71,8 +76,6 @@ public class LogUserHistory extends SubCommand<Log> {
                 return CommandResult.INVALID_ARGS;
             }
 
-            Message.USER_ATTEMPTING_LOOKUP.send(sender);
-
             UUID uuid1 = plugin.getDatastore().getUUID(user);
 
             if (uuid1 == null) {

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", "", MIGRATION, Predicate.alwaysFalse());
+        super("bpermissions", "Migration from bPermissions", MIGRATION, Predicate.alwaysFalse(), null);
     }
 
     @Override

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

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

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

@@ -24,10 +24,7 @@ package me.lucko.luckperms.commands.migration.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
 import me.lucko.luckperms.api.Logger;
-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.commands.*;
 import me.lucko.luckperms.constants.Constants;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.LogEntry;
@@ -45,7 +42,9 @@ import java.util.stream.Collectors;
 
 public class MigrationGroupManager extends SubCommand<Object> {
     public MigrationGroupManager() {
-        super("groupmanager", "Migration from GroupManager", "[world names...]", Permission.MIGRATION, Predicate.is(0));
+        super("groupmanager", "Migration from GroupManager", Permission.MIGRATION, Predicate.is(0),
+                Arg.list(Arg.create("world names...", false, "a list of worlds to migrate permissions from"))
+        );
     }
 
     @Override

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

@@ -25,10 +25,7 @@ package me.lucko.luckperms.commands.migration.subcommands;
 import me.lucko.luckperms.LuckPermsPlugin;
 import me.lucko.luckperms.api.Logger;
 import me.lucko.luckperms.api.PlatformType;
-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.commands.*;
 import me.lucko.luckperms.constants.Constants;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.LogEntry;
@@ -50,7 +47,9 @@ import java.util.stream.Collectors;
 
 public class MigrationPermissionsEx extends SubCommand<Object> {
     public MigrationPermissionsEx() {
-        super("permissionsex", "Migration from PermissionsEx", "[world names...]", Permission.MIGRATION, Predicate.alwaysFalse());
+        super("permissionsex", "Migration from PermissionsEx", Permission.MIGRATION, Predicate.alwaysFalse(),
+                Arg.list(Arg.create("world names...", false, "a list of worlds to migrate permissions from"))
+        );
     }
 
     @SuppressWarnings("deprecation")

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

@@ -29,10 +29,7 @@ import lombok.Cleanup;
 import me.lucko.luckperms.LuckPermsPlugin;
 import me.lucko.luckperms.api.Logger;
 import me.lucko.luckperms.api.data.Callback;
-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.commands.*;
 import me.lucko.luckperms.commands.migration.subcommands.utils.LPResultRunnable;
 import me.lucko.luckperms.constants.Constants;
 import me.lucko.luckperms.core.PermissionHolder;
@@ -119,8 +116,15 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
 
 
     public MigrationPowerfulPerms() {
-        super("powerfulperms", "Migration from PowerfulPerms", "<address> <database> <username> <password> <db table>",
-                MIGRATION, Predicate.not(5));
+        super("powerfulperms", "Migration from PowerfulPerms", MIGRATION, Predicate.not(5),
+                Arg.list(
+                        Arg.create("address", true, "the address of the PP database"),
+                        Arg.create("database", true, "the name of the PP database"),
+                        Arg.create("username", true, "the username to log into the DB"),
+                        Arg.create("password", true, "the password to log into the DB"),
+                        Arg.create("db table", true, "the name of the PP table where player data is stored")
+                )
+        );
     }
 
     @Override

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

@@ -24,10 +24,7 @@ package me.lucko.luckperms.commands.migration.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
 import me.lucko.luckperms.api.Logger;
-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.commands.*;
 import me.lucko.luckperms.constants.Constants;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.LogEntry;
@@ -49,7 +46,9 @@ import java.util.stream.Collectors;
  */
 public class MigrationZPermissions extends SubCommand<Object> {
     public MigrationZPermissions() {
-        super("zpermissions", "Migration from zPermissions", "[world names...]", Permission.MIGRATION, Predicate.alwaysFalse());
+        super("zpermissions", "Migration from zPermissions", Permission.MIGRATION, Predicate.alwaysFalse(),
+                Arg.list(Arg.create("world names...", false, "a list of worlds to migrate permissions from"))
+        );
     }
 
     @Override

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

@@ -127,14 +127,24 @@ public class ExportCommand extends SingleMainCommand {
                 plugin.getDatastore().loadUser(uuid, "null");
                 User user = plugin.getUserManager().get(uuid);
 
+                boolean inDefault = false;
                 for (Node node : user.getNodes()) {
                     if (node.isGroupNode() && node.getGroupName().equalsIgnoreCase("default")) {
+                        inDefault = true;
                         continue;
                     }
+
                     write(writer, nodeToString(node, user.getUuid().toString(), false));
                 }
 
-                write(writer, "/luckperms user " + user.getUuid().toString() + " setprimarygroup " + user.getPrimaryGroup());
+                if (!user.getPrimaryGroup().equalsIgnoreCase("default")) {
+                    write(writer, "/luckperms user " + user.getUuid().toString() + " setprimarygroup " + user.getPrimaryGroup());
+                }
+
+                if (!inDefault) {
+                    write(writer, "/luckperms user " + user.getUuid().toString() + " removegroup default");
+                }
+
                 plugin.getUserManager().cleanup(user);
             }
             log.info("Export: Exported " + userCount + " users.");

common/src/main/java/me/lucko/luckperms/commands/track/TrackMainCommand.java

@@ -43,6 +43,7 @@ public class TrackMainCommand extends MainCommand<Track> {
             .add(new TrackRemove())
             .add(new TrackClear())
             .add(new TrackRename())
+            .add(new TrackClone())
             .build()
         );
     }

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

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

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

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

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

@@ -0,0 +1,73 @@
+/*
+ * 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.track.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.data.LogEntry;
+import me.lucko.luckperms.tracks.Track;
+import me.lucko.luckperms.utils.ArgumentChecker;
+
+import java.util.List;
+
+public class TrackClone extends SubCommand<Track> {
+    public TrackClone() {
+        super("clone", "Clone the track", Permission.TRACK_CLONE, Predicate.not(1),
+                Arg.list(Arg.create("name", true, "the name of the clone"))
+        );
+    }
+
+    @Override
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
+        String newTrackName = args.get(0).toLowerCase();
+        if (ArgumentChecker.checkName(newTrackName)) {
+            Message.TRACK_INVALID_ENTRY.send(sender);
+            return CommandResult.INVALID_ARGS;
+        }
+
+        if (plugin.getDatastore().loadTrack(newTrackName)) {
+            Message.TRACK_ALREADY_EXISTS.send(sender);
+            return CommandResult.INVALID_ARGS;
+        }
+
+        if (!plugin.getDatastore().createAndLoadTrack(newTrackName)) {
+            Message.CREATE_TRACK_ERROR.send(sender);
+            return CommandResult.FAILURE;
+        }
+
+        Track newTrack = plugin.getTrackManager().get(newTrackName);
+        if (newTrack == null) {
+            Message.TRACK_LOAD_ERROR.send(sender);
+            return CommandResult.LOADING_ERROR;
+        }
+
+        newTrack.setGroups(track.getGroups());
+
+        Message.CLONE_SUCCESS.send(sender, track.getName(), newTrack.getName());
+        LogEntry.build().actor(sender).acted(track).action("clone " + newTrack.getName()).build().submit(plugin, sender);
+        save(newTrack, sender, plugin);
+        return CommandResult.SUCCESS;
+    }
+}

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

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

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

@@ -36,8 +36,12 @@ import java.util.List;
 
 public class TrackInsert extends SubCommand<Track> {
     public TrackInsert() {
-        super("insert", "Inserts a group at a given position along the track", "<group> <position>",
-                Permission.TRACK_INSERT, Predicate.not(2));
+        super("insert", "Inserts a group at a given position along the track", Permission.TRACK_INSERT, Predicate.not(2),
+                Arg.list(
+                        Arg.create("group", true, "the group to insert"),
+                        Arg.create("position", true, "the position to insert the group at (the first position on the track is 1)")
+                )
+        );
     }
 
     @Override
@@ -45,7 +49,7 @@ public class TrackInsert extends SubCommand<Track> {
         String groupName = args.get(0).toLowerCase();
 
         if (ArgumentChecker.checkNode(groupName)) {
-            sendUsage(sender);
+            sendDetailedUsage(sender);
             return CommandResult.INVALID_ARGS;
         }
 

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

@@ -35,7 +35,9 @@ import java.util.List;
 
 public class TrackRemove extends SubCommand<Track> {
     public TrackRemove() {
-        super("remove", "Removes a group from the track", "<group>", Permission.TRACK_REMOVE, Predicate.not(1));
+        super("remove", "Removes a group from the track", Permission.TRACK_REMOVE, Predicate.not(1),
+                Arg.list(Arg.create("group", true, "the group to remove"))
+        );
     }
 
     @Override
@@ -43,7 +45,7 @@ public class TrackRemove extends SubCommand<Track> {
         String groupName = args.get(0).toLowerCase();
 
         if (ArgumentChecker.checkNode(groupName)) {
-            sendUsage(sender);
+            sendDetailedUsage(sender);
             return CommandResult.INVALID_ARGS;
         }
 

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

@@ -23,10 +23,7 @@
 package me.lucko.luckperms.commands.track.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-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.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.LogEntry;
@@ -37,7 +34,9 @@ import java.util.List;
 
 public class TrackRename extends SubCommand<Track> {
     public TrackRename() {
-        super("rename", "Rename this track", "<new name>", Permission.TRACK_APPEND, Predicate.not(1));
+        super("rename", "Rename the track", Permission.TRACK_RENAME, Predicate.not(1),
+                Arg.list(Arg.create("name", true, "the new name"))
+        );
     }
 
     @Override
@@ -69,7 +68,7 @@ public class TrackRename extends SubCommand<Track> {
             return CommandResult.FAILURE;
         }
 
-        plugin.getTrackManager().copy(track, newTrack);
+        newTrack.setGroups(track.getGroups());
 
         Message.RENAME_SUCCESS.send(sender, track.getName(), newTrack.getName());
         LogEntry.build().actor(sender).acted(track).action("rename " + newTrack.getName()).build().submit(plugin, sender);

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

@@ -83,8 +83,6 @@ public class UserMainCommand extends MainCommand<User> {
                     return null;
                 }
 
-                Message.USER_ATTEMPTING_LOOKUP.send(sender);
-
                 u = plugin.getDatastore().getUUID(target);
                 if (u == null) {
                     Message.USER_NOT_FOUND.send(sender);

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

@@ -23,10 +23,7 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-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.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.LogEntry;
@@ -39,7 +36,13 @@ import java.util.List;
 
 public class UserAddGroup extends SubCommand<User> {
     public UserAddGroup() {
-        super("addgroup", "Adds the user to a group", "<group> [server] [world]", Permission.USER_ADDGROUP, Predicate.notInRange(1, 3));
+        super("addgroup", "Adds the user to a group", Permission.USER_ADDGROUP, Predicate.notInRange(1, 3),
+                Arg.list(
+                        Arg.create("group", true, "the group to add the user to"),
+                        Arg.create("server", false, "the server to add the group on"),
+                        Arg.create("world", false, "the world to add the group on")
+                )
+        );
     }
 
     @Override
@@ -47,7 +50,7 @@ public class UserAddGroup extends SubCommand<User> {
         String groupName = args.get(0).toLowerCase();
 
         if (ArgumentChecker.checkNode(groupName)) {
-            sendUsage(sender);
+            sendDetailedUsage(sender);
             return CommandResult.INVALID_ARGS;
         }
 

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

@@ -23,10 +23,7 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-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.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.LogEntry;
@@ -38,8 +35,14 @@ import java.util.List;
 
 public class UserAddPrefix extends SubCommand<User> {
     public UserAddPrefix() {
-        super("addprefix", "Adds a prefix to the user", "<priority> <prefix> [server] [world]", Permission.USER_ADDPREFIX,
-                Predicate.notInRange(2, 4));
+        super("addprefix", "Adds a prefix to the user",  Permission.USER_ADDPREFIX, Predicate.notInRange(2, 4),
+                Arg.list(
+                        Arg.create("priority", true, "the priority to add the prefix at"),
+                        Arg.create("prefix", true, "the prefix string"),
+                        Arg.create("server", false, "the server to add the prefix on"),
+                        Arg.create("world", false, "the world to add the prefix on")
+                )
+        );
     }
 
     @Override

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

@@ -23,10 +23,7 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-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.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.LogEntry;
@@ -38,8 +35,14 @@ import java.util.List;
 
 public class UserAddSuffix extends SubCommand<User> {
     public UserAddSuffix() {
-        super("addsuffix", "Adds a suffix to the user", "<priority> <suffix> [server] [world]", Permission.USER_ADDSUFFIX,
-                Predicate.notInRange(2, 4));
+        super("addsuffix", "Adds a suffix to the user", Permission.USER_ADDSUFFIX, Predicate.notInRange(2, 4),
+                Arg.list(
+                        Arg.create("priority", true, "the priority to add the suffix at"),
+                        Arg.create("suffix", true, "the suffix string"),
+                        Arg.create("server", false, "the server to add the suffix on"),
+                        Arg.create("world", false, "the world to add the suffix on")
+                )
+        );
     }
 
     @Override

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

@@ -23,10 +23,7 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-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.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.LogEntry;
@@ -40,8 +37,14 @@ import java.util.List;
 
 public class UserAddTempGroup extends SubCommand<User> {
     public UserAddTempGroup() {
-        super("addtempgroup", "Adds the user to a group temporarily", "<group> <duration> [server] [world]",
-                Permission.USER_ADDTEMPGROUP, Predicate.notInRange(2, 4));
+        super("addtempgroup", "Adds the user to a group temporarily", Permission.USER_ADDTEMPGROUP, Predicate.notInRange(2, 4),
+                Arg.list(
+                        Arg.create("group", true, "the group to add the user to"),
+                        Arg.create("duration", true, "the duration of the group membership"),
+                        Arg.create("server", false, "the server to add the group on"),
+                        Arg.create("world", false, "the world to add the group on")
+                )
+        );
     }
 
     @Override
@@ -49,7 +52,7 @@ public class UserAddTempGroup extends SubCommand<User> {
         String groupName = args.get(0).toLowerCase();
 
         if (ArgumentChecker.checkNode(groupName)) {
-            sendUsage(sender);
+            sendDetailedUsage(sender);
             return CommandResult.INVALID_ARGS;
         }
 

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

@@ -23,10 +23,7 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-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.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.LogEntry;
@@ -39,8 +36,15 @@ import java.util.List;
 
 public class UserAddTempPrefix extends SubCommand<User> {
     public UserAddTempPrefix() {
-        super("addtempprefix", "Adds a prefix to the user temporarily", "<priority> <prefix> <duration> [server] [world]",
-                Permission.USER_ADD_TEMP_PREFIX, Predicate.notInRange(3, 5));
+        super("addtempprefix", "Adds a prefix to the user temporarily", Permission.USER_ADD_TEMP_PREFIX, Predicate.notInRange(3, 5),
+                Arg.list(
+                        Arg.create("priority", true, "the priority to add the prefix at"),
+                        Arg.create("prefix", true, "the prefix string"),
+                        Arg.create("duration", true, "the duration until the prefix expires"),
+                        Arg.create("server", false, "the server to add the prefix on"),
+                        Arg.create("world", false, "the world to add the prefix on")
+                )
+        );
     }
 
     @Override

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

@@ -23,10 +23,7 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-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.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.LogEntry;
@@ -39,8 +36,15 @@ import java.util.List;
 
 public class UserAddTempSuffix extends SubCommand<User> {
     public UserAddTempSuffix() {
-        super("addtempsuffix", "Adds a suffix to the user temporarily", "<priority> <suffix> <duration> [server] [world]",
-                Permission.USER_ADD_TEMP_SUFFIX, Predicate.notInRange(3, 5));
+        super("addtempsuffix", "Adds a suffix to the user temporarily", Permission.USER_ADD_TEMP_SUFFIX, Predicate.notInRange(3, 5),
+                Arg.list(
+                        Arg.create("priority", true, "the priority to add the suffix at"),
+                        Arg.create("suffix", true, "the suffix string"),
+                        Arg.create("duration", true, "the duration until the suffix expires"),
+                        Arg.create("server", false, "the server to add the suffix on"),
+                        Arg.create("world", false, "the world to add the suffix on")
+                )
+        );
     }
 
     @Override

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

@@ -24,12 +24,11 @@ package me.lucko.luckperms.commands.user.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.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
 import me.lucko.luckperms.users.User;
 
 import java.util.HashSet;
@@ -39,8 +38,13 @@ import java.util.Set;
 
 public class UserBulkChange extends SubCommand<User> {
     public UserBulkChange() {
-        super("bulkchange", "Applies a bulk permission change to the users permissions", "<server|world> <from> <to>",
-                Permission.USER_BULKCHANGE, Predicate.not(3));
+        super("bulkchange", "Applies a bulk permission change to the user's permissions", Permission.USER_BULKCHANGE, Predicate.not(3),
+                Arg.list(
+                        Arg.create("server|world", true, "if the bulk change is modifying a 'server' or a 'world'"),
+                        Arg.create("from", true, "the server/world to be changed from. can be 'global' or 'null' respectively"),
+                        Arg.create("to", true, "the server/world to replace 'from' (can be 'null')")
+                )
+        );
     }
 
     @Override
@@ -53,6 +57,7 @@ public class UserBulkChange extends SubCommand<User> {
         }
 
         Set<Node> toAdd = new HashSet<>();
+        Set<Node> toRemove = new HashSet<>();
 
         if (!type.equals("world") && !type.equals("server")) {
             Message.BULK_CHANGE_TYPE_ERROR.send(sender);
@@ -63,28 +68,49 @@ public class UserBulkChange extends SubCommand<User> {
         if (type.equals("world")) {
             while (iterator.hasNext()) {
                 Node element = iterator.next();
+
+                if (element.isGroupNode()) {
+                    continue;
+                }
+
                 String world = element.getWorld().orElse("null");
                 if (!world.equals(from)) {
                     continue;
                 }
 
-                iterator.remove();
+                toRemove.add(element);
                 toAdd.add(me.lucko.luckperms.core.Node.builderFromExisting(element).setWorld(to).build());
             }
         } else {
             while (iterator.hasNext()) {
                 Node element = iterator.next();
+
+                if (element.isGroupNode()) {
+                    continue;
+                }
+
                 String server = element.getServer().orElse("global");
                 if (!server.equals(from)) {
                     continue;
                 }
 
-                iterator.remove();
+                toRemove.add(element);
                 toAdd.add(me.lucko.luckperms.core.Node.builderFromExisting(element).setServer(to).build());
             }
         }
 
-        user.getNodes().addAll(toAdd);
+        toRemove.forEach(n -> {
+            try {
+                user.unsetPermission(n);
+            } catch (ObjectLacksException ignored) {}
+        });
+
+        toAdd.forEach(n -> {
+            try {
+                user.setPermission(n);
+            } catch (ObjectAlreadyHasException ignored) {}
+        });
+
         save(user, sender, plugin);
         Message.BULK_CHANGE_SUCCESS.send(sender, toAdd.size());
         return CommandResult.SUCCESS;

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

@@ -23,11 +23,11 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.Contexts;
 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.users.User;
 
 import java.util.AbstractMap.SimpleEntry;
@@ -38,7 +38,7 @@ import java.util.TreeSet;
 
 public class UserChatMeta extends SubCommand<User> {
     public UserChatMeta() {
-        super("chatmeta", "Displays a users chat meta", "", Permission.USER_CHATMETA, Predicate.alwaysFalse());
+        super("chatmeta", "Lists the user's chat meta", Permission.USER_CHATMETA, Predicate.alwaysFalse(), null);
     }
 
     @Override

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

@@ -36,7 +36,7 @@ import java.util.List;
 
 public class UserClear extends SubCommand<User> {
     public UserClear() {
-        super("clear", "Clears a users permissions and groups", "", Permission.USER_CLEAR, Predicate.alwaysFalse());
+        super("clear", "Clears the user's permissions and groups", Permission.USER_CLEAR, Predicate.alwaysFalse(), null);
     }
 
     @Override