Bump minor version

README.md

@@ -14,13 +14,16 @@ LuckPerms is an advanced permissions implementation aiming to be a flexible, per
 * [Sponge Plugin Page](https://forums.spongepowered.org/t/luckperms-an-advanced-permissions-system/14274 "Sponge Plugin Page")
 
 ## LuckPerms vs Other Plugins
+### Bukkit
 ![alt text](https://static.lucko.me/luckperms-compare-copy.png "Feature comparison")
 _Features checked on 23rd Aug 2016. If you find any inaccuracies, please do let me know. I tried to be as fair as possible, and copy all major features from the respective plugin pages._
-
+### Sponge
+![alt text](https://static.lucko.me/luckperms-compare-sponge.png "Feature comparison")
+_Features checked on 8th Oct 2016. If you find any inaccuracies, please do let me know. I tried to be as fair as possible, and copy all major features from the respective plugin pages._
 ## License
-See LICENSE.md.
+LuckPerms is licensed under the permissive MIT license. See LICENSE.md for more info.
 
 ## Thanks to:
 [![JProfiler](https://www.ej-technologies.com/images/product_banners/jprofiler_large.png)](http://www.ej-technologies.com/products/jprofiler/overview.html)
 
-Thanks to ej-technologies for granting LuckPerms an open source licence to their [java profiling software](http://www.ej-technologies.com/products/jprofiler/overview.html "Java Profiler").
+Thanks to ej-technologies for granting LuckPerms an open source licence to their [Java Profiling Software](http://www.ej-technologies.com/products/jprofiler/overview.html "Java Profiler").

api/pom.xml

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

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

@@ -0,0 +1,224 @@
+/*
+ * 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, 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 static Contexts of(Map<String, String> context, boolean includeGlobal, boolean includeGlobalWorld, boolean applyGroups, boolean applyGlobalGroups, boolean applyGlobalWorldGroups, boolean op) {
+        return new Contexts(context, includeGlobal, includeGlobalWorld, applyGroups, applyGlobalGroups, applyGlobalWorldGroups, op);
+    }
+
+    public Contexts(Map<String, String> context, boolean includeGlobal, boolean includeGlobalWorld, boolean applyGroups, boolean applyGlobalGroups, boolean applyGlobalWorldGroups, boolean op) {
+        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;
+        this.op = op;
+    }
+
+    public Contexts(Map<String, String> context, boolean includeGlobal, boolean includeGlobalWorld, boolean applyGroups, boolean applyGlobalGroups, boolean applyGlobalWorldGroups) {
+        this(context, includeGlobal, includeGlobalWorld, applyGroups, applyGlobalGroups, applyGlobalWorldGroups, false);
+    }
+
+    /**
+     * The contexts that apply for this lookup
+     *
+     * The keys for servers and worlds are defined as static values.
+     */
+    private final Map<String, String> context;
+
+    /**
+     * The mode to parse defaults on Bukkit
+     * @since 2.12
+     */
+    private final boolean op;
+
+    /**
+     * 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 OP defaults should be included
+     * @return true if op defaults should be included
+     */
+    public boolean isOp() {
+        return this.op;
+    }
+
+    /**
+     * 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() + ", " +
+                "op=" + this.isOp() + ", " +
+                "includeGlobal=" + this.isIncludeGlobal() + ", " +
+                "includeGlobalWorld=" + this.isIncludeGlobalWorld() + ", " +
+                "applyGroups=" + this.isApplyGroups() + ", " +
+                "applyGlobalGroups=" + this.isApplyGlobalGroups() + ", " +
+                "applyGlobalWorldGroups=" + this.isApplyGlobalWorldGroups() +
+                ")";
+    }
+
+    /*
+     * Ugly auto-generated lombok code
+     */
+
+    /**
+     * Check for equality
+     * @param o the other
+     * @return true if equal
+     * @since 2.12
+     */
+    public boolean equals(Object o) {
+        if (o == this) return true;
+        if (!(o instanceof Contexts)) return false;
+        final Contexts other = (Contexts) o;
+        final Object this$context = this.getContext();
+        final Object other$context = other.getContext();
+        if (this$context == null ? other$context != null : !this$context.equals(other$context)) return false;
+        if (this.isOp() != other.isOp()) return false;
+        if (this.isIncludeGlobal() != other.isIncludeGlobal()) return false;
+        if (this.isIncludeGlobalWorld() != other.isIncludeGlobalWorld()) return false;
+        if (this.isApplyGroups() != other.isApplyGroups()) return false;
+        if (this.isApplyGlobalGroups() != other.isApplyGlobalGroups()) return false;
+        if (this.isApplyGlobalWorldGroups() != other.isApplyGlobalWorldGroups()) return false;
+        return true;
+    }
+
+    /**
+     * Gets the hashcode
+     * @return the hashcode
+     * @since 2.12
+     */
+    public int hashCode() {
+        final int PRIME = 59;
+        int result = 1;
+        final Object $context = this.getContext();
+        result = result * PRIME + ($context == null ? 43 : $context.hashCode());
+        result = result * PRIME + (this.isOp() ? 79 : 97);
+        result = result * PRIME + (this.isIncludeGlobal() ? 79 : 97);
+        result = result * PRIME + (this.isIncludeGlobalWorld() ? 79 : 97);
+        result = result * PRIME + (this.isApplyGroups() ? 79 : 97);
+        result = result * PRIME + (this.isApplyGlobalGroups() ? 79 : 97);
+        result = result * PRIME + (this.isApplyGlobalWorldGroups() ? 79 : 97);
+        return result;
+    }
+
+}

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/LuckPermsApi.java

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

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

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

api/src/main/java/me/lucko/luckperms/api/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);
 
     /**

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

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

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

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

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

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

bukkit-legacy/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>luckperms</artifactId>
         <groupId>me.lucko.luckperms</groupId>
-        <version>2.9-SNAPSHOT</version>
+        <version>2.12-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
@@ -67,6 +67,14 @@
                                     <pattern>org.h2</pattern>
                                     <shadedPattern>me.lucko.luckperms.lib.h2</shadedPattern>
                                 </relocation>
+                                <relocation>
+                                    <pattern>com.google.common</pattern>
+                                    <shadedPattern>me.lucko.luckperms.lib.guava</shadedPattern>
+                                </relocation>
+                                <relocation>
+                                    <pattern>com.google.gson</pattern>
+                                    <shadedPattern>me.lucko.luckperms.lib.gson</shadedPattern>
+                                </relocation>
                             </relocations>
                         </configuration>
                     </execution>

bukkit-placeholders/pom.xml

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

bukkit/pom.xml

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

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

@@ -1,337 +0,0 @@
-/*
- * 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;
-
-import lombok.NonNull;
-import lombok.Setter;
-import me.lucko.luckperms.LPBukkitPlugin;
-import me.lucko.luckperms.api.Node;
-import me.lucko.luckperms.core.PermissionHolder;
-import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
-import me.lucko.luckperms.groups.Group;
-import me.lucko.luckperms.users.User;
-import me.lucko.luckperms.utils.Contexts;
-import net.milkbowl.vault.chat.Chat;
-
-import java.util.Iterator;
-import java.util.Map;
-
-import static me.lucko.luckperms.utils.ArgumentChecker.escapeCharacters;
-import static me.lucko.luckperms.utils.ArgumentChecker.unescapeCharacters;
-
-/**
- * Provides the Vault Chat service through the use of normal permission nodes.
- *
- * Prefixes / Suffixes:
- * Normal inheritance rules apply.
- * Permission Nodes = prefix.priority.value OR suffix.priority.value
- * If a user/group has / inherits multiple prefixes and suffixes, the one with the highest priority is the one that
- * will apply.
- *
- * Meta:
- * Normal inheritance rules DO NOT apply.
- * Permission Nodes = meta.node.value
- *
- * 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) {
-        super(perms);
-        this.perms = perms;
-    }
-
-    public String getName() {
-        return perms.getName();
-    }
-
-    public boolean isEnabled() {
-        return perms.isEnabled();
-    }
-
-    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();
-            }
-        }
-
-        Node.Builder metaNode = new me.lucko.luckperms.utils.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) {}
-        
-        perms.objectSave(holder);
-    }
-
-    private String getMeta(PermissionHolder holder, String world, String node, String defaultValue) {
-        if (holder == null) return defaultValue;
-        if (node.equals("")) return defaultValue;
-        node = escapeCharacters(node);
-
-        for (Node n : holder.getPermissions(true)) {
-            if (!n.getValue()) {
-                continue;
-            }
-
-            if (!n.isMeta()) {
-                continue;
-            }
-
-            if (!n.shouldApplyOnServer(perms.getServer(), perms.isIncludeGlobal(), false)) {
-                continue;
-            }
-
-            if (!n.shouldApplyOnWorld(world, perms.isIncludeGlobal(), false)) {
-                continue;
-            }
-
-            Map.Entry<String, String> meta = n.getMeta();
-            if (meta.getKey().equalsIgnoreCase(node)) {
-                return unescapeCharacters(meta.getValue());
-            }
-        }
-
-        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.utils.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 "";
-
-        int priority = Integer.MIN_VALUE;
-        String meta = null;
-
-        for (Node n : holder.getAllNodes(null, Contexts.allowAll())) {
-            if (!n.getValue()) {
-                continue;
-            }
-
-            if (prefix ? !n.isPrefix() : !n.isSuffix()) {
-                continue;
-            }
-
-            if (!n.shouldApplyOnServer(perms.getServer(), perms.isIncludeGlobal(), false)) {
-                continue;
-            }
-
-            if (!n.shouldApplyOnWorld(world, perms.isIncludeGlobal(), false)) {
-                continue;
-            }
-
-            Map.Entry<Integer, String> value = prefix ? n.getPrefix() : n.getSuffix();
-            if (value.getKey() > priority) {
-                meta = value.getValue();
-                priority = value.getKey();
-            }
-        }
-
-        return meta == null ? "" : unescapeCharacters(meta);
-    }
-
-    public String getPlayerPrefix(String world, @NonNull String player) {
-        final User user = plugin.getUserManager().get(player);
-        return getChatMeta(true, user, world);
-    }
-
-    public void setPlayerPrefix(String world, @NonNull String player, @NonNull String prefix) {
-        final User user = plugin.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);
-    }
-
-    public void setPlayerSuffix(String world, @NonNull String player, @NonNull String suffix) {
-        final User user = plugin.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);
-    }
-
-    public void setGroupPrefix(String world, @NonNull String group, @NonNull String prefix) {
-        final Group g = plugin.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);
-    }
-
-    public void setGroupSuffix(String world, @NonNull String group, @NonNull String suffix) {
-        final Group g = plugin.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);
-        try {
-            return Integer.parseInt(getMeta(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);
-        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);
-        try {
-            return Integer.parseInt(getMeta(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);
-        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);
-        try {
-            return Double.parseDouble(getMeta(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);
-        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);
-        try {
-            return Double.parseDouble(getMeta(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);
-        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));
-        if (!s.equalsIgnoreCase("true") && !s.equalsIgnoreCase("false")) {
-            return defaultValue;
-        }
-        return Boolean.parseBoolean(s);
-    }
-
-    public void setPlayerInfoBoolean(String world, @NonNull String player, @NonNull String node, boolean value) {
-        final User user = plugin.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));
-        if (!s.equalsIgnoreCase("true") && !s.equalsIgnoreCase("false")) {
-            return defaultValue;
-        }
-        return Boolean.parseBoolean(s);
-    }
-
-    public void setGroupInfoBoolean(String world, @NonNull String group, @NonNull String node, boolean value) {
-        final Group g = plugin.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);
-    }
-
-    public void setPlayerInfoString(String world, @NonNull String player, @NonNull String node, String value) {
-        final User user = plugin.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);
-    }
-
-    public void setGroupInfoString(String world, @NonNull String group, @NonNull String node, String value) {
-        final Group g = plugin.getGroupManager().get(group);
-        saveMeta(g, world, node, value);
-    }
-
-}

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

@@ -1,226 +0,0 @@
-/*
- * 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;
-
-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.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.permission.Permission;
-
-public class VaultPermissionHook extends Permission {
-
-    @Setter
-    private LPBukkitPlugin plugin;
-
-    @Getter
-    @Setter
-    private String server = "global";
-
-    @Getter
-    @Setter
-    private boolean includeGlobal = true;
-
-    @Override
-    public String getName() {
-        return "LuckPerms";
-    }
-
-    @Override
-    public boolean isEnabled() {
-        return plugin.getDatastore().isAcceptingLogins();
-    }
-
-    @Override
-    public boolean hasSuperPermsCompat() {
-        return true;
-    }
-
-    private boolean objectHas(String world, PermissionHolder object, String permission) {
-        if (object == null) return false;
-
-        if (world != null && !world.equals("")) {
-            return object.hasPermission(permission, true, server, world);
-        } else {
-            return object.hasPermission(permission, true, server);
-        }
-    }
-
-    private boolean objectAdd(String world, PermissionHolder object, String permission) {
-        if (object == null) return false;
-
-        try {
-            if (world != null && !world.equals("")) {
-                object.setPermission(permission, true, server, world);
-            } else {
-                object.setPermission(permission, true, server);
-            }
-        } catch (ObjectAlreadyHasException ignored) {}
-
-        objectSave(object);
-        return true;
-    }
-
-    private boolean objectRemove(String world, PermissionHolder object, String permission) {
-        if (object == null) return false;
-
-        try {
-            if (world != null && !world.equals("")) {
-                object.unsetPermission(permission, server, world);
-            } else {
-                object.unsetPermission(permission, server);
-            }
-        } catch (ObjectLacksException ignored) {}
-
-        objectSave(object);
-        return true;
-    }
-
-    void objectSave(PermissionHolder t) {
-        if (t instanceof User) {
-            ((User) t).refreshPermissions();
-            plugin.getDatastore().saveUser(((User) t), Callback.empty());
-        }
-        if (t instanceof Group) {
-            plugin.getDatastore().saveGroup(((Group) t), c -> plugin.runUpdateTask());
-        }
-    }
-
-    @Override
-    public boolean playerHas(String world, @NonNull String player, @NonNull String permission) {
-        return objectHas(world, plugin.getUserManager().get(player), permission);
-    }
-
-    @Override
-    public boolean playerAdd(String world, @NonNull String player, @NonNull String permission) {
-        final User user = plugin.getUserManager().get(player);
-        return objectAdd(world, user, permission);
-    }
-
-    @Override
-    public boolean playerRemove(String world, @NonNull String player, @NonNull String permission) {
-        final User user = plugin.getUserManager().get(player);
-        return objectRemove(world, user, permission);
-    }
-
-    @Override
-    public boolean groupHas(String world, @NonNull String groupName, @NonNull String permission) {
-        final Group group = plugin.getGroupManager().get(groupName);
-        return objectHas(world, group, permission);
-    }
-
-    @Override
-    public boolean groupAdd(String world, @NonNull String groupName, @NonNull String permission) {
-        final Group group = plugin.getGroupManager().get(groupName);
-        return objectAdd(world, group, permission);
-    }
-
-    @Override
-    public boolean groupRemove(String world, @NonNull String groupName, @NonNull String permission) {
-        final Group group = plugin.getGroupManager().get(groupName);
-        return objectRemove(world, group, permission);
-    }
-
-    @Override
-    public boolean playerInGroup(String world, @NonNull String player, @NonNull String group) {
-        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);
-        }
-    }
-
-    @Override
-    public boolean playerAddGroup(String world, @NonNull String player, @NonNull String groupName) {
-        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);
-        return true;
-    }
-
-    @Override
-    public boolean playerRemoveGroup(String world, @NonNull String player, @NonNull String groupName) {
-        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);
-        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]);
-    }
-
-    @Override
-    public String getPrimaryGroup(String world, @NonNull String player) {
-        final User user = plugin.getUserManager().get(player);
-        return (user == null) ? null : user.getPrimaryGroup();
-    }
-
-    @Override
-    public String[] getGroups() {
-        return plugin.getGroupManager().getAll().keySet().toArray(new String[0]);
-    }
-
-    @Override
-    public boolean hasGroupSupport() {
-        return true;
-    }
-}

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

@@ -0,0 +1,63 @@
+/*
+ * 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.bukkit;
+
+import lombok.AllArgsConstructor;
+import me.lucko.luckperms.api.Contexts;
+import me.lucko.luckperms.bukkit.calculators.AttachmentProcessor;
+import me.lucko.luckperms.bukkit.calculators.DefaultsProcessor;
+import me.lucko.luckperms.bukkit.inject.Injector;
+import me.lucko.luckperms.bukkit.inject.LPPermissible;
+import me.lucko.luckperms.common.calculators.*;
+import me.lucko.luckperms.common.users.User;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+@AllArgsConstructor
+public class BukkitCalculatorFactory implements CalculatorFactory {
+    private final LPBukkitPlugin plugin;
+
+    @Override
+    public PermissionCalculator build(Contexts contexts, User user, Map<String, Boolean> map) {
+        UUID uuid = plugin.getUuidCache().getExternalUUID(user.getUuid());
+
+        List<PermissionProcessor> processors = new ArrayList<>(5);
+        processors.add(new MapProcessor(map));
+        processors.add(new AttachmentProcessor(() -> {
+            LPPermissible permissible = Injector.getPermissible(uuid);
+            return permissible == null ? null : permissible.getAttachmentPermissions();
+        }));
+        if (plugin.getConfiguration().isApplyingWildcards()) {
+            processors.add(new WildcardProcessor(map));
+        }
+        if (plugin.getConfiguration().isApplyingRegex()) {
+            processors.add(new RegexProcessor(map));
+        }
+        processors.add(new DefaultsProcessor(contexts.isOp(), plugin.getDefaultsProvider()));
+
+        return new PermissionCalculator(plugin, user.getName(), plugin.getConfiguration().isDebugPermissionChecks(), processors);
+    }
+}

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

@@ -20,14 +20,15 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms;
+package me.lucko.luckperms.bukkit;
 
 import com.google.common.base.Joiner;
 import com.google.common.base.Splitter;
 import me.lucko.luckperms.api.data.Callback;
-import me.lucko.luckperms.commands.CommandManager;
-import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.constants.Patterns;
+import me.lucko.luckperms.common.LuckPermsPlugin;
+import me.lucko.luckperms.common.commands.CommandManager;
+import me.lucko.luckperms.common.commands.Util;
+import me.lucko.luckperms.common.constants.Patterns;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
@@ -44,7 +45,7 @@ class BukkitCommand extends CommandManager implements CommandExecutor, TabExecut
     @Override
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
         onCommand(
-                BukkitSenderFactory.get().wrap(sender),
+                BukkitSenderFactory.get(getPlugin()).wrap(sender),
                 label,
                 Util.stripQuotes(Splitter.on(Patterns.COMMAND_SEPARATOR).omitEmptyStrings().splitToList(Joiner.on(' ').join(args))),
                 Callback.empty()
@@ -55,6 +56,6 @@ class BukkitCommand extends CommandManager implements CommandExecutor, TabExecut
 
     @Override
     public List<String> onTabComplete(CommandSender sender, Command command, String label, String[] args) {
-        return onTabComplete(BukkitSenderFactory.get().wrap(sender), Arrays.asList(args));
+        return onTabComplete(BukkitSenderFactory.get(getPlugin()).wrap(sender), Arrays.asList(args));
     }
 }

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

@@ -20,16 +20,17 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms;
+package me.lucko.luckperms.bukkit;
 
-import me.lucko.luckperms.core.LPConfiguration;
-import org.bukkit.configuration.InvalidConfigurationException;
+import me.lucko.luckperms.common.config.AbstractConfiguration;
+import org.bukkit.configuration.ConfigurationSection;
 import org.bukkit.configuration.file.YamlConfiguration;
 
 import java.io.File;
-import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
 
-class BukkitConfig extends LPConfiguration<LPBukkitPlugin> {
+class BukkitConfig extends AbstractConfiguration<LPBukkitPlugin> {
     private YamlConfiguration configuration;
 
     BukkitConfig(LPBukkitPlugin plugin) {
@@ -46,18 +47,7 @@ class BukkitConfig extends LPConfiguration<LPBukkitPlugin> {
             getPlugin().saveResource("config.yml", false);
         }
 
-        configuration = new YamlConfiguration();
-
-        try {
-            configuration.load(configFile);
-        } catch (InvalidConfigurationException | IOException e) {
-            e.printStackTrace();
-        }
-    }
-
-    @Override
-    protected void set(String path, Object value) {
-        configuration.set(path, value);
+        configuration = YamlConfiguration.loadConfiguration(configFile);
     }
 
     @Override
@@ -74,4 +64,20 @@ class BukkitConfig extends LPConfiguration<LPBukkitPlugin> {
     protected boolean getBoolean(String path, boolean def) {
         return configuration.getBoolean(path, def);
     }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    protected Map<String, String> getMap(String path, Map<String, String> def) {
+        Map<String, String> map = new HashMap<>();
+        ConfigurationSection section = configuration.getConfigurationSection(path);
+        if (section == null) {
+            return def;
+        }
+
+        for (String key : section.getKeys(false)) {
+            map.put(key, section.getString(key));
+        }
+
+        return map;
+    }
 }

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

@@ -20,19 +20,21 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms;
+package me.lucko.luckperms.bukkit;
 
-import me.lucko.luckperms.constants.Message;
-import me.lucko.luckperms.inject.Injector;
-import me.lucko.luckperms.inject.LPPermissible;
-import me.lucko.luckperms.users.BukkitUser;
-import me.lucko.luckperms.users.User;
-import me.lucko.luckperms.utils.AbstractListener;
+import me.lucko.luckperms.bukkit.inject.Injector;
+import me.lucko.luckperms.bukkit.inject.LPPermissible;
+import me.lucko.luckperms.common.constants.Message;
+import me.lucko.luckperms.common.users.User;
+import me.lucko.luckperms.common.utils.AbstractListener;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
-import org.bukkit.event.player.*;
+import org.bukkit.event.player.AsyncPlayerPreLoginEvent;
+import org.bukkit.event.player.PlayerCommandPreprocessEvent;
+import org.bukkit.event.player.PlayerLoginEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
 
 import java.util.UUID;
 
@@ -47,64 +49,86 @@ class BukkitListener extends AbstractListener implements Listener {
     @EventHandler(priority = EventPriority.LOWEST)
     public void onPlayerPreLogin(AsyncPlayerPreLoginEvent e) {
         if (!plugin.getDatastore().isAcceptingLogins()) {
+
             // The datastore is disabled, prevent players from joining the server
             e.disallow(AsyncPlayerPreLoginEvent.Result.KICK_OTHER, Message.LOADING_ERROR.toString());
             return;
         }
 
+        // Process login
         onAsyncLogin(e.getUniqueId(), e.getName());
     }
 
+    @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
+            onLeave(e.getUniqueId());
+        }
+    }
+
     @EventHandler(priority = EventPriority.LOWEST)
     public void onPlayerLogin(PlayerLoginEvent e) {
         final Player player = e.getPlayer();
         final User user = plugin.getUserManager().get(plugin.getUuidCache().getUUID(player.getUniqueId()));
 
         if (user == null) {
+            // User wasn't loaded for whatever reason.
             e.disallow(PlayerLoginEvent.Result.KICK_OTHER, Message.LOADING_ERROR.toString());
             return;
         }
 
-        if (user instanceof BukkitUser) {
-            BukkitUser u = (BukkitUser) user;
+        try {
+            // Make a new permissible for the user
+            LPPermissible lpPermissible = new LPPermissible(player, user, plugin);
 
-            try {
-                LPPermissible lpPermissible = new LPPermissible(player, plugin);
-                Injector.inject(player, lpPermissible);
-                u.setLpPermissible(lpPermissible);
-            } catch (Throwable t) {
-                t.printStackTrace();
-            }
+            // Inject into the player
+            Injector.inject(player, lpPermissible);
+
+        } catch (Throwable t) {
+            t.printStackTrace();
         }
 
-        plugin.doAsync(user::refreshPermissions);
+        if (player.isOp()) {
+
+            // We assume all users are not op, but those who are need extra calculation.
+            plugin.doAsync(() -> user.getUserData().preCalculate(plugin.getPreProcessContexts(true)));
+        }
     }
 
-    @EventHandler(priority = EventPriority.LOWEST)
-    public void onPlayerJoin(PlayerJoinEvent e) {
-        // Refresh permissions again
-        UUID internal = plugin.getUuidCache().getUUID(e.getPlayer().getUniqueId());
-        plugin.getUserManager().getWorldCache().put(internal, e.getPlayer().getWorld().getName());
-        plugin.doAsync(() -> refreshPlayer(internal));
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void onPlayerLoginMonitor(PlayerLoginEvent e) {
+        if (e.getResult() != PlayerLoginEvent.Result.ALLOWED) {
+
+            // The player got denied on sync login.
+            onLeave(e.getPlayer().getUniqueId());
+        }
     }
 
-    @EventHandler(priority = EventPriority.LOWEST)
-    public void onPlayerChangedWorld(PlayerChangedWorldEvent e) {
-        UUID internal = plugin.getUuidCache().getUUID(e.getPlayer().getUniqueId());
-        plugin.getUserManager().getWorldCache().put(internal, e.getPlayer().getWorld().getName());
-        plugin.doAsync(() -> refreshPlayer(internal));
-
-    }
-
-    @EventHandler(priority = EventPriority.LOWEST)
+    @EventHandler(priority = EventPriority.HIGHEST) // Allow other plugins to see data when this event gets called.
     public void onPlayerQuit(PlayerQuitEvent e) {
-        plugin.getUserManager().getWorldCache().remove(plugin.getUuidCache().getUUID(e.getPlayer().getUniqueId()));
-        onLeave(e.getPlayer().getUniqueId());
+        final Player player = e.getPlayer();
+        final UUID internal = plugin.getUuidCache().getUUID(player.getUniqueId());
+
+        // Remove from World cache
+        plugin.getWorldCalculator().getWorldCache().remove(internal);
+
+        // Remove the custom permissible
+        Injector.unInject(player);
+
+        // Handle auto op
+        if (plugin.getConfiguration().isAutoOp()) {
+            player.setOp(false);
+        }
+
+        // Call internal leave handling
+        onLeave(player.getUniqueId());
     }
 
     @EventHandler
     public void onPlayerCommand(PlayerCommandPreprocessEvent e) {
-        if (plugin.getConfiguration().getEnableOps()) {
+        if (plugin.getConfiguration().isOpsEnabled()) {
             return;
         }
 

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

@@ -20,23 +20,26 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms;
+package me.lucko.luckperms.bukkit;
 
-import lombok.AccessLevel;
-import lombok.NoArgsConstructor;
-import me.lucko.luckperms.commands.SenderFactory;
-import me.lucko.luckperms.constants.Constants;
+import me.lucko.luckperms.common.LuckPermsPlugin;
+import me.lucko.luckperms.common.commands.SenderFactory;
+import me.lucko.luckperms.common.constants.Constants;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 
 import java.util.UUID;
 
-@NoArgsConstructor(access = AccessLevel.PRIVATE)
 public class BukkitSenderFactory extends SenderFactory<CommandSender> {
     private static BukkitSenderFactory instance = null;
-    public static synchronized BukkitSenderFactory get() {
+
+    private BukkitSenderFactory(LuckPermsPlugin plugin) {
+        super(plugin);
+    }
+
+    public static synchronized BukkitSenderFactory get(LuckPermsPlugin plugin) {
         if (instance == null) {
-            instance = new BukkitSenderFactory();
+            instance = new BukkitSenderFactory(plugin);
         }
         return instance;
     }

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

@@ -20,28 +20,37 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms;
+package me.lucko.luckperms.bukkit;
 
 import lombok.Getter;
+import me.lucko.luckperms.ApiHandler;
+import me.lucko.luckperms.api.Contexts;
 import me.lucko.luckperms.api.Logger;
 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.commands.ConsecutiveExecutor;
-import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.constants.Message;
-import me.lucko.luckperms.core.LPConfiguration;
-import me.lucko.luckperms.core.UuidCache;
-import me.lucko.luckperms.data.Importer;
-import me.lucko.luckperms.groups.GroupManager;
-import me.lucko.luckperms.runnables.ExpireTemporaryTask;
-import me.lucko.luckperms.runnables.UpdateTask;
-import me.lucko.luckperms.storage.Datastore;
-import me.lucko.luckperms.storage.StorageFactory;
-import me.lucko.luckperms.tracks.TrackManager;
-import me.lucko.luckperms.users.BukkitUserManager;
-import me.lucko.luckperms.utils.LogFactory;
+import me.lucko.luckperms.bukkit.calculators.DefaultsProvider;
+import me.lucko.luckperms.bukkit.vault.VaultHook;
+import me.lucko.luckperms.common.LuckPermsPlugin;
+import me.lucko.luckperms.common.api.ApiProvider;
+import me.lucko.luckperms.common.calculators.CalculatorFactory;
+import me.lucko.luckperms.common.commands.ConsecutiveExecutor;
+import me.lucko.luckperms.common.commands.Sender;
+import me.lucko.luckperms.common.config.LPConfiguration;
+import me.lucko.luckperms.common.constants.Message;
+import me.lucko.luckperms.common.contexts.ContextManager;
+import me.lucko.luckperms.common.contexts.ServerCalculator;
+import me.lucko.luckperms.common.core.UuidCache;
+import me.lucko.luckperms.common.data.Importer;
+import me.lucko.luckperms.common.groups.GroupManager;
+import me.lucko.luckperms.common.runnables.ExpireTemporaryTask;
+import me.lucko.luckperms.common.runnables.UpdateTask;
+import me.lucko.luckperms.common.storage.Datastore;
+import me.lucko.luckperms.common.storage.StorageFactory;
+import me.lucko.luckperms.common.tracks.TrackManager;
+import me.lucko.luckperms.common.users.UserManager;
+import me.lucko.luckperms.common.utils.LocaleManager;
+import me.lucko.luckperms.common.utils.LogFactory;
+import org.bukkit.World;
 import org.bukkit.command.PluginCommand;
 import org.bukkit.entity.Player;
 import org.bukkit.permissions.Permission;
@@ -57,9 +66,11 @@ 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;
+    private UserManager userManager;
     private GroupManager groupManager;
     private TrackManager trackManager;
     private Datastore datastore;
@@ -68,6 +79,11 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
     private Logger log;
     private Importer importer;
     private ConsecutiveExecutor consecutiveExecutor;
+    private DefaultsProvider defaultsProvider;
+    private LocaleManager localeManager;
+    private ContextManager<Player> contextManager;
+    private WorldCalculator worldCalculator;
+    private CalculatorFactory calculatorFactory;
 
     @Override
     public void onEnable() {
@@ -76,6 +92,20 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
         getLog().info("Loading configuration...");
         configuration = new BukkitConfig(this);
 
+        localeManager = new LocaleManager();
+        File locale = new File(getDataFolder(), "lang.yml");
+        if (locale.exists()) {
+            getLog().info("Found locale file. Attempting to load from it.");
+            try {
+                localeManager.loadFromFile(locale);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+
+        defaultsProvider = new DefaultsProvider();
+        getServer().getScheduler().runTaskLater(this, () -> defaultsProvider.refresh(), 1L);
+
         // register events
         PluginManager pm = getServer().getPluginManager();
         pm.registerEvents(new BukkitListener(this), this);
@@ -91,12 +121,19 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
         datastore = StorageFactory.getDatastore(this, "h2");
 
         getLog().info("Loading internal permission managers...");
-        uuidCache = new UuidCache(getConfiguration().getOnlineMode());
-        userManager = new BukkitUserManager(this);
+        uuidCache = new UuidCache(getConfiguration().isOnlineMode());
+        userManager = new UserManager(this);
         groupManager = new GroupManager(this);
         trackManager = new TrackManager();
         importer = new Importer(commandManager);
         consecutiveExecutor = new ConsecutiveExecutor(commandManager);
+        calculatorFactory = new BukkitCalculatorFactory(this);
+
+        contextManager = new ContextManager<>();
+        worldCalculator = new WorldCalculator(this);
+        pm.registerEvents(worldCalculator, this);
+        contextManager.registerCalculator(worldCalculator);
+        contextManager.registerCalculator(new ServerCalculator<>(getConfiguration().getServer()));
 
         int mins = getConfiguration().getSyncTime();
         if (mins > 0) {
@@ -104,7 +141,7 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
             getServer().getScheduler().runTaskTimerAsynchronously(this, new UpdateTask(this), ticks, ticks);
         }
 
-        getServer().getScheduler().runTaskTimer(this, BukkitSenderFactory.get(), 1L, 1L);
+        getServer().getScheduler().runTaskTimer(this, BukkitSenderFactory.get(this), 1L, 1L);
         getServer().getScheduler().runTaskTimerAsynchronously(this, new ExpireTemporaryTask(this), 60L, 60L);
         getServer().getScheduler().runTaskTimerAsynchronously(this, consecutiveExecutor, 20L, 20L);
 
@@ -112,7 +149,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.");
@@ -124,7 +162,7 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
 
         getLog().info("Registering API...");
         apiProvider = new ApiProvider(this);
-        LuckPerms.registerProvider(apiProvider);
+        ApiHandler.registerProvider(apiProvider);
         getServer().getServicesManager().register(LuckPermsApi.class, apiProvider, this, ServicePriority.Normal);
 
         // Run update task to refresh any online users
@@ -135,8 +173,8 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
             e.printStackTrace();
         }
 
-        registerPermissions(getConfiguration().getCommandsAllowOp() ? PermissionDefault.OP : PermissionDefault.FALSE);
-        if (!getConfiguration().getEnableOps()) {
+        registerPermissions(getConfiguration().isCommandsAllowOp() ? PermissionDefault.OP : PermissionDefault.FALSE);
+        if (!getConfiguration().isOpsEnabled()) {
             getServer().getOperators().forEach(o -> o.setOp(false));
         }
 
@@ -149,8 +187,12 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
         datastore.shutdown();
 
         getLog().info("Unregistering API...");
-        LuckPerms.unregisterProvider();
+        ApiHandler.unregisterProvider();
         getServer().getServicesManager().unregisterAll(this);
+
+        if (vaultHook != null) {
+            vaultHook.unhook(this);
+        }
     }
 
     @Override
@@ -196,26 +238,79 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
     @Override
     public List<Sender> getNotifyListeners() {
         return getServer().getOnlinePlayers().stream()
-                .map(p -> BukkitSenderFactory.get().wrap(p, Collections.singleton(me.lucko.luckperms.constants.Permission.LOG_NOTIFY)))
-                .filter(me.lucko.luckperms.constants.Permission.LOG_NOTIFY::isAuthorized)
+                .map(p -> BukkitSenderFactory.get(this).wrap(p, Collections.singleton(me.lucko.luckperms.common.constants.Permission.LOG_NOTIFY)))
+                .filter(me.lucko.luckperms.common.constants.Permission.LOG_NOTIFY::isAuthorized)
                 .collect(Collectors.toList());
     }
 
     @Override
     public Sender getConsoleSender() {
-        return BukkitSenderFactory.get().wrap(getServer().getConsoleSender());
+        return BukkitSenderFactory.get(this).wrap(getServer().getConsoleSender());
     }
 
     @Override
-    public List<String> getPossiblePermissions() {
-        final List<String> perms = new ArrayList<>();
+    public Set<Contexts> getPreProcessContexts(boolean op) {
+        Set<Map<String, String>> c = new HashSet<>();
+        c.add(Collections.emptyMap());
+        c.add(Collections.singletonMap("server", getConfiguration().getServer()));
 
-        getServer().getPluginManager().getPermissions().forEach(p -> {
-            perms.add(p.getName());
-            p.getChildren().keySet().forEach(perms::add);
-        });
+        // Pre process all worlds
+        c.addAll(getServer().getWorlds().stream()
+                .map(World::getName)
+                .map(s -> {
+                    Map<String, String> map = new HashMap<>();
+                    map.put("server", getConfiguration().getServer());
+                    map.put("world", s);
+                    return map;
+                })
+                .collect(Collectors.toList())
+        );
 
-        return perms;
+        // Pre process the separate Vault server, if any
+        if (!getConfiguration().getServer().equals(getConfiguration().getVaultServer())) {
+            c.add(Collections.singletonMap("server", getConfiguration().getVaultServer()));
+            c.addAll(getServer().getWorlds().stream()
+                    .map(World::getName)
+                    .map(s -> {
+                        Map<String, String> map = new HashMap<>();
+                        map.put("server", getConfiguration().getVaultServer());
+                        map.put("world", s);
+                        return map;
+                    })
+                    .collect(Collectors.toList())
+            );
+        }
+
+        Set<Contexts> contexts = new HashSet<>();
+
+        // Convert to full Contexts
+        contexts.addAll(c.stream()
+                .map(map -> new Contexts(
+                        map,
+                        getConfiguration().isIncludingGlobalPerms(),
+                        getConfiguration().isIncludingGlobalWorldPerms(),
+                        true,
+                        getConfiguration().isApplyingGlobalGroups(),
+                        getConfiguration().isApplyingGlobalWorldGroups(),
+                        op
+                ))
+                .collect(Collectors.toSet())
+        );
+
+        // Check for and include varying Vault config options
+        try {
+            assert getConfiguration().isVaultIncludingGlobal() == getConfiguration().isIncludingGlobalPerms();
+            assert getConfiguration().isIncludingGlobalWorldPerms();
+            assert getConfiguration().isApplyingGlobalGroups();
+            assert getConfiguration().isApplyingGlobalWorldGroups();
+        } catch (AssertionError e) {
+            contexts.addAll(c.stream()
+                    .map(map -> new Contexts(map, getConfiguration().isVaultIncludingGlobal(), true, true, true, true, op))
+                    .collect(Collectors.toSet())
+            );
+        }
+
+        return contexts;
     }
 
     @Override
@@ -253,7 +348,7 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
 
         Map<String, List<String>> wildcards = new HashMap<>();
         List<String> all = new ArrayList<>();
-        for (me.lucko.luckperms.constants.Permission p : me.lucko.luckperms.constants.Permission.values()) {
+        for (me.lucko.luckperms.common.constants.Permission p : me.lucko.luckperms.common.constants.Permission.values()) {
             pm.addPermission(new Permission(p.getNode(), def));
             if (p.getGroup() != null) {
                 if (!wildcards.containsKey(p.getGroup())) {

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

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

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

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

@@ -0,0 +1,50 @@
+/*
+ * 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.bukkit.calculators;
+
+import lombok.AllArgsConstructor;
+import me.lucko.luckperms.api.Tristate;
+import me.lucko.luckperms.common.calculators.PermissionProcessor;
+import org.bukkit.Bukkit;
+import org.bukkit.permissions.Permission;
+
+@AllArgsConstructor
+public class DefaultsProcessor implements PermissionProcessor {
+    private final boolean isOp;
+    private final DefaultsProvider defaultsProvider;
+
+    @Override
+    public Tristate hasPermission(String permission) {
+        Tristate t = defaultsProvider.hasDefault(permission, isOp);
+        if (t != Tristate.UNDEFINED) {
+            return t;
+        }
+
+        Permission defPerm = Bukkit.getServer().getPluginManager().getPermission(permission);
+        if (defPerm != null) {
+            return Tristate.fromBoolean(defPerm.getDefault().getValue(isOp));
+        } else {
+            return Tristate.UNDEFINED;
+        }
+    }
+}

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

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

bukkit/src/main/java/me/lucko/luckperms/bukkit/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.bukkit.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/bukkit/inject/Injector.java

@@ -20,37 +20,39 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.inject;
+package me.lucko.luckperms.bukkit.inject;
 
 import lombok.experimental.UtilityClass;
 import org.bukkit.Bukkit;
-import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 import org.bukkit.permissions.Permissible;
-import org.bukkit.permissions.PermissibleBase;
 
 import java.lang.reflect.Field;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * Injects a {@link LPPermissible} into a {@link Player}
  */
 @UtilityClass
 public class Injector {
+    private static final Map<UUID, LPPermissible> INJECTED_PERMISSIBLES = new ConcurrentHashMap<>();
     private static Field HUMAN_ENTITY_FIELD;
 
     static {
         try {
-            HUMAN_ENTITY_FIELD = Class.forName(getInternalClassName("entity.CraftHumanEntity")).getDeclaredField("perm");
+            HUMAN_ENTITY_FIELD = Class.forName(getVersionedClassName("entity.CraftHumanEntity")).getDeclaredField("perm");
             HUMAN_ENTITY_FIELD.setAccessible(true);
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
 
-    public static boolean inject(CommandSender sender, PermissibleBase permissible) {
+    public static boolean inject(Player player, LPPermissible permissible) {
         try {
-            Field f = getPermField(sender);
-            f.set(sender, permissible);
+            HUMAN_ENTITY_FIELD.set(player, permissible);
+            INJECTED_PERMISSIBLES.put(player.getUniqueId(), permissible);
             return true;
         } catch (Exception e) {
             e.printStackTrace();
@@ -58,12 +60,16 @@ public class Injector {
         }
     }
 
-    public static boolean unInject(CommandSender sender) {
+    public static boolean unInject(Player player) {
         try {
-            Permissible permissible = getPermissible(sender);
+            Permissible permissible = (Permissible) HUMAN_ENTITY_FIELD.get(player);
             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. */
+                HUMAN_ENTITY_FIELD.set(player, new DummyPermissibleBase());
             }
+            INJECTED_PERMISSIBLES.remove(player.getUniqueId());
             return true;
         } catch (Exception e) {
             e.printStackTrace();
@@ -71,23 +77,11 @@ public class Injector {
         }
     }
 
-    private static Permissible getPermissible(CommandSender sender) {
-        try {
-            Field f = getPermField(sender);
-            return (Permissible) f.get(sender);
-        } catch (Exception e) {
-            throw new RuntimeException(e);
-        }
+    public static LPPermissible getPermissible(UUID uuid) {
+        return INJECTED_PERMISSIBLES.get(uuid);
     }
 
-    private static Field getPermField(CommandSender sender) {
-        if (sender instanceof Player) {
-            return HUMAN_ENTITY_FIELD;
-        }
-        throw new RuntimeException("Couldn't get perm field for sender " + sender.getClass().getName());
-    }
-
-    private static String getInternalClassName(String className) {
+    private static String getVersionedClassName(String className) {
         Class server = Bukkit.getServer().getClass();
         if (!server.getSimpleName().equals("CraftServer")) {
             throw new RuntimeException("Couldn't inject into server " + server);

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

@@ -20,66 +20,64 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.inject;
+package me.lucko.luckperms.bukkit.inject;
 
-import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NonNull;
-import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.Contexts;
 import me.lucko.luckperms.api.Tristate;
-import me.lucko.luckperms.utils.PermissionCalculator;
-import me.lucko.luckperms.utils.PermissionProcessor;
+import me.lucko.luckperms.bukkit.LPBukkitPlugin;
+import me.lucko.luckperms.common.users.User;
 import org.bukkit.Bukkit;
-import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
 import org.bukkit.permissions.*;
 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;
 
 /**
  * Modified PermissibleBase for LuckPerms
  */
-public class LPPermissible extends PermissibleBase {
+public class LPPermissible extends PermissibleBase { // TODO autoop stuff
 
     @Getter
-    private final CommandSender parent;
-
-    private final PermissionCalculator calculator;
+    private final User user;
 
     @Getter
-    private final Map<String, Boolean> luckPermsPermissions = new ConcurrentHashMap<>();
-    private final List<PermissionAttachment> attachments = new LinkedList<>();
+    private final Player parent;
+
+    private final LPBukkitPlugin plugin;
+
+    // Attachment stuff.
+    @Getter
     private final Map<String, PermissionAttachmentInfo> attachmentPermissions = new HashMap<>();
+    private final List<PermissionAttachment> attachments = new LinkedList<>();
 
-    public LPPermissible(@NonNull CommandSender sender, LuckPermsPlugin plugin) {
-        super(sender);
-        this.parent = sender;
+    public LPPermissible(@NonNull Player parent, User user, LPBukkitPlugin plugin) {
+        super(parent);
+        this.user = user;
+        this.parent = parent;
+        this.plugin = plugin;
 
-        List<PermissionProcessor> processors = new ArrayList<>(5);
-        processors.add(new PermissionCalculator.MapProcessor(luckPermsPermissions));
-        processors.add(new AttachmentProcessor(attachmentPermissions));
-        if (plugin.getConfiguration().getApplyWildcards()) {
-            processors.add(new PermissionCalculator.WildcardProcessor(luckPermsPermissions));
-        }
-        if (plugin.getConfiguration().getApplyRegex()) {
-            processors.add(new PermissionCalculator.RegexProcessor(luckPermsPermissions));
-        }
-        processors.add(new BukkitDefaultsProcessor(parent::isOp));
-
-        calculator = new PermissionCalculator(plugin, parent.getName(), plugin.getConfiguration().getDebugPermissionChecks(), processors);
+        recalculatePermissions();
     }
 
-    public void invalidateCache() {
-        calculator.invalidateCache();
+    private Contexts calculateContexts() {
+        return new Contexts(
+                plugin.getContextManager().giveApplicableContext(parent, new HashMap<>()),
+                plugin.getConfiguration().isIncludingGlobalPerms(),
+                plugin.getConfiguration().isIncludingGlobalWorldPerms(),
+                true,
+                plugin.getConfiguration().isApplyingGlobalGroups(),
+                plugin.getConfiguration().isApplyingGlobalWorldGroups(),
+                parent.isOp()
+        );
     }
 
-    @Override
-    public boolean isOp() {
-        return parent.isOp();
+    private boolean hasData() {
+        return user.getUserData() != null;
     }
 
     @Override
@@ -89,7 +87,7 @@ public class LPPermissible extends PermissibleBase {
 
     @Override
     public boolean isPermissionSet(@NonNull String name) {
-        return luckPermsPermissions.containsKey(name.toLowerCase()) || attachmentPermissions.containsKey(name.toLowerCase());
+        return hasData() && user.getUserData().getPermissionData(calculateContexts()).getPermissionValue(name) != Tristate.UNDEFINED;
     }
 
     @Override
@@ -99,9 +97,11 @@ public class LPPermissible extends PermissibleBase {
 
     @Override
     public boolean hasPermission(@NonNull String name) {
-        Tristate ts = calculator.getPermissionValue(name);
-        if (ts != Tristate.UNDEFINED) {
-            return ts.asBoolean();
+        if (hasData()) {
+            Tristate ts = user.getUserData().getPermissionData(calculateContexts()).getPermissionValue(name);
+            if (ts != Tristate.UNDEFINED) {
+                return ts.asBoolean();
+            }
         }
 
         return Permission.DEFAULT_PERMISSION.getValue(isOp());
@@ -109,14 +109,32 @@ public class LPPermissible extends PermissibleBase {
 
     @Override
     public boolean hasPermission(@NonNull Permission perm) {
-        Tristate ts = calculator.getPermissionValue(perm.getName());
-        if (ts != Tristate.UNDEFINED) {
-            return ts.asBoolean();
+        if (hasData()) {
+            Tristate ts = user.getUserData().getPermissionData(calculateContexts()).getPermissionValue(perm.getName());
+            if (ts != Tristate.UNDEFINED) {
+                return ts.asBoolean();
+            }
         }
 
         return perm.getDefault().getValue(isOp());
     }
 
+    @Override
+    public Set<PermissionAttachmentInfo> getEffectivePermissions() {
+        Set<PermissionAttachmentInfo> perms = new HashSet<>();
+        perms.addAll(attachmentPermissions.values());
+
+        if (hasData()) {
+            perms.addAll(
+                    user.getUserData().getPermissionData(calculateContexts()).getImmutableBacking().entrySet().stream()
+                            .map(e -> new PermissionAttachmentInfo(parent, e.getKey(), null, e.getValue()))
+                            .collect(Collectors.toList())
+            );
+        }
+
+        return perms;
+    }
+
     @Override
     public PermissionAttachment addAttachment(@NonNull Plugin plugin, @NonNull String name, boolean value) {
         if (!plugin.isEnabled()) {
@@ -198,22 +216,14 @@ public class LPPermissible extends PermissibleBase {
         }
 
         attachmentPermissions.clear();
-        Set<Permission> defaults = Bukkit.getServer().getPluginManager().getDefaultPermissions(isOp());
-        Bukkit.getServer().getPluginManager().subscribeToDefaultPerms(isOp(), parent);
-
-        for (Permission perm : defaults) {
-            String name = perm.getName().toLowerCase();
-
-            attachmentPermissions.put(name, new PermissionAttachmentInfo(parent, name, null, true));
-            Bukkit.getServer().getPluginManager().subscribeToPermission(name, parent);
-            calculateChildPermissions(perm.getChildren(), false, null);
-        }
 
         for (PermissionAttachment attachment : attachments) {
             calculateChildPermissions(attachment.getPermissions(), false, attachment);
         }
 
-        invalidateCache();
+        if (hasData()) {
+            user.getUserData().invalidateCache();
+        }
     }
 
     @Override
@@ -245,18 +255,6 @@ public class LPPermissible extends PermissibleBase {
         }
     }
 
-    @Override
-    public Set<PermissionAttachmentInfo> getEffectivePermissions() {
-        Set<PermissionAttachmentInfo> perms = new HashSet<>();
-        perms.addAll(attachmentPermissions.values());
-
-        perms.addAll(luckPermsPermissions.entrySet().stream()
-                .map(e -> new PermissionAttachmentInfo(parent, e.getKey(), null, e.getValue()))
-                .collect(Collectors.toList()));
-
-        return perms;
-    }
-
     private class RemoveAttachmentRunnable implements Runnable {
         private PermissionAttachment attachment;
 
@@ -268,36 +266,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;
-
-        @Override
-        public Tristate hasPermission(String permission) {
-            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/bukkit/vault/VaultChatHook.java

@@ -0,0 +1,389 @@
+/*
+ * 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.bukkit.vault;
+
+import lombok.NonNull;
+import me.lucko.luckperms.api.Contexts;
+import me.lucko.luckperms.api.Node;
+import me.lucko.luckperms.common.caching.MetaData;
+import me.lucko.luckperms.common.core.PermissionHolder;
+import me.lucko.luckperms.common.groups.Group;
+import me.lucko.luckperms.common.users.User;
+import me.lucko.luckperms.common.utils.ArgumentChecker;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+import net.milkbowl.vault.chat.Chat;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import static me.lucko.luckperms.common.utils.ArgumentChecker.escapeCharacters;
+import static me.lucko.luckperms.common.utils.ArgumentChecker.unescapeCharacters;
+
+/**
+ * Provides the Vault Chat service through the use of normal permission nodes.
+ *
+ * Prefixes / Suffixes:
+ * Normal inheritance rules apply.
+ * Permission Nodes = prefix.priority.value OR suffix.priority.value
+ * If a user/group has / inherits multiple prefixes and suffixes, the one with the highest priority is the one that
+ * will apply.
+ *
+ * Meta:
+ * Normal inheritance rules DO NOT apply.
+ * Permission Nodes = meta.node.value
+ *
+ * Node that special characters used within LuckPerms are escaped:
+ * See {@link ArgumentChecker#escapeCharacters(String)}
+ */
+public class VaultChatHook extends Chat {
+    private final VaultPermissionHook perms;
+
+    VaultChatHook(VaultPermissionHook perms) {
+        super(perms);
+        this.perms = perms;
+    }
+
+    public String getName() {
+        return perms.getName();
+    }
+
+    public boolean isEnabled() {
+        return perms.isEnabled();
+    }
+
+    private void setMeta(PermissionHolder holder, String world, String node, String value) {
+        String finalWorld = perms.isIgnoreWorld() ? null : world;
+        if (holder == null) return;
+        if (node.equals("")) return;
+
+        perms.log("Setting meta: '" + node + "' for " + holder.getObjectName() + " on world " + world + ", server " + perms.getServer());
+
+        perms.getScheduler().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.common.core.Node.Builder("meta." + k + "." + v).setValue(true);
+            if (!perms.getServer().equalsIgnoreCase("global")) {
+                metaNode.setServer(perms.getServer());
+            }
+            if (finalWorld != null && !finalWorld.equals("")) {
+                metaNode.setServer(perms.getServer()).setWorld(finalWorld);
+            }
+
+            try {
+                holder.setPermission(metaNode.build());
+            } catch (ObjectAlreadyHasException ignored) {}
+
+            perms.save(holder);
+        });
+    }
+
+    private void setChatMeta(boolean prefix, PermissionHolder holder, String value, String world) {
+        String finalWorld = perms.isIgnoreWorld() ? null : world;
+        if (holder == null) return;
+        if (value.equals("")) return;
+
+        perms.log("Setting " + (prefix ? "prefix" : "suffix") + " for " + holder.getObjectName() + " on world " + world + ", server " + perms.getServer());
+
+        perms.getScheduler().scheduleTask(() -> {
+            Node.Builder node = new me.lucko.luckperms.common.core.Node.Builder(prefix ? "prefix" : "suffix" + ".1000." + escapeCharacters(value));
+            node.setValue(true);
+            if (!perms.getServer().equalsIgnoreCase("global")) {
+                node.setServer(perms.getServer());
+            }
+
+            if (finalWorld != null && !finalWorld.equals("")) {
+                node.setServer(perms.getServer()).setWorld(finalWorld);
+            }
+
+            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;
+        world = perms.isIgnoreWorld() ? null : world;
+        node = escapeCharacters(node);
+
+        perms.log("Getting meta: '" + node + "' for user " + user.getName() + " on world " + world + ", server " + perms.getServer());
+
+        if (user.getUserData() == null) {
+            return defaultValue;
+        }
+
+        return unescapeCharacters(user.getUserData().getMetaData(perms.createContext(perms.getServer(), world)).getMeta().getOrDefault(node, defaultValue));
+    }
+
+    private String getUserChatMeta(boolean prefix, User user, String world) {
+        if (user == null) return "";
+        world = perms.isIgnoreWorld() ? null : world;
+
+        perms.log("Getting " + (prefix ? "prefix" : "suffix") + " for user " + user.getName() + " on world " + world + ", server " + perms.getServer());
+
+        if (user.getUserData() == null) {
+            return "";
+        }
+
+        MetaData data = user.getUserData().getMetaData(perms.createContext(perms.getServer(), world));
+        String v = prefix ? data.getPrefix() : data.getSuffix();
+        return v == null ? "" : unescapeCharacters(v);
+    }
+
+    private String getGroupMeta(Group group, String world, String node, String defaultValue) {
+        world = perms.isIgnoreWorld() ? null : world;
+        if (group == null) return defaultValue;
+        if (node.equals("")) return defaultValue;
+        node = escapeCharacters(node);
+
+        perms.log("Getting meta: '" + node + "' for group " + group.getName() + " on world " + world + ", server " + perms.getServer());
+
+        for (Node n : group.getPermissions(true)) {
+            if (!n.getValue()) {
+                continue;
+            }
+
+            if (!n.isMeta()) {
+                continue;
+            }
+
+            if (!n.shouldApplyOnServer(perms.getServer(), perms.isIncludeGlobal(), false)) {
+                continue;
+            }
+
+            if (!n.shouldApplyOnWorld(world, perms.isIncludeGlobal(), false)) {
+                continue;
+            }
+
+            Map.Entry<String, String> meta = n.getMeta();
+            if (meta.getKey().equalsIgnoreCase(node)) {
+                return unescapeCharacters(meta.getValue());
+            }
+        }
+
+        return defaultValue;
+    }
+
+    private String getGroupChatMeta(boolean prefix, Group group, String world) {
+        world = perms.isIgnoreWorld() ? null : world;
+        if (group == null) return "";
+
+        perms.log("Getting " + (prefix ? "prefix" : "suffix") + " for group " + group + " on world " + world + ", server " + perms.getServer());
+
+        int priority = Integer.MIN_VALUE;
+        String meta = null;
+
+        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;
+            }
+
+            if (prefix ? !n.isPrefix() : !n.isSuffix()) {
+                continue;
+            }
+
+            if (!n.shouldApplyOnServer(perms.getServer(), perms.isIncludeGlobal(), false)) {
+                continue;
+            }
+
+            if (!n.shouldApplyOnWorld(world, perms.isIncludeGlobal(), false)) {
+                continue;
+            }
+
+            Map.Entry<Integer, String> value = prefix ? n.getPrefix() : n.getSuffix();
+            if (value.getKey() > priority) {
+                meta = value.getValue();
+                priority = value.getKey();
+            }
+        }
+
+        return meta == null ? "" : unescapeCharacters(meta);
+    }
+
+    public String getPlayerPrefix(String world, @NonNull String player) {
+        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 = perms.getPlugin().getUserManager().get(player);
+        setChatMeta(true, user, prefix, world);
+    }
+
+    public String getPlayerSuffix(String world, @NonNull String player) {
+        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 = perms.getPlugin().getUserManager().get(player);
+        setChatMeta(false, user, suffix, world);
+    }
+
+    public String getGroupPrefix(String world, @NonNull String group) {
+        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 = perms.getPlugin().getGroupManager().get(group);
+        setChatMeta(true, g, prefix, world);
+    }
+
+    public String getGroupSuffix(String world, @NonNull String group) {
+        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 = 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 = perms.getPlugin().getUserManager().get(player);
+        try {
+            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 = perms.getPlugin().getUserManager().get(player);
+        setMeta(user, world, node, String.valueOf(value));
+    }
+
+    public int getGroupInfoInteger(String world, @NonNull String group, @NonNull String node, int defaultValue) {
+        final Group g = perms.getPlugin().getGroupManager().get(group);
+        try {
+            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 = perms.getPlugin().getGroupManager().get(group);
+        setMeta(g, world, node, String.valueOf(value));
+    }
+
+    public double getPlayerInfoDouble(String world, @NonNull String player, @NonNull String node, double defaultValue) {
+        final User user = perms.getPlugin().getUserManager().get(player);
+        try {
+            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 = perms.getPlugin().getUserManager().get(player);
+        setMeta(user, world, node, String.valueOf(value));
+    }
+
+    public double getGroupInfoDouble(String world, @NonNull String group, @NonNull String node, double defaultValue) {
+        final Group g = perms.getPlugin().getGroupManager().get(group);
+        try {
+            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 = perms.getPlugin().getGroupManager().get(group);
+        setMeta(g, world, node, String.valueOf(value));
+    }
+
+    public boolean getPlayerInfoBoolean(String world, @NonNull String player, @NonNull String node, boolean 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;
+        }
+        return Boolean.parseBoolean(s);
+    }
+
+    public void setPlayerInfoBoolean(String world, @NonNull String player, @NonNull String node, boolean value) {
+        final User user = perms.getPlugin().getUserManager().get(player);
+        setMeta(user, world, node, String.valueOf(value));
+    }
+
+    public boolean getGroupInfoBoolean(String world, @NonNull String group, @NonNull String node, boolean 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;
+        }
+        return Boolean.parseBoolean(s);
+    }
+
+    public void setGroupInfoBoolean(String world, @NonNull String group, @NonNull String node, boolean value) {
+        final Group g = perms.getPlugin().getGroupManager().get(group);
+        setMeta(g, world, node, String.valueOf(value));
+    }
+
+    public String getPlayerInfoString(String world, @NonNull String player, @NonNull String node, String 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 = perms.getPlugin().getUserManager().get(player);
+        setMeta(user, world, node, value);
+    }
+
+    public String getGroupInfoString(String world, @NonNull String group, @NonNull String node, String 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 = perms.getPlugin().getGroupManager().get(group);
+        setMeta(g, world, node, value);
+    }
+
+}

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

@@ -20,42 +20,56 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.api.vault;
+package me.lucko.luckperms.bukkit.vault;
 
-import me.lucko.luckperms.LPBukkitPlugin;
+import lombok.Getter;
+import me.lucko.luckperms.bukkit.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();
             }
             permissionHook.setPlugin(plugin);
             permissionHook.setServer(plugin.getConfiguration().getVaultServer());
-            permissionHook.setIncludeGlobal(plugin.getConfiguration().getVaultIncludeGlobal());
+            permissionHook.setIncludeGlobal(plugin.getConfiguration().isVaultIncludingGlobal());
+            permissionHook.setIncludeGlobal(plugin.getConfiguration().isVaultIgnoreWorld());
+            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/bukkit/vault/VaultPermissionHook.java

@@ -0,0 +1,327 @@
+/*
+ * 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.bukkit.vault;
+
+import lombok.Getter;
+import lombok.NonNull;
+import lombok.Setter;
+import me.lucko.luckperms.api.Contexts;
+import me.lucko.luckperms.api.Node;
+import me.lucko.luckperms.bukkit.LPBukkitPlugin;
+import me.lucko.luckperms.common.core.PermissionHolder;
+import me.lucko.luckperms.common.groups.Group;
+import me.lucko.luckperms.common.users.User;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+import net.milkbowl.vault.permission.Permission;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * The LuckPerms Vault Permission implementation
+ * Most lookups are cached.
+ */
+public class VaultPermissionHook extends Permission {
+
+    @Getter
+    @Setter
+    private LPBukkitPlugin plugin;
+
+    @Getter
+    private VaultScheduler scheduler;
+
+    @Getter
+    @Setter
+    private String server = "global";
+
+    @Getter
+    @Setter
+    private boolean includeGlobal = true;
+
+    @Getter
+    @Setter
+    private boolean ignoreWorld = false;
+
+    public void setup() {
+        scheduler = new VaultScheduler(plugin);
+    }
+
+    public void log(String s) {
+        if (plugin.getConfiguration().isDebugPermissionChecks()) {
+            plugin.getLog().info("[VAULT] " + s);
+        }
+    }
+
+    @Override
+    public String getName() {
+        return "LuckPerms";
+    }
+
+    @Override
+    public boolean isEnabled() {
+        return plugin.getDatastore().isAcceptingLogins();
+    }
+
+    @Override
+    public boolean hasSuperPermsCompat() {
+        return true;
+    }
+
+    /**
+     * Generic method to add a permission to a holder
+     * @param world the world to add in
+     * @param holder the holder to add the permission to
+     * @param permission the permission to add
+     */
+    private void add(String world, PermissionHolder holder, String permission) {
+        try {
+            if (world != null && !world.equals("")) {
+                holder.setPermission(permission, true, server, world);
+            } else {
+                holder.setPermission(permission, true, server);
+            }
+        } catch (ObjectAlreadyHasException ignored) {}
+
+        save(holder);
+    }
+
+    /**
+     * Generic method to remove a permission from a holder
+     * @param world the world to remove in
+     * @param holder the holder to remove the permission from
+     * @param permission the permission to remove
+     */
+    private void remove(String world, PermissionHolder holder, String permission) {
+        try {
+            if (world != null && !world.equals("")) {
+                holder.unsetPermission(permission, server, world);
+            } else {
+                holder.unsetPermission(permission, server);
+            }
+        } catch (ObjectLacksException ignored) {}
+
+        save(holder);
+    }
+
+    /**
+     * Utility method for saving a user or group
+     * @param holder the holder instance
+     */
+    void save(PermissionHolder holder) {
+        if (holder instanceof User) {
+            ((User) holder).refreshPermissions();
+            plugin.getDatastore().saveUser(((User) holder));
+        }
+        if (holder instanceof Group) {
+            plugin.getDatastore().saveGroup(((Group) holder));
+            plugin.runUpdateTask();
+        }
+    }
+
+    Contexts createContext(String server, String world) {
+        Map<String, String> context = new HashMap<>();
+        if (world != null && !world.equals("")) {
+            context.put("world", world);
+        }
+        context.put("server", server);
+        return new Contexts(context, isIncludeGlobal(), true, true, true, true);
+    }
+
+    @Override
+    public boolean playerHas(String world, @NonNull String player, @NonNull String permission) {
+        world = ignoreWorld ? null : world; // Correct world value
+        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 (user.getUserData() == null) {
+            return false;
+        }
+
+        // Effectively fallback to the standard Bukkit #hasPermission check.
+        return user.getUserData().getPermissionData(createContext(server, world)).getPermissionValue(permission).asBoolean();
+    }
+
+    @Override
+    public boolean playerAdd(String world, @NonNull String player, @NonNull String permission) {
+        String finalWorld = ignoreWorld ? null : world; // Correct world value
+        log("Adding permission to player " + player + ": '" + permission + "' on world " + finalWorld + ", server " + server);
+
+        final User user = plugin.getUserManager().get(player);
+        if (user == null) return false;
+
+        scheduler.scheduleTask(() -> add(finalWorld, user, permission));
+        return true;
+    }
+
+    @Override
+    public boolean playerRemove(String world, @NonNull String player, @NonNull String permission) {
+        String finalWorld = ignoreWorld ? null : world; // Correct world value
+        log("Removing permission from player " + player + ": '" + permission + "' on world " + finalWorld + ", server " + server);
+
+        final User user = plugin.getUserManager().get(player);
+        if (user == null) return false;
+
+        scheduler.scheduleTask(() -> remove(finalWorld, user, permission));
+        return true;
+    }
+
+    @Override
+    public boolean groupHas(String world, @NonNull String groupName, @NonNull String permission) {
+        world = ignoreWorld ? null : world; // Correct world value
+        log("Checking if group " + groupName + " has permission: " + permission + " on world " + world + ", server " + server);
+
+        final Group group = plugin.getGroupManager().get(groupName);
+        if (group == null) return false;
+
+        // This is a nasty call. Groups aren't cached. :(
+        Map<String, Boolean> permissions = group.exportNodes(createContext(server, world), Collections.emptyList(), true);
+
+        return permissions.containsKey(permission) && permissions.get(permission);
+    }
+
+    @Override
+    public boolean groupAdd(String world, @NonNull String groupName, @NonNull String permission) {
+        String finalWorld = ignoreWorld ? null : world; // Correct world value
+        log("Adding permission to group " + groupName + ": '" + permission + "' on world " + finalWorld + ", server " + server);
+
+        final Group group = plugin.getGroupManager().get(groupName);
+        if (group == null) return false;
+
+        scheduler.scheduleTask(() -> add(finalWorld, group, permission));
+        return true;
+    }
+
+    @Override
+    public boolean groupRemove(String world, @NonNull String groupName, @NonNull String permission) {
+        String finalWorld = ignoreWorld ? null : world; // Correct world value
+        log("Removing permission from group " + groupName + ": '" + permission + "' on world " + finalWorld + ", server " + server);
+
+        final Group group = plugin.getGroupManager().get(groupName);
+        if (group == null) return false;
+
+        scheduler.scheduleTask(() -> remove(finalWorld, group, permission));
+        return true;
+    }
+
+    @Override
+    public boolean playerInGroup(String world, @NonNull String player, @NonNull String group) {
+        String finalWorld = ignoreWorld ? null : world; // Correct world value
+        log("Checking if player " + player + " is in group: " + group + " on world " + finalWorld + ", server " + server);
+
+        final User user = plugin.getUserManager().get(player);
+        if (user == null) return false;
+
+        return user.getNodes().stream()
+                .filter(Node::isGroupNode)
+                .filter(n -> n.shouldApplyOnServer(server, isIncludeGlobal(), false))
+                .filter(n -> n.shouldApplyOnWorld(finalWorld, true, false))
+                .map(Node::getGroupName)
+                .filter(s -> s.equalsIgnoreCase(group))
+                .findAny().isPresent();
+    }
+
+    @Override
+    public boolean playerAddGroup(String world, @NonNull String player, @NonNull String groupName) {
+        String finalWorld = ignoreWorld ? null : world; // Correct world value
+        log("Adding player " + player + " to group: '" + groupName + "' on world " + finalWorld + ", 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;
+
+        scheduler.scheduleTask(() -> {
+            try {
+                if (finalWorld != null && !finalWorld.equals("")) {
+                    user.addGroup(group, server, finalWorld);
+                } else {
+                    user.addGroup(group, server);
+                }
+            } catch (ObjectAlreadyHasException ignored) {}
+            save(user);
+        });
+        return true;
+    }
+
+    @Override
+    public boolean playerRemoveGroup(String world, @NonNull String player, @NonNull String groupName) {
+        String finalWorld = ignoreWorld ? null : world; // Correct world value
+        log("Removing player " + player + " from group: '" + groupName + "' on world " + finalWorld + ", 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;
+
+        scheduler.scheduleTask(() -> {
+            try {
+                if (finalWorld != null && !finalWorld.equals("")) {
+                    user.removeGroup(group, server, finalWorld);
+                } else {
+                    user.removeGroup(group, server);
+                }
+            } catch (ObjectLacksException ignored) {}
+            save(user);
+        });
+        return true;
+    }
+
+    @Override
+    public String[] getPlayerGroups(String world, @NonNull String player) {
+        String finalWorld = ignoreWorld ? null : world; // Correct world value
+        log("Getting groups of player: " + player + ", on world " + finalWorld + ", 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(finalWorld, 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();
+    }
+
+    @Override
+    public String[] getGroups() {
+        return plugin.getGroupManager().getAll().keySet().toArray(new String[0]);
+    }
+
+    @Override
+    public boolean hasGroupSupport() {
+        return true;
+    }
+}

bukkit/src/main/java/me/lucko/luckperms/bukkit/vault/VaultScheduler.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.bukkit.vault;
+
+import me.lucko.luckperms.bukkit.LPBukkitPlugin;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class VaultScheduler implements Runnable {
+    private final List<Runnable> tasks = new ArrayList<>();
+
+    public VaultScheduler(LPBukkitPlugin plugin) {
+        plugin.getServer().getScheduler().runTaskTimerAsynchronously(plugin, this, 1L, 1L);
+    }
+
+    public 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);
+    }
+}

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

@@ -1,122 +0,0 @@
-/*
- * 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.users;
-
-import lombok.Getter;
-import lombok.Setter;
-import me.lucko.luckperms.LPBukkitPlugin;
-import me.lucko.luckperms.api.event.events.UserPermissionRefreshEvent;
-import me.lucko.luckperms.api.implementation.internal.UserLink;
-import me.lucko.luckperms.inject.LPPermissible;
-import me.lucko.luckperms.utils.Contexts;
-import org.bukkit.permissions.Permissible;
-
-import java.util.Collections;
-import java.util.Map;
-import java.util.UUID;
-
-public class BukkitUser extends User {
-    private final LPBukkitPlugin plugin;
-
-    @Getter
-    @Setter
-    private LPPermissible lpPermissible = null;
-
-    BukkitUser(UUID uuid, LPBukkitPlugin plugin) {
-        super(uuid, plugin);
-        this.plugin = plugin;
-    }
-
-    BukkitUser(UUID uuid, String username, LPBukkitPlugin plugin) {
-        super(uuid, username, plugin);
-        this.plugin = plugin;
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public synchronized void refreshPermissions() {
-        if (lpPermissible == null) {
-            return;
-        }
-
-        // Calculate the permissions that should be applied. This is done async, who cares about how long it takes or how often it's done.
-        Map<String, Boolean> toApply = exportNodes(
-                new Contexts(
-                        getPlugin().getConfiguration().getServer(),
-                        plugin.getUserManager().getWorldCache().get(getUuid()),
-                        null,
-                        getPlugin().getConfiguration().getIncludeGlobalPerms(),
-                        getPlugin().getConfiguration().getIncludeGlobalWorldPerms(),
-                        true,
-                        getPlugin().getConfiguration().getApplyGlobalGroups(),
-                        getPlugin().getConfiguration().getApplyGlobalWorldGroups()
-                ),
-                Collections.emptyList()
-        );
-
-        try {
-            Map<String, Boolean> existing = lpPermissible.getLuckPermsPermissions();
-
-            boolean different = false;
-            if (toApply.size() != existing.size()) {
-                different = true;
-            } else {
-                for (Map.Entry<String, Boolean> e : existing.entrySet()) {
-                    if (toApply.containsKey(e.getKey()) && toApply.get(e.getKey()) == e.getValue()) {
-                        continue;
-                    }
-                    different = true;
-                    break;
-                }
-            }
-
-            if (!different) return;
-
-            existing.clear();
-            lpPermissible.invalidateCache();
-            existing.putAll(toApply);
-
-            if (plugin.getConfiguration().getAutoOp()) {
-                boolean op = false;
-
-                for (Map.Entry<String, Boolean> e : toApply.entrySet()) {
-                    if (e.getKey().equalsIgnoreCase("luckperms.autoop") && e.getValue()) {
-                        op = true;
-                        break;
-                    }
-                }
-
-                final boolean finalOp = op;
-                if (lpPermissible.isOp() != op) {
-                    final Permissible parent = lpPermissible.getParent();
-                    plugin.doSync(() -> parent.setOp(finalOp));
-                }
-            }
-
-            plugin.getApiProvider().fireEventAsync(new UserPermissionRefreshEvent(new UserLink(this)));
-
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-}

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

@@ -1,92 +0,0 @@
-/*
- * 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.users;
-
-import lombok.Getter;
-import me.lucko.luckperms.LPBukkitPlugin;
-import me.lucko.luckperms.inject.Injector;
-import org.bukkit.entity.Player;
-
-import java.util.Map;
-import java.util.Set;
-import java.util.UUID;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.stream.Collectors;
-
-public class BukkitUserManager extends UserManager {
-    private final LPBukkitPlugin plugin;
-
-    @Getter
-    private final Map<UUID, String> worldCache = new ConcurrentHashMap<>();
-
-    public BukkitUserManager(LPBukkitPlugin plugin) {
-        super(plugin);
-        this.plugin = plugin;
-    }
-
-    @Override
-    public void preUnload(User user) {
-        if (user instanceof BukkitUser) {
-            BukkitUser u = (BukkitUser) user;
-            Player player = plugin.getServer().getPlayer(plugin.getUuidCache().getExternalUUID(u.getUuid()));
-            if (player != null) {
-                if (u.getLpPermissible() != null) {
-                    Injector.unInject(player);
-                    u.setLpPermissible(null);
-                }
-
-                if (plugin.getConfiguration().getAutoOp()) {
-                    player.setOp(false);
-                }
-            }
-        }
-    }
-
-    @Override
-    public void cleanup(User user) {
-        if (plugin.getServer().getPlayer(plugin.getUuidCache().getExternalUUID(user.getUuid())) == null) {
-            unload(user);
-        }
-    }
-
-    @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);
-    }
-
-    @Override
-    public void updateAllUsers() {
-        // Sometimes called async, so 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()))
-                    .collect(Collectors.toSet());
-            plugin.doAsync(() -> players.forEach(u -> plugin.getDatastore().loadUser(u, "null")));
-        });
-    }
-}

bukkit/src/main/resources/config.yml

@@ -80,14 +80,25 @@ vault-server: global
 # If global permissions should be considered when retrieving meta or player groups
 vault-include-global: true
 
+# If Vault operations should ignore any world arguments if supplied.
+vault-ignore-world: false
+
+# Mirrors world names. Whenever LuckPerms checks what world a user is in, if the world name is in this list, the value assigned
+# will be sent forward for permission calculation instead.
+world-rewrite:
+  #world_nether: world
+  #world_the_end: world
+
+# Rewrites group names. The underlying name of the group does not change, just the output in commands / placeholders / Vault.
+group-name-rewrite:
+  #default: Member
+
 # Which storage method the plugin should use.
 # Currently supported: mysql, sqlite, h2, json, yaml, mongodb
 # Fill out connection info below if you're using MySQL or MongoDB
 storage-method: h2
 
 # This block enables support for split datastores.
-# Only touch this if you're sure that you know what you're doing.
-# I (the author) do not endorse nor recommend the use of this feature.
 split-storage:
   enabled: false
   methods:

bukkit/src/main/resources/plugin.yml

@@ -4,7 +4,7 @@ description: A permissions plugin
 author: Luck
 website: https://github.com/lucko/LuckPerms
 
-main: me.lucko.luckperms.LPBukkitPlugin
+main: me.lucko.luckperms.bukkit.LPBukkitPlugin
 softdepend: [Vault, PermissionsEx, GroupManager, PowerfulPerms, zPermissions, bPermissions] # For migration
 
 commands:

bungee/pom.xml

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

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

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

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

@@ -20,41 +20,32 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.users;
+package me.lucko.luckperms.bungee;
 
-import me.lucko.luckperms.LPBungeePlugin;
+import lombok.AllArgsConstructor;
+import me.lucko.luckperms.api.Contexts;
+import me.lucko.luckperms.common.calculators.*;
+import me.lucko.luckperms.common.users.User;
 
-import java.util.UUID;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
 
-public class BungeeUserManager extends UserManager {
+@AllArgsConstructor
+public class BungeeCalculatorFactory implements CalculatorFactory {
     private final LPBungeePlugin plugin;
 
-    public BungeeUserManager(LPBungeePlugin plugin) {
-        super(plugin);
-        this.plugin = plugin;
-    }
-
     @Override
-    public void cleanup(User user) {
-        if (plugin.getProxy().getPlayer(plugin.getUuidCache().getExternalUUID(user.getUuid())) == null) {
-            unload(user);
+    public PermissionCalculator build(Contexts contexts, User user, Map<String, Boolean> map) {
+        List<PermissionProcessor> processors = new ArrayList<>(3);
+        processors.add(new MapProcessor(map));
+        if (plugin.getConfiguration().isApplyingWildcards()) {
+            processors.add(new WildcardProcessor(map));
+        }
+        if (plugin.getConfiguration().isApplyingRegex()) {
+            processors.add(new RegexProcessor(map));
         }
-    }
 
-    @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);
-    }
-
-    @Override
-    public void updateAllUsers() {
-        plugin.getProxy().getPlayers().stream()
-                .map(p -> plugin.getUuidCache().getUUID(p.getUniqueId()))
-                .forEach(u -> plugin.getDatastore().loadUser(u, "null"));
+        return new PermissionCalculator(plugin, user.getName(), plugin.getConfiguration().isDebugPermissionChecks(), processors);
     }
 }

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

@@ -20,14 +20,14 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms;
+package me.lucko.luckperms.bungee;
 
 import com.google.common.base.Joiner;
 import com.google.common.base.Splitter;
 import me.lucko.luckperms.api.data.Callback;
-import me.lucko.luckperms.commands.CommandManager;
-import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.constants.Patterns;
+import me.lucko.luckperms.common.commands.CommandManager;
+import me.lucko.luckperms.common.commands.Util;
+import me.lucko.luckperms.common.constants.Patterns;
 import net.md_5.bungee.api.CommandSender;
 import net.md_5.bungee.api.plugin.Command;
 import net.md_5.bungee.api.plugin.TabExecutor;
@@ -45,7 +45,7 @@ class BungeeCommand extends Command implements TabExecutor {
     @Override
     public void execute(CommandSender sender, String[] args) {
         manager.onCommand(
-                BungeeSenderFactory.get().wrap(sender),
+                BungeeSenderFactory.get(manager.getPlugin()).wrap(sender),
                 "bperms",
                 Util.stripQuotes(Splitter.on(Patterns.COMMAND_SEPARATOR).omitEmptyStrings().splitToList(Joiner.on(' ').join(args))),
                 Callback.empty()
@@ -54,6 +54,6 @@ class BungeeCommand extends Command implements TabExecutor {
 
     @Override
     public Iterable<String> onTabComplete(CommandSender sender, String[] args) {
-        return manager.onTabComplete(BungeeSenderFactory.get().wrap(sender), Arrays.asList(args));
+        return manager.onTabComplete(BungeeSenderFactory.get(manager.getPlugin()).wrap(sender), Arrays.asList(args));
     }
 }

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

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

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

@@ -20,19 +20,25 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms;
+package me.lucko.luckperms.bungee;
 
-import me.lucko.luckperms.constants.Message;
-import me.lucko.luckperms.core.UuidCache;
-import me.lucko.luckperms.users.User;
-import me.lucko.luckperms.utils.AbstractListener;
+import me.lucko.luckperms.api.Contexts;
+import me.lucko.luckperms.api.event.events.UserFirstLoginEvent;
+import me.lucko.luckperms.common.constants.Message;
+import me.lucko.luckperms.common.core.UuidCache;
+import me.lucko.luckperms.common.users.User;
+import me.lucko.luckperms.common.utils.AbstractListener;
 import net.md_5.bungee.api.chat.TextComponent;
 import net.md_5.bungee.api.connection.PendingConnection;
 import net.md_5.bungee.api.connection.ProxiedPlayer;
-import net.md_5.bungee.api.event.*;
+import net.md_5.bungee.api.event.LoginEvent;
+import net.md_5.bungee.api.event.PermissionCheckEvent;
+import net.md_5.bungee.api.event.PlayerDisconnectEvent;
+import net.md_5.bungee.api.event.PostLoginEvent;
 import net.md_5.bungee.api.plugin.Listener;
 import net.md_5.bungee.event.EventHandler;
 
+import java.util.HashMap;
 import java.util.UUID;
 import java.util.concurrent.TimeUnit;
 
@@ -55,12 +61,26 @@ public class BungeeListener extends AbstractListener implements Listener {
 
         final ProxiedPlayer player = ((ProxiedPlayer) e.getSender());
 
-        BungeePlayerCache playerCache = plugin.getPlayerCache().get(plugin.getUuidCache().getUUID(player.getUniqueId()));
-        if (playerCache == null) {
+        User user = plugin.getUserManager().get(plugin.getUuidCache().getUUID(player.getUniqueId()));
+        if (user == null) {
             return;
         }
 
-        e.setHasPermission(playerCache.getPermissionValue(e.getPermission()));
+        if (user.getUserData() == null) {
+            plugin.getLog().warn("Player " + player.getName() + " does not have any user data setup.");
+            return;
+        }
+
+        Contexts contexts = new Contexts(
+                plugin.getContextManager().giveApplicableContext(player, new HashMap<>()),
+                plugin.getConfiguration().isIncludingGlobalPerms(),
+                plugin.getConfiguration().isIncludingGlobalWorldPerms(),
+                true,
+                plugin.getConfiguration().isApplyingGlobalGroups(),
+                plugin.getConfiguration().isApplyingGlobalWorldGroups()
+        );
+
+        e.setHasPermission(user.getUserData().getPermissionData(contexts).getPermissionValue(e.getPermission()).asBoolean());
     }
 
     @EventHandler
@@ -80,10 +100,16 @@ public class BungeeListener extends AbstractListener implements Listener {
                     cache.addToCache(c.getUniqueId(), uuid);
                 } else {
                     // No previous data for this player
+                    plugin.getApiProvider().fireEventAsync(new UserFirstLoginEvent(c.getUniqueId(), c.getName()));
                     cache.addToCache(c.getUniqueId(), c.getUniqueId());
                     plugin.getDatastore().saveUUIDData(c.getName(), c.getUniqueId());
                 }
             } else {
+                UUID uuid = plugin.getDatastore().getUUID(c.getName());
+                if (uuid == null) {
+                    plugin.getApiProvider().fireEventAsync(new UserFirstLoginEvent(c.getUniqueId(), c.getName()));
+                }
+
                 // Online mode, no cache needed. This is just for name -> uuid lookup.
                 plugin.getDatastore().saveUUIDData(c.getName(), c.getUniqueId());
             }
@@ -91,6 +117,13 @@ public class BungeeListener extends AbstractListener implements Listener {
             // We have to make a new user on this thread whilst the connection is being held, or we get concurrency issues as the Bukkit server
             // and the BungeeCord server try to make a new user at the same time.
             plugin.getDatastore().loadUser(cache.getUUID(c.getUniqueId()), c.getName());
+            User user = plugin.getUserManager().get(cache.getUUID(c.getUniqueId()));
+            if (user == null) {
+                plugin.getLog().warn("Failed to load user: " + c.getName());
+            } else {
+                user.setupData(false); // Pretty nasty calculation call. Sets up the caching system so data is ready when the user joins.
+            }
+
             final long time = System.currentTimeMillis() - startTime;
             if (time >= 1000) {
                 plugin.getLog().warn("Processing login for " + c.getName() + " took " + time + "ms.");
@@ -102,25 +135,15 @@ public class BungeeListener extends AbstractListener implements Listener {
     @EventHandler
     public void onPlayerPostLogin(PostLoginEvent e) {
         final ProxiedPlayer player = e.getPlayer();
-        final UUID internal = plugin.getUuidCache().getUUID(e.getPlayer().getUniqueId());
-        final User user = plugin.getUserManager().get(internal);
+        final User user = plugin.getUserManager().get(plugin.getUuidCache().getUUID(e.getPlayer().getUniqueId()));
 
         if (user == null) {
             plugin.getProxy().getScheduler().schedule(plugin, () -> player.sendMessage(WARN_MESSAGE), 3, TimeUnit.SECONDS);
-        } else {
-            plugin.getPlayerCache().put(internal, new BungeePlayerCache(plugin, e.getPlayer().getName()));
-            user.refreshPermissions();
         }
     }
 
     @EventHandler
     public void onPlayerQuit(PlayerDisconnectEvent e) {
-        plugin.getPlayerCache().remove(plugin.getUuidCache().getUUID(e.getPlayer().getUniqueId()));
         onLeave(e.getPlayer().getUniqueId());
     }
-
-    @EventHandler
-    public void onPlayerServerSwitch(ServerSwitchEvent e) {
-        refreshPlayer(e.getPlayer().getUniqueId());
-    }
 }

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

@@ -20,24 +20,27 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms;
+package me.lucko.luckperms.bungee;
 
-import lombok.AccessLevel;
-import lombok.NoArgsConstructor;
-import me.lucko.luckperms.commands.SenderFactory;
-import me.lucko.luckperms.constants.Constants;
+import me.lucko.luckperms.common.LuckPermsPlugin;
+import me.lucko.luckperms.common.commands.SenderFactory;
+import me.lucko.luckperms.common.constants.Constants;
 import net.md_5.bungee.api.CommandSender;
 import net.md_5.bungee.api.chat.TextComponent;
 import net.md_5.bungee.api.connection.ProxiedPlayer;
 
 import java.util.UUID;
 
-@NoArgsConstructor(access = AccessLevel.PRIVATE)
 public class BungeeSenderFactory extends SenderFactory<CommandSender> {
     private static BungeeSenderFactory instance = null;
-    public static synchronized BungeeSenderFactory get() {
+
+    private BungeeSenderFactory(LuckPermsPlugin plugin) {
+        super(plugin);
+    }
+
+    public static synchronized BungeeSenderFactory get(LuckPermsPlugin plugin) {
         if (instance == null) {
-            instance = new BungeeSenderFactory();
+            instance = new BungeeSenderFactory(plugin);
         }
         return instance;
     }

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

@@ -20,29 +20,36 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms;
+package me.lucko.luckperms.bungee;
 
 import lombok.Getter;
+import me.lucko.luckperms.ApiHandler;
+import me.lucko.luckperms.api.Contexts;
 import me.lucko.luckperms.api.Logger;
 import me.lucko.luckperms.api.PlatformType;
-import me.lucko.luckperms.api.implementation.ApiProvider;
-import me.lucko.luckperms.commands.CommandManager;
-import me.lucko.luckperms.commands.ConsecutiveExecutor;
-import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.constants.Message;
-import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.core.LPConfiguration;
-import me.lucko.luckperms.core.UuidCache;
-import me.lucko.luckperms.data.Importer;
-import me.lucko.luckperms.groups.GroupManager;
-import me.lucko.luckperms.runnables.ExpireTemporaryTask;
-import me.lucko.luckperms.runnables.UpdateTask;
-import me.lucko.luckperms.storage.Datastore;
-import me.lucko.luckperms.storage.StorageFactory;
-import me.lucko.luckperms.tracks.TrackManager;
-import me.lucko.luckperms.users.BungeeUserManager;
-import me.lucko.luckperms.users.UserManager;
-import me.lucko.luckperms.utils.LogFactory;
+import me.lucko.luckperms.common.LuckPermsPlugin;
+import me.lucko.luckperms.common.api.ApiProvider;
+import me.lucko.luckperms.common.calculators.CalculatorFactory;
+import me.lucko.luckperms.common.commands.CommandManager;
+import me.lucko.luckperms.common.commands.ConsecutiveExecutor;
+import me.lucko.luckperms.common.commands.Sender;
+import me.lucko.luckperms.common.config.LPConfiguration;
+import me.lucko.luckperms.common.constants.Message;
+import me.lucko.luckperms.common.constants.Permission;
+import me.lucko.luckperms.common.contexts.ContextManager;
+import me.lucko.luckperms.common.contexts.ServerCalculator;
+import me.lucko.luckperms.common.core.UuidCache;
+import me.lucko.luckperms.common.data.Importer;
+import me.lucko.luckperms.common.groups.GroupManager;
+import me.lucko.luckperms.common.runnables.ExpireTemporaryTask;
+import me.lucko.luckperms.common.runnables.UpdateTask;
+import me.lucko.luckperms.common.storage.Datastore;
+import me.lucko.luckperms.common.storage.StorageFactory;
+import me.lucko.luckperms.common.tracks.TrackManager;
+import me.lucko.luckperms.common.users.UserManager;
+import me.lucko.luckperms.common.utils.LocaleManager;
+import me.lucko.luckperms.common.utils.LogFactory;
+import net.md_5.bungee.api.config.ServerInfo;
 import net.md_5.bungee.api.connection.ProxiedPlayer;
 import net.md_5.bungee.api.plugin.Plugin;
 
@@ -54,7 +61,6 @@ import java.util.stream.Collectors;
 
 @Getter
 public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
-    private final Map<UUID, BungeePlayerCache> playerCache = new ConcurrentHashMap<>();
     private final Set<UUID> ignoringLogs = ConcurrentHashMap.newKeySet();
     private LPConfiguration configuration;
     private UserManager userManager;
@@ -66,6 +72,9 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
     private Logger log;
     private Importer importer;
     private ConsecutiveExecutor consecutiveExecutor;
+    private LocaleManager localeManager;
+    private ContextManager<ProxiedPlayer> contextManager;
+    private CalculatorFactory calculatorFactory;
 
     @Override
     public void onEnable() {
@@ -74,6 +83,17 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
         getLog().info("Loading configuration...");
         configuration = new BungeeConfig(this);
 
+        localeManager = new LocaleManager();
+        File locale = new File(getDataFolder(), "lang.yml");
+        if (locale.exists()) {
+            getLog().info("Found locale file. Attempting to load from it.");
+            try {
+                localeManager.loadFromFile(locale);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+
         // register events
         getProxy().getPluginManager().registerListener(this, new BungeeListener(this));
 
@@ -88,12 +108,19 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
         datastore = StorageFactory.getDatastore(this, "h2");
 
         getLog().info("Loading internal permission managers...");
-        uuidCache = new UuidCache(getConfiguration().getOnlineMode());
-        userManager = new BungeeUserManager(this);
+        uuidCache = new UuidCache(getConfiguration().isOnlineMode());
+        userManager = new UserManager(this);
         groupManager = new GroupManager(this);
         trackManager = new TrackManager();
         importer = new Importer(commandManager);
         consecutiveExecutor = new ConsecutiveExecutor(commandManager);
+        calculatorFactory = new BungeeCalculatorFactory(this);
+
+        contextManager = new ContextManager<>();
+        BackendServerCalculator serverCalculator = new BackendServerCalculator();
+        getProxy().getPluginManager().registerListener(this, serverCalculator);
+        contextManager.registerCalculator(serverCalculator);
+        contextManager.registerCalculator(new ServerCalculator<>(getConfiguration().getServer()));
 
         int mins = getConfiguration().getSyncTime();
         if (mins > 0) {
@@ -101,13 +128,13 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
         }
 
         // 20 times per second (once per "tick")
-        getProxy().getScheduler().schedule(this, BungeeSenderFactory.get(), 50L, 50L, TimeUnit.MILLISECONDS);
+        getProxy().getScheduler().schedule(this, BungeeSenderFactory.get(this), 50L, 50L, TimeUnit.MILLISECONDS);
         getProxy().getScheduler().schedule(this, new ExpireTemporaryTask(this), 3L, 3L, TimeUnit.SECONDS);
         getProxy().getScheduler().schedule(this, consecutiveExecutor, 1L, 1L, TimeUnit.SECONDS);
 
         getLog().info("Registering API...");
         apiProvider = new ApiProvider(this);
-        LuckPerms.registerProvider(apiProvider);
+        ApiHandler.registerProvider(apiProvider);
 
         // Run update task to refresh any online users
         getLog().info("Scheduling Update Task to refresh any online users.");
@@ -126,7 +153,7 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
         datastore.shutdown();
 
         getLog().info("Unregistering API...");
-        LuckPerms.unregisterProvider();
+        ApiHandler.unregisterProvider();
     }
 
     @Override
@@ -162,20 +189,42 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
     @Override
     public List<Sender> getNotifyListeners() {
         return getProxy().getPlayers().stream()
-                .map(p -> BungeeSenderFactory.get().wrap(p, Collections.singleton(Permission.LOG_NOTIFY)))
+                .map(p -> BungeeSenderFactory.get(this).wrap(p, Collections.singleton(Permission.LOG_NOTIFY)))
                 .filter(Permission.LOG_NOTIFY::isAuthorized)
                 .collect(Collectors.toList());
     }
 
     @Override
     public Sender getConsoleSender() {
-        return BungeeSenderFactory.get().wrap(getProxy().getConsole());
+        return BungeeSenderFactory.get(this).wrap(getProxy().getConsole());
     }
 
     @Override
-    public List<String> getPossiblePermissions() {
-        // No such thing on Bungee. Wildcards are processed in the listener instead.
-        return Collections.emptyList();
+    public Set<Contexts> getPreProcessContexts(boolean op) {
+        Set<Map<String, String>> c = new HashSet<>();
+        c.add(Collections.emptyMap());
+        c.add(Collections.singletonMap("server", getConfiguration().getServer()));
+        c.addAll(getProxy().getServers().values().stream()
+                .map(ServerInfo::getName)
+                .map(s -> {
+                    Map<String, String> map = new HashMap<>();
+                    map.put("server", getConfiguration().getServer());
+                    map.put("world", s);
+                    return map;
+                })
+                .collect(Collectors.toList())
+        );
+
+        return c.stream()
+                .map(map -> new Contexts(
+                        map,
+                        getConfiguration().isIncludingGlobalPerms(),
+                        getConfiguration().isIncludingGlobalWorldPerms(),
+                        true,
+                        getConfiguration().isApplyingGlobalGroups(),
+                        getConfiguration().isApplyingGlobalWorldGroups()
+                ))
+                .collect(Collectors.toSet());
     }
 
     @Override

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

@@ -1,101 +0,0 @@
-/*
- * 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.users;
-
-import me.lucko.luckperms.BungeePlayerCache;
-import me.lucko.luckperms.LPBungeePlugin;
-import me.lucko.luckperms.api.event.events.UserPermissionRefreshEvent;
-import me.lucko.luckperms.api.implementation.internal.UserLink;
-import me.lucko.luckperms.utils.Contexts;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-
-import java.util.Collections;
-import java.util.Map;
-import java.util.UUID;
-
-public class BungeeUser extends User {
-    private final LPBungeePlugin plugin;
-
-    BungeeUser(UUID uuid, LPBungeePlugin plugin) {
-        super(uuid, plugin);
-        this.plugin = plugin;
-    }
-
-    BungeeUser(UUID uuid, String username, LPBungeePlugin plugin) {
-        super(uuid, username, plugin);
-        this.plugin = plugin;
-    }
-
-    @Override
-    public synchronized void refreshPermissions() {
-        ProxiedPlayer player = plugin.getProxy().getPlayer(plugin.getUuidCache().getExternalUUID(getUuid()));
-        if (player == null) {
-            return;
-        }
-
-        BungeePlayerCache playerCache = plugin.getPlayerCache().get(getUuid());
-        if (playerCache == null) {
-            return;
-        }
-
-        final String server = player.getServer() == null ? null : (player.getServer().getInfo() == null ? null : player.getServer().getInfo().getName());
-
-        // Calculate the permissions that should be applied. This is done async.
-        Map<String, Boolean> toApply = exportNodes(
-                new Contexts(
-                        plugin.getConfiguration().getServer(),
-                        server,
-                        null,
-                        plugin.getConfiguration().getIncludeGlobalPerms(),
-                        plugin.getConfiguration().getIncludeGlobalWorldPerms(),
-                        true,
-                        plugin.getConfiguration().getApplyGlobalGroups(),
-                        plugin.getConfiguration().getApplyGlobalWorldGroups()
-                ),
-                Collections.emptyList()
-        );
-
-        Map<String, Boolean> existing = playerCache.getPermissions();
-
-        boolean different = false;
-        if (toApply.size() != existing.size()) {
-            different = true;
-        } else {
-            for (Map.Entry<String, Boolean> e : existing.entrySet()) {
-                if (toApply.containsKey(e.getKey()) && toApply.get(e.getKey()) == e.getValue()) {
-                    continue;
-                }
-                different = true;
-                break;
-            }
-        }
-
-        if (!different) return;
-
-        existing.clear();
-        playerCache.invalidateCache();
-        existing.putAll(toApply);
-
-        plugin.getApiProvider().fireEventAsync(new UserPermissionRefreshEvent(new UserLink(this)));
-    }
-}

bungee/src/main/resources/config.yml

@@ -59,14 +59,24 @@ log-notify: true
 # If LuckPerms should print to console every time a plugin checks if a player has a permission
 debug-permission-checks: false
 
+# Mirrors world names. Whenever LuckPerms checks what world a user is in, if the world name is in this list, the value assigned
+# will be sent forward for permission calculation instead.
+# Remember world names on BungeeCord relate to the backend server name a user is connected to.
+world-rewrite:
+  #hub2: hub
+  #hub3: hub
+  #opfactions: factions
+
+# Rewrites group names. The underlying name of the group does not change, just the output in commands / placeholders / Vault.
+group-name-rewrite:
+  #default: Member
+
 # Which storage method the plugin should use.
 # Currently supported: mysql, sqlite, h2, json, yaml, mongodb
 # Fill out connection info below if you're using MySQL or MongoDB
 storage-method: h2
 
 # This block enables support for split datastores.
-# Only touch this if you're sure that you know what you're doing.
-# I (the author) do not endorse nor recommend the use of this feature.
 split-storage:
   enabled: false
   methods:

bungee/src/main/resources/plugin.yml

@@ -2,5 +2,5 @@ name: LuckPerms
 version: ${release.version}.${git.closest.tag.commit.count}
 description: A permissions plugin
 author: Luck
-main: me.lucko.luckperms.LPBungeePlugin
+main: me.lucko.luckperms.bungee.LPBungeePlugin
 softdepends: [PowerfulPerms] # For migration

common/pom.xml

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

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

@@ -20,8 +20,18 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.gui;
+package me.lucko.luckperms;
+
+import me.lucko.luckperms.api.LuckPermsApi;
+
+public class ApiHandler {
+
+    public static void registerProvider(LuckPermsApi luckPermsApi) {
+        LuckPerms.registerProvider(luckPermsApi);
+    }
+
+    public static void unregisterProvider() {
+        LuckPerms.unregisterProvider();
+    }
 
-public class InterfaceManager {
-    // TODO
 }

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

@@ -1,114 +0,0 @@
-/*
- * 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.CommandResult;
-import me.lucko.luckperms.commands.Predicate;
-import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
-import me.lucko.luckperms.constants.Message;
-import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.data.LogEntry;
-import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
-import me.lucko.luckperms.groups.Group;
-import me.lucko.luckperms.utils.ArgumentChecker;
-import me.lucko.luckperms.utils.DateUtil;
-
-import java.util.List;
-
-public class GroupAddTempPrefix extends SubCommand<Group> {
-    public GroupAddTempPrefix() {
-        super("addtempprefix", "Adds a prefix to the group temporarily", "/%s group <group> addtempprefix <priority> <prefix> <duration> [server] [world]",
-                Permission.GROUP_ADD_TEMP_PREFIX, Predicate.notInRange(3, 5));
-    }
-
-    @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
-        final String prefix = args.get(1).replace("{SPACE}", " ");
-        int priority;
-        try {
-            priority = Integer.parseInt(args.get(0));
-        } catch (NumberFormatException e) {
-            Message.META_INVALID_PRIORITY.send(sender, args.get(0));
-            return CommandResult.INVALID_ARGS;
-        }
-
-        long duration;
-        try {
-            duration = Long.parseLong(args.get(2));
-        } catch (NumberFormatException e) {
-            try {
-                duration = DateUtil.parseDateDiff(args.get(2), true);
-            } catch (DateUtil.IllegalDateException e1) {
-                Message.ILLEGAL_DATE_ERROR.send(sender, args.get(2));
-                return CommandResult.INVALID_ARGS;
-            }
-        }
-
-        if (DateUtil.shouldExpire(duration)) {
-            Message.PAST_DATE_ERROR.send(sender);
-            return CommandResult.INVALID_ARGS;
-        }
-
-        final String node = "prefix." + priority + "." + ArgumentChecker.escapeCharacters(prefix);
-
-        try {
-            if (args.size() >= 4) {
-                final String server = args.get(3).toLowerCase();
-                if (ArgumentChecker.checkServer(server)) {
-                    Message.SERVER_INVALID_ENTRY.send(sender);
-                    return CommandResult.INVALID_ARGS;
-                }
-
-                if (args.size() == 4) {
-                    group.setPermission(node, true, server, duration);
-                    Message.ADD_TEMP_PREFIX_SERVER_SUCCESS.send(sender, group.getName(), prefix, priority, server, DateUtil.formatDateDiff(duration));
-                    LogEntry.build().actor(sender).acted(group)
-                            .action("addtempprefix " + priority + " " + args.get(1) + " " + duration + " " + server)
-                            .build().submit(plugin, sender);
-                } else {
-                    final String world = args.get(4).toLowerCase();
-                    group.setPermission(node, true, server, world, duration);
-                    Message.ADD_TEMP_PREFIX_SERVER_WORLD_SUCCESS.send(sender, group.getName(), prefix, priority, server, world, DateUtil.formatDateDiff(duration));
-                    LogEntry.build().actor(sender).acted(group)
-                            .action("addtempprefix " + priority + " " + args.get(1) + " " + duration + " " + server + " " + world)
-                            .build().submit(plugin, sender);
-                }
-
-            } else {
-                group.setPermission(node, true, duration);
-                Message.ADD_TEMP_PREFIX_SUCCESS.send(sender, group.getName(), prefix, priority, DateUtil.formatDateDiff(duration));
-                LogEntry.build().actor(sender).acted(group)
-                        .action("addtempprefix " + priority + " " + args.get(1) + " " + duration)
-                        .build().submit(plugin, sender);
-            }
-
-            save(group, sender, plugin);
-            return CommandResult.SUCCESS;
-        } catch (ObjectAlreadyHasException e) {
-            Message.ALREADY_HAS_PREFIX.send(sender, group.getName());
-            return CommandResult.STATE_ERROR;
-        }
-    }
-}

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

@@ -1,60 +0,0 @@
-/*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
- *
- *  Permission is hereby granted, free of charge, to any person obtaining a copy
- *  of this software and associated documentation files (the "Software"), to deal
- *  in the Software without restriction, including without limitation the rights
- *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- *  copies of the Software, and to permit persons to whom the Software is
- *  furnished to do so, subject to the following conditions:
- *
- *  The above copyright notice and this permission notice shall be included in all
- *  copies or substantial portions of the Software.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- *  SOFTWARE.
- */
-
-package me.lucko.luckperms.commands.group.subcommands;
-
-import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.*;
-import me.lucko.luckperms.constants.Message;
-import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.groups.Group;
-import me.lucko.luckperms.utils.ArgumentChecker;
-
-import java.util.List;
-
-public class GroupInheritsPerm extends SubCommand<Group> {
-    public GroupInheritsPerm() {
-        super("inheritspermission", "Checks to see if a group inherits a certain permission node",
-                "/%s group <group> inheritspermission <node> [server] [world]", Permission.GROUP_INHERITSPERMISSION,
-                Predicate.notInRange(1, 3));
-    }
-
-    @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
-        if (args.size() >= 2) {
-            if (ArgumentChecker.checkServer(args.get(1))) {
-                Message.SERVER_INVALID_ENTRY.send(sender);
-                return CommandResult.INVALID_ARGS;
-            }
-
-            if (args.size() == 2) {
-                Util.sendBoolean(sender, args.get(0), group.inheritsPermission(args.get(0), true, args.get(1)));
-            } else {
-                Util.sendBoolean(sender, args.get(0), group.inheritsPermission(args.get(0), true, args.get(1), args.get(2)));
-            }
-
-        } else {
-            Util.sendBoolean(sender, args.get(0), group.inheritsPermission(args.get(0), true));
-        }
-        return CommandResult.SUCCESS;
-    }
-}

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

@@ -1,96 +0,0 @@
-/*
- * 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.CommandResult;
-import me.lucko.luckperms.commands.Predicate;
-import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
-import me.lucko.luckperms.constants.Message;
-import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.data.LogEntry;
-import me.lucko.luckperms.exceptions.ObjectLacksException;
-import me.lucko.luckperms.groups.Group;
-import me.lucko.luckperms.utils.ArgumentChecker;
-
-import java.util.List;
-
-public class GroupRemovePrefix extends SubCommand<Group> {
-    public GroupRemovePrefix() {
-        super("removeprefix", "Removes a prefix from a group", "/%s group <group> removeprefix <priority> <prefix> [server] [world]",
-                Permission.GROUP_REMOVEPREFIX, Predicate.notInRange(2, 4));
-    }
-
-    @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
-        final String prefix = args.get(1).replace("{SPACE}", " ");
-        int priority;
-        try {
-            priority = Integer.parseInt(args.get(0));
-        } catch (NumberFormatException e) {
-            Message.META_INVALID_PRIORITY.send(sender, args.get(0));
-            return CommandResult.INVALID_ARGS;
-        }
-
-        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.getName(), prefix, priority, server);
-                    LogEntry.build().actor(sender).acted(group)
-                            .action("removeprefix " + priority + " " + args.get(1) + " " + server)
-                            .build().submit(plugin, sender);
-                } else {
-                    final String world = args.get(3).toLowerCase();
-                    group.unsetPermission(node, server, world);
-                    Message.REMOVEPREFIX_SERVER_WORLD_SUCCESS.send(sender, group.getName(), prefix, priority, server, world);
-                    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.getName(), 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.getName());
-            return CommandResult.STATE_ERROR;
-        }
-    }
-}

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

@@ -1,96 +0,0 @@
-/*
- * 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.CommandResult;
-import me.lucko.luckperms.commands.Predicate;
-import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
-import me.lucko.luckperms.constants.Message;
-import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.data.LogEntry;
-import me.lucko.luckperms.exceptions.ObjectLacksException;
-import me.lucko.luckperms.groups.Group;
-import me.lucko.luckperms.utils.ArgumentChecker;
-
-import java.util.List;
-
-public class GroupRemoveSuffix extends SubCommand<Group> {
-    public GroupRemoveSuffix() {
-        super("removesuffix", "Removes a suffix from a group", "/%s group <group> removesuffix <priority> <suffix> [server] [world]",
-                Permission.GROUP_REMOVESUFFIX, Predicate.notInRange(2, 4));
-    }
-
-    @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
-        final String suffix = args.get(1).replace("{SPACE}", " ");
-        int priority;
-        try {
-            priority = Integer.parseInt(args.get(0));
-        } catch (NumberFormatException e) {
-            Message.META_INVALID_PRIORITY.send(sender, args.get(0));
-            return CommandResult.INVALID_ARGS;
-        }
-
-        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.getName(), suffix, priority, server);
-                    LogEntry.build().actor(sender).acted(group)
-                            .action("removesuffix " + priority + " " + args.get(1) + " " + server)
-                            .build().submit(plugin, sender);
-                } else {
-                    final String world = args.get(3).toLowerCase();
-                    group.unsetPermission(node, server, world);
-                    Message.REMOVESUFFIX_SERVER_WORLD_SUCCESS.send(sender, group.getName(), suffix, priority, server, world);
-                    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.getName(), 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.getName());
-            return CommandResult.STATE_ERROR;
-        }
-    }
-}

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

@@ -1,96 +0,0 @@
-/*
- * 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.CommandResult;
-import me.lucko.luckperms.commands.Predicate;
-import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
-import me.lucko.luckperms.constants.Message;
-import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.data.LogEntry;
-import me.lucko.luckperms.exceptions.ObjectLacksException;
-import me.lucko.luckperms.groups.Group;
-import me.lucko.luckperms.utils.ArgumentChecker;
-
-import java.util.List;
-
-public class GroupRemoveTempPrefix extends SubCommand<Group> {
-    public GroupRemoveTempPrefix() {
-        super("removetempprefix", "Removes a temporary prefix from a group", "/%s group <group> removetempprefix <priority> <prefix> [server] [world]",
-                Permission.GROUP_REMOVE_TEMP_PREFIX, Predicate.notInRange(2, 4));
-    }
-
-    @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
-        final String prefix = args.get(1).replace("{SPACE}", " ");
-        int priority;
-        try {
-            priority = Integer.parseInt(args.get(0));
-        } catch (NumberFormatException e) {
-            Message.META_INVALID_PRIORITY.send(sender, args.get(0));
-            return CommandResult.INVALID_ARGS;
-        }
-
-        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.getName(), prefix, priority, server);
-                    LogEntry.build().actor(sender).acted(group)
-                            .action("removetempprefix " + priority + " " + args.get(1) + " " + server)
-                            .build().submit(plugin, sender);
-                } else {
-                    final String world = args.get(3).toLowerCase();
-                    group.unsetPermission(node, server, world, true);
-                    Message.REMOVE_TEMP_PREFIX_SERVER_WORLD_SUCCESS.send(sender, group.getName(), prefix, priority, server, world);
-                    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.getName(), 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.getName());
-            return CommandResult.STATE_ERROR;
-        }
-    }
-}

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

@@ -1,96 +0,0 @@
-/*
- * 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.CommandResult;
-import me.lucko.luckperms.commands.Predicate;
-import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
-import me.lucko.luckperms.constants.Message;
-import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.data.LogEntry;
-import me.lucko.luckperms.exceptions.ObjectLacksException;
-import me.lucko.luckperms.groups.Group;
-import me.lucko.luckperms.utils.ArgumentChecker;
-
-import java.util.List;
-
-public class GroupRemoveTempSuffix extends SubCommand<Group> {
-    public GroupRemoveTempSuffix() {
-        super("removetempsuffix", "Removes a temporary suffix from a group", "/%s group <group> removetempsuffix <priority> <suffix> [server] [world]",
-                Permission.GROUP_REMOVE_TEMP_SUFFIX, Predicate.notInRange(2, 4));
-    }
-
-    @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
-        final String suffix = args.get(1).replace("{SPACE}", " ");
-        int priority;
-        try {
-            priority = Integer.parseInt(args.get(0));
-        } catch (NumberFormatException e) {
-            Message.META_INVALID_PRIORITY.send(sender, args.get(0));
-            return CommandResult.INVALID_ARGS;
-        }
-
-        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.getName(), suffix, priority, server);
-                    LogEntry.build().actor(sender).acted(group)
-                            .action("removetempsuffix " + priority + " " + args.get(1) + " " + server)
-                            .build().submit(plugin, sender);
-                } else {
-                    final String world = args.get(3).toLowerCase();
-                    group.unsetPermission(node, server, world, true);
-                    Message.REMOVE_TEMP_SUFFIX_SERVER_WORLD_SUCCESS.send(sender, group.getName(), suffix, priority, server, world);
-                    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.getName(), 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.getName());
-            return CommandResult.STATE_ERROR;
-        }
-    }
-}

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

@@ -1,96 +0,0 @@
-/*
- * 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.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.constants.Message;
-import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.data.LogEntry;
-import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
-import me.lucko.luckperms.users.User;
-import me.lucko.luckperms.utils.ArgumentChecker;
-
-import java.util.List;
-
-public class UserAddPrefix extends SubCommand<User> {
-    public UserAddPrefix() {
-        super("addprefix", "Adds a prefix to the user", "/%s user <user> addprefix <priority> <prefix> [server] [world]",
-                Permission.USER_ADDPREFIX, Predicate.notInRange(2, 4));
-    }
-
-    @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
-        final String prefix = args.get(1).replace("{SPACE}", " ");
-        int priority;
-        try {
-            priority = Integer.parseInt(args.get(0));
-        } catch (NumberFormatException e) {
-            Message.META_INVALID_PRIORITY.send(sender, args.get(0));
-            return CommandResult.INVALID_ARGS;
-        }
-
-        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) {
-                    user.setPermission(node, true, server);
-                    Message.ADDPREFIX_SERVER_SUCCESS.send(sender, user.getName(), prefix, priority, server);
-                    LogEntry.build().actor(sender).acted(user)
-                            .action("addprefix " + priority + " " + args.get(1) + " " + server)
-                            .build().submit(plugin, sender);
-                } else {
-                    final String world = args.get(3).toLowerCase();
-                    user.setPermission(node, true, server, world);
-                    Message.ADDPREFIX_SERVER_WORLD_SUCCESS.send(sender, user.getName(), prefix, priority, server, world);
-                    LogEntry.build().actor(sender).acted(user)
-                            .action("addprefix " + priority + " " + args.get(1) + " " + server + " " + world)
-                            .build().submit(plugin, sender);
-                }
-
-            } else {
-                user.setPermission(node, true);
-                Message.ADDPREFIX_SUCCESS.send(sender, user.getName(), prefix, priority);
-                LogEntry.build().actor(sender).acted(user)
-                        .action("addprefix " + priority + " " + args.get(1))
-                        .build().submit(plugin, sender);
-            }
-
-            save(user, sender, plugin);
-            return CommandResult.SUCCESS;
-        } catch (ObjectAlreadyHasException e) {
-            Message.ALREADY_HAS_PREFIX.send(sender, user.getName());
-            return CommandResult.STATE_ERROR;
-        }
-    }
-}

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

@@ -1,96 +0,0 @@
-/*
- * 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.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.constants.Message;
-import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.data.LogEntry;
-import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
-import me.lucko.luckperms.users.User;
-import me.lucko.luckperms.utils.ArgumentChecker;
-
-import java.util.List;
-
-public class UserAddSuffix extends SubCommand<User> {
-    public UserAddSuffix() {
-        super("addsuffix", "Adds a suffix to the user", "/%s user <user> addsuffix <priority> <suffix> [server] [world]",
-                Permission.USER_ADDSUFFIX, Predicate.notInRange(2, 4));
-    }
-
-    @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
-        final String suffix = args.get(1).replace("{SPACE}", " ");
-        int priority;
-        try {
-            priority = Integer.parseInt(args.get(0));
-        } catch (NumberFormatException e) {
-            Message.META_INVALID_PRIORITY.send(sender, args.get(0));
-            return CommandResult.INVALID_ARGS;
-        }
-
-        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) {
-                    user.setPermission(node, true, server);
-                    Message.ADDSUFFIX_SERVER_SUCCESS.send(sender, user.getName(), suffix, priority, server);
-                    LogEntry.build().actor(sender).acted(user)
-                            .action("addsuffix " + priority + " " + args.get(1) + " " + server)
-                            .build().submit(plugin, sender);
-                } else {
-                    final String world = args.get(3).toLowerCase();
-                    user.setPermission(node, true, server, world);
-                    Message.ADDSUFFIX_SERVER_WORLD_SUCCESS.send(sender, user.getName(), suffix, priority, server, world);
-                    LogEntry.build().actor(sender).acted(user)
-                            .action("addsuffix " + priority + " " + args.get(1) + " " + server + " " + world)
-                            .build().submit(plugin, sender);
-                }
-
-            } else {
-                user.setPermission(node, true);
-                Message.ADDSUFFIX_SUCCESS.send(sender, user.getName(), suffix, priority);
-                LogEntry.build().actor(sender).acted(user)
-                        .action("addsuffix " + priority + " " + args.get(1))
-                        .build().submit(plugin, sender);
-            }
-
-            save(user, sender, plugin);
-            return CommandResult.SUCCESS;
-        } catch (ObjectAlreadyHasException e) {
-            Message.ALREADY_HAS_SUFFIX.send(sender, user.getName());
-            return CommandResult.STATE_ERROR;
-        }
-    }
-}

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

@@ -1,114 +0,0 @@
-/*
- * 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.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.constants.Message;
-import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.data.LogEntry;
-import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
-import me.lucko.luckperms.users.User;
-import me.lucko.luckperms.utils.ArgumentChecker;
-import me.lucko.luckperms.utils.DateUtil;
-
-import java.util.List;
-
-public class UserAddTempSuffix extends SubCommand<User> {
-    public UserAddTempSuffix() {
-        super("addtempsuffix", "Adds a suffix to the user temporarily", "/%s user <user> addtempsuffix <priority> <suffix> <duration> [server] [world]",
-                Permission.USER_ADD_TEMP_SUFFIX, Predicate.notInRange(3, 5));
-    }
-
-    @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
-        final String suffix = args.get(1).replace("{SPACE}", " ");
-        int priority;
-        try {
-            priority = Integer.parseInt(args.get(0));
-        } catch (NumberFormatException e) {
-            Message.META_INVALID_PRIORITY.send(sender, args.get(0));
-            return CommandResult.INVALID_ARGS;
-        }
-
-        long duration;
-        try {
-            duration = Long.parseLong(args.get(2));
-        } catch (NumberFormatException e) {
-            try {
-                duration = DateUtil.parseDateDiff(args.get(2), true);
-            } catch (DateUtil.IllegalDateException e1) {
-                Message.ILLEGAL_DATE_ERROR.send(sender, args.get(2));
-                return CommandResult.INVALID_ARGS;
-            }
-        }
-
-        if (DateUtil.shouldExpire(duration)) {
-            Message.PAST_DATE_ERROR.send(sender);
-            return CommandResult.INVALID_ARGS;
-        }
-
-        final String node = "suffix." + priority + "." + ArgumentChecker.escapeCharacters(suffix);
-
-        try {
-            if (args.size() >= 4) {
-                final String server = args.get(3).toLowerCase();
-                if (ArgumentChecker.checkServer(server)) {
-                    Message.SERVER_INVALID_ENTRY.send(sender);
-                    return CommandResult.INVALID_ARGS;
-                }
-
-                if (args.size() == 4) {
-                    user.setPermission(node, true, server, duration);
-                    Message.ADD_TEMP_SUFFIX_SERVER_SUCCESS.send(sender, user.getName(), suffix, priority, server, DateUtil.formatDateDiff(duration));
-                    LogEntry.build().actor(sender).acted(user)
-                            .action("addtempsuffix " + priority + " " + args.get(1) + " " + duration + " " + server)
-                            .build().submit(plugin, sender);
-                } else {
-                    final String world = args.get(4).toLowerCase();
-                    user.setPermission(node, true, server, world, duration);
-                    Message.ADD_TEMP_SUFFIX_SERVER_WORLD_SUCCESS.send(sender, user.getName(), suffix, priority, server, world, DateUtil.formatDateDiff(duration));
-                    LogEntry.build().actor(sender).acted(user)
-                            .action("addtempsuffix " + priority + " " + args.get(1) + " " + duration + " " + server + " " + world)
-                            .build().submit(plugin, sender);
-                }
-
-            } else {
-                user.setPermission(node, true, duration);
-                Message.ADD_TEMP_SUFFIX_SUCCESS.send(sender, user.getName(), suffix, priority, DateUtil.formatDateDiff(duration));
-                LogEntry.build().actor(sender).acted(user)
-                        .action("addtempsuffix " + priority + " " + args.get(1) + " " + duration)
-                        .build().submit(plugin, sender);
-            }
-
-            save(user, sender, plugin);
-            return CommandResult.SUCCESS;
-        } catch (ObjectAlreadyHasException e) {
-            Message.ALREADY_HAS_SUFFIX.send(sender, user.getName());
-            return CommandResult.STATE_ERROR;
-        }
-    }
-}

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

@@ -1,94 +0,0 @@
-/*
- * 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.user.subcommands;
-
-import me.lucko.luckperms.LuckPermsPlugin;
-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.users.User;
-import me.lucko.luckperms.utils.Contexts;
-
-import java.util.AbstractMap.SimpleEntry;
-import java.util.List;
-import java.util.Map;
-import java.util.SortedSet;
-import java.util.TreeSet;
-
-public class UserChatMeta extends SubCommand<User> {
-    public UserChatMeta() {
-        super("chatmeta", "Displays a users chat meta", "/%s user <user> chatmeta", Permission.USER_CHATMETA,
-                Predicate.alwaysFalse());
-    }
-
-    @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
-        SortedSet<Map.Entry<Integer, String>> prefixes = new TreeSet<>(Util.getMetaComparator().reversed());
-        SortedSet<Map.Entry<Integer, String>> suffixes = new TreeSet<>(Util.getMetaComparator().reversed());
-
-        for (Node node : user.getAllNodes(null, Contexts.allowAll())) {
-            if (!node.isSuffix() && !node.isPrefix()) {
-                continue;
-            }
-
-            StringBuilder sb = new StringBuilder();
-            if (node.isServerSpecific()) {
-                if (node.isWorldSpecific()) {
-                    sb.append("&6W=").append(node.getWorld().get()).append(" ");
-                }
-                sb.append("&6S=").append(node.getServer().get()).append(" ");
-            }
-
-            if (node.isPrefix()) {
-                sb.append(node.getPrefix().getValue());
-                prefixes.add(new SimpleEntry<>(node.getPrefix().getKey(), sb.toString()));
-            }
-
-            if (node.isSuffix()) {
-                sb.append(node.getSuffix().getValue());
-                suffixes.add(new SimpleEntry<>(node.getSuffix().getKey(), sb.toString()));
-            }
-        }
-
-        if (prefixes.isEmpty()) {
-            Message.CHAT_META_PREFIX_NONE.send(sender, user.getName());
-        } else {
-            Message.CHAT_META_PREFIX_HEADER.send(sender, user.getName());
-            for (Map.Entry<Integer, String> e : prefixes) {
-                Message.CHAT_META_ENTRY.send(sender, e.getKey(), e.getValue());
-            }
-        }
-
-        if (suffixes.isEmpty()) {
-            Message.CHAT_META_SUFFIX_NONE.send(sender, user.getName());
-        } else {
-            Message.CHAT_META_SUFFIX_HEADER.send(sender, user.getName());
-            for (Map.Entry<Integer, String> e : suffixes) {
-                Message.CHAT_META_ENTRY.send(sender, e.getKey(), e.getValue());
-            }
-        }
-
-        return CommandResult.SUCCESS;
-    }
-}

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

@@ -1,60 +0,0 @@
-/*
- * 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.user.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.users.User;
-import me.lucko.luckperms.utils.ArgumentChecker;
-
-import java.util.List;
-
-public class UserInheritsPerm extends SubCommand<User> {
-    public UserInheritsPerm() {
-        super("inheritspermission", "Checks to see if a user inherits a certain permission node",
-                "/%s user <user> inheritspermission <node> [server] [world]", Permission.USER_INHERITSPERMISSION,
-                Predicate.notInRange(1, 3));
-    }
-
-    @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
-        if (args.size() >= 2) {
-            if (ArgumentChecker.checkServer(args.get(1))) {
-                Message.SERVER_INVALID_ENTRY.send(sender);
-                return CommandResult.INVALID_ARGS;
-            }
-
-            if (args.size() == 2) {
-                Util.sendBoolean(sender, args.get(0), user.inheritsPermission(args.get(0), true, args.get(1)));
-            } else {
-                Util.sendBoolean(sender, args.get(0), user.inheritsPermission(args.get(0), true, args.get(1), args.get(2)));
-            }
-
-        } else {
-            Util.sendBoolean(sender, args.get(0), user.inheritsPermission(args.get(0), true));
-        }
-        return CommandResult.SUCCESS;
-    }
-}

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

@@ -1,96 +0,0 @@
-/*
- * 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.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.constants.Message;
-import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.data.LogEntry;
-import me.lucko.luckperms.exceptions.ObjectLacksException;
-import me.lucko.luckperms.users.User;
-import me.lucko.luckperms.utils.ArgumentChecker;
-
-import java.util.List;
-
-public class UserRemovePrefix extends SubCommand<User> {
-    public UserRemovePrefix() {
-        super("removeprefix", "Removes a prefix from a user", "/%s user <user> removeprefix <priority> <prefix> [server] [world]",
-                Permission.USER_REMOVEPREFIX, Predicate.notInRange(2, 4));
-    }
-
-    @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
-        final String prefix = args.get(1).replace("{SPACE}", " ");
-        int priority;
-        try {
-            priority = Integer.parseInt(args.get(0));
-        } catch (NumberFormatException e) {
-            Message.META_INVALID_PRIORITY.send(sender, args.get(0));
-            return CommandResult.INVALID_ARGS;
-        }
-
-        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) {
-                    user.unsetPermission(node, server);
-                    Message.REMOVEPREFIX_SERVER_SUCCESS.send(sender, user.getName(), prefix, priority, server);
-                    LogEntry.build().actor(sender).acted(user)
-                            .action("removeprefix " + priority + " " + args.get(1) + " " + server)
-                            .build().submit(plugin, sender);
-                } else {
-                    final String world = args.get(3).toLowerCase();
-                    user.unsetPermission(node, server, world);
-                    Message.REMOVEPREFIX_SERVER_WORLD_SUCCESS.send(sender, user.getName(), prefix, priority, server, world);
-                    LogEntry.build().actor(sender).acted(user)
-                            .action("removeprefix " + priority + " " + args.get(1) + " " + server + " " + world)
-                            .build().submit(plugin, sender);
-                }
-
-            } else {
-                user.unsetPermission(node);
-                Message.REMOVEPREFIX_SUCCESS.send(sender, user.getName(), prefix, priority);
-                LogEntry.build().actor(sender).acted(user)
-                        .action("removeprefix " + priority + " " + args.get(1))
-                        .build().submit(plugin, sender);
-            }
-
-            save(user, sender, plugin);
-            return CommandResult.SUCCESS;
-        } catch (ObjectLacksException e) {
-            Message.DOES_NOT_HAVE_PREFIX.send(sender, user.getName());
-            return CommandResult.STATE_ERROR;
-        }
-    }
-}

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

@@ -1,96 +0,0 @@
-/*
- * 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.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.constants.Message;
-import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.data.LogEntry;
-import me.lucko.luckperms.exceptions.ObjectLacksException;
-import me.lucko.luckperms.users.User;
-import me.lucko.luckperms.utils.ArgumentChecker;
-
-import java.util.List;
-
-public class UserRemoveSuffix extends SubCommand<User> {
-    public UserRemoveSuffix() {
-        super("removesuffix", "Removes a suffix from a user", "/%s user <user> removesuffix <priority> <suffix> [server] [world]",
-                Permission.USER_REMOVESUFFIX, Predicate.notInRange(2, 4));
-    }
-
-    @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
-        final String suffix = args.get(1).replace("{SPACE}", " ");
-        int priority;
-        try {
-            priority = Integer.parseInt(args.get(0));
-        } catch (NumberFormatException e) {
-            Message.META_INVALID_PRIORITY.send(sender, args.get(0));
-            return CommandResult.INVALID_ARGS;
-        }
-
-        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) {
-                    user.unsetPermission(node, server);
-                    Message.REMOVESUFFIX_SERVER_SUCCESS.send(sender, user.getName(), suffix, priority, server);
-                    LogEntry.build().actor(sender).acted(user)
-                            .action("removesuffix " + priority + " " + args.get(1) + " " + server)
-                            .build().submit(plugin, sender);
-                } else {
-                    final String world = args.get(3).toLowerCase();
-                    user.unsetPermission(node, server, world);
-                    Message.REMOVESUFFIX_SERVER_WORLD_SUCCESS.send(sender, user.getName(), suffix, priority, server, world);
-                    LogEntry.build().actor(sender).acted(user)
-                            .action("removesuffix " + priority + " " + args.get(1) + " " + server + " " + world)
-                            .build().submit(plugin, sender);
-                }
-
-            } else {
-                user.unsetPermission(node);
-                Message.REMOVESUFFIX_SUCCESS.send(sender, user.getName(), suffix, priority);
-                LogEntry.build().actor(sender).acted(user)
-                        .action("removesuffix " + priority + " " + args.get(1))
-                        .build().submit(plugin, sender);
-            }
-
-            save(user, sender, plugin);
-            return CommandResult.SUCCESS;
-        } catch (ObjectLacksException e) {
-            Message.DOES_NOT_HAVE_SUFFIX.send(sender, user.getName());
-            return CommandResult.STATE_ERROR;
-        }
-    }
-}

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

@@ -1,96 +0,0 @@
-/*
- * 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.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.constants.Message;
-import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.data.LogEntry;
-import me.lucko.luckperms.exceptions.ObjectLacksException;
-import me.lucko.luckperms.users.User;
-import me.lucko.luckperms.utils.ArgumentChecker;
-
-import java.util.List;
-
-public class UserRemoveTempPrefix extends SubCommand<User> {
-    public UserRemoveTempPrefix() {
-        super("removetempprefix", "Removes a temporary prefix from a user", "/%s user <user> removetempprefix <priority> <prefix> [server] [world]",
-                Permission.USER_REMOVE_TEMP_PREFIX, Predicate.notInRange(2, 4));
-    }
-
-    @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
-        final String prefix = args.get(1).replace("{SPACE}", " ");
-        int priority;
-        try {
-            priority = Integer.parseInt(args.get(0));
-        } catch (NumberFormatException e) {
-            Message.META_INVALID_PRIORITY.send(sender, args.get(0));
-            return CommandResult.INVALID_ARGS;
-        }
-
-        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) {
-                    user.unsetPermission(node, server, true);
-                    Message.REMOVE_TEMP_PREFIX_SERVER_SUCCESS.send(sender, user.getName(), prefix, priority, server);
-                    LogEntry.build().actor(sender).acted(user)
-                            .action("removetempprefix " + priority + " " + args.get(1) + " " + server)
-                            .build().submit(plugin, sender);
-                } else {
-                    final String world = args.get(3).toLowerCase();
-                    user.unsetPermission(node, server, world, true);
-                    Message.REMOVE_TEMP_PREFIX_SERVER_WORLD_SUCCESS.send(sender, user.getName(), prefix, priority, server, world);
-                    LogEntry.build().actor(sender).acted(user)
-                            .action("removetempprefix " + priority + " " + args.get(1) + " " + server + " " + world)
-                            .build().submit(plugin, sender);
-                }
-
-            } else {
-                user.unsetPermission(node, true);
-                Message.REMOVE_TEMP_PREFIX_SUCCESS.send(sender, user.getName(), prefix, priority);
-                LogEntry.build().actor(sender).acted(user)
-                        .action("removetempprefix " + priority + " " + args.get(1))
-                        .build().submit(plugin, sender);
-            }
-
-            save(user, sender, plugin);
-            return CommandResult.SUCCESS;
-        } catch (ObjectLacksException e) {
-            Message.DOES_NOT_HAVE_PREFIX.send(sender, user.getName());
-            return CommandResult.STATE_ERROR;
-        }
-    }
-}

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

@@ -1,96 +0,0 @@
-/*
- * 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.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.constants.Message;
-import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.data.LogEntry;
-import me.lucko.luckperms.exceptions.ObjectLacksException;
-import me.lucko.luckperms.users.User;
-import me.lucko.luckperms.utils.ArgumentChecker;
-
-import java.util.List;
-
-public class UserRemoveTempSuffix extends SubCommand<User> {
-    public UserRemoveTempSuffix() {
-        super("removetempsuffix", "Removes a temporary suffix from a user", "/%s user <user> removetempsuffix <priority> <suffix> [server] [world]",
-                Permission.USER_REMOVE_TEMP_SUFFIX, Predicate.notInRange(2, 4));
-    }
-
-    @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
-        final String suffix = args.get(1).replace("{SPACE}", " ");
-        int priority;
-        try {
-            priority = Integer.parseInt(args.get(0));
-        } catch (NumberFormatException e) {
-            Message.META_INVALID_PRIORITY.send(sender, args.get(0));
-            return CommandResult.INVALID_ARGS;
-        }
-
-        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) {
-                    user.unsetPermission(node, server, true);
-                    Message.REMOVE_TEMP_SUFFIX_SERVER_SUCCESS.send(sender, user.getName(), suffix, priority, server);
-                    LogEntry.build().actor(sender).acted(user)
-                            .action("removetempsuffix " + priority + " " + args.get(1) + " " + server)
-                            .build().submit(plugin, sender);
-                } else {
-                    final String world = args.get(3).toLowerCase();
-                    user.unsetPermission(node, server, world, true);
-                    Message.REMOVE_TEMP_SUFFIX_SERVER_WORLD_SUCCESS.send(sender, user.getName(), suffix, priority, server, world);
-                    LogEntry.build().actor(sender).acted(user)
-                            .action("removetempsuffix " + priority + " " + args.get(1) + " " + server + " " + world)
-                            .build().submit(plugin, sender);
-                }
-
-            } else {
-                user.unsetPermission(node, true);
-                Message.REMOVE_TEMP_SUFFIX_SUCCESS.send(sender, user.getName(), suffix, priority);
-                LogEntry.build().actor(sender).acted(user)
-                        .action("removetempsuffix " + priority + " " + args.get(1))
-                        .build().submit(plugin, sender);
-            }
-
-            save(user, sender, plugin);
-            return CommandResult.SUCCESS;
-        } catch (ObjectLacksException e) {
-            Message.DOES_NOT_HAVE_SUFFIX.send(sender, user.getName());
-            return CommandResult.STATE_ERROR;
-        }
-    }
-}

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

@@ -20,21 +20,25 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms;
+package me.lucko.luckperms.common;
 
+import me.lucko.luckperms.api.Contexts;
 import me.lucko.luckperms.api.Logger;
 import me.lucko.luckperms.api.PlatformType;
-import me.lucko.luckperms.api.implementation.ApiProvider;
-import me.lucko.luckperms.commands.ConsecutiveExecutor;
-import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.constants.Message;
-import me.lucko.luckperms.core.LPConfiguration;
-import me.lucko.luckperms.core.UuidCache;
-import me.lucko.luckperms.data.Importer;
-import me.lucko.luckperms.groups.GroupManager;
-import me.lucko.luckperms.storage.Datastore;
-import me.lucko.luckperms.tracks.TrackManager;
-import me.lucko.luckperms.users.UserManager;
+import me.lucko.luckperms.common.api.ApiProvider;
+import me.lucko.luckperms.common.calculators.CalculatorFactory;
+import me.lucko.luckperms.common.commands.ConsecutiveExecutor;
+import me.lucko.luckperms.common.commands.Sender;
+import me.lucko.luckperms.common.config.LPConfiguration;
+import me.lucko.luckperms.common.constants.Message;
+import me.lucko.luckperms.common.contexts.ContextManager;
+import me.lucko.luckperms.common.core.UuidCache;
+import me.lucko.luckperms.common.data.Importer;
+import me.lucko.luckperms.common.groups.GroupManager;
+import me.lucko.luckperms.common.storage.Datastore;
+import me.lucko.luckperms.common.tracks.TrackManager;
+import me.lucko.luckperms.common.users.UserManager;
+import me.lucko.luckperms.common.utils.LocaleManager;
 
 import java.io.File;
 import java.util.List;
@@ -60,6 +64,9 @@ public interface LuckPermsPlugin {
     ApiProvider getApiProvider();
     Importer getImporter();
     ConsecutiveExecutor getConsecutiveExecutor();
+    LocaleManager getLocaleManager();
+    ContextManager getContextManager();
+    CalculatorFactory getCalculatorFactory();
 
     /**
      * @return the version of the plugin
@@ -110,11 +117,8 @@ public interface LuckPermsPlugin {
      */
     Sender getConsoleSender();
 
-    /**
-     * Gets all possible permission nodes, used for resolving wildcards
-     * @return a {@link List} of permission nodes
-     */
-    List<String> getPossiblePermissions();
+    // TODO javadoc
+    Set<Contexts> getPreProcessContexts(boolean op);
 
     /**
      * Gets a set of players ignoring logging output

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

@@ -20,23 +20,25 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.api.implementation;
+package me.lucko.luckperms.common.api;
 
 import com.google.common.eventbus.EventBus;
 import lombok.AllArgsConstructor;
 import lombok.NonNull;
-import me.lucko.luckperms.LuckPermsPlugin;
 import me.lucko.luckperms.api.*;
+import me.lucko.luckperms.api.context.ContextListener;
+import me.lucko.luckperms.api.context.IContextCalculator;
 import me.lucko.luckperms.api.event.LPEvent;
 import me.lucko.luckperms.api.event.LPListener;
-import me.lucko.luckperms.api.implementation.internal.*;
+import me.lucko.luckperms.common.LuckPermsPlugin;
+import me.lucko.luckperms.common.users.UserIdentifier;
 
 import java.util.Optional;
 import java.util.Set;
 import java.util.UUID;
 import java.util.stream.Collectors;
 
-import static me.lucko.luckperms.api.implementation.internal.Utils.checkNode;
+import static me.lucko.luckperms.common.api.internal.Utils.checkNode;
 
 /**
  * Implements the LuckPerms API using the plugin instance
@@ -67,7 +69,7 @@ public class ApiProvider implements LuckPermsApi {
 
     @Override
     public double getApiVersion() {
-        return 2.9;
+        return 2.12;
     }
 
     @Override
@@ -92,17 +94,17 @@ public class ApiProvider implements LuckPermsApi {
 
     @Override
     public LPConfiguration getConfiguration() {
-        return new LPConfigurationLink(plugin.getConfiguration());
+        return new me.lucko.luckperms.common.api.internal.LPConfigurationLink(plugin.getConfiguration());
     }
 
     @Override
     public Datastore getDatastore() {
-        return new DatastoreLink(plugin, plugin.getDatastore());
+        return new me.lucko.luckperms.common.api.internal.DatastoreLink(plugin, plugin.getDatastore());
     }
 
     @Override
     public UuidCache getUuidCache() {
-        return new UuidCacheLink(plugin.getUuidCache());
+        return new me.lucko.luckperms.common.api.internal.UuidCacheLink(plugin.getUuidCache());
     }
 
     @Override
@@ -112,12 +114,12 @@ public class ApiProvider implements LuckPermsApi {
 
     @Override
     public User getUser(@NonNull UUID uuid) {
-        final me.lucko.luckperms.users.User user = plugin.getUserManager().get(uuid);
+        final me.lucko.luckperms.common.users.User user = plugin.getUserManager().get(uuid);
         if (user == null) {
             return null;
         }
 
-        return new UserLink(user);
+        return new me.lucko.luckperms.common.api.internal.UserLink(user);
     }
 
     @Override
@@ -127,12 +129,12 @@ public class ApiProvider implements LuckPermsApi {
 
     @Override
     public User getUser(@NonNull String name) {
-        final me.lucko.luckperms.users.User user = plugin.getUserManager().get(name);
+        final me.lucko.luckperms.common.users.User user = plugin.getUserManager().get(name);
         if (user == null) {
             return null;
         }
 
-        return new UserLink(user);
+        return new me.lucko.luckperms.common.api.internal.UserLink(user);
     }
 
     @Override
@@ -142,28 +144,28 @@ public class ApiProvider implements LuckPermsApi {
 
     @Override
     public Set<User> getUsers() {
-        return plugin.getUserManager().getAll().values().stream().map(UserLink::new).collect(Collectors.toSet());
+        return plugin.getUserManager().getAll().values().stream().map(me.lucko.luckperms.common.api.internal.UserLink::new).collect(Collectors.toSet());
     }
 
     @Override
     public boolean isUserLoaded(@NonNull UUID uuid) {
-        return plugin.getUserManager().isLoaded(uuid);
+        return plugin.getUserManager().isLoaded(UserIdentifier.of(uuid, null));
     }
 
     @Override
     public void cleanupUser(@NonNull User user) {
-        Utils.checkUser(user);
-        plugin.getUserManager().cleanup(((UserLink) user).getMaster());
+        me.lucko.luckperms.common.api.internal.Utils.checkUser(user);
+        plugin.getUserManager().cleanup(((me.lucko.luckperms.common.api.internal.UserLink) user).getMaster());
     }
 
     @Override
     public Group getGroup(@NonNull String name) {
-        final me.lucko.luckperms.groups.Group group = plugin.getGroupManager().get(name);
+        final me.lucko.luckperms.common.groups.Group group = plugin.getGroupManager().get(name);
         if (group == null) {
             return null;
         }
 
-        return new GroupLink(group);
+        return new me.lucko.luckperms.common.api.internal.GroupLink(group);
     }
 
     @Override
@@ -173,7 +175,7 @@ public class ApiProvider implements LuckPermsApi {
 
     @Override
     public Set<Group> getGroups() {
-        return plugin.getGroupManager().getAll().values().stream().map(GroupLink::new).collect(Collectors.toSet());
+        return plugin.getGroupManager().getAll().values().stream().map(me.lucko.luckperms.common.api.internal.GroupLink::new).collect(Collectors.toSet());
     }
 
     @Override
@@ -183,12 +185,12 @@ public class ApiProvider implements LuckPermsApi {
 
     @Override
     public Track getTrack(@NonNull String name) {
-        final me.lucko.luckperms.tracks.Track track = plugin.getTrackManager().get(name);
+        final me.lucko.luckperms.common.tracks.Track track = plugin.getTrackManager().get(name);
         if (track == null) {
             return null;
         }
 
-        return new TrackLink(track);
+        return new me.lucko.luckperms.common.api.internal.TrackLink(track);
     }
 
     @Override
@@ -198,7 +200,7 @@ public class ApiProvider implements LuckPermsApi {
 
     @Override
     public Set<Track> getTracks() {
-        return plugin.getTrackManager().getAll().values().stream().map(TrackLink::new).collect(Collectors.toSet());
+        return plugin.getTrackManager().getAll().values().stream().map(me.lucko.luckperms.common.api.internal.TrackLink::new).collect(Collectors.toSet());
     }
 
     @Override
@@ -208,6 +210,18 @@ public class ApiProvider implements LuckPermsApi {
 
     @Override
     public Node.Builder buildNode(@NonNull String permission) throws IllegalArgumentException {
-        return new me.lucko.luckperms.utils.Node.Builder(checkNode(permission));
+        return new me.lucko.luckperms.common.core.Node.Builder(checkNode(permission));
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public void registerContextCalculator(IContextCalculator<?> contextCalculator) {
+        plugin.getContextManager().registerCalculator(contextCalculator);
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public void registerContextListener(ContextListener<?> contextListener) {
+        plugin.getContextManager().registerListener(contextListener);
     }
 }

common/src/main/java/me/lucko/luckperms/common/api/internal/DatastoreLink.java

@@ -20,15 +20,15 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.api.implementation.internal;
+package me.lucko.luckperms.common.api.internal;
 
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 import lombok.NoArgsConstructor;
 import lombok.NonNull;
-import me.lucko.luckperms.LuckPermsPlugin;
 import me.lucko.luckperms.api.*;
 import me.lucko.luckperms.api.data.Callback;
+import me.lucko.luckperms.common.LuckPermsPlugin;
 
 import java.util.Set;
 import java.util.UUID;
@@ -36,21 +36,21 @@ import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 
-import static me.lucko.luckperms.api.implementation.internal.Utils.*;
+import static me.lucko.luckperms.common.api.internal.Utils.*;
 
 /**
- * Provides a link between {@link Datastore} and {@link me.lucko.luckperms.storage.Datastore}
+ * Provides a link between {@link Datastore} and {@link me.lucko.luckperms.common.storage.Datastore}
  */
 @SuppressWarnings({"unused", "WeakerAccess"})
 public class DatastoreLink implements Datastore {
 
     private final LuckPermsPlugin plugin;
-    private final me.lucko.luckperms.storage.Datastore master;
+    private final me.lucko.luckperms.common.storage.Datastore master;
     private final Async async;
     private final Sync sync;
     private final Future future;
 
-    public DatastoreLink(@NonNull LuckPermsPlugin plugin, @NonNull me.lucko.luckperms.storage.Datastore master) {
+    public DatastoreLink(@NonNull LuckPermsPlugin plugin, @NonNull me.lucko.luckperms.common.storage.Datastore master) {
         this.plugin = plugin;
         this.master = master;
         this.async = new Async(master);
@@ -93,7 +93,7 @@ public class DatastoreLink implements Datastore {
 
     @AllArgsConstructor
     public class Async implements Datastore.Async {
-        private final me.lucko.luckperms.storage.Datastore master;
+        private final me.lucko.luckperms.common.storage.Datastore master;
 
         @Override
         public void logAction(@NonNull LogEntry entry, Callback<Boolean> callback) {
@@ -206,7 +206,7 @@ public class DatastoreLink implements Datastore {
 
     @AllArgsConstructor
     public class Sync implements Datastore.Sync {
-        private final me.lucko.luckperms.storage.Datastore master;
+        private final me.lucko.luckperms.common.storage.Datastore master;
 
         @Override
         public boolean logAction(@NonNull LogEntry entry) {
@@ -319,7 +319,7 @@ public class DatastoreLink implements Datastore {
 
     @AllArgsConstructor
     public class Future implements Datastore.Future {
-        private final me.lucko.luckperms.storage.Datastore master;
+        private final me.lucko.luckperms.common.storage.Datastore master;
 
         @Override
         public java.util.concurrent.Future<Boolean> logAction(@NonNull LogEntry entry) {

common/src/main/java/me/lucko/luckperms/common/api/internal/GroupLink.java

@@ -20,7 +20,7 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.api.implementation.internal;
+package me.lucko.luckperms.common.api.internal;
 
 import lombok.AccessLevel;
 import lombok.EqualsAndHashCode;
@@ -32,22 +32,22 @@ import me.lucko.luckperms.exceptions.ObjectLacksException;
 
 import java.util.List;
 
-import static me.lucko.luckperms.api.implementation.internal.Utils.*;
+import static me.lucko.luckperms.common.api.internal.Utils.*;
 
 /**
- * Provides a link between {@link Group} and {@link me.lucko.luckperms.groups.Group}
+ * Provides a link between {@link Group} and {@link me.lucko.luckperms.common.groups.Group}
  */
 @EqualsAndHashCode(of = {"name"}, callSuper = false)
 @SuppressWarnings("unused")
 public class GroupLink extends PermissionHolderLink implements Group {
 
     @Getter(AccessLevel.PACKAGE)
-    private final me.lucko.luckperms.groups.Group master;
+    private final me.lucko.luckperms.common.groups.Group master;
 
     @Getter
     private final String name;
 
-    public GroupLink(@NonNull me.lucko.luckperms.groups.Group master) {
+    public GroupLink(@NonNull me.lucko.luckperms.common.groups.Group master) {
         super(master);
         this.master = master;
         this.name = master.getName();

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

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

common/src/main/java/me/lucko/luckperms/common/api/internal/LogLink.java

@@ -20,7 +20,7 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.api.implementation.internal;
+package me.lucko.luckperms.common.api.internal;
 
 import lombok.AllArgsConstructor;
 import lombok.NonNull;
@@ -31,14 +31,14 @@ import java.util.SortedMap;
 import java.util.SortedSet;
 import java.util.UUID;
 
-import static me.lucko.luckperms.api.implementation.internal.Utils.checkName;
+import static me.lucko.luckperms.common.api.internal.Utils.checkName;
 
 /**
- * Provides a link between {@link Log} and {@link me.lucko.luckperms.data.Log}
+ * Provides a link between {@link Log} and {@link me.lucko.luckperms.common.data.Log}
  */
 @AllArgsConstructor
 public class LogLink implements Log {
-    private final me.lucko.luckperms.data.Log master;
+    private final me.lucko.luckperms.common.data.Log master;
     
     @Override
     public SortedSet<LogEntry> getContent() {

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

@@ -20,31 +20,28 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.api.implementation.internal;
+package me.lucko.luckperms.common.api.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.api.*;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
-import me.lucko.luckperms.utils.Contexts;
 
 import java.util.*;
 
-import static me.lucko.luckperms.api.implementation.internal.Utils.*;
-import static me.lucko.luckperms.core.PermissionHolder.exportToLegacy;
+import static me.lucko.luckperms.common.api.internal.Utils.*;
+import static me.lucko.luckperms.common.core.PermissionHolder.exportToLegacy;
 
 /**
- * Provides a link between {@link PermissionHolder} and {@link me.lucko.luckperms.core.PermissionHolder}
+ * Provides a link between {@link PermissionHolder} and {@link me.lucko.luckperms.common.core.PermissionHolder}
  */
-@SuppressWarnings({"unused", "deprecation"})
+@SuppressWarnings("unused")
 @AllArgsConstructor
 public class PermissionHolderLink implements PermissionHolder {
 
     @NonNull
-    private final me.lucko.luckperms.core.PermissionHolder master;
+    private final me.lucko.luckperms.common.core.PermissionHolder master;
 
     @Override
     public String getObjectName() {
@@ -52,23 +49,33 @@ 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
     public Set<Node> getAllNodes() {
-        return Collections.unmodifiableSet(master.getAllNodes(Collections.emptyList(), Contexts.allowAll()));
+        return Collections.unmodifiableSet(master.getAllNodes(null, Contexts.allowAll()));
+    }
+
+    @Override
+    public SortedSet<LocalizedNode> getAllNodes(@NonNull Contexts contexts) {
+        return master.getAllNodes(null, contexts);
+    }
+
+    @Override
+    public Set<LocalizedNode> getAllNodesFiltered(@NonNull Contexts contexts) {
+        return master.getAllNodesFiltered(contexts);
     }
 
     @Override
@@ -233,27 +240,50 @@ 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
     public Map<String, Boolean> getPermissions(String server, String world, Map<String, String> extraContext, boolean includeGlobal, List<String> possibleNodes, boolean applyGroups) {
-        return master.exportNodes(new Contexts(server, world, extraContext, includeGlobal, includeGlobal, applyGroups, true, true), possibleNodes);
+        if (extraContext == null) {
+            extraContext = new HashMap<>();
+        }
+        if (server != null && !server.equals("")) {
+            extraContext.put("server", server);
+        }
+        if (world != null && !world.equals("")) {
+            extraContext.put("world", world);
+        }
+        return master.exportNodes(new Contexts(extraContext, includeGlobal, includeGlobal, applyGroups, true, true), possibleNodes, false);
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/common/api/internal/TrackLink.java

@@ -20,7 +20,7 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.api.implementation.internal;
+package me.lucko.luckperms.common.api.internal;
 
 import lombok.AccessLevel;
 import lombok.EqualsAndHashCode;
@@ -33,22 +33,22 @@ import me.lucko.luckperms.exceptions.ObjectLacksException;
 
 import java.util.List;
 
-import static me.lucko.luckperms.api.implementation.internal.Utils.checkGroup;
+import static me.lucko.luckperms.common.api.internal.Utils.checkGroup;
 
 /**
- * Provides a link between {@link Track} and {@link me.lucko.luckperms.tracks.Track}
+ * Provides a link between {@link Track} and {@link me.lucko.luckperms.common.tracks.Track}
  */
 @EqualsAndHashCode(of = {"name"})
 @SuppressWarnings("unused")
 public class TrackLink implements Track {
 
     @Getter(AccessLevel.PACKAGE)
-    private final me.lucko.luckperms.tracks.Track master;
+    private final me.lucko.luckperms.common.tracks.Track master;
 
     @Getter
     private final String name;
 
-    public TrackLink(@NonNull me.lucko.luckperms.tracks.Track master) {
+    public TrackLink(@NonNull me.lucko.luckperms.common.tracks.Track master) {
         this.master = master;
         this.name = master.getName();
     }

common/src/main/java/me/lucko/luckperms/common/api/internal/UserLink.java

@@ -20,7 +20,7 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.api.implementation.internal;
+package me.lucko.luckperms.common.api.internal;
 
 import lombok.EqualsAndHashCode;
 import lombok.Getter;
@@ -33,22 +33,22 @@ import me.lucko.luckperms.exceptions.ObjectLacksException;
 import java.util.List;
 import java.util.UUID;
 
-import static me.lucko.luckperms.api.implementation.internal.Utils.*;
+import static me.lucko.luckperms.common.api.internal.Utils.*;
 
 /**
- * Provides a link between {@link User} and {@link me.lucko.luckperms.users.User}
+ * Provides a link between {@link User} and {@link me.lucko.luckperms.common.users.User}
  */
 @EqualsAndHashCode(of = {"uuid"}, callSuper = false)
 @SuppressWarnings("unused")
 public class UserLink extends PermissionHolderLink implements User {
 
     @Getter
-    private final me.lucko.luckperms.users.User master;
+    private final me.lucko.luckperms.common.users.User master;
 
     @Getter
     private final UUID uuid;
 
-    public UserLink(@NonNull me.lucko.luckperms.users.User master) {
+    public UserLink(@NonNull me.lucko.luckperms.common.users.User master) {
         super(master);
         this.master = master;
         this.uuid = master.getUuid();

common/src/main/java/me/lucko/luckperms/common/api/internal/Utils.java

@@ -20,13 +20,13 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.api.implementation.internal;
+package me.lucko.luckperms.common.api.internal;
 
 import lombok.experimental.UtilityClass;
 import me.lucko.luckperms.api.Group;
 import me.lucko.luckperms.api.Track;
 import me.lucko.luckperms.api.User;
-import me.lucko.luckperms.utils.ArgumentChecker;
+import me.lucko.luckperms.common.utils.ArgumentChecker;
 
 @UtilityClass
 public class Utils {

common/src/main/java/me/lucko/luckperms/common/api/internal/UuidCacheLink.java

@@ -20,7 +20,7 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.api.implementation.internal;
+package me.lucko.luckperms.common.api.internal;
 
 import lombok.AllArgsConstructor;
 import me.lucko.luckperms.api.UuidCache;
@@ -28,11 +28,11 @@ import me.lucko.luckperms.api.UuidCache;
 import java.util.UUID;
 
 /**
- * Provides a link between {@link UuidCache} and {@link me.lucko.luckperms.core.UuidCache}
+ * Provides a link between {@link UuidCache} and {@link me.lucko.luckperms.common.core.UuidCache}
  */
 @AllArgsConstructor
 public class UuidCacheLink implements UuidCache {
-    private final me.lucko.luckperms.core.UuidCache master;
+    private final me.lucko.luckperms.common.core.UuidCache master;
 
     @Override
     public UUID getUUID(UUID external) {

common/src/main/java/me/lucko/luckperms/common/caching/MetaData.java

@@ -0,0 +1,116 @@
+/*
+ * 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.common.caching;
+
+import com.google.common.collect.ImmutableMap;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import me.lucko.luckperms.api.Contexts;
+import me.lucko.luckperms.api.LocalizedNode;
+import me.lucko.luckperms.api.Node;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.SortedSet;
+import java.util.concurrent.ConcurrentHashMap;
+
+@RequiredArgsConstructor
+public class MetaData {
+    private final Contexts contexts;
+
+    @Getter
+    private String prefix = null;
+
+    @Getter
+    private String suffix = null;
+    private Map<String, String> meta = new ConcurrentHashMap<>();
+
+    public void loadMeta(SortedSet<LocalizedNode> nodes) {
+        invalidateCache();
+
+        Map<String, String> contexts = new HashMap<>(this.contexts.getContext());
+        String server = contexts.remove("server");
+        String world = contexts.remove("world");
+
+        int prefixPriority = Integer.MIN_VALUE;
+        int suffixPriority = Integer.MIN_VALUE;
+
+        for (LocalizedNode ln : nodes) {
+            Node n = ln.getNode();
+
+            if (!n.getValue()) {
+                continue;
+            }
+
+            if (!n.isMeta() || !n.isPrefix() || n.isSuffix()) {
+                continue;
+            }
+
+            if (!n.shouldApplyOnServer(server, this.contexts.isIncludeGlobal(), false)) {
+                continue;
+            }
+
+            if (!n.shouldApplyOnWorld(world, this.contexts.isIncludeGlobalWorld(), false)) {
+                continue;
+            }
+
+            if (!n.shouldApplyWithContext(contexts, false)) {
+                continue;
+            }
+
+            if (n.isPrefix()) {
+                Map.Entry<Integer, String> value = n.getPrefix();
+                if (value.getKey() > prefixPriority) {
+                    this.prefix = value.getValue();
+                    prefixPriority = value.getKey();
+                }
+                continue;
+            }
+
+            if (n.isSuffix()) {
+                Map.Entry<Integer, String> value = n.getSuffix();
+                if (value.getKey() > suffixPriority) {
+                    this.suffix = value.getValue();
+                    suffixPriority = value.getKey();
+                }
+                continue;
+            }
+
+            if (n.isMeta()) {
+                Map.Entry<String, String> meta = n.getMeta();
+                this.meta.put(meta.getKey(), meta.getValue());
+            }
+        }
+    }
+
+    public void invalidateCache() {
+        meta.clear();
+        prefix = null;
+        suffix = null;
+    }
+
+    public Map<String, String> getMeta() {
+        return ImmutableMap.copyOf(meta);
+    }
+
+}

common/src/main/java/me/lucko/luckperms/common/caching/PermissionData.java

@@ -0,0 +1,89 @@
+/*
+ * 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.common.caching;
+
+import com.google.common.collect.ImmutableMap;
+import lombok.NonNull;
+import me.lucko.luckperms.api.Contexts;
+import me.lucko.luckperms.api.Tristate;
+import me.lucko.luckperms.common.calculators.CalculatorFactory;
+import me.lucko.luckperms.common.calculators.PermissionCalculator;
+import me.lucko.luckperms.common.users.User;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class PermissionData {
+    private final Contexts contexts;
+    private final Map<String, Boolean> permissions;
+
+    private final PermissionCalculator calculator;
+
+    public PermissionData(Contexts contexts, User user, CalculatorFactory calculatorFactory) {
+        this.contexts = contexts;
+        permissions = new ConcurrentHashMap<>();
+        calculator = calculatorFactory.build(contexts, user, permissions);
+    }
+
+    public void invalidateCache() {
+        calculator.invalidateCache();
+    }
+
+    public void setPermissions(Map<String, Boolean> permissions) {
+        this.permissions.clear();
+        this.permissions.putAll(permissions);
+        invalidateCache();
+    }
+
+    public void comparePermissions(Map<String, Boolean> toApply) {
+        boolean different = false;
+        if (toApply.size() != permissions.size()) {
+            different = true;
+        } else {
+            for (Map.Entry<String, Boolean> e : permissions.entrySet()) {
+                if (toApply.containsKey(e.getKey()) && toApply.get(e.getKey()) == e.getValue()) {
+                    continue;
+                }
+                different = true;
+                break;
+            }
+        }
+
+        if (different) {
+            setPermissions(toApply);
+        }
+    }
+
+    public Map<String, Boolean> getImmutableBacking() {
+        return ImmutableMap.copyOf(permissions);
+    }
+
+    public Tristate getPermissionValue(@NonNull String permission) {
+        Tristate t = calculator.getPermissionValue(permission);
+        if (t != Tristate.UNDEFINED) {
+            return Tristate.fromBoolean(t.asBoolean());
+        } else {
+            return Tristate.UNDEFINED;
+        }
+    }
+}

common/src/main/java/me/lucko/luckperms/common/caching/UserData.java

@@ -0,0 +1,107 @@
+/*
+ * 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.common.caching;
+
+import lombok.RequiredArgsConstructor;
+import me.lucko.luckperms.api.Contexts;
+import me.lucko.luckperms.common.calculators.CalculatorFactory;
+import me.lucko.luckperms.common.users.User;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+@RequiredArgsConstructor
+public class UserData {
+    private final User user;
+    private final CalculatorFactory calculatorFactory;
+
+    private final Map<Contexts, PermissionData> permission = new ConcurrentHashMap<>();
+    private final Map<Contexts, MetaData> meta = new ConcurrentHashMap<>();
+
+    public PermissionData getPermissionData(Contexts contexts) {
+        return permission.computeIfAbsent(contexts, this::calculatePermissions);
+    }
+
+    public MetaData getMetaData(Contexts contexts) {
+        return meta.computeIfAbsent(contexts, this::calculateMeta);
+    }
+
+    public PermissionData calculatePermissions(Contexts contexts) {
+        PermissionData data = new PermissionData(contexts, user, calculatorFactory);
+        data.setPermissions(user.exportNodes(contexts, Collections.emptyList(), true));
+        return data;
+    }
+
+    public void recalculatePermissions(Contexts contexts) {
+        permission.compute(contexts, (c, data) -> {
+            if (data == null) {
+                data = new PermissionData(c, user, calculatorFactory);
+            }
+
+            data.comparePermissions(user.exportNodes(c, Collections.emptyList(), true));
+            return data;
+        });
+    }
+
+    public void recalculatePermissions() {
+        permission.keySet().forEach(this::recalculatePermissions);
+    }
+
+    public MetaData calculateMeta(Contexts contexts) {
+        MetaData data = new MetaData(contexts);
+        data.loadMeta(user.getAllNodes(null, contexts));
+        return data;
+    }
+
+    public void recalculateMeta(Contexts contexts) {
+        meta.compute(contexts, (c, data) -> {
+            if (data == null) {
+                data = new MetaData(c);
+            }
+
+            data.loadMeta(user.getAllNodes(null, c));
+            return data;
+        });
+    }
+
+    public void recalculateMeta() {
+        meta.keySet().forEach(this::recalculateMeta);
+    }
+
+    public void preCalculate(Set<Contexts> contexts) {
+        contexts.forEach(this::preCalculate);
+    }
+
+    public void preCalculate(Contexts contexts) {
+        getPermissionData(contexts);
+        getMetaData(contexts);
+    }
+
+    public void invalidateCache() {
+        permission.clear();
+        meta.clear();
+    }
+
+}

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

@@ -20,24 +20,18 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms;
+package me.lucko.luckperms.common.calculators;
 
-import me.lucko.luckperms.internal.StandaloneBase;
+import me.lucko.luckperms.api.Contexts;
+import me.lucko.luckperms.common.users.User;
 
-public class LPStandaloneApp {
-    private StandaloneBase standaloneBase;
+import java.util.Map;
 
-    public static void main(String[] args) {
-        new LPStandaloneApp().start();
-    }
+/**
+ * Creates a calculator instance given a set of contexts
+ */
+public interface CalculatorFactory {
 
-    public void start() {
-        standaloneBase = new StandaloneBase(this);
-        LuckPerms.registerProvider(standaloneBase.getApiProvider());
-    }
-
-    public void stop() {
-        standaloneBase.shutdown();
-    }
+    PermissionCalculator build(Contexts contexts, User user, Map<String, Boolean> map);
 
 }

common/src/main/java/me/lucko/luckperms/common/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.common.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/common/calculators/PermissionCalculator.java

@@ -20,42 +20,52 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms;
+package me.lucko.luckperms.common.calculators;
 
-import lombok.Getter;
-import me.lucko.luckperms.utils.PermissionCalculator;
-import me.lucko.luckperms.utils.PermissionProcessor;
+import lombok.RequiredArgsConstructor;
+import me.lucko.luckperms.api.Tristate;
+import me.lucko.luckperms.common.LuckPermsPlugin;
 
-import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
-public class BungeePlayerCache {
-
-    private final PermissionCalculator calculator;
-
-    @Getter
-    private final Map<String, Boolean> permissions = new ConcurrentHashMap<>();
-
-    public BungeePlayerCache(LuckPermsPlugin plugin, String name) {
-        List<PermissionProcessor> processors = new ArrayList<>(3);
-        processors.add(new PermissionCalculator.MapProcessor(permissions));
-        if (plugin.getConfiguration().getApplyWildcards()) {
-            processors.add(new PermissionCalculator.WildcardProcessor(permissions));
-        }
-        if (plugin.getConfiguration().getApplyRegex()) {
-            processors.add(new PermissionCalculator.RegexProcessor(permissions));
-        }
-
-        calculator = new PermissionCalculator(plugin, name, plugin.getConfiguration().getDebugPermissionChecks(), processors);
-    }
+/**
+ * Calculates and caches permissions
+ */
+@RequiredArgsConstructor
+public class PermissionCalculator {
+    private final LuckPermsPlugin plugin;
+    private final String objectName;
+    private final boolean debug;
+    private final List<PermissionProcessor> processors;
+    private final Map<String, Tristate> cache = new ConcurrentHashMap<>();
 
     public void invalidateCache() {
-        calculator.invalidateCache();
+        cache.clear();
     }
 
-    public boolean getPermissionValue(String permission) {
-        return calculator.getPermissionValue(permission).asBoolean();
+    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 + " - (" + t.toString() + ")");
+        }
+
+        return t;
+    }
+
+    private Tristate lookupPermissionValue(String permission) {
+        for (PermissionProcessor processor : processors) {
+            Tristate v = processor.hasPermission(permission);
+            if (v == Tristate.UNDEFINED) {
+                continue;
+            }
+
+            return v;
+        }
+
+        return Tristate.UNDEFINED;
     }
 }

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

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

common/src/main/java/me/lucko/luckperms/common/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.common.calculators;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import me.lucko.luckperms.api.Tristate;
+import me.lucko.luckperms.common.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/common/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.common.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/common/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.common.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/common/commands/CommandManager.java

@@ -20,26 +20,26 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.commands;
+package me.lucko.luckperms.common.commands;
 
 import com.google.common.collect.ImmutableList;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
-import me.lucko.luckperms.LuckPermsPlugin;
 import me.lucko.luckperms.api.data.Callback;
-import me.lucko.luckperms.commands.group.CreateGroup;
-import me.lucko.luckperms.commands.group.DeleteGroup;
-import me.lucko.luckperms.commands.group.GroupMainCommand;
-import me.lucko.luckperms.commands.group.ListGroups;
-import me.lucko.luckperms.commands.log.LogMainCommand;
-import me.lucko.luckperms.commands.migration.MigrationMainCommand;
-import me.lucko.luckperms.commands.misc.*;
-import me.lucko.luckperms.commands.track.CreateTrack;
-import me.lucko.luckperms.commands.track.DeleteTrack;
-import me.lucko.luckperms.commands.track.ListTracks;
-import me.lucko.luckperms.commands.track.TrackMainCommand;
-import me.lucko.luckperms.commands.user.UserMainCommand;
-import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.common.LuckPermsPlugin;
+import me.lucko.luckperms.common.commands.group.CreateGroup;
+import me.lucko.luckperms.common.commands.group.DeleteGroup;
+import me.lucko.luckperms.common.commands.group.GroupMainCommand;
+import me.lucko.luckperms.common.commands.group.ListGroups;
+import me.lucko.luckperms.common.commands.log.LogMainCommand;
+import me.lucko.luckperms.common.commands.migration.MigrationMainCommand;
+import me.lucko.luckperms.common.commands.misc.*;
+import me.lucko.luckperms.common.commands.track.CreateTrack;
+import me.lucko.luckperms.common.commands.track.DeleteTrack;
+import me.lucko.luckperms.common.commands.track.ListTracks;
+import me.lucko.luckperms.common.commands.track.TrackMainCommand;
+import me.lucko.luckperms.common.commands.user.UserMainCommand;
+import me.lucko.luckperms.common.commands.usersbulkedit.UsersBulkEditMainCommand;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -49,6 +49,7 @@ import java.util.stream.Collectors;
 
 @AllArgsConstructor
 public class CommandManager {
+    @Getter
     private final LuckPermsPlugin plugin;
 
     @Getter
@@ -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,10 +179,9 @@ public class CommandManager {
     }
 
     private void sendCommandUsage(Sender sender, String label) {
-        Message.INFO_BRIEF.send(sender, plugin.getVersion());
-
+        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/common/commands/CommandResult.java

@@ -20,7 +20,7 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.commands;
+package me.lucko.luckperms.common.commands;
 
 import lombok.AllArgsConstructor;
 

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

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

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

@@ -20,13 +20,13 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.commands;
+package me.lucko.luckperms.common.commands;
 
 import com.google.common.collect.ImmutableList;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
-import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.common.LuckPermsPlugin;
+import me.lucko.luckperms.common.constants.Message;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -98,7 +98,7 @@ public abstract class MainCommand<T> {
         }
 
         if (sub.getIsArgumentInvalid().test(strippedArgs.size())) {
-            sub.sendUsage(sender, label);
+            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,10 +146,10 @@ public abstract class MainCommand<T> {
                 .collect(Collectors.toList());
 
         if (subs.size() > 0) {
-            Util.sendPluginMessage(sender, "&e" + getName() + " Sub Commands:");
+            Util.sendPluginMessage(sender, "&b" + getName() + " Sub Commands: &7(" + String.format(getUsage(), label) + " ...)");
 
             for (SubCommand s : subs) {
-                s.sendUsage(sender, label);
+                s.sendUsage(sender);
             }
 
         } else {

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

@@ -20,7 +20,7 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.commands;
+package me.lucko.luckperms.common.commands;
 
 import lombok.experimental.UtilityClass;
 

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

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

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

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

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

@@ -20,10 +20,10 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.commands;
+package me.lucko.luckperms.common.commands;
 
-import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.common.LuckPermsPlugin;
+import me.lucko.luckperms.common.constants.Permission;
 
 import java.util.Collections;
 import java.util.List;

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

@@ -20,16 +20,17 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.commands;
+package me.lucko.luckperms.common.commands;
 
+import com.google.common.collect.ImmutableList;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
-import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.constants.Message;
-import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.groups.Group;
-import me.lucko.luckperms.tracks.Track;
-import me.lucko.luckperms.users.User;
+import me.lucko.luckperms.common.LuckPermsPlugin;
+import me.lucko.luckperms.common.constants.Message;
+import me.lucko.luckperms.common.constants.Permission;
+import me.lucko.luckperms.common.groups.Group;
+import me.lucko.luckperms.common.tracks.Track;
+import me.lucko.luckperms.common.users.User;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -55,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
      */
@@ -70,6 +66,8 @@ public abstract class SubCommand<T> {
      */
     private final Predicate<? super Integer> isArgumentInvalid;
 
+    private final ImmutableList<Arg> args;
+
     /**
      * Called when this sub command is ran
      * @param plugin a link to the main plugin instance
@@ -95,10 +93,28 @@ public abstract class SubCommand<T> {
     /**
      * Send the command usage to a sender
      * @param sender the sender to send the usage to
-     * @param label the command label used
      */
-    public void sendUsage(Sender sender, String label) {
-        Util.sendPluginMessage(sender, "&e-> &d" + String.format(getUsage(), label));
+    public void sendUsage(Sender sender) {
+        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/common/commands/Util.java

@@ -20,13 +20,15 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.commands;
+package me.lucko.luckperms.common.commands;
 
 import lombok.experimental.UtilityClass;
+import me.lucko.luckperms.api.LocalizedNode;
 import me.lucko.luckperms.api.Node;
-import me.lucko.luckperms.constants.Message;
-import me.lucko.luckperms.constants.Patterns;
-import me.lucko.luckperms.utils.DateUtil;
+import me.lucko.luckperms.api.Tristate;
+import me.lucko.luckperms.common.constants.Message;
+import me.lucko.luckperms.common.constants.Patterns;
+import me.lucko.luckperms.common.utils.DateUtil;
 
 import java.util.*;
 
@@ -34,7 +36,11 @@ import java.util.*;
 public class Util {
 
     public static void sendPluginMessage(Sender sender, String message) {
-        sender.sendMessage(color(Message.PREFIX + message));
+        String prefix = sender.getPlatform().getLocaleManager().getTranslation(Message.PREFIX);
+        if (prefix == null) {
+            prefix = Message.PREFIX.getMessage();
+        }
+        sender.sendMessage(color(prefix + message));
     }
 
     public static List<String> stripQuotes(List<String> input) {
@@ -79,27 +85,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 +128,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 +142,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 +165,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 +179,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,7 +192,65 @@ public class Util {
         }
 
         if (sb.length() == 0) {
-            return "&6None";
+            return "&3None";
+        }
+
+        return sb.toString();
+    }
+
+    public static String permGroupsToString(SortedSet<LocalizedNode> nodes) {
+        StringBuilder sb = new StringBuilder();
+        for (Node node : nodes) {
+            if (!node.isGroupNode()) {
+                continue;
+            }
+
+            if (node.isTemporary()) {
+                continue;
+            }
+
+            sb.append("&3> &f").append(node.getGroupName());
+            if (node.isServerSpecific()) {
+                sb.append(" &7(&f").append(node.getServer().get()).append("&7)");
+            }
+            if (node.isWorldSpecific()) {
+                sb.append(" &7(&f").append(node.getWorld().get()).append("&7)");
+            }
+            sb.append("\n");
+        }
+
+        if (sb.length() == 0) {
+            return "&3None";
+        }
+
+        return sb.toString();
+    }
+
+    public static String tempGroupsToString(SortedSet<LocalizedNode> nodes) {
+        StringBuilder sb = new StringBuilder();
+
+        for (Node node : nodes) {
+            if (!node.isGroupNode()) {
+                continue;
+            }
+
+            if (!node.isTemporary()) {
+                continue;
+            }
+
+            sb.append("&3> &f").append(node.getGroupName());
+            if (node.isServerSpecific()) {
+                sb.append(" &7(&f").append(node.getServer().get()).append("&7)");
+            }
+            if (node.isWorldSpecific()) {
+                sb.append(" &7(&f").append(node.getWorld().get()).append("&7)");
+            }
+
+            sb.append("&6 - expires in ").append(DateUtil.formatDateDiff(node.getExpiryUnixTime())).append("\n");
+        }
+
+        if (sb.length() == 0) {
+            return "&3None";
         }
 
         return sb.toString();

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

@@ -20,16 +20,16 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.commands.group;
+package me.lucko.luckperms.common.commands.group;
 
-import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.CommandResult;
-import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SingleMainCommand;
-import me.lucko.luckperms.constants.Message;
-import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.data.LogEntry;
-import me.lucko.luckperms.utils.ArgumentChecker;
+import me.lucko.luckperms.common.LuckPermsPlugin;
+import me.lucko.luckperms.common.commands.CommandResult;
+import me.lucko.luckperms.common.commands.Sender;
+import me.lucko.luckperms.common.commands.SingleMainCommand;
+import me.lucko.luckperms.common.constants.Message;
+import me.lucko.luckperms.common.constants.Permission;
+import me.lucko.luckperms.common.data.LogEntry;
+import me.lucko.luckperms.common.utils.ArgumentChecker;
 
 import java.util.List;
 

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

@@ -20,16 +20,16 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.commands.group;
+package me.lucko.luckperms.common.commands.group;
 
-import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.CommandResult;
-import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SingleMainCommand;
-import me.lucko.luckperms.constants.Message;
-import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.data.LogEntry;
-import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.common.LuckPermsPlugin;
+import me.lucko.luckperms.common.commands.CommandResult;
+import me.lucko.luckperms.common.commands.Sender;
+import me.lucko.luckperms.common.commands.SingleMainCommand;
+import me.lucko.luckperms.common.constants.Message;
+import me.lucko.luckperms.common.constants.Permission;
+import me.lucko.luckperms.common.data.LogEntry;
+import me.lucko.luckperms.common.groups.Group;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -71,7 +71,7 @@ public class DeleteGroup extends SingleMainCommand {
             return CommandResult.FAILURE;
         }
 
-        Message.DELETE_SUCCESS.send(sender, groupName);
+        Message.DELETE_SUCCESS.send(sender, group.getDisplayName());
         LogEntry.build().actor(sender).actedName(groupName).type('G').action("delete").build().submit(plugin, sender);
         plugin.runUpdateTask();
         return CommandResult.SUCCESS;

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

@@ -20,16 +20,17 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.commands.group;
+package me.lucko.luckperms.common.commands.group;
 
 import com.google.common.collect.ImmutableList;
-import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.MainCommand;
-import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
-import me.lucko.luckperms.commands.group.subcommands.*;
-import me.lucko.luckperms.constants.Message;
-import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.common.LuckPermsPlugin;
+import me.lucko.luckperms.common.commands.MainCommand;
+import me.lucko.luckperms.common.commands.Sender;
+import me.lucko.luckperms.common.commands.SubCommand;
+import me.lucko.luckperms.common.commands.group.subcommands.*;
+import me.lucko.luckperms.common.commands.meta.MetaCommands;
+import me.lucko.luckperms.common.constants.Message;
+import me.lucko.luckperms.common.groups.Group;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -39,6 +40,7 @@ public class GroupMainCommand extends MainCommand<Group> {
         super("Group", "/%s group <group>", 2, ImmutableList.<SubCommand<Group>>builder()
             .add(new GroupInfo())
             .add(new GroupListNodes())
+            .add(new GroupListParents())
             .add(new GroupHasPerm())
             .add(new GroupInheritsPerm())
             .add(new GroupSetPermission())
@@ -50,17 +52,11 @@ public class GroupMainCommand extends MainCommand<Group> {
             .add(new GroupSetTempInherit())
             .add(new GroupUnsetTempInherit())
             .add(new GroupShowTracks())
-            .add(new GroupChatMeta())
-            .add(new GroupAddPrefix())
-            .add(new GroupAddSuffix())
-            .add(new GroupRemovePrefix())
-            .add(new GroupRemoveSuffix())
-            .add(new GroupAddTempPrefix())
-            .add(new GroupAddTempSuffix())
-            .add(new GroupRemoveTempPrefix())
-            .add(new GroupRemoveTempSuffix())
+            .add(new MetaCommands<>(false))
+            .add(new GroupBulkChange())
             .add(new GroupClear())
             .add(new GroupRename())
+            .add(new GroupClone())
             .build()
         );
     }

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

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

common/src/main/java/me/lucko/luckperms/common/commands/group/subcommands/GroupBulkChange.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.common.commands.group.subcommands;
+
+import me.lucko.luckperms.api.Node;
+import me.lucko.luckperms.common.LuckPermsPlugin;
+import me.lucko.luckperms.common.commands.*;
+import me.lucko.luckperms.common.constants.Message;
+import me.lucko.luckperms.common.constants.Permission;
+import me.lucko.luckperms.common.groups.Group;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+
+public class GroupBulkChange extends SubCommand<Group> {
+    public GroupBulkChange() {
+        super("bulkchange", "Applies a bulk permission change to the 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
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+        String type = args.get(0).toLowerCase();
+        String from = args.get(1);
+        String to = args.get(2);
+        if (to.equals("null")) {
+            to = null;
+        }
+
+        Set<Node> toAdd = new HashSet<>();
+        Set<Node> toRemove = new HashSet<>();
+
+        if (!type.equals("world") && !type.equals("server")) {
+            Message.BULK_CHANGE_TYPE_ERROR.send(sender);
+            return CommandResult.FAILURE;
+        }
+
+        Iterator<Node> iterator = group.getNodes().iterator();
+        if (type.equals("world")) {
+            while (iterator.hasNext()) {
+                Node element = iterator.next();
+                String world = element.getWorld().orElse("null");
+                if (!world.equals(from)) {
+                    continue;
+                }
+
+                toRemove.add(element);
+                toAdd.add(me.lucko.luckperms.common.core.Node.builderFromExisting(element).setWorld(to).build());
+            }
+        } else {
+            while (iterator.hasNext()) {
+                Node element = iterator.next();
+                String server = element.getServer().orElse("global");
+                if (!server.equals(from)) {
+                    continue;
+                }
+
+                toRemove.add(element);
+                toAdd.add(me.lucko.luckperms.common.core.Node.builderFromExisting(element).setServer(to).build());
+            }
+        }
+
+        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;
+    }
+}