Changes for & release of API 2.14

add methods for older sponge api versions
Fix PM migration
2016-11-12 14:10:42 +00:00 · 2016-11-11 22:54:09 +00:00 · 2016-11-11 20:43:05 +00:00 · 2016-11-11 20:35:11 +00:00 · 2016-11-11 20:31:42 +00:00 · 2016-11-11 19:32:25 +00:00
357 changed files with 25413 additions and 14750 deletions
@@ -1,31 +1,27 @@
-# built application files
-*.jar
+# Created by https://www.gitignore.io/

-# Java class files
-*.class
+### Intellij ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and Webstorm
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839

-# Local configuration file (sdk path, etc)
-logs/
-
-# Eclipse project files
-.classpath
-.project
-
-# Intellij project files
-*.iml
-*.ipr
-*.iws
+# User-specific stuff:
 .idea/
+*.iws
+/out/
+*.iml
+.idea_modules/

-# Gradle
-.gradletasknamecache
-.gradle/
-build/
-bin/
-gradle/
-gradlew*
+# JIRA plugin
+atlassian-ide-plugin.xml

-# Maven
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+
+### Maven ###
 target/
 pom.xml.tag
 pom.xml.releaseBackup
@@ -34,4 +30,135 @@ pom.xml.next
 release.properties
 dependency-reduced-pom.xml
 buildNumber.properties
-.mvn/timing.properties
+.mvn/timing.properties
+
+
+### Eclipse ###
+
+.metadata
+bin/
+tmp/
+*.tmp
+*.bak
+*.swp
+*~.nib
+local.properties
+.settings/
+.loadpath
+.recommenders
+
+# Eclipse Core
+.project
+
+# External tool builders
+.externalToolBuilders/
+
+# Locally stored "Eclipse launch configurations"
+*.launch
+
+# PyDev specific (Python IDE for Eclipse)
+*.pydevproject
+
+# CDT-specific (C/C++ Development Tooling)
+.cproject
+
+# JDT-specific (Eclipse Java Development Tools)
+.classpath
+
+# Java annotation processor (APT)
+.factorypath
+
+# PDT-specific (PHP Development Tools)
+.buildpath
+
+# sbteclipse plugin
+.target
+
+# Tern plugin
+.tern-project
+
+# TeXlipse plugin
+.texlipse
+
+# STS (Spring Tool Suite)
+.springBeans
+
+# Code Recommenders
+.recommenders/
+
+
+### Linux ###
+*~
+
+# temporary files which can be created if a process still has a handle open of a deleted file
+.fuse_hidden*
+
+# KDE directory preferences
+.directory
+
+# Linux trash folder which might appear on any partition or disk
+.Trash-*
+
+# .nfs files are created when an open file is removed but is still being accessed
+.nfs*
+
+
+### macOS ###
+*.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+# Thumbnails
+._*
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+
+### Windows ###
+# Windows image file caches
+Thumbs.db
+ehthumbs.db
+
+# Folder config file
+Desktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+
+
+### Java ###
+*.class
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.ear
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
@@ -1,5 +1,6 @@
+![alt text](https://i.imgur.com/7TwJZ5e.png "Banner")
 # LuckPerms [![Build Status](https://ci.lucko.me/job/LuckPerms/badge/icon)](https://ci.lucko.me/job/LuckPerms/)
-A permissions implementation for Bukkit/Spigot, BungeeCord and Sponge.
+An advanced permissions implementation for Bukkit/Spigot, BungeeCord and Sponge.

 ## Links
 * **Development Builds** - <https://ci.lucko.me/job/LuckPerms>
@@ -9,9 +10,20 @@ A permissions implementation for Bukkit/Spigot, BungeeCord and Sponge.
 ## Description
 LuckPerms is an advanced permissions implementation aiming to be a flexible, performant and reliable alternative to other permission systems, providing all the features you could ever possibly need in a permissions plugin, along with an extensive and well documented API for developers.

+* [Spigot Plugin Page](https://www.spigotmc.org/resources/luckperms-an-advanced-permissions-system.28140/ "Spigot Plugin Page")
+* [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").
@@ -5,7 +5,7 @@
    <parent>
        <artifactId>luckperms</artifactId>
        <groupId>me.lucko.luckperms</groupId>
-        <version>2.8-SNAPSHOT</version>
+        <version>2.14-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

@@ -0,0 +1,248 @@
+/*
+ * 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 me.lucko.luckperms.api.context.ContextSet;
+
+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(ContextSet.empty(), true, true, true, true, true, true);
+    }
+
+    public static Contexts of(ContextSet 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(ContextSet context, boolean includeGlobal, boolean includeGlobalWorld, boolean applyGroups, boolean applyGlobalGroups, boolean applyGlobalWorldGroups, boolean op) {
+        if (context == null) {
+            throw new NullPointerException("context");
+        }
+
+        this.context = context.makeImmutable();
+        this.includeGlobal = includeGlobal;
+        this.includeGlobalWorld = includeGlobalWorld;
+        this.applyGroups = applyGroups;
+        this.applyGlobalGroups = applyGlobalGroups;
+        this.applyGlobalWorldGroups = applyGlobalWorldGroups;
+        this.op = op;
+    }
+
+    @SuppressWarnings("deprecation")
+    @Deprecated
+    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);
+    }
+
+    @SuppressWarnings("deprecation")
+    @Deprecated
+    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);
+    }
+
+    @Deprecated
+    public Contexts(Map<String, String> context, boolean includeGlobal, boolean includeGlobalWorld, boolean applyGroups, boolean applyGlobalGroups, boolean applyGlobalWorldGroups, boolean op) {
+        this(context == null ? null : ContextSet.fromMap(context), includeGlobal, includeGlobalWorld, applyGroups, applyGlobalGroups, applyGlobalWorldGroups, op);
+    }
+
+    @SuppressWarnings("deprecation")
+    @Deprecated
+    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 ContextSet 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 set of context key value pairs
+     * @since 2.13
+     */
+    public ContextSet getContexts() {
+        return this.context;
+    }
+
+    /**
+     * Gets the contexts that apply for this lookup
+     * @return an immutable map of context key value pairs
+     * @deprecated in favour of {@link #getContexts()}
+     */
+    @Deprecated
+    public Map<String, String> getContext() {
+        return this.context.toMap();
+    }
+
+    /**
+     * 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.getContexts() + ", " +
+                "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.getContexts();
+        final Object other$context = other.getContexts();
+        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.getContexts();
+        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;
+    }
+
+}
@@ -29,226 +29,50 @@ import java.util.UUID;

 /**
 * Interface for the internal Datastore instance
+ * @deprecated as of version 2.14 in favour of {@link Storage}.
 */
-@SuppressWarnings("unused")
+@Deprecated
 public interface Datastore {

    String getName();
    boolean isAcceptingLogins();

-    /**
-     * Gets the {@link Sync} interface.
-     *
-     * All operations through this interface are called immediately and in the same thread as they are called.
-     * Datastore operations are thread blocking, and Sync operations should not be called on the main server thread.
-     * @return the sync interface
-     */
+    @Deprecated
    Sync sync();

-    /**
-     * Gets the {@link Async} interface.
-     * 
-     * All operations through this interface are called in a new, separate asynchronous thread.
-     * When the operation is complete, the provided callback method is called, in applicable, in the main server thread.
-     * @return the async interface
-     */
+    @Deprecated
    Async async();

-    /**
-     * Gets the {@link Future} interface.
-     * 
-     * All operations through this interface are called in a new, separate asynchronous thread, similar to {@link Async}.
-     * The only difference is that instead of providing a callback, a {@link java.util.concurrent.Future} is returned.
-     * See the Oracle JavaDocs for usage of the Future class.
-     * @return the future interface
-     */
+    @Deprecated
    Future future();

-    /**
-     * All operations through this interface are called immediately and in the same thread as they are called.
-     * Datastore operations are thread blocking, and Sync operations should not be called on the main server thread.
-     */
+    @Deprecated
    interface Sync {
-
-        /**
-         * Saves an action to the datastore
-         * @param entry the log entry to be saved
-         * @return true if the operation completed successfully.
-         * @throws NullPointerException if entry is null
-         */
        boolean logAction(LogEntry entry);
-
-        /**
-         * Loads and returns the log from the datastore
-         * @return a log instance, could be null
-         */
        Log getLog();
-
-        /**
-         * Either loads or creates a user object, and loads it into the plugins internal storage
-         * @param uuid the uuid of the user
-         * @param username the users username. (if you want to specify <code>null</code> here, just input "null" as a string.)
-         * @return true if the operation completed successfully.
-         * @throws NullPointerException if uuid or username is null
-         * @throws IllegalArgumentException if either of the parameters are invalid
-         * @deprecated functionality of this method is taken on by {@link #loadUser(UUID, String)}
-         */
        @Deprecated
        boolean loadOrCreateUser(UUID uuid, String username);
-
-        /**
-         * Loads a user from the datastore into the plugins internal storage.
-         * @param uuid the uuid of the user to load
-         * @return true if the user exists, and was loaded correctly.
-         * @throws NullPointerException if uuid is null
-         * @deprecated replaced by {@link #loadUser(UUID, String)}
-         */
        @Deprecated
        boolean loadUser(UUID uuid);
-
-        /**
-         * Loads a user's data into the plugins internal storage.
-         * @param uuid the uuid of the user to load
-         * @param username the users username. (if you want to specify <code>null</code> here, just input "null" as a string.)
-         * @return if the operation was performed successfully
-         * @throws NullPointerException if uuid or username is null
-         * @since 2.6
-         */
        boolean loadUser(UUID uuid, String username);
-
-        /**
-         * Saves a user object into the datastore. You should call this after you make any changes to a user.
-         * @param user the user to save
-         * @return true if the operation completed successfully.
-         * @throws NullPointerException if user is null
-         * @throws IllegalStateException if the user instance was not obtained from LuckPerms.
-         */
        boolean saveUser(User user);
-
-        /**
-         * Removes users from the datastore who are "default". This is called every time the plugin loads.
-         * @return true if the operation completed successfully
-         * @since 2.6
-         */
        boolean cleanupUsers();
-
-        /**
-         * Gets a set all user's UUIDs who are "unique", and aren't just a member of the "default" group.
-         * @return a set of uuids, or null if the operation failed.
-         * @since 2.6
-         */
        Set<UUID> getUniqueUsers();
-
-        /**
-         * Creates and loads a group into the plugins internal storage
-         * @param name the name of the group
-         * @return true if the operation completed successfully
-         * @throws NullPointerException if name is null
-         * @throws IllegalArgumentException if the name is invalid
-         */
        boolean createAndLoadGroup(String name);
-
-        /**
-         * Loads a group into the plugins internal storage.
-         * @param name the name of the group
-         * @return true if the operation completed successfully
-         * @throws NullPointerException if name is null
-         * @throws IllegalArgumentException if the name is invalid
-         */
        boolean loadGroup(String name);
-
-        /**
-         * Loads all groups from the datastore into the plugins internal storage
-         * @return true if the operation completed successfully.
-         */
        boolean loadAllGroups();
-
-        /**
-         * Saves a group back to the datastore. You should call this after you make any changes to a group.
-         * @param group the group to save
-         * @return true if the operation completed successfully.
-         * @throws NullPointerException if group is null
-         * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-         */
        boolean saveGroup(Group group);
-
-        /**
-         * Permanently deletes a group from the datastore
-         * @param group the group to delete
-         * @return true if the operation completed successfully.
-         * @throws NullPointerException if group is null
-         * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-         */
        boolean deleteGroup(Group group);
-
-        /**
-         * Creates and loads a track into the plugins internal storage
-         * @param name the name of the track
-         * @return true if the operation completed successfully
-         * @throws NullPointerException if name is null
-         * @throws IllegalArgumentException if the name is invalid
-         */
        boolean createAndLoadTrack(String name);
-
-        /**
-         * Loads a track into the plugins internal storage.
-         * @param name the name of the track
-         * @return true if the operation completed successfully
-         * @throws NullPointerException if name is null
-         * @throws IllegalArgumentException if the name is invalid
-         */
        boolean loadTrack(String name);
-
-        /**
-         * Loads all tracks from the datastore into the plugins internal storage
-         * @return true if the operation completed successfully.
-         */
        boolean loadAllTracks();
-
-        /**
-         * Saves a track back to the datastore. You should call this after you make any changes to a track.
-         * @param track the track to save
-         * @return true if the operation completed successfully.
-         * @throws NullPointerException if track is null
-         * @throws IllegalStateException if the track instance was not obtained from LuckPerms.
-         */
        boolean saveTrack(Track track);
-
-        /**
-         * Permanently deletes a track from the datastore
-         * @param track the track to delete
-         * @return true if the operation completed successfully.
-         * @throws NullPointerException if track is null
-         * @throws IllegalStateException if the track instance was not obtained from LuckPerms.
-         */
        boolean deleteTrack(Track track);
-
-        /**
-         * Saves UUID caching data to the datastore
-         * @param username the users username
-         * @param uuid the users mojang unique id
-         * @return true if the operation completed successfully.
-         * @throws NullPointerException if either parameters are null
-         * @throws IllegalArgumentException if the username is invalid
-         */
        boolean saveUUIDData(String username, UUID uuid);
-
-        /**
-         * Gets a UUID from a username
-         * @param username the corresponding username
-         * @return a uuid object, could be null
-         * @throws NullPointerException if either parameters are null
-         * @throws IllegalArgumentException if the username is invalid
-         */
        UUID getUUID(String username);
    }

-    /**
-     * All operations through this interface are called in a new, separate asynchronous thread.
-     * When the operation is complete, the provided callback method is called, in applicable, in the main server thread.
-     * 
-     * See {@link Sync} for method documentation. 
-     */
+    @Deprecated
    interface Async {
        void logAction(LogEntry entry, Callback<Boolean> callback);
        void getLog(Callback<Log> callback);
@@ -274,13 +98,7 @@ public interface Datastore {
        void getUUID(String username, Callback<UUID> callback);
    }

-    /**
-     * All operations through this interface are called in a new, separate asynchronous thread, similar to {@link Async}.
-     * The only difference is that instead of providing a callback, a {@link java.util.concurrent.Future} is returned.
-     * See the Oracle JavaDocs for usage of the Future class.
-     * 
-     * See {@link Sync} for method documentation.
-     */
+    @Deprecated
    interface Future {
        java.util.concurrent.Future<Boolean> logAction(LogEntry entry);
        java.util.concurrent.Future<Log> getLog();
@@ -62,6 +62,24 @@ public interface LPConfiguration {
     */
    boolean getIncludeGlobalPerms();

+    /**
+     * @return if the users on this server will have their global world permissions applied
+     * @since 2.9
+     */
+    boolean getIncludeGlobalWorldPerms();
+
+    /**
+     * @return true if the platform is applying global groups
+     * @since 2.9
+     */
+    boolean getApplyGlobalGroups();
+
+    /**
+     * @return true if the platform is applying global world groups
+     * @since 2.9
+     */
+    boolean getApplyGlobalWorldGroups();
+
    /**
     * @return the online mode setting in the config
     */
@@ -88,6 +106,14 @@ public interface LPConfiguration {
     */
    boolean getLogNotify();

+    /**
+     * @return true if permission checks are being recorded / debugged
+     * @since 2.9
+     * @deprecated as this value is now always false. Functionality was replaced by the verbose command.
+     */
+    @Deprecated
+    boolean getDebugPermissionChecks();
+
    /**
     * @return true if the vanilla op system is enabled
     * @since 2.8
@@ -100,6 +126,12 @@ public interface LPConfiguration {
     */
    boolean getCommandsAllowOp();

+    /**
+     * @return true if auto op is enabled
+     * @since 2.9
+     */
+    boolean getAutoOp();
+
    /**
     * @return the name of the server used within Vault operations
     * @since 2.7
@@ -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();
+
+}
@@ -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;
@@ -77,11 +79,27 @@ public interface LuckPermsApi {
    LPConfiguration getConfiguration();

    /**
-     * Gets a wrapped {@link Datastore} instance, with somewhat limited access
-     * @return a datastore instance
+     * Gets a wrapped {@link Storage} instance.
+     * @return a storage instance
+     * @since 2.14
     */
+    Storage getStorage();
+
+    /**
+     * Gets a wrapped Datastore instance.
+     * @return a datastore instance
+     * @deprecated in favour of {@link #getStorage()}
+     */
+    @SuppressWarnings("deprecation")
+    @Deprecated
    Datastore getDatastore();

+    /**
+     * Gets the messaging service in use on the platform, if present.
+     * @return an optional that may contain a messaging service instance.
+     */
+    Optional<MessagingService> getMessagingService();
+
    /**
     * Gets the {@link Logger} wrapping used by the platform
     * @return the logger instance
@@ -90,7 +108,7 @@ public interface LuckPermsApi {

    /**
     * Gets a wrapped {@link UuidCache} instance, providing read access to the LuckPerms internal uuid caching system
-     * @return a uuidcache instance
+     * @return a uuid cache instance
     */
    UuidCache getUuidCache();

@@ -187,7 +205,7 @@ public interface LuckPermsApi {
    Track getTrack(String name);

    /**
-     * Gets a wrapped tracj object from the track storage. This method does not return null, unlike {@link #getTrack}
+     * Gets a wrapped track object from the track storage. This method does not return null, unlike {@link #getTrack}
     * @param name the name of the track to get
     * @return an optional {@link Track} object
     * @throws NullPointerException if the name is null
@@ -218,4 +236,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);
+
 }
@@ -0,0 +1,37 @@
+/*
+ * 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;
+
+/**
+ * Exposes any networking provider being used on the platform. e.g. Redis
+ * @since 2.14
+ */
+public interface MessagingService {
+
+    /**
+     * Uses the messaging service to inform other servers about changes.
+     * This will push the update asynchronously, and this method will return almost immediately.
+     */
+    void pushUpdate();
+
+}
@@ -258,7 +258,7 @@ public class MetaUtils {

        int priority = Integer.MIN_VALUE;
        String meta = null;
-        for (Node n : holder.getAllNodes()) {
+        for (Node n : holder.getAllNodes(Contexts.allowAll())) {
            if (!n.getValue()) {
                continue;
            }
@@ -22,10 +22,9 @@

 package me.lucko.luckperms.api;

-import java.util.Date;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
+import me.lucko.luckperms.api.context.ContextSet;
+
+import java.util.*;

 /**
 * Represents an immutable node object
@@ -105,11 +104,44 @@ 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
+     * @since 2.13
+     */
+    boolean shouldApplyWithContext(ContextSet 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
+     * @since 2.13
     */
-    boolean shouldApplyWithContext(Map<String, String> context);
+    boolean shouldApplyWithContext(ContextSet 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
+     * @deprecated in favour of {@link #shouldApplyWithContext(ContextSet, boolean)}
+     */
+    @Deprecated
+    default boolean shouldApplyWithContext(Map<String, String> context, boolean worldAndServer) {
+        return shouldApplyWithContext(ContextSet.fromMap(context), worldAndServer);
+    }
+
+    /**
+     * If this node should apply in the given context
+     * @param context the context key value pairs
+     * @return true if the node should apply
+     * @deprecated in favour of {@link #shouldApplyWithContext(ContextSet)}
+     */
+    @Deprecated
+    default boolean shouldApplyWithContext(Map<String, String> context) {
+        return shouldApplyWithContext(ContextSet.fromMap(context));
+    }

    /**
     * Similar to {@link #shouldApplyOnServer(String, boolean, boolean)}, except this method accepts a List
@@ -178,8 +210,18 @@ public interface Node extends Map.Entry<String, Boolean> {

    /**
     * @return the extra contexts required for this node to apply
+     * @deprecated in favour of {@link #getContexts()}
     */
-    Map<String, String> getExtraContexts();
+    @Deprecated
+    default Map<String, String> getExtraContexts() {
+        return getContexts().toMap();
+    }
+
+    /**
+     * @return the extra contexts required for this node to apply
+     * @since 2.13
+     */
+    ContextSet getContexts();

    /**
     * Converts this node into a serialized form
@@ -294,7 +336,9 @@ public interface Node extends Map.Entry<String, Boolean> {
        Builder setServer(String server) throws IllegalArgumentException;
        Builder withExtraContext(String key, String value);
        Builder withExtraContext(Map<String, String> map);
+        Builder withExtraContext(Set<Map.Entry<String, String>> context);
        Builder withExtraContext(Map.Entry<String, String> entry);
+        Builder withExtraContext(ContextSet set);
        Node build();
    }

@@ -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);

    /**
@@ -30,7 +30,12 @@ public enum PlatformType {

    BUKKIT("Bukkit"),
    BUNGEE("Bungee"),
-    SPONGE("Sponge");
+    SPONGE("Sponge"),
+
+    /**
+     * @since 2.9
+     */
+    STANDALONE("Standalone");

    private final String friendlyName;

@@ -0,0 +1,217 @@
+/*
+ * 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 java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executor;
+import java.util.function.Consumer;
+
+/**
+ * Interface for the internal Storage instance
+ *
+ * All methods return {@link CompletableFuture}s, which will be populated with the result once the data has been loaded
+ * asynchronously. Care should be taken when using the methods to ensure that the main server thread is not blocked.
+ *
+ * Methods such as {@link CompletableFuture#get()} and equivalent should <strong>not</strong> be called on the main server thread.
+ * If you need to use the result of these operations on the main server thread, please register a callback using
+ * {@link CompletableFuture#thenAcceptAsync(Consumer, Executor)} and {@link #getSyncExecutor()}.
+ *
+ * @since 2.14
+ */
+public interface Storage {
+
+    /**
+     * Get the name of the storage implementation.
+     * @return the name of the implementation
+     */
+    String getName();
+
+    /**
+     * Return whether the storage instance is allowing logins on the platform.
+     * @return true if logins are enabled
+     */
+    boolean isAcceptingLogins();
+
+    /**
+     * Returns an executor which will run all passed runnables on the main server thread.
+     * @return an executor instance
+     */
+    Executor getSyncExecutor();
+
+    /**
+     * Returns an executor which will run all passed runnables asynchronously using the platforms scheduler & thread pools.
+     * @return an executor instance
+     */
+    Executor getAsyncExecutor();
+
+    /**
+     * Saves an action to storage
+     * @param entry the log entry to be saved
+     * @return true if the operation completed successfully.
+     * @throws NullPointerException if entry is null
+     */
+    CompletableFuture<Boolean> logAction(LogEntry entry);
+
+    /**
+     * Loads and returns the entire log from storage
+     * @return a log instance, could be null if loading failed
+     */
+    CompletableFuture<Log> getLog();
+
+    /**
+     * Loads a user's data from the main storage into the plugins local storage.
+     * @param uuid the uuid of the user to load
+     * @param username the users username. (if you want to specify <code>null</code> here, just input "null" as a string.)
+     * @return if the operation completed successfully
+     * @throws NullPointerException if uuid or username is null
+     */
+    CompletableFuture<Boolean> loadUser(UUID uuid, String username);
+
+    /**
+     * Saves a user object back to storage. You should call this after you make any changes to a user.
+     * @param user the user to save
+     * @return true if the operation completed successfully.
+     * @throws NullPointerException if user is null
+     * @throws IllegalStateException if the user instance was not obtained from LuckPerms.
+     */
+    CompletableFuture<Boolean> saveUser(User user);
+
+    /**
+     * Removes users from the main storage who are "default". This is called every time the plugin loads.
+     * @return true if the operation completed successfully
+     */
+    CompletableFuture<Boolean> cleanupUsers();
+
+    /**
+     * Gets a set all "unique" user UUIDs.
+     * "Unique" meaning the user isn't just a member of the "default" group.
+     * @return a set of uuids, or null if the operation failed.
+     */
+    CompletableFuture<Set<UUID>> getUniqueUsers();
+
+    /**
+     * Creates and loads a group into the plugins local storage
+     * @param name the name of the group
+     * @return true if the operation completed successfully
+     * @throws NullPointerException if name is null
+     * @throws IllegalArgumentException if the name is invalid
+     */
+    CompletableFuture<Boolean> createAndLoadGroup(String name);
+
+    /**
+     * Loads a group into the plugins local storage.
+     * @param name the name of the group
+     * @return true if the operation completed successfully
+     * @throws NullPointerException if name is null
+     * @throws IllegalArgumentException if the name is invalid
+     */
+    CompletableFuture<Boolean> loadGroup(String name);
+
+    /**
+     * Loads all groups from the storage into memory
+     * @return true if the operation completed successfully.
+     */
+    CompletableFuture<Boolean> loadAllGroups();
+
+    /**
+     * Saves a group back to storage. You should call this after you make any changes to a group.
+     * @param group the group to save
+     * @return true if the operation completed successfully.
+     * @throws NullPointerException if group is null
+     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
+     */
+    CompletableFuture<Boolean> saveGroup(Group group);
+
+    /**
+     * Permanently deletes a group from storage.
+     * @param group the group to delete
+     * @return true if the operation completed successfully.
+     * @throws NullPointerException if group is null
+     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
+     */
+    CompletableFuture<Boolean> deleteGroup(Group group);
+
+    /**
+     * Creates and loads a track into the plugins local storage
+     * @param name the name of the track
+     * @return true if the operation completed successfully
+     * @throws NullPointerException if name is null
+     * @throws IllegalArgumentException if the name is invalid
+     */
+    CompletableFuture<Boolean> createAndLoadTrack(String name);
+
+    /**
+     * Loads a track into the plugins local storage.
+     * @param name the name of the track
+     * @return true if the operation completed successfully
+     * @throws NullPointerException if name is null
+     * @throws IllegalArgumentException if the name is invalid
+     */
+    CompletableFuture<Boolean> loadTrack(String name);
+
+    /**
+     * Loads all tracks from the storage into memory
+     * @return true if the operation completed successfully.
+     */
+    CompletableFuture<Boolean> loadAllTracks();
+
+    /**
+     * Saves a track back to storage. You should call this after you make any changes to a track.
+     * @param track the track to save
+     * @return true if the operation completed successfully.
+     * @throws NullPointerException if track is null
+     * @throws IllegalStateException if the track instance was not obtained from LuckPerms.
+     */
+    CompletableFuture<Boolean> saveTrack(Track track);
+
+    /**
+     * Permanently deletes a track from storage
+     * @param track the track to delete
+     * @return true if the operation completed successfully.
+     * @throws NullPointerException if track is null
+     * @throws IllegalStateException if the track instance was not obtained from LuckPerms.
+     */
+    CompletableFuture<Boolean> deleteTrack(Track track);
+
+    /**
+     * Saves UUID caching data to the global cache
+     * @param username the users username
+     * @param uuid the users mojang unique id
+     * @return true if the operation completed successfully.
+     * @throws NullPointerException if either parameters are null
+     * @throws IllegalArgumentException if the username is invalid
+     */
+    CompletableFuture<Boolean> saveUUIDData(String username, UUID uuid);
+
+    /**
+     * Gets a UUID from a username
+     * @param username the corresponding username
+     * @return a uuid object, could be null
+     * @throws NullPointerException if either parameters are null
+     * @throws IllegalArgumentException if the username is invalid
+     */
+    CompletableFuture<UUID> getUUID(String username);
+
+}
@@ -22,10 +22,12 @@

 package me.lucko.luckperms.api;

+import me.lucko.luckperms.api.caching.UserData;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.exceptions.ObjectLacksException;

 import java.util.List;
+import java.util.Optional;
 import java.util.UUID;

 /**
@@ -64,6 +66,13 @@ public interface User extends PermissionHolder {
     */
    void refreshPermissions();

+    /**
+     * Gets the user's {@link UserData} cache, if they have one setup.
+     * @return an optional, possibly containing the user's cached lookup data.
+     * @since 2.13
+     */
+    Optional<UserData> getUserDataCache();
+
    /**
     * Check to see if the user is a member of a group
     * @param group The group to check membership of
@@ -32,8 +32,8 @@ import java.util.UUID;
 * they first join the server, but this UUID will then not be consistent across the network. LuckPerms will instead check
 * the datastore cache, to get a UUID for a user that is consistent across an entire network.
 *
- * <p> If you want to get a user object from the datastore using the api on a server in offline mode, you will need to use this cache,
- * OR use Datastore#getUUID, for users that are not online.
+ * <p> If you want to get a user object from the Storage using the api on a server in offline mode, you will need to use this cache,
+ * OR use Storage#getUUID, for users that are not online.
 *
 * <p> WARNING: THIS IS ONLY EFFECTIVE FOR ONLINE PLAYERS. USE THE DATASTORE METHODS FOR OFFLINE PLAYERS.
 */
@@ -0,0 +1,64 @@
+/*
+ * 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.caching;
+
+import java.util.Map;
+import java.util.SortedMap;
+
+/**
+ * Holds cached Meta lookup data for a specific set of contexts
+ * @since 2.13
+ */
+public interface MetaData {
+
+    /**
+     * Gets an immutable copy of the meta this user has
+     * @return an immutable map of meta
+     */
+    Map<String, String> getMeta();
+
+    /**
+     * Gets an immutable sorted map of all of the prefixes the user has, whereby the first value is the highest priority prefix.
+     * @return a sorted map of prefixes
+     */
+    SortedMap<Integer, String> getPrefixes();
+
+    /**
+     * Gets an immutable sorted map of all of the suffixes the user has, whereby the first value is the highest priority suffix.
+     * @return a sorted map of suffixes
+     */
+    SortedMap<Integer, String> getSuffixes();
+
+    /**
+     * Gets the user's highest priority prefix, or null if the user has no prefixes
+     * @return a prefix string, or null
+     */
+    String getPrefix();
+
+    /**
+     * Gets the user's highest priority suffix, or null if the user has no suffixes
+     * @return a suffix string, or null
+     */
+    String getSuffix();
+
+}
@@ -0,0 +1,55 @@
+/*
+ * 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.caching;
+
+import me.lucko.luckperms.api.Tristate;
+
+import java.util.Map;
+
+/**
+ * Holds cached Permission lookup data for a specific set of contexts
+ * @since 2.13
+ */
+public interface PermissionData {
+
+    /**
+     * Gets a permission value for the given permission node
+     * @param permission the permission node
+     * @return a tristate result
+     * @throws NullPointerException if permission is null
+     */
+    Tristate getPermissionValue(String permission);
+
+    /**
+     * Invalidates the underlying permission calculator cache.
+     * Can be called to allow for an update in defaults.
+     */
+    void invalidateCache();
+
+    /**
+     * Gets an immutable copy of the permission map backing the permission calculator
+     * @return an immutable set of permissions
+     */
+    Map<String, Boolean> getImmutableBacking();
+
+}
@@ -0,0 +1,119 @@
+/*
+ * 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.caching;
+
+import me.lucko.luckperms.api.Contexts;
+
+import java.util.Set;
+
+/**
+ * Holds cached permission and meta lookup data for a {@link me.lucko.luckperms.api.User}.
+ * Data is only likely to be available for online users. All calls will account for inheritance, as well as any
+ * default data provided by the platform. This calls are heavily cached and are therefore fast.
+ *
+ * @since 2.13
+ */
+public interface UserData {
+
+    /**
+     * Gets PermissionData from the cache, given a specified context.
+     * If the data is not cached, it is calculated. Therefore, this call could be costly.
+     * @param contexts the contexts to get the permission data in
+     * @return a permission data instance
+     * @throws NullPointerException if contexts is null
+     */
+    PermissionData getPermissionData(Contexts contexts);
+
+    /**
+     * Gets MetaData from the cache, given a specified context.
+     * If the data is not cached, it is calculated. Therefore, this call could be costly.
+     * @param contexts the contexts to get the permission data in
+     * @return a meta data instance
+     * @throws NullPointerException if contexts is null
+     */
+    MetaData getMetaData(Contexts contexts);
+
+    /**
+     * Calculates permission data, bypassing the cache.
+     * @param contexts the contexts to get permission data in
+     * @return a permission data instance
+     * @throws NullPointerException if contexts is null
+     */
+    PermissionData calculatePermissions(Contexts contexts);
+
+    /**
+     * Calculates meta data, bypassing the cache.
+     * @param contexts the contexts to get meta data in
+     * @return a meta data instance
+     * @throws NullPointerException if contexts is null
+     */
+    MetaData calculateMeta(Contexts contexts);
+
+    /**
+     * Calculates permission data and stores it in the cache. If there is already data cached for the given contexts,
+     * and if the resultant output is different, the cached value is updated.
+     * @param contexts the contexts to recalculate in.
+     * @throws NullPointerException if contexts is null
+     */
+    void recalculatePermissions(Contexts contexts);
+
+    /**
+     * Calculates meta data and stores it in the cache. If there is already data cached for the given contexts,
+     * and if the resultant output is different, the cached value is updated.
+     * @param contexts the contexts to recalculate in.
+     * @throws NullPointerException if contexts is null
+     */
+    void recalculateMeta(Contexts contexts);
+
+    /**
+     * Calls {@link #recalculatePermissions(Contexts)} for all current loaded contexts
+     */
+    void recalculatePermissions();
+
+    /**
+     * Calls {@link #recalculateMeta(Contexts)} for all current loaded contexts
+     */
+    void recalculateMeta();
+
+    /**
+     * Calls {@link #preCalculate(Contexts)} for the given contexts
+     * @param contexts a set of contexts
+     * @throws NullPointerException if contexts is null
+     */
+    void preCalculate(Set<Contexts> contexts);
+
+    /**
+     * Ensures that PermissionData and MetaData is cached for a context. If the cache does not contain any data for the
+     * context, it will be calculated and saved.
+     * @param contexts the contexts to pre-calculate for
+     * @throws NullPointerException if contexts is null
+     */
+    void preCalculate(Contexts contexts);
+
+    /**
+     * Invalidates all of the underlying Permission calculators.
+     * Can be called to allow for an update in defaults.
+     */
+    void invalidatePermissionCalculators();
+
+}
@@ -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);
+    }
+
+}
@@ -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;
+
+}
@@ -0,0 +1,311 @@
+/*
+ * 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 com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * Holds contexts.
+ * All contained contexts are immutable, and unlike {@link MutableContextSet}, contexts cannot be added or removed.
+ *
+ * @since 2.13
+ */
+public class ContextSet {
+
+    /**
+     * Make a singleton ContextSet from a context pair
+     * @param key the key
+     * @param value the value
+     * @return a new ContextSet containing one KV pair
+     * @throws NullPointerException if key or value is null
+     */
+    public static ContextSet singleton(String key, String value) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+        if (value == null) {
+            throw new NullPointerException("value");
+        }
+
+        MutableContextSet set = new MutableContextSet();
+        set.add(key, value);
+        return set.immutableCopy();
+    }
+
+    /**
+     * Creates a ContextSet from an existing map
+     * @param map the map to copy from
+     * @return a new ContextSet representing the pairs from the map
+     * @throws NullPointerException if the map is null
+     */
+    public static ContextSet fromMap(Map<String, String> map) {
+        if (map == null) {
+            throw new NullPointerException("map");
+        }
+
+        MutableContextSet set = new MutableContextSet();
+        set.addAll(map);
+        return set.immutableCopy();
+    }
+
+    /**
+     * Creates a ContextSet from an existing iterable of Map Entries
+     * @param iterable the iterable to copy from
+     * @return a new ContextSet representing the pairs in the iterable
+     * @throws NullPointerException if the iterable is null
+     */
+    public static ContextSet fromEntries(Iterable<Map.Entry<String, String>> iterable) {
+        if (iterable == null) {
+            throw new NullPointerException("iterable");
+        }
+
+        MutableContextSet set = new MutableContextSet();
+        set.addAll(iterable);
+        return set.immutableCopy();
+    }
+
+    /**
+     * Creates a new ContextSet from an existing set.
+     * Only really useful for converting between mutable and immutable types.
+     * @param contextSet the context set to copy from
+     * @return a new ContextSet with the same content and the one provided
+     * @throws NullPointerException if contextSet is null
+     */
+    public static ContextSet fromSet(ContextSet contextSet) {
+        if (contextSet == null) {
+            throw new NullPointerException("contextSet");
+        }
+
+        MutableContextSet set = new MutableContextSet();
+        set.addAll(contextSet.toSet());
+        return set.immutableCopy();
+    }
+
+    /**
+     * Creates a new empty ContextSet.
+     * @return a new ContextSet
+     */
+    public static ContextSet empty() {
+        return new ContextSet();
+    }
+
+    final Set<Map.Entry<String, String>> contexts;
+
+    public ContextSet() {
+        this.contexts = new HashSet<>();
+    }
+
+    protected ContextSet(Set<Map.Entry<String, String>> contexts) {
+        this.contexts = contexts;
+    }
+
+    /**
+     * Check to see if this set is in an immutable form
+     * @return true if the set is immutable
+     */
+    public boolean isImmutable() {
+        return true;
+    }
+
+    /**
+     * If the set is mutable, this method will return an immutable copy. Otherwise just returns itself.
+     * @return an immutable ContextSet
+     */
+    public ContextSet makeImmutable() {
+        return this;
+    }
+
+    /**
+     * Converts this ContextSet to an immutable {@link Set} of {@link Map.Entry}s.
+     * @return an immutable set
+     */
+    public Set<Map.Entry<String, String>> toSet() {
+        synchronized (contexts) {
+            return ImmutableSet.copyOf(contexts);
+        }
+    }
+
+    /**
+     * Converts this ContextSet to an immutable {@link Map}
+     *
+     * <b>NOTE: Use of this method may result in data being lost. ContextSets can contain lots of different values for
+     * one key.</b>
+     *
+     * @return an immutable map
+     */
+    public Map<String, String> toMap() {
+        synchronized (contexts) {
+            return ImmutableMap.copyOf(contexts.stream().collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)));
+        }
+    }
+
+    /**
+     * Check if the set contains at least one value for the given key.
+     * @param key the key to check for
+     * @return true if the set contains a value for the key
+     * @throws NullPointerException if the key is null
+     */
+    public boolean containsKey(String key) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+
+        synchronized (contexts) {
+            for (Map.Entry<String, String> e : contexts) {
+                if (e.getKey().equalsIgnoreCase(key)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Gets a set of all of the values mapped to the given key
+     * @param key the key to find values for
+     * @return a set of values
+     * @throws NullPointerException if the key is null
+     */
+    public Set<String> getValues(String key) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+
+        synchronized (contexts) {
+            return ImmutableSet.copyOf(contexts.stream()
+                    .filter(e -> e.getKey().equalsIgnoreCase(key))
+                    .map(Map.Entry::getValue)
+                    .collect(Collectors.toSet())
+            );
+        }
+    }
+
+    /**
+     * Check if thr set contains a given key mapped to a given value
+     * @param key the key to look for
+     * @param value the value to look for (case sensitive)
+     * @return true if the set contains the KV pair
+     * @throws NullPointerException if the key or value is null
+     */
+    public boolean has(String key, String value) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+        if (value == null) {
+            throw new NullPointerException("value");
+        }
+
+        synchronized (contexts) {
+            for (Map.Entry<String, String> e : contexts) {
+                if (!e.getKey().equalsIgnoreCase(key)) {
+                    continue;
+                }
+
+                if (!e.getValue().equals(value)) {
+                    continue;
+                }
+
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Same as {@link #has(String, String)}, except ignores the case of the value.
+     * @param key the key to look for
+     * @param value the value to look for
+     * @return true if the set contains the KV pair
+     * @throws NullPointerException if the key or value is null
+     */
+    public boolean hasIgnoreCase(String key, String value) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+        if (value == null) {
+            throw new NullPointerException("value");
+        }
+
+        synchronized (contexts) {
+            for (Map.Entry<String, String> e : contexts) {
+                if (!e.getKey().equalsIgnoreCase(key)) {
+                    continue;
+                }
+
+                if (!e.getValue().equalsIgnoreCase(value)) {
+                    continue;
+                }
+
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Check if the set is empty
+     * @return true if the set is empty
+     */
+    public boolean isEmpty() {
+        synchronized (contexts) {
+            return contexts.isEmpty();
+        }
+    }
+
+    /**
+     * Gets the number of key-value context pairs in the set
+     * @return the size of the set
+     */
+    public int size() {
+        synchronized (contexts) {
+            return contexts.size();
+        }
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == this) return true;
+        if (!(o instanceof ContextSet)) return false;
+        final ContextSet other = (ContextSet) o;
+
+        final Object thisContexts = this.contexts;
+        final Object otherContexts = other.contexts;
+        return thisContexts == null ? otherContexts == null : thisContexts.equals(otherContexts);
+    }
+
+    @Override
+    public int hashCode() {
+        return 59 + (this.contexts == null ? 43 : this.contexts.hashCode());
+    }
+
+    @Override
+    public String toString() {
+        return "ContextSet(contexts=" + this.contexts + ")";
+    }
+}
@@ -0,0 +1,88 @@
+/*
+ * 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.HashMap;
+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 to
+     * @param accumulator a map of contexts to add to
+     * @return the map
+     * @deprecated in favour of {@link #giveApplicableContext(Object, MutableContextSet)}. Older implementations of this interface
+     * will still work, as the replacement method is given as a default, and falls back to using this method.
+     */
+    @Deprecated
+    default Map<String, String> giveApplicableContext(T subject, Map<String, String> accumulator) {
+        MutableContextSet acc = new MutableContextSet();
+        giveApplicableContext(subject, acc);
+
+        accumulator.putAll(acc.toMap());
+        return accumulator;
+    }
+
+    /**
+     * Gives the subject all of the applicable contexts they meet
+     *
+     * <p><b>You MUST implement this method. The default is only provided for backwards compatibility with
+     * {@link #giveApplicableContext(Object, Map)}.</b>
+     *
+     * @param subject the subject to add contexts to
+     * @param accumulator a map of contexts to add to
+     * @return the map
+     * @since 2.13
+     */
+    @SuppressWarnings("deprecation")
+    default MutableContextSet giveApplicableContext(T subject, MutableContextSet accumulator) {
+        Map<String, String> acc = new HashMap<>();
+        giveApplicableContext(subject, acc);
+
+        accumulator.addAll(acc.entrySet());
+        return 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);
+
+}
@@ -0,0 +1,272 @@
+/*
+ * 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 com.google.common.collect.Maps;
+
+import java.util.HashSet;
+import java.util.Map;
+
+/**
+ * Holds contexts
+ * All contained contexts are immutable, but contexts can be added or removed from the set.
+ *
+ * @since 2.13
+ */
+public class MutableContextSet extends ContextSet {
+
+    /**
+     * Make a singleton MutableContextSet from a context pair
+     * @param key the key
+     * @param value the value
+     * @return a new MutableContextSet containing one KV pair
+     * @throws NullPointerException if key or value is null
+     */
+    public static MutableContextSet singleton(String key, String value) {
+        MutableContextSet set = new MutableContextSet();
+        set.add(key, value);
+        return set;
+    }
+
+    /**
+     * Creates a MutableContextSet from an existing map
+     * @param map the map to copy from
+     * @return a new MutableContextSet representing the pairs from the map
+     * @throws NullPointerException if the map is null
+     */
+    public static MutableContextSet fromMap(Map<String, String> map) {
+        MutableContextSet set = new MutableContextSet();
+        set.addAll(map);
+        return set;
+    }
+
+    /**
+     * Creates a MutableContextSet from an existing iterable of Map Entries
+     * @param iterable the iterable to copy from
+     * @return a new MutableContextSet representing the pairs in the iterable
+     * @throws NullPointerException if the iterable is null
+     */
+    public static MutableContextSet fromEntries(Iterable<Map.Entry<String, String>> iterable) {
+        MutableContextSet set = new MutableContextSet();
+        set.addAll(iterable);
+        return set;
+    }
+
+    /**
+     * Creates a new MutableContextSet from an existing set.
+     * Only really useful for converting between mutable and immutable types.
+     * @param contextSet the context set to copy from
+     * @return a new MutableContextSet with the same content and the one provided
+     * @throws NullPointerException if contextSet is null
+     */
+    public static MutableContextSet fromSet(ContextSet contextSet) {
+        MutableContextSet set = new MutableContextSet();
+        set.addAll(contextSet.toSet());
+        return set;
+    }
+
+    /**
+     * Creates a new empty MutableContextSet.
+     * @return a new MutableContextSet
+     */
+    public static MutableContextSet empty() {
+        return new MutableContextSet();
+    }
+
+    @Override
+    public boolean isImmutable() {
+        return false;
+    }
+
+    @Override
+    public ContextSet makeImmutable() {
+        return immutableCopy();
+    }
+
+    /**
+     * Returns an immutable copy of this set.
+     * @return an immutable copy of this set
+     */
+    public ContextSet immutableCopy() {
+        synchronized (contexts) {
+            return new ContextSet(new HashSet<>(contexts));
+        }
+    }
+
+    /**
+     * Adds a new key value pair to the set
+     * @param key the key to add
+     * @param value the value to add
+     * @throws NullPointerException if the key or value is null
+     */
+    public void add(String key, String value) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+        if (value == null) {
+            throw new NullPointerException("value");
+        }
+
+        synchronized (contexts) {
+            contexts.add(Maps.immutableEntry(key, value));
+        }
+    }
+
+    /**
+     * Adds a new key value pair to the set
+     * @param entry the entry to add
+     * @throws NullPointerException if the entry is null
+     */
+    public void add(Map.Entry<String, String> entry) {
+        if (entry == null) {
+            throw new NullPointerException("context");
+        }
+
+        synchronized (contexts) {
+            contexts.add(Maps.immutableEntry(entry.getKey(), entry.getValue()));
+        }
+    }
+
+    /**
+     * Adds an iterable containing contexts to the set
+     * @param iterable an iterable of key value context pairs
+     * @throws NullPointerException if iterable is null
+     */
+    public void addAll(Iterable<Map.Entry<String, String>> iterable) {
+        if (iterable == null) {
+            throw new NullPointerException("contexts");
+        }
+
+        synchronized (this.contexts) {
+            for (Map.Entry<String, String> e : iterable) {
+                this.contexts.add(Maps.immutableEntry(e.getKey(), e.getValue()));
+            }
+        }
+    }
+
+    /**
+     * Adds the entry set of a map to the set
+     * @param map the map to add from
+     * @throws NullPointerException if the map is null
+     */
+    public void addAll(Map<String, String> map) {
+        if (map == null) {
+            throw new NullPointerException("contexts");
+        }
+        addAll(map.entrySet());
+    }
+
+    /**
+     * Adds of of the values in another ContextSet to this set
+     * @param contextSet the set to add from
+     * @throws NullPointerException if the contextSet is null
+     */
+    public void addAll(ContextSet contextSet) {
+        if (contextSet == null) {
+            throw new NullPointerException("contextSet");
+        }
+
+        synchronized (this.contexts) {
+            this.contexts.addAll(contextSet.toSet());
+        }
+    }
+
+    /**
+     * Remove a key value pair from this set
+     * @param key the key to remove
+     * @param value the value to remove (case sensitive)
+     * @throws NullPointerException if the key or value is null
+     */
+    public void remove(String key, String value) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+        if (value == null) {
+            throw new NullPointerException("value");
+        }
+
+        synchronized (contexts) {
+            contexts.removeIf(e -> e.getKey().equalsIgnoreCase(key) && e.getValue().equals(value));
+        }
+    }
+
+    /**
+     * Same as {@link #remove(String, String)}, except ignores the case of the value
+     * @param key the key to remove
+     * @param value the value to remove
+     * @throws NullPointerException if the key or value is null
+     */
+    public void removeIgnoreCase(String key, String value) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+        if (value == null) {
+            throw new NullPointerException("value");
+        }
+
+        synchronized (contexts) {
+            contexts.removeIf(e -> e.getKey().equalsIgnoreCase(key) && e.getValue().equalsIgnoreCase(value));
+        }
+    }
+
+    /**
+     * Removes all pairs with the given key
+     * @param key the key to remove
+     * @throws NullPointerException if the key is null
+     */
+    public void removeAll(String key) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+
+        synchronized (contexts) {
+            contexts.removeIf(e -> e.getKey().equalsIgnoreCase(key));
+        }
+    }
+
+    /**
+     * Clears the set
+     */
+    public void clear() {
+        synchronized (contexts) {
+            contexts.clear();
+        }
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == this) return true;
+        if (!(o instanceof ContextSet)) return false;
+        final ContextSet other = (ContextSet) o;
+
+        final Object thisContexts = this.contexts;
+        final Object otherContexts = other.contexts;
+        return thisContexts == null ? otherContexts == null : thisContexts.equals(otherContexts);
+    }
+
+    @Override
+    public int hashCode() {
+        return 59 + (this.contexts == null ? 43 : this.contexts.hashCode());
+    }
+
+}
@@ -28,7 +28,9 @@ import java.util.function.Consumer;
 * A callback used to wait for the completion of asynchronous operations.
 * All callbacks are ran on the main server thread.
 * @param <T> the return type
+ * @deprecated in favour of {@link Consumer}
 */
+@Deprecated
 public interface Callback<T> {

    /**
@@ -55,4 +57,17 @@ public interface Callback<T> {
        return consumer::accept;
    }

+    /**
+     * Helper method for converting old {@link Callback}s to use the new {@link me.lucko.luckperms.api.Storage} interface.
+     * @param callback the callback to convert
+     * @param <T> the return type
+     * @return a consumer instance
+     * @since 2.14
+     * @deprecated in favour of just using {@link Consumer}s.
+     */
+    @Deprecated
+    static <T> Consumer<T> convertToConsumer(Callback<T> callback) {
+        return callback::onComplete;
+    }
+
 }
@@ -1,3 +1,25 @@
+/*
+ * 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.exceptions;

 /**
@@ -0,0 +1,139 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>luckperms</artifactId>
+        <groupId>me.lucko.luckperms</groupId>
+        <version>2.14-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>luckperms-bukkit-legacy</artifactId>
+    <build>
+        <defaultGoal>clean package</defaultGoal>
+        <finalName>LuckPerms-bukkit-legacy-${release.version}.${git.closest.tag.commit.count}</finalName>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>true</filtering>
+            </resource>
+        </resources>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.5.1</version>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>2.4.3</version>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                        <configuration>
+                            <minimizeJar>false</minimizeJar>
+                            <artifactSet>
+                                <excludes>
+                                    <exclude>org.xerial:*</exclude>
+                                </excludes>
+                            </artifactSet>
+                            <relocations>
+                                <relocation>
+                                    <pattern>org.slf4j</pattern>
+                                    <shadedPattern>me.lucko.luckperms.lib.slf4j</shadedPattern>
+                                </relocation>
+                                <relocation>
+                                    <pattern>com.zaxxer.hikari</pattern>
+                                    <shadedPattern>me.lucko.luckperms.lib.hikari</shadedPattern>
+                                </relocation>
+                                <relocation>
+                                    <pattern>com.mongodb</pattern>
+                                    <shadedPattern>me.lucko.luckperms.lib.mongodb</shadedPattern>
+                                </relocation>
+                                <relocation>
+                                    <pattern>org.bson</pattern>
+                                    <shadedPattern>me.lucko.luckperms.lib.bson</shadedPattern>
+                                </relocation>
+                                <relocation>
+                                    <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>
+                                <relocation>
+                                    <pattern>redis.clients.jedis</pattern>
+                                    <shadedPattern>me.lucko.luckperms.lib.jedis.jedis</shadedPattern>
+                                </relocation>
+                                <relocation>
+                                    <pattern>redis.clients.util</pattern>
+                                    <shadedPattern>me.lucko.luckperms.lib.jedis.util</shadedPattern>
+                                </relocation>
+                                <relocation>
+                                    <pattern>org.apache.commons.pool2</pattern>
+                                    <shadedPattern>me.lucko.luckperms.lib.jedis.pool2</shadedPattern>
+                                </relocation>
+                            </relocations>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>pl.project13.maven</groupId>
+                <artifactId>git-commit-id-plugin</artifactId>
+                <version>2.2.1</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>revision</goal>
+                        </goals>
+                    </execution>
+                </executions>
+                <configuration>
+                    <injectAllReactorProjects>true</injectAllReactorProjects>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <dependencies>
+        <!-- LuckPerms Bukkit -->
+        <dependency>
+            <groupId>me.lucko.luckperms</groupId>
+            <artifactId>luckperms-bukkit</artifactId>
+            <version>${project.version}</version>
+            <scope>compile</scope>
+        </dependency>
+
+        <!-- Shade gson and guava, as they are not included in earlier Bukkit releases -->
+        <!-- gson -->
+        <dependency>
+            <groupId>com.google.code.gson</groupId>
+            <artifactId>gson</artifactId>
+            <version>2.7</version>
+            <scope>compile</scope>
+        </dependency>
+        <!-- guava -->
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>19.0</version>
+            <scope>compile</scope>
+        </dependency>
+    </dependencies>
+
+</project>
@@ -5,7 +5,7 @@
    <parent>
        <artifactId>luckperms</artifactId>
        <groupId>me.lucko.luckperms</groupId>
-        <version>2.8-SNAPSHOT</version>
+        <version>2.14-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

@@ -30,8 +30,8 @@
        <dependency>
            <groupId>me.lucko.luckperms</groupId>
            <artifactId>luckperms-api</artifactId>
-            <version>2.5</version>
-            <scope>compile</scope>
+            <version>2.13-SNAPSHOT</version>
+            <scope>provided</scope>
        </dependency>
        <!-- BukkitAPI -->
        <dependency>
@@ -25,21 +25,21 @@ package me.lucko.luckperms.api.placeholders;
 import me.clip.placeholderapi.PlaceholderAPIPlugin;
 import me.clip.placeholderapi.expansion.PlaceholderExpansion;
 import me.clip.placeholderapi.util.TimeUtil;
-import me.lucko.luckperms.api.LuckPermsApi;
-import me.lucko.luckperms.api.Track;
-import me.lucko.luckperms.api.User;
+import me.lucko.luckperms.api.*;
+import me.lucko.luckperms.api.caching.UserData;
+import me.lucko.luckperms.api.context.MutableContextSet;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;

-import java.util.Map;
 import java.util.Optional;
-import java.util.regex.Pattern;
+import java.util.stream.Collectors;

 /*
 * PlaceholderAPI Expansion for LuckPerms, implemented using the LuckPerms API.
 *
 * Placeholders:
 * - group_name
+ * - groups
 * - has_permission_<node>
 * - inherits_permission_<node>
 * - in_group_<name>
@@ -75,7 +75,14 @@ public class LuckPermsPlaceholderExpansion extends PlaceholderExpansion {

    @Override
    public String getVersion() {
-        return "2.5";
+        return "2.13";
+    }
+
+    private Contexts makeContexts(Player player) {
+        MutableContextSet contextSet = new MutableContextSet();
+        contextSet.add("server", api.getConfiguration().getVaultServer());
+        contextSet.add("world", player.getWorld().getName());// ignore world?
+        return Contexts.of(contextSet.makeImmutable(), api.getConfiguration().getVaultIncludeGlobal(), true, true, true, true, player.isOp());
    }

    @Override
@@ -84,18 +91,28 @@ public class LuckPermsPlaceholderExpansion extends PlaceholderExpansion {
            return "";
        }

-        Optional<User> u = api.getUserSafe(player.getUniqueId());
+        Optional<User> u = api.getUserSafe(api.getUuidCache().getUUID(player.getUniqueId()));
        if (!u.isPresent()) {
            return "";
        }
+        final User user = u.get();
+
+        Optional<UserData> d = user.getUserDataCache();
+        if (!d.isPresent()) {
+            return "";
+        }
+        final UserData data = d.get();

        identifier = identifier.toLowerCase();
-        final User user = u.get();

        if (identifier.equalsIgnoreCase("group_name")) {
            return user.getPrimaryGroup();
        }

+        if (identifier.equalsIgnoreCase("groups")) {
+            return user.getGroupNames().stream().collect(Collectors.joining(", "));
+        }
+
        if (identifier.startsWith("has_permission_") && identifier.length() > "has_permission_".length()) {
            String node = identifier.substring("has_permission_".length());
            return formatBoolean(user.hasPermission(node, true));
@@ -103,7 +120,7 @@ public class LuckPermsPlaceholderExpansion extends PlaceholderExpansion {

        if (identifier.startsWith("inherits_permission_") && identifier.length() > "inherits_permission_".length()) {
            String node = identifier.substring("inherits_permission_".length());
-            return formatBoolean(user.inheritsPermission(node, true));
+            return formatBoolean(data.getPermissionData(makeContexts(player)).getPermissionValue(node).asBoolean());
        }

        if (identifier.startsWith("in_group_") && identifier.length() > "in_group_".length()) {
@@ -113,7 +130,7 @@ public class LuckPermsPlaceholderExpansion extends PlaceholderExpansion {

        if (identifier.startsWith("inherits_group_") && identifier.length() > "inherits_group_".length()) {
            String groupName = identifier.substring("inherits_group_".length());
-            return formatBoolean(user.getLocalGroups("global").contains(groupName));
+            return formatBoolean(data.getPermissionData(makeContexts(player)).getPermissionValue("group." + groupName).asBoolean());
        }

        if (identifier.startsWith("on_track_") && identifier.length() > "on_track_".length()) {
@@ -127,17 +144,11 @@ public class LuckPermsPlaceholderExpansion extends PlaceholderExpansion {

        if (identifier.startsWith("expiry_time_") && identifier.length() > "expiry_time_".length()) {
            String node = identifier.substring("expiry_time_".length());
-
-
            long currentTime = System.currentTimeMillis() / 1000L;
-            Map<Map.Entry<String, Boolean>, Long> temps = user.getTemporaryNodes();
-
-            for (Map.Entry<Map.Entry<String, Boolean>, Long> e : temps.entrySet()) {
-                if (!e.getKey().getKey().equalsIgnoreCase(node)) {
-                    continue;
+            for (Node n : user.getTemporaryPermissionNodes()) {
+                if (n.toSerializedNode().equalsIgnoreCase(node)) {
+                    return TimeUtil.getTime((int) (n.getExpiryUnixTime() - currentTime));
                }
-
-                return TimeUtil.getTime((int) (e.getValue() - currentTime));
            }

            return "";
@@ -145,42 +156,39 @@ public class LuckPermsPlaceholderExpansion extends PlaceholderExpansion {

        if (identifier.startsWith("group_expiry_time_") && identifier.length() > "group_expiry_time_".length()) {
            String node = "group." + identifier.substring("group_expiry_time_".length());
-
            long currentTime = System.currentTimeMillis() / 1000L;
-            Map<Map.Entry<String, Boolean>, Long> temps = user.getTemporaryNodes();
-
-            for (Map.Entry<Map.Entry<String, Boolean>, Long> e : temps.entrySet()) {
-                if (!e.getKey().getKey().equalsIgnoreCase(node)) {
-                    continue;
+            for (Node n : user.getTemporaryPermissionNodes()) {
+                if (n.getPermission().equalsIgnoreCase(node)) {
+                    return TimeUtil.getTime((int) (n.getExpiryUnixTime() - currentTime));
                }
-
-                return TimeUtil.getTime((int) (e.getValue() - currentTime));
            }

            return "";
        }

        if (identifier.equalsIgnoreCase("prefix")) {
-            return getChatMeta(PREFIX_PATTERN, user);
+            String prefix = data.calculateMeta(makeContexts(player)).getPrefix();
+            if (prefix == null) {
+                prefix = "";
+            }
+            return prefix;
        }

        if (identifier.equalsIgnoreCase("suffix")) {
-            return getChatMeta(SUFFIX_PATTERN, user);
+            String suffix = data.calculateMeta(makeContexts(player)).getSuffix();
+            if (suffix == null) {
+                suffix = "";
+            }
+            return suffix;
        }

        if (identifier.startsWith("meta_") && identifier.length() > "meta_".length()) {
-            String node = "meta." + escapeCharacters(identifier.substring("meta_".length())) + ".";
-            Map<String, Boolean> nodes = user.getNodes();
-
-            for (Map.Entry<String, Boolean> e : nodes.entrySet()) {
-                if (!e.getValue()) continue;
-                if (!e.getKey().toLowerCase().startsWith(node)) continue;
-
-                String meta = e.getKey().substring(node.length());
-                return unescapeCharacters(meta);
+            String node = identifier.substring("meta_".length());
+            String meta = data.getMetaData(makeContexts(player)).getMeta().get(node);
+            if (meta == null) {
+                meta = "";
            }
-
-            return "";
+            return meta;
        }

        return null;
@@ -204,44 +212,4 @@ public class LuckPermsPlaceholderExpansion extends PlaceholderExpansion {
    private static String formatBoolean(boolean b) {
        return b ? PlaceholderAPIPlugin.booleanTrue() : PlaceholderAPIPlugin.booleanFalse();
    }
-
-    private static String escapeCharacters(String s) {
-        s = s.replace(".", "{SEP}");
-        s = s.replace("/", "{FSEP}");
-        s = s.replace("$", "{DSEP}");
-
-        return s;
-    }
-
-    private static String unescapeCharacters(String s) {
-        s = s.replace("{SEP}", ".");
-        s = s.replace("{FSEP}", "/");
-        s = s.replace("{DSEP}", "$");
-
-        return s;
-    }
-
-    private static final Pattern PREFIX_PATTERN = Pattern.compile("(?i)prefix\\.\\d+\\..*");
-    private static final Pattern SUFFIX_PATTERN = Pattern.compile("(?i)suffix\\.\\d+\\..*");
-    private static final Pattern DOT_PATTERN = Pattern.compile("\\.");
-
-    private static String getChatMeta(Pattern pattern, User user) {
-        int priority = 0;
-        String meta = null;
-        for (Map.Entry<String, Boolean> e : user.getLocalPermissions(null, null).entrySet()) {
-            if (!e.getValue()) continue;
-
-            if (pattern.matcher(e.getKey()).matches()) {
-                String[] parts = DOT_PATTERN.split(e.getKey(), 3);
-                int p = Integer.parseInt(parts[1]);
-
-                if (meta == null || p > priority) {
-                    meta = parts[2];
-                    priority = p;
-                }
-            }
-        }
-
-        return meta == null ? "" : unescapeCharacters(meta);
-    }
 }
@@ -5,7 +5,7 @@
    <parent>
        <artifactId>luckperms</artifactId>
        <groupId>me.lucko.luckperms</groupId>
-        <version>2.8-SNAPSHOT</version>
+        <version>2.14-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

@@ -70,6 +70,18 @@
                                    <pattern>org.h2</pattern>
                                    <shadedPattern>me.lucko.luckperms.lib.h2</shadedPattern>
                                </relocation>
+                                <relocation>
+                                    <pattern>redis.clients.jedis</pattern>
+                                    <shadedPattern>me.lucko.luckperms.lib.jedis.jedis</shadedPattern>
+                                </relocation>
+                                <relocation>
+                                    <pattern>redis.clients.util</pattern>
+                                    <shadedPattern>me.lucko.luckperms.lib.jedis.util</shadedPattern>
+                                </relocation>
+                                <relocation>
+                                    <pattern>org.apache.commons.pool2</pattern>
+                                    <shadedPattern>me.lucko.luckperms.lib.jedis.pool2</shadedPattern>
+                                </relocation>
                            </relocations>
                        </configuration>
                    </execution>
@@ -129,5 +141,46 @@
            <version>1.16.10</version>
            <scope>provided</scope>
        </dependency>
+        <!-- **************Migration Plugins************** -->
+        <dependency>
+            <groupId>org.tyrannyofheaven.bukkit</groupId>
+            <artifactId>zPermissions</artifactId>
+            <version>1.3</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>ru.tehkode</groupId>
+            <artifactId>PermissionsEx</artifactId>
+            <version>1.23</version>
+            <scope>provided</scope>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.bukkit</groupId>
+                    <artifactId>bukkit</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>net.gravitydevelopment.updater</groupId>
+                    <artifactId>updater</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        <dependency>
+            <groupId>com.github.cheesesoftware</groupId>
+            <artifactId>PowerfulPermsAPI</artifactId>
+            <version>1.0.1</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.anjocaido</groupId>
+            <artifactId>GroupManager</artifactId>
+            <version>1.4</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>de.bananaco</groupId>
+            <artifactId>bpermissions-api</artifactId>
+            <version>2.12</version>
+            <scope>provided</scope>
+        </dependency>
    </dependencies>
 </project>
@@ -1,277 +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;
-
-import lombok.Getter;
-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 org.bukkit.command.PluginCommand;
-import org.bukkit.entity.Player;
-import org.bukkit.permissions.Permission;
-import org.bukkit.permissions.PermissionDefault;
-import org.bukkit.plugin.PluginManager;
-import org.bukkit.plugin.ServicePriority;
-import org.bukkit.plugin.java.JavaPlugin;
-
-import java.io.File;
-import java.util.*;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.stream.Collectors;
-
-@Getter
-public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
-    private final Set<UUID> ignoringLogs = ConcurrentHashMap.newKeySet();
-    private LPConfiguration configuration;
-    private BukkitUserManager userManager;
-    private GroupManager groupManager;
-    private TrackManager trackManager;
-    private Datastore datastore;
-    private UuidCache uuidCache;
-    private ApiProvider apiProvider;
-    private Logger log;
-    private Importer importer;
-    private ConsecutiveExecutor consecutiveExecutor;
-
-    @Override
-    public void onEnable() {
-        log = LogFactory.wrap(getLogger());
-
-        getLog().info("Loading configuration...");
-        configuration = new BukkitConfig(this);
-
-        // register events
-        PluginManager pm = getServer().getPluginManager();
-        pm.registerEvents(new BukkitListener(this), this);
-
-        // register commands
-        getLog().info("Registering commands...");
-        BukkitCommand commandManager = new BukkitCommand(this);
-        PluginCommand main = getServer().getPluginCommand("luckperms");
-        main.setExecutor(commandManager);
-        main.setTabCompleter(commandManager);
-        main.setAliases(Arrays.asList("perms", "lp", "permissions", "p", "perm"));
-
-        datastore = StorageFactory.getDatastore(this, "h2");
-
-        getLog().info("Loading internal permission managers...");
-        uuidCache = new UuidCache(getConfiguration().getOnlineMode());
-        userManager = new BukkitUserManager(this);
-        groupManager = new GroupManager(this);
-        trackManager = new TrackManager();
-        importer = new Importer(commandManager);
-        consecutiveExecutor = new ConsecutiveExecutor(commandManager);
-
-        int mins = getConfiguration().getSyncTime();
-        if (mins > 0) {
-            long ticks = mins * 60 * 20;
-            getServer().getScheduler().runTaskTimerAsynchronously(this, new UpdateTask(this), ticks, ticks);
-        }
-
-        getServer().getScheduler().runTaskTimer(this, BukkitSenderFactory.get(), 1L, 1L);
-        getServer().getScheduler().runTaskTimerAsynchronously(this, new ExpireTemporaryTask(this), 60L, 60L);
-        getServer().getScheduler().runTaskTimerAsynchronously(this, consecutiveExecutor, 20L, 20L);
-
-        // Provide vault support
-        getLog().info("Attempting to hook into Vault...");
-        try {
-            if (getServer().getPluginManager().isPluginEnabled("Vault")) {
-                VaultHook.hook(this);
-                getLog().info("Registered Vault permission & chat hook.");
-            } else {
-                getLog().info("Vault not found.");
-            }
-        } catch (Exception e) {
-            getLog().severe("Error occurred whilst hooking into Vault.");
-            e.printStackTrace();
-        }
-
-        getLog().info("Registering API...");
-        apiProvider = new ApiProvider(this);
-        LuckPerms.registerProvider(apiProvider);
-        getServer().getServicesManager().register(LuckPermsApi.class, apiProvider, this, ServicePriority.Normal);
-
-        // Run update task to refresh any online users
-        getLog().info("Scheduling Update Task to refresh any online users.");
-        try {
-            new UpdateTask(this).run();
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-
-        registerPermissions(getConfiguration().getCommandsAllowOp() ? PermissionDefault.OP : PermissionDefault.FALSE);
-        if (!getConfiguration().getEnableOps()) {
-            getServer().getOperators().forEach(o -> o.setOp(false));
-        }
-
-        getLog().info("Successfully loaded.");
-    }
-
-    @Override
-    public void onDisable() {
-        getLog().info("Closing datastore...");
-        datastore.shutdown();
-
-        getLog().info("Unregistering API...");
-        LuckPerms.unregisterProvider();
-        getServer().getServicesManager().unregisterAll(this);
-    }
-
-    @Override
-    public void doAsync(Runnable r) {
-        getServer().getScheduler().runTaskAsynchronously(this, r);
-    }
-
-    @Override
-    public void doSync(Runnable r) {
-        getServer().getScheduler().runTask(this, r);
-    }
-
-    @Override
-    public String getVersion() {
-        return getDescription().getVersion();
-    }
-
-    @Override
-    public PlatformType getType() {
-        return PlatformType.BUKKIT;
-    }
-
-    @Override
-    public File getMainDir() {
-        return getDataFolder();
-    }
-
-    @Override
-    public Message getPlayerStatus(UUID uuid) {
-        return getServer().getPlayer(getUuidCache().getExternalUUID(uuid)) != null ? Message.PLAYER_ONLINE : Message.PLAYER_OFFLINE;
-    }
-
-    @Override
-    public int getPlayerCount() {
-        return getServer().getOnlinePlayers().size();
-    }
-
-    @Override
-    public List<String> getPlayerList() {
-        return getServer().getOnlinePlayers().stream().map(Player::getName).collect(Collectors.toList());
-    }
-
-    @Override
-    public List<Sender> getSenders() {
-        return getServer().getOnlinePlayers().stream().map(p -> BukkitSenderFactory.get().wrap(p)).collect(Collectors.toList());
-    }
-
-    @Override
-    public Sender getConsoleSender() {
-        return BukkitSenderFactory.get().wrap(getServer().getConsoleSender());
-    }
-
-    @Override
-    public List<String> getPossiblePermissions() {
-        final List<String> perms = new ArrayList<>();
-
-        getServer().getPluginManager().getPermissions().forEach(p -> {
-            perms.add(p.getName());
-            p.getChildren().keySet().forEach(perms::add);
-        });
-
-        return perms;
-    }
-
-    @Override
-    public Object getPlugin(String name) {
-        return getServer().getPluginManager().getPlugin(name);
-    }
-
-    @Override
-    public Object getService(Class clazz) {
-        return getServer().getServicesManager().load(clazz);
-    }
-
-    @SuppressWarnings("deprecation")
-    @Override
-    public UUID getUUID(String playerName) {
-        try {
-            return getServer().getOfflinePlayer(playerName).getUniqueId();
-        } catch (Exception e) {
-            return null;
-        }
-    }
-
-    @Override
-    public boolean isPluginLoaded(String name) {
-        return getServer().getPluginManager().isPluginEnabled(name);
-    }
-
-    @Override
-    public void runUpdateTask() {
-        getServer().getScheduler().runTaskAsynchronously(this, new UpdateTask(this));
-    }
-
-    private void registerPermissions(PermissionDefault def) {
-        PluginManager pm = getServer().getPluginManager();
-
-        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()) {
-            pm.addPermission(new Permission(p.getNode(), def));
-            if (p.getGroup() != null) {
-                if (!wildcards.containsKey(p.getGroup())) {
-                    wildcards.put(p.getGroup(), new ArrayList<>());
-                }
-                wildcards.get(p.getGroup()).add(p.getTag());
-            }
-
-            all.add(p.getNode());
-        }
-
-        for (Map.Entry<String, List<String>> e : wildcards.entrySet()) {
-            pm.addPermission(new Permission(
-                    "luckperms." + e.getKey() + ".*", def,
-                    e.getValue().stream()
-                            .map(tag -> "luckperms." + e.getKey() + "." + tag)
-                            .collect(Collectors.toMap(s -> s, s -> false))
-                    )
-            );
-        }
-
-        pm.addPermission(new Permission("luckperms.*", def, all.stream().collect(Collectors.toMap(s -> s, s -> false))));
-    }
-}
@@ -1,340 +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 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 (!perms.getServer().equalsIgnoreCase("global")) {
-                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)) {
-            if (!n.getValue()) {
-                continue;
-            }
-
-            if (!perms.getServer().equalsIgnoreCase("global")) {
-                if (!n.shouldApplyOnServer(perms.getServer(), perms.isIncludeGlobal(), false)) {
-                    continue;
-                }
-            }
-
-            if (!n.shouldApplyOnWorld(world, perms.isIncludeGlobal(), false)) {
-                continue;
-            }
-
-            if (prefix ? !n.isPrefix() : !n.isSuffix()) {
-                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);
-    }
-
-}
@@ -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;
-    }
-}
@@ -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 com.google.common.collect.ImmutableList;
+import lombok.AllArgsConstructor;
+import me.lucko.luckperms.api.Contexts;
+import me.lucko.luckperms.bukkit.calculators.AttachmentProcessor;
+import me.lucko.luckperms.bukkit.calculators.ChildProcessor;
+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.UUID;
+
+@AllArgsConstructor
+public class BukkitCalculatorFactory implements CalculatorFactory {
+    private final LPBukkitPlugin plugin;
+
+    @Override
+    public PermissionCalculator build(Contexts contexts, User user) {
+        UUID uuid = plugin.getUuidCache().getExternalUUID(user.getUuid());
+
+        ImmutableList.Builder<PermissionProcessor> processors = ImmutableList.builder();
+        processors.add(new MapProcessor());
+        processors.add(new ChildProcessor(plugin.getChildPermissionProvider()));
+        processors.add(new AttachmentProcessor(() -> {
+            LPPermissible permissible = Injector.getPermissible(uuid);
+            return permissible == null ? null : permissible.getAttachmentPermissions();
+        }));
+        if (plugin.getConfiguration().isApplyingWildcards()) {
+            processors.add(new WildcardProcessor());
+        }
+        if (plugin.getConfiguration().isApplyingRegex()) {
+            processors.add(new RegexProcessor());
+        }
+        processors.add(new DefaultsProcessor(contexts.isOp(), plugin.getDefaultsProvider()));
+
+        return new PermissionCalculator(plugin, user.getName(), processors.build());
+    }
+}
@@ -20,10 +20,14 @@
 *  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.common.commands.CommandManager;
+import me.lucko.luckperms.common.commands.utils.Util;
+import me.lucko.luckperms.common.constants.Patterns;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
@@ -33,19 +37,26 @@ import java.util.Arrays;
 import java.util.List;

 class BukkitCommand extends CommandManager implements CommandExecutor, TabExecutor {
-    BukkitCommand(LuckPermsPlugin plugin) {
+    private final LPBukkitPlugin plugin;
+
+    BukkitCommand(LPBukkitPlugin plugin) {
        super(plugin);
+        this.plugin = plugin;
    }

    @Override
    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        onCommand(BukkitSenderFactory.get().wrap(sender), label, Arrays.asList(args), Callback.empty());
+        onCommand(
+                plugin.getSenderFactory().wrap(sender),
+                label,
+                Util.stripQuotes(Splitter.on(Patterns.COMMAND_SEPARATOR).omitEmptyStrings().splitToList(Joiner.on(' ').join(args))),
+                Callback.empty()
+        );
        return true;
    }

-
    @Override
    public List<String> onTabComplete(CommandSender sender, Command command, String label, String[] args) {
-        return onTabComplete(BukkitSenderFactory.get().wrap(sender), Arrays.asList(args));
+        return onTabComplete(plugin.getSenderFactory().wrap(sender), Arrays.asList(args));
    }
 }
@@ -20,16 +20,20 @@
 *  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.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;

-class BukkitConfig extends LPConfiguration<LPBukkitPlugin> {
+class BukkitConfig extends AbstractConfiguration<LPBukkitPlugin> {
    private YamlConfiguration configuration;

    BukkitConfig(LPBukkitPlugin plugin) {
@@ -46,18 +50,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 +67,35 @@ class BukkitConfig extends LPConfiguration<LPBukkitPlugin> {
    protected boolean getBoolean(String path, boolean def) {
        return configuration.getBoolean(path, def);
    }
+
+    @Override
+    protected List<String> getList(String path, List<String> def) {
+        return Optional.ofNullable(configuration.getStringList(path)).orElse(def);
+    }
+
+    @Override
+    protected List<String> getObjectList(String path, List<String> def) {
+        ConfigurationSection section = configuration.getConfigurationSection(path);
+        if (section == null) {
+            return def;
+        }
+
+        return Optional.ofNullable(section.getKeys(false).stream().collect(Collectors.toList())).orElse(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;
+    }
 }
@@ -20,20 +20,23 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms;
+package me.lucko.luckperms.bukkit;

-import me.lucko.luckperms.constants.Message;
-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.permissions.PermissionAttachment;
+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.Map;
-import java.util.concurrent.ConcurrentHashMap;
+import java.util.UUID;

 class BukkitListener extends AbstractListener implements Listener {
    private final LPBukkitPlugin plugin;
@@ -43,72 +46,89 @@ class BukkitListener extends AbstractListener implements Listener {
        this.plugin = plugin;
    }

-    @EventHandler
+    @EventHandler(priority = EventPriority.LOWEST)
    public void onPlayerPreLogin(AsyncPlayerPreLoginEvent e) {
-        if (!plugin.getDatastore().isAcceptingLogins()) {
+        if (!plugin.isStarted() || !plugin.getStorage().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
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void onPlayerPreLoginMonitor(AsyncPlayerPreLoginEvent e) {
+        if (plugin.isStarted() && plugin.getStorage().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);

-            PermissionAttachment attachment = player.addAttachment(plugin);
-            Map<String, Boolean> newPermMap = new ConcurrentHashMap<>();
-            try {
-                /* Replace the standard LinkedHashMap in the attachment with a ConcurrentHashMap.
-                   This means that we can iterate over and change the permissions within our attachment asynchronously,
-                   without worrying about thread safety. The Bukkit side of things should still operate normally. Internal
-                   permission stuff should work the same. This is by far the most easy and efficient way to do things, without
-                   having to do tons of reflection. */
-                BukkitUser.getPermissionsField().set(attachment, newPermMap);
-            } catch (Throwable t) {
-                t.printStackTrace();
-            }
+            // Inject into the player
+            Injector.inject(player, lpPermissible);

-            u.setAttachment(new BukkitUser.PermissionAttachmentHolder(attachment, newPermMap));
+        } 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
-    public void onPlayerJoin(PlayerJoinEvent e) {
-        // Refresh permissions again
-        plugin.getUserManager().getWorldCache().put(e.getPlayer().getUniqueId(), e.getPlayer().getWorld().getName());
-        plugin.doAsync(() -> refreshPlayer(e.getPlayer().getUniqueId()));
+    @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
-    public void onPlayerChangedWorld(PlayerChangedWorldEvent e) {
-        plugin.getUserManager().getWorldCache().put(e.getPlayer().getUniqueId(), e.getPlayer().getWorld().getName());
-        plugin.doAsync(() -> refreshPlayer(e.getPlayer().getUniqueId()));
-
-    }
-
-    @EventHandler
+    @EventHandler(priority = EventPriority.MONITOR) // Allow other plugins to see data when this event gets called.
    public void onPlayerQuit(PlayerQuitEvent e) {
-        plugin.getUserManager().getWorldCache().remove(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;
        }

@@ -20,25 +20,19 @@
 *  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.sender.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 BukkitSenderFactory get() {
-        if (instance == null){
-            instance = new BukkitSenderFactory();
-        }
-        return instance;
+    public BukkitSenderFactory(LuckPermsPlugin plugin) {
+        super(plugin);
    }

    @Override
@@ -0,0 +1,432 @@
+/*
+ * 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.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.context.ContextSet;
+import me.lucko.luckperms.api.context.MutableContextSet;
+import me.lucko.luckperms.bukkit.calculators.AutoOPListener;
+import me.lucko.luckperms.bukkit.calculators.ChildPermissionProvider;
+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.Sender;
+import me.lucko.luckperms.common.config.LPConfiguration;
+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.messaging.RedisMessaging;
+import me.lucko.luckperms.common.runnables.ExpireTemporaryTask;
+import me.lucko.luckperms.common.runnables.UpdateTask;
+import me.lucko.luckperms.common.storage.Storage;
+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.BufferedRequest;
+import me.lucko.luckperms.common.utils.DebugHandler;
+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.PermissionDefault;
+import org.bukkit.plugin.PluginManager;
+import org.bukkit.plugin.ServicePriority;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.io.File;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.stream.Collectors;
+
+@Getter
+public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
+    private ExecutorService executorService;
+    private Executor syncExecutor;
+    private Executor asyncExecutor;
+    private VaultHook vaultHook = null;
+
+    private final Set<UUID> ignoringLogs = ConcurrentHashMap.newKeySet();
+    private LPConfiguration configuration;
+    private UserManager userManager;
+    private GroupManager groupManager;
+    private TrackManager trackManager;
+    private Storage storage;
+    private RedisMessaging redisMessaging = null;
+    private UuidCache uuidCache;
+    private ApiProvider apiProvider;
+    private Logger log;
+    private Importer importer;
+    private ConsecutiveExecutor consecutiveExecutor;
+    private DefaultsProvider defaultsProvider;
+    private ChildPermissionProvider childPermissionProvider;
+    private LocaleManager localeManager;
+    private ContextManager<Player> contextManager;
+    private WorldCalculator worldCalculator;
+    private CalculatorFactory calculatorFactory;
+    private BufferedRequest<Void> updateTaskBuffer;
+    private boolean started = false;
+    private DebugHandler debugHandler;
+    private BukkitSenderFactory senderFactory;
+
+    @Override
+    public void onEnable() {
+        // Used whilst the server is still starting
+        executorService = Executors.newCachedThreadPool();
+        asyncExecutor = executorService;
+        syncExecutor = r -> getServer().getScheduler().runTask(this, r);
+
+        log = LogFactory.wrap(getLogger());
+        debugHandler = new DebugHandler();
+        senderFactory = new BukkitSenderFactory(this);
+
+        getLog().info("Loading configuration...");
+        configuration = new BukkitConfig(this);
+
+        // setup the Bukkit defaults hook
+        defaultsProvider = new DefaultsProvider();
+        childPermissionProvider = new ChildPermissionProvider();
+
+        // give all plugins a chance to load their defaults, then refresh.
+        getServer().getScheduler().runTaskLater(this, () -> {
+            defaultsProvider.refresh();
+            childPermissionProvider.setup();
+        }, 1L);
+
+        // register events
+        PluginManager pm = getServer().getPluginManager();
+        pm.registerEvents(new BukkitListener(this), this);
+
+        // initialise datastore
+        storage = StorageFactory.getInstance(this, "h2");
+
+        // initialise redis
+        if (getConfiguration().isRedisEnabled()) {
+            getLog().info("Loading redis...");
+            redisMessaging = new RedisMessaging(this);
+            try {
+                redisMessaging.init(getConfiguration().getRedisAddress(), getConfiguration().getRedisPassword());
+                getLog().info("Loaded redis successfully...");
+            } catch (Exception e) {
+                getLog().info("Couldn't load redis...");
+                e.printStackTrace();
+            }
+        }
+
+        // setup the update task buffer
+        updateTaskBuffer = new BufferedRequest<Void>(1000L, this::doAsync) {
+            @Override
+            protected Void perform() {
+                new UpdateTask(LPBukkitPlugin.this).run();
+                return null;
+            }
+        };
+
+        // load locale
+        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 commands
+        getLog().info("Registering commands...");
+        BukkitCommand commandManager = new BukkitCommand(this);
+        PluginCommand main = getServer().getPluginCommand("luckperms");
+        main.setExecutor(commandManager);
+        main.setTabCompleter(commandManager);
+        main.setAliases(Arrays.asList("perms", "lp", "permissions", "p", "perm"));
+
+        // load internal managers
+        getLog().info("Loading internal permission managers...");
+        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()));
+
+        // handle server operators
+        if (getConfiguration().isAutoOp()) {
+            contextManager.registerListener(new AutoOPListener());
+        }
+
+        // Provide vault support
+        getLog().info("Attempting to hook into Vault...");
+        try {
+            if (getServer().getPluginManager().isPluginEnabled("Vault")) {
+                vaultHook = new VaultHook();
+                vaultHook.hook(this);
+                getLog().info("Registered Vault permission & chat hook.");
+            } else {
+                getLog().info("Vault not found.");
+            }
+        } catch (Exception e) {
+            getLog().severe("Error occurred whilst hooking into Vault.");
+            e.printStackTrace();
+        }
+
+        // register with the LP API
+        getLog().info("Registering API...");
+        apiProvider = new ApiProvider(this);
+        ApiHandler.registerProvider(apiProvider);
+        getServer().getServicesManager().register(LuckPermsApi.class, apiProvider, this, ServicePriority.Normal);
+
+
+        // schedule update tasks
+        int mins = getConfiguration().getSyncTime();
+        if (mins > 0) {
+            long ticks = mins * 60 * 20;
+            getServer().getScheduler().runTaskTimerAsynchronously(this, () -> updateTaskBuffer.request(), 20L, ticks);
+        }
+
+        // run an update instantly.
+        updateTaskBuffer.requestDirectly();
+
+        // register tasks
+        getServer().getScheduler().runTaskTimerAsynchronously(this, new ExpireTemporaryTask(this), 60L, 60L);
+        getServer().getScheduler().runTaskTimerAsynchronously(this, consecutiveExecutor, 20L, 20L);
+
+        // register permissions
+        registerPermissions(getConfiguration().isCommandsAllowOp() ? PermissionDefault.OP : PermissionDefault.FALSE);
+        if (!getConfiguration().isOpsEnabled()) {
+            getServer().getOperators().forEach(o -> o.setOp(false));
+        }
+
+        // replace the temporary executor when the Bukkit one starts
+        getServer().getScheduler().runTaskAsynchronously(this, () -> {
+            asyncExecutor = r -> getServer().getScheduler().runTaskAsynchronously(this, r);
+        });
+
+        started = true;
+        getLog().info("Successfully loaded.");
+    }
+
+    @Override
+    public void onDisable() {
+        started = false;
+        getLog().info("Closing datastore...");
+        storage.shutdown();
+
+        if (redisMessaging != null) {
+            getLog().info("Closing redis...");
+            redisMessaging.shutdown();
+        }
+
+        getLog().info("Unregistering API...");
+        ApiHandler.unregisterProvider();
+        getServer().getServicesManager().unregisterAll(this);
+
+        if (vaultHook != null) {
+            vaultHook.unhook(this);
+        }
+    }
+
+    @Override
+    public void doAsync(Runnable r) {
+        asyncExecutor.execute(r);
+    }
+
+    @Override
+    public void doSync(Runnable r) {
+        syncExecutor.execute(r);
+    }
+
+    @Override
+    public void doAsyncRepeating(Runnable r, long interval) {
+        getServer().getScheduler().runTaskTimerAsynchronously(this, r, interval, interval);
+    }
+
+    @Override
+    public String getVersion() {
+        return getDescription().getVersion();
+    }
+
+    @Override
+    public PlatformType getType() {
+        return PlatformType.BUKKIT;
+    }
+
+    @Override
+    public File getMainDir() {
+        return getDataFolder();
+    }
+
+    @Override
+    public int getPlayerCount() {
+        return getServer().getOnlinePlayers().size();
+    }
+
+    @Override
+    public List<String> getPlayerList() {
+        return getServer().getOnlinePlayers().stream().map(Player::getName).collect(Collectors.toList());
+    }
+
+    @Override
+    public Set<UUID> getOnlinePlayers() {
+        return getServer().getOnlinePlayers().stream().map(Player::getUniqueId).collect(Collectors.toSet());
+    }
+
+    @Override
+    public boolean isOnline(UUID external) {
+        return getServer().getPlayer(external) != null;
+    }
+
+    @Override
+    public List<Sender> getSenders() {
+        return getServer().getOnlinePlayers().stream()
+                .map(p -> getSenderFactory().wrap(p))
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    public Sender getConsoleSender() {
+        return getSenderFactory().wrap(getServer().getConsoleSender());
+    }
+
+    @Override
+    public Set<Contexts> getPreProcessContexts(boolean op) {
+        Set<ContextSet> c = new HashSet<>();
+        c.add(ContextSet.empty());
+        c.add(ContextSet.singleton("server", getConfiguration().getServer()));
+
+        // Pre process all worlds
+        c.addAll(getServer().getWorlds().stream()
+                .map(World::getName)
+                .map(s -> {
+                    MutableContextSet set = new MutableContextSet();
+                    set.add("server", getConfiguration().getServer());
+                    set.add("world", s);
+                    return set.makeImmutable();
+                })
+                .collect(Collectors.toList())
+        );
+
+        // Pre process the separate Vault server, if any
+        if (!getConfiguration().getServer().equals(getConfiguration().getVaultServer())) {
+            c.add(ContextSet.singleton("server", getConfiguration().getVaultServer()));
+            c.addAll(getServer().getWorlds().stream()
+                    .map(World::getName)
+                    .map(s -> {
+                        MutableContextSet set = new MutableContextSet();
+                        set.add("server", getConfiguration().getVaultServer());
+                        set.add("world", s);
+                        return set.makeImmutable();
+                    })
+                    .collect(Collectors.toList())
+            );
+        }
+
+        Set<Contexts> contexts = new HashSet<>();
+
+        // Convert to full Contexts
+        contexts.addAll(c.stream()
+                .map(set -> new Contexts(
+                        set,
+                        getConfiguration().isIncludingGlobalPerms(),
+                        getConfiguration().isIncludingGlobalWorldPerms(),
+                        true,
+                        getConfiguration().isApplyingGlobalGroups(),
+                        getConfiguration().isApplyingGlobalWorldGroups(),
+                        op
+                ))
+                .collect(Collectors.toSet())
+        );
+
+        // Check for and include varying Vault config options
+        boolean vaultDiff = getConfiguration().isVaultIncludingGlobal() != getConfiguration().isIncludingGlobalPerms() ||
+                !getConfiguration().isIncludingGlobalWorldPerms() ||
+                !getConfiguration().isApplyingGlobalGroups() ||
+                !getConfiguration().isApplyingGlobalWorldGroups();
+
+        if (vaultDiff) {
+            contexts.addAll(c.stream()
+                    .map(map -> new Contexts(map, getConfiguration().isVaultIncludingGlobal(), true, true, true, true, op))
+                    .collect(Collectors.toSet())
+            );
+        }
+
+        return contexts;
+    }
+
+    @Override
+    public Object getPlugin(String name) {
+        return getServer().getPluginManager().getPlugin(name);
+    }
+
+    @Override
+    public Object getService(Class clazz) {
+        return getServer().getServicesManager().load(clazz);
+    }
+
+    @SuppressWarnings("deprecation")
+    @Override
+    public UUID getUUID(String playerName) {
+        try {
+            return getServer().getOfflinePlayer(playerName).getUniqueId();
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+    @Override
+    public boolean isPluginLoaded(String name) {
+        return getServer().getPluginManager().isPluginEnabled(name);
+    }
+
+    private void registerPermissions(PermissionDefault def) {
+        PluginManager pm = getServer().getPluginManager();
+
+        for (Permission p : Permission.values()) {
+            for (String node : p.getNodes()) {
+                pm.addPermission(new org.bukkit.permissions.Permission(node, def));
+            }
+        }
+    }
+}
@@ -0,0 +1,103 @@
+/*
+ * 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.api.context.MutableContextSet;
+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 org.bukkit.event.player.PlayerLoginEvent;
+
+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 MutableContextSet giveApplicableContext(Player subject, MutableContextSet accumulator) {
+        String world = getWorld(subject);
+
+        if (world != null) {
+            accumulator.add(Maps.immutableEntry(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());
+        String world = worldCache.get(internal);
+        if (world == null) {
+            return null;
+        }
+
+        return plugin.getConfiguration().getWorldRewrites().getOrDefault(world, world);
+    }
+
+    @EventHandler(priority = EventPriority.LOW)
+    public void onPlayerJoin(PlayerLoginEvent e) {
+        UUID internal = plugin.getUuidCache().getUUID(e.getPlayer().getUniqueId());
+        worldCache.put(internal, e.getPlayer().getWorld().getName());
+        pushUpdate(
+                e.getPlayer(),
+                Maps.immutableEntry(WORLD_KEY, null),
+                Maps.immutableEntry(WORLD_KEY, e.getPlayer().getWorld().getName())
+        );
+    }
+
+    @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())
+        );
+    }
+}
@@ -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.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;
+        }
+
+        PermissionAttachmentInfo pai = m.get(permission);
+        return pai == null ? Tristate.UNDEFINED : Tristate.fromBoolean(pai.getValue());
+    }
+
+    @Override
+    public void updateBacking(Map<String, Boolean> map) {
+        // Do nothing, this doesn't use the backing
+    }
+
+}
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.bukkit.calculators;
+
+import me.lucko.luckperms.api.context.ContextListener;
+import me.lucko.luckperms.bukkit.inject.Injector;
+import me.lucko.luckperms.bukkit.inject.LPPermissible;
+import org.bukkit.entity.Player;
+
+import java.util.Map;
+import java.util.Optional;
+
+public class AutoOPListener implements ContextListener<Player> {
+
+    @Override
+    public void onContextChange(Player subject, Map.Entry<String, String> before, Map.Entry<String, String> current) throws Exception {
+        LPPermissible permissible = Injector.getPermissible(subject.getUniqueId());
+        if (permissible == null) {
+            return;
+        }
+
+        Map<String, Boolean> backing = permissible.getUser().getUserData().getPermissionData(permissible.calculateContexts()).getImmutableBacking();
+        boolean op = Optional.ofNullable(backing.get("luckperms.autoop")).orElse(false);
+        subject.setOp(op);
+    }
+
+}
@@ -0,0 +1,75 @@
+/*
+ * 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 com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Maps;
+import lombok.Getter;
+import org.bukkit.Bukkit;
+import org.bukkit.permissions.Permission;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+public class ChildPermissionProvider {
+
+    @Getter
+    private ImmutableMap<Map.Entry<String, Boolean>, ImmutableMap<String, Boolean>> permissions = ImmutableMap.of();
+
+    public void setup() {
+        ImmutableMap.Builder<Map.Entry<String, Boolean>, ImmutableMap<String, Boolean>> permissions = ImmutableMap.builder();
+
+        for (Permission permission : Bukkit.getServer().getPluginManager().getPermissions()) {
+            // handle true
+            Map<String, Boolean> children = new HashMap<>();
+            resolveChildren(children, Collections.singletonMap(permission.getName(), true), false);
+            permissions.put(Maps.immutableEntry(permission.getName().toLowerCase(), true), ImmutableMap.copyOf(children));
+
+            // handle false
+            Map<String, Boolean> nChildren = new HashMap<>();
+            resolveChildren(nChildren, Collections.singletonMap(permission.getName(), false), false);
+            permissions.put(Maps.immutableEntry(permission.getName().toLowerCase(), false), ImmutableMap.copyOf(nChildren));
+        }
+
+        this.permissions = permissions.build();
+    }
+
+    private static void resolveChildren(Map<String, Boolean> accumulator, Map<String, Boolean> children, boolean invert) {
+        for (Map.Entry<String, Boolean> e : children.entrySet()) {
+            if (accumulator.containsKey(e.getKey())) {
+                continue; // Prevent infinite loops
+            }
+
+            Permission perm = Bukkit.getServer().getPluginManager().getPermission(e.getKey());
+            boolean value = e.getValue() ^ invert;
+            String lName = e.getKey().toLowerCase();
+
+            accumulator.put(lName, value);
+
+            if (perm != null) {
+                resolveChildren(accumulator, perm.getChildren(), !value);
+            }
+        }
+    }
+}
@@ -20,41 +20,34 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.users;
+package me.lucko.luckperms.bukkit.calculators;

-import me.lucko.luckperms.LPSpongePlugin;
+import lombok.RequiredArgsConstructor;
+import me.lucko.luckperms.api.Tristate;
+import me.lucko.luckperms.common.calculators.PermissionProcessor;

-import java.util.UUID;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;

-public class SpongeUserManager extends UserManager {
-    private final LPSpongePlugin plugin;
+@RequiredArgsConstructor
+public class ChildProcessor implements PermissionProcessor {
+    private final ChildPermissionProvider provider;
+    private Map<String, Boolean> childPermissions = new ConcurrentHashMap<>();

-    public SpongeUserManager(LPSpongePlugin plugin) {
-        super(plugin);
-        this.plugin = plugin;
+    @Override
+    public Tristate hasPermission(String permission) {
+        Boolean b = childPermissions.get(permission);
+        return b == null ? Tristate.UNDEFINED : Tristate.fromBoolean(b);
    }

    @Override
-    public void cleanup(User user) {
-        if (!plugin.getGame().getServer().getPlayer(plugin.getUuidCache().getExternalUUID(user.getUuid())).isPresent()) {
-            unload(user);
+    public void updateBacking(Map<String, Boolean> map) {
+        childPermissions.clear();
+        for (Map.Entry<String, Boolean> e : map.entrySet()) {
+            Map<String, Boolean> children = provider.getPermissions().get(e);
+            if (children != null) {
+                childPermissions.putAll(children);
+            }
        }
    }
-
-    @Override
-    public User make(UUID uuid) {
-        return new SpongeUser(uuid, plugin);
-    }
-
-    @Override
-    public User make(UUID uuid, String username) {
-        return new SpongeUser(uuid, username, plugin);
-    }
-
-    @Override
-    public void updateAllUsers() {
-        plugin.getGame().getServer().getOnlinePlayers().stream()
-                .map(p -> plugin.getUuidCache().getUUID(p.getUniqueId()))
-                .forEach(u -> plugin.getDatastore().loadUser(u, "null"));
-    }
 }
@@ -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 me.lucko.luckperms.api.Tristate;
+import me.lucko.luckperms.common.calculators.PermissionProcessor;
+import org.bukkit.Bukkit;
+import org.bukkit.permissions.Permission;
+
+import java.util.Map;
+
+@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);
+        return defPerm == null ? Tristate.UNDEFINED : Tristate.fromBoolean(defPerm.getDefault().getValue(isOp));
+    }
+
+    @Override
+    public void updateBacking(Map<String, Boolean> map) {
+        // Do nothing, this doesn't use the backing
+    }
+}
@@ -0,0 +1,175 @@
+/*
+ * 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;
+
+        Boolean b = map.get(permission);
+        return b == null ? Tristate.UNDEFINED : Tristate.fromBoolean(b);
+    }
+
+    @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) {
+
+        }
+    }
+
+}
@@ -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();
+    }
+}
@@ -0,0 +1,102 @@
+/*
+ * 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 lombok.experimental.UtilityClass;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.permissions.Permissible;
+
+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(getVersionedClassName("entity.CraftHumanEntity")).getDeclaredField("perm");
+            HUMAN_ENTITY_FIELD.setAccessible(true);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static boolean inject(Player player, LPPermissible permissible) {
+        try {
+            HUMAN_ENTITY_FIELD.set(player, permissible);
+            INJECTED_PERMISSIBLES.put(player.getUniqueId(), permissible);
+            return true;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+
+    public static boolean unInject(Player player) {
+        try {
+            Permissible permissible = (Permissible) HUMAN_ENTITY_FIELD.get(player);
+            if (permissible instanceof LPPermissible) {
+                /* 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();
+            return false;
+        }
+    }
+
+    public static LPPermissible getPermissible(UUID uuid) {
+        return INJECTED_PERMISSIBLES.get(uuid);
+    }
+
+    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);
+        }
+
+        String version;
+        if (server.getName().equals("org.bukkit.craftbukkit.CraftServer")) {
+            // Non versioned class
+            version = ".";
+        } else {
+            version = server.getName().substring("org.bukkit.craftbukkit".length());
+            version = version.substring(0, version.length() - "CraftServer".length());
+        }
+
+        return "org.bukkit.craftbukkit" + version + className;
+    }
+
+}
@@ -0,0 +1,257 @@
+/*
+ * 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 lombok.Getter;
+import lombok.NonNull;
+import me.lucko.luckperms.api.Contexts;
+import me.lucko.luckperms.api.Tristate;
+import me.lucko.luckperms.bukkit.LPBukkitPlugin;
+import me.lucko.luckperms.common.users.User;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.permissions.*;
+import org.bukkit.plugin.Plugin;
+
+import java.util.*;
+import java.util.logging.Level;
+import java.util.stream.Collectors;
+
+/**
+ * Modified PermissibleBase for LuckPerms
+ */
+public class LPPermissible extends PermissibleBase {
+
+    @Getter
+    private final User user;
+
+    @Getter
+    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 Player parent, User user, LPBukkitPlugin plugin) {
+        super(parent);
+        this.user = user;
+        this.parent = parent;
+        this.plugin = plugin;
+
+        recalculatePermissions();
+    }
+
+    public Contexts calculateContexts() {
+        return new Contexts(
+                plugin.getContextManager().getApplicableContext(parent),
+                plugin.getConfiguration().isIncludingGlobalPerms(),
+                plugin.getConfiguration().isIncludingGlobalWorldPerms(),
+                true,
+                plugin.getConfiguration().isApplyingGlobalGroups(),
+                plugin.getConfiguration().isApplyingGlobalWorldGroups(),
+                parent.isOp()
+        );
+    }
+
+    private boolean hasData() {
+        return user.getUserData() != null;
+    }
+
+    @Override
+    public void setOp(boolean value) {
+        parent.setOp(value);
+    }
+
+    @Override
+    public boolean isPermissionSet(@NonNull String name) {
+        return hasData() && user.getUserData().getPermissionData(calculateContexts()).getPermissionValue(name) != Tristate.UNDEFINED;
+    }
+
+    @Override
+    public boolean isPermissionSet(@NonNull Permission perm) {
+        return isPermissionSet(perm.getName());
+    }
+
+    @Override
+    public boolean hasPermission(@NonNull String name) {
+        if (hasData()) {
+            Tristate ts = user.getUserData().getPermissionData(calculateContexts()).getPermissionValue(name);
+            if (ts != Tristate.UNDEFINED) {
+                return ts.asBoolean();
+            }
+        }
+
+        return Permission.DEFAULT_PERMISSION.getValue(isOp());
+    }
+
+    @Override
+    public boolean hasPermission(@NonNull Permission perm) {
+        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()) {
+            throw new IllegalArgumentException("Plugin " + plugin.getDescription().getFullName() + " is not enabled");
+        }
+
+        PermissionAttachment result = addAttachment(plugin);
+        result.setPermission(name, value);
+
+        recalculatePermissions();
+
+        return result;
+    }
+
+    @Override
+    public PermissionAttachment addAttachment(@NonNull Plugin plugin) {
+        if (!plugin.isEnabled()) {
+            throw new IllegalArgumentException("Plugin " + plugin.getDescription().getFullName() + " is not enabled");
+        }
+
+        PermissionAttachment result = new PermissionAttachment(plugin, parent);
+
+        attachments.add(result);
+        recalculatePermissions();
+
+        return result;
+    }
+
+    @Override
+    public PermissionAttachment addAttachment(@NonNull Plugin plugin, @NonNull String name, boolean value, int ticks) {
+        if (!plugin.isEnabled()) {
+            throw new IllegalArgumentException("Plugin " + plugin.getDescription().getFullName() + " is not enabled");
+        }
+
+        PermissionAttachment result = addAttachment(plugin, ticks);
+        if (result != null) {
+            result.setPermission(name, value);
+        }
+
+        return result;
+    }
+
+    @Override
+    public PermissionAttachment addAttachment(@NonNull Plugin plugin, int ticks) {
+        if (!plugin.isEnabled()) {
+            throw new IllegalArgumentException("Plugin " + plugin.getDescription().getFullName() + " is not enabled");
+        }
+
+        PermissionAttachment result = addAttachment(plugin);
+        if (Bukkit.getServer().getScheduler().scheduleSyncDelayedTask(plugin, () -> result.remove(), ticks) == -1) {
+            Bukkit.getServer().getLogger().log(Level.WARNING, "Could not add PermissionAttachment to " + parent + " for plugin " + plugin.getDescription().getFullName() + ": Scheduler returned -1");
+            result.remove();
+            return null;
+        } else {
+            return result;
+        }
+    }
+
+    @Override
+    public void removeAttachment(@NonNull PermissionAttachment attachment) {
+        if (attachments.contains(attachment)) {
+            attachments.remove(attachment);
+            PermissionRemovedExecutor ex = attachment.getRemovalCallback();
+
+            if (ex != null) {
+                ex.attachmentRemoved(attachment);
+            }
+
+            recalculatePermissions();
+        } else {
+            throw new IllegalArgumentException("Given attachment is not part of Permissible object " + parent);
+        }
+    }
+
+    @Override
+    public void recalculatePermissions() {
+        if (attachmentPermissions == null) {
+            return;
+        }
+
+        attachmentPermissions.clear();
+
+        for (PermissionAttachment attachment : attachments) {
+            calculateChildPermissions(attachment.getPermissions(), false, attachment);
+        }
+
+        if (hasData()) {
+            user.getUserData().invalidatePermissionCalculators();
+        }
+    }
+
+    @Override
+    public synchronized void clearPermissions() {
+        Set<String> perms = attachmentPermissions.keySet();
+
+        for (String name : perms) {
+            Bukkit.getServer().getPluginManager().unsubscribeFromPermission(name, parent);
+        }
+
+        Bukkit.getServer().getPluginManager().unsubscribeFromDefaultPerms(false, parent);
+        Bukkit.getServer().getPluginManager().unsubscribeFromDefaultPerms(true, parent);
+
+        attachmentPermissions.clear();
+    }
+
+    private void calculateChildPermissions(Map<String, Boolean> children, boolean invert, PermissionAttachment attachment) {
+        for (Map.Entry<String, Boolean> e : children.entrySet()) {
+            Permission perm = Bukkit.getServer().getPluginManager().getPermission(e.getKey());
+            boolean value = e.getValue() ^ invert;
+            String name = e.getKey().toLowerCase();
+
+            attachmentPermissions.put(name, new PermissionAttachmentInfo(parent, name, attachment, value));
+            Bukkit.getServer().getPluginManager().subscribeToPermission(name, parent);
+
+            if (perm != null) {
+                calculateChildPermissions(perm.getChildren(), !value, attachment);
+            }
+        }
+    }
+}
@@ -1,23 +1,46 @@
-package me.lucko.luckperms.commands.migration.subcommands;
+/*
+ * 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.migration;

 import de.bananaco.bpermissions.api.*;
-import me.lucko.luckperms.LuckPermsPlugin;
 import me.lucko.luckperms.api.Logger;
-import me.lucko.luckperms.commands.CommandResult;
-import me.lucko.luckperms.commands.Predicate;
-import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
-import me.lucko.luckperms.constants.Constants;
-import me.lucko.luckperms.core.PermissionHolder;
-import me.lucko.luckperms.data.LogEntry;
+import me.lucko.luckperms.api.MetaUtils;
+import me.lucko.luckperms.common.LuckPermsPlugin;
+import me.lucko.luckperms.common.commands.CommandException;
+import me.lucko.luckperms.common.commands.CommandResult;
+import me.lucko.luckperms.common.commands.SubCommand;
+import me.lucko.luckperms.common.commands.sender.Sender;
+import me.lucko.luckperms.common.constants.Constants;
+import me.lucko.luckperms.common.core.PermissionHolder;
+import me.lucko.luckperms.common.data.LogEntry;
+import me.lucko.luckperms.common.utils.Predicates;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
-import me.lucko.luckperms.utils.ArgumentChecker;

 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.*;

-import static me.lucko.luckperms.constants.Permission.MIGRATION;
+import static me.lucko.luckperms.common.constants.Permission.MIGRATION;

 public class MigrationBPermissions extends SubCommand<Object> {
    private static Field uConfigField;
@@ -60,11 +83,11 @@ public class MigrationBPermissions extends SubCommand<Object> {
    }

    public MigrationBPermissions() {
-        super("bpermissions", "Migration from bPermissions", "/%s migration bpermissions", MIGRATION, Predicate.alwaysFalse());
+        super("bpermissions", "Migration from bPermissions", MIGRATION, Predicates.alwaysFalse(), null);
    }

    @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) {
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) throws CommandException {
        final Logger log = plugin.getLog();

        WorldManager worldManager = WorldManager.getInstance();
@@ -99,8 +122,8 @@ public class MigrationBPermissions extends SubCommand<Object> {
                }

                // Make a LuckPerms group for the one being migrated.
-                plugin.getDatastore().createAndLoadGroup(groupName);
-                me.lucko.luckperms.groups.Group lpGroup = plugin.getGroupManager().get(groupName);
+                plugin.getStorage().createAndLoadGroup(groupName).join();
+                me.lucko.luckperms.common.groups.Group lpGroup = plugin.getGroupManager().get(groupName);
                try {
                    LogEntry.build()
                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
@@ -111,7 +134,7 @@ public class MigrationBPermissions extends SubCommand<Object> {
                }
                
                migrateHolder(plugin, world, group, lpGroup);
-                plugin.getDatastore().saveGroup(lpGroup);
+                plugin.getStorage().saveGroup(lpGroup);
            }
            log.info("bPermissions Migration: Migrated " + groupCount + " groups in world " + world.getName() + ".");

@@ -135,12 +158,12 @@ public class MigrationBPermissions extends SubCommand<Object> {
                }

                // Make a LuckPerms user for the one being migrated.
-                plugin.getDatastore().loadUser(uuid, "null");
-                me.lucko.luckperms.users.User lpUser = plugin.getUserManager().get(uuid);
+                plugin.getStorage().loadUser(uuid, "null").join();
+                me.lucko.luckperms.common.users.User lpUser = plugin.getUserManager().get(uuid);

                migrateHolder(plugin, world, user, lpUser);

-                plugin.getDatastore().saveUser(lpUser);
+                plugin.getStorage().saveUser(lpUser);
                plugin.getUserManager().cleanup(lpUser);
            }

@@ -200,7 +223,7 @@ public class MigrationBPermissions extends SubCommand<Object> {
        // Migrate existing meta
        for (Map.Entry<String, String> meta : c.getMeta().entrySet()) {
            if (meta.getKey().equalsIgnoreCase("prefix") || meta.getKey().equalsIgnoreCase("suffix")) {
-                String chatMeta = ArgumentChecker.escapeCharacters(meta.getValue());
+                String chatMeta = MetaUtils.escapeCharacters(meta.getValue());
                try {
                    holder.setPermission(meta.getKey().toLowerCase() + "." + c.getPriority() + "." + chatMeta, true);
                    LogEntry.build()
@@ -20,18 +20,22 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.commands.migration.subcommands;
+package me.lucko.luckperms.bukkit.migration;

-import me.lucko.luckperms.LuckPermsPlugin;
 import me.lucko.luckperms.api.Logger;
-import me.lucko.luckperms.commands.CommandResult;
-import me.lucko.luckperms.commands.Predicate;
-import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
-import me.lucko.luckperms.constants.Constants;
-import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.data.LogEntry;
+import me.lucko.luckperms.common.LuckPermsPlugin;
+import me.lucko.luckperms.common.commands.Arg;
+import me.lucko.luckperms.common.commands.CommandException;
+import me.lucko.luckperms.common.commands.CommandResult;
+import me.lucko.luckperms.common.commands.SubCommand;
+import me.lucko.luckperms.common.commands.sender.Sender;
+import me.lucko.luckperms.common.constants.Constants;
+import me.lucko.luckperms.common.constants.Permission;
+import me.lucko.luckperms.common.core.NodeFactory;
+import me.lucko.luckperms.common.data.LogEntry;
+import me.lucko.luckperms.common.utils.Predicates;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
 import org.anjocaido.groupmanager.GlobalGroups;
 import org.anjocaido.groupmanager.GroupManager;
 import org.anjocaido.groupmanager.data.Group;
@@ -39,18 +43,18 @@ import org.anjocaido.groupmanager.data.User;
 import org.anjocaido.groupmanager.dataholder.WorldDataHolder;
 import org.anjocaido.groupmanager.dataholder.worlds.WorldsHolder;

-import java.lang.reflect.InvocationTargetException;
 import java.util.*;
 import java.util.stream.Collectors;

 public class MigrationGroupManager extends SubCommand<Object> {
    public MigrationGroupManager() {
-        super("groupmanager", "Migration from GroupManager", "/%s migration groupmanager [world names]",
-                Permission.MIGRATION, Predicate.is(0));
+        super("groupmanager", "Migration from GroupManager", Permission.MIGRATION, Predicates.is(0),
+                Arg.list(Arg.create("world names...", false, "a list of worlds to migrate permissions from"))
+        );
    }

    @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) {
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) throws CommandException {
        final Logger log = plugin.getLog();
        if (!plugin.isPluginLoaded("GroupManager")) {
            log.severe("GroupManager Migration: Error -> GroupManager is not loaded.");
@@ -65,18 +69,11 @@ public class MigrationGroupManager extends SubCommand<Object> {

        // Migrate Global Groups
        log.info("GroupManager Migration: Starting Global Group migration.");
-
-        GlobalGroups gg;
-        try {
-            gg = (GlobalGroups) GroupManager.class.getMethod("getGlobalGroups").invoke(gm);
-        } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
-            e.printStackTrace();
-            return CommandResult.FAILURE;
-        }
+        GlobalGroups gg = GroupManager.getGlobalGroups();

        for (Group g : gg.getGroupList()) {
-            plugin.getDatastore().createAndLoadGroup(g.getName().toLowerCase());
-            me.lucko.luckperms.groups.Group group = plugin.getGroupManager().get(g.getName().toLowerCase());
+            plugin.getStorage().createAndLoadGroup(g.getName().toLowerCase()).join();
+            me.lucko.luckperms.common.groups.Group group = plugin.getGroupManager().get(g.getName().toLowerCase());
            try {
                LogEntry.build()
                        .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
@@ -123,32 +120,21 @@ public class MigrationGroupManager extends SubCommand<Object> {
                }
            }

+            plugin.getStorage().saveGroup(group);
        }

        Map<UUID, Map<Map.Entry<String, String>, Boolean>> users = new HashMap<>();
+        Map<UUID, String> primaryGroups = new HashMap<>();
        Map<String, Map<Map.Entry<String, String>, Boolean>> groups = new HashMap<>();

-        WorldsHolder wh;
-        try {
-            wh = (WorldsHolder) GroupManager.class.getMethod("getWorldsHolder").invoke(gm);
-        } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
-            e.printStackTrace();
-            return CommandResult.FAILURE;
-        }
+        WorldsHolder wh = gm.getWorldsHolder();

        // Collect data for all users and groups.
        log.info("GroupManager Migration: Starting user and group migration.");
        for (String world : worlds) {
            world = world.toLowerCase();

-            WorldDataHolder wdh;
-
-            try {
-                wdh = (WorldDataHolder) WorldsHolder.class.getMethod("getWorldData", String.class).invoke(wh, world);
-            } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
-                e.printStackTrace();
-                return CommandResult.FAILURE;
-            }
+            WorldDataHolder wdh = wh.getWorldData(world);

            for (Group g : wdh.getGroupList()) {
                groups.putIfAbsent(g.getName().toLowerCase(), new HashMap<>());
@@ -194,7 +180,13 @@ public class MigrationGroupManager extends SubCommand<Object> {
                    users.get(uuid).put(new AbstractMap.SimpleEntry<>(world, node), value);
                }

-                users.get(uuid).put(new AbstractMap.SimpleEntry<>(world, "group." + user.getGroupName().toLowerCase()), true);
+                String finalWorld = world;
+                users.get(uuid).putAll(user.subGroupListStringCopy().stream()
+                        .map(n -> "group." + n)
+                        .map(n -> new AbstractMap.SimpleEntry<>(finalWorld, n))
+                        .collect(Collectors.toMap(n -> n, n -> true))
+                );
+                primaryGroups.put(uuid, user.getGroupName());
            }

        }
@@ -203,8 +195,8 @@ public class MigrationGroupManager extends SubCommand<Object> {
        log.info("GroupManager Migration: Found a total of " + users.size() + " users and " + groups.size() + " groups.");

        for (Map.Entry<String, Map<Map.Entry<String, String>, Boolean>> e : groups.entrySet()) {
-            plugin.getDatastore().createAndLoadGroup(e.getKey());
-            me.lucko.luckperms.groups.Group group = plugin.getGroupManager().get(e.getKey());
+            plugin.getStorage().createAndLoadGroup(e.getKey()).join();
+            me.lucko.luckperms.common.groups.Group group = plugin.getGroupManager().get(e.getKey());
            try {
                LogEntry.build()
                        .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
@@ -220,7 +212,7 @@ public class MigrationGroupManager extends SubCommand<Object> {
                // n.key.value = node
                // n.value = true/false
                try {
-                    group.setPermission("global-" + n.getKey().getKey() + "/" + n.getKey().getValue(), n.getValue());
+                    group.setPermission(NodeFactory.fromSerialisedNode("global-" + n.getKey().getKey() + "/" + n.getKey().getValue(), n.getValue()));

                    if (n.getKey().getValue().startsWith("group.")) {
                        String groupName = n.getKey().getValue().substring(6);
@@ -242,19 +234,19 @@ public class MigrationGroupManager extends SubCommand<Object> {
                }
            }

-            plugin.getDatastore().saveGroup(group);
+            plugin.getStorage().saveGroup(group);
        }

        for (Map.Entry<UUID, Map<Map.Entry<String, String>, Boolean>> e : users.entrySet()) {
-            plugin.getDatastore().loadUser(e.getKey(), "null");
-            me.lucko.luckperms.users.User user = plugin.getUserManager().get(e.getKey());
+            plugin.getStorage().loadUser(e.getKey(), "null").join();
+            me.lucko.luckperms.common.users.User user = plugin.getUserManager().get(e.getKey());

            for (Map.Entry<Map.Entry<String, String>, Boolean> n : e.getValue().entrySet()) {
                // n.key.key = world
                // n.key.value = node
                // n.value = true/false
                try {
-                    user.setPermission("global-" + n.getKey().getKey() + "/" + n.getKey().getValue(), n.getValue());
+                    user.setPermission(NodeFactory.fromSerialisedNode("global-" + n.getKey().getKey() + "/" + n.getKey().getValue(), n.getValue()));

                    if (n.getKey().getValue().startsWith("group.")) {
                        String group = n.getKey().getValue().substring(6);
@@ -276,7 +268,18 @@ public class MigrationGroupManager extends SubCommand<Object> {
                }
            }

-            plugin.getDatastore().saveUser(user);
+            String primaryGroup = primaryGroups.get(e.getKey());
+            if (primaryGroup != null) {
+                try {
+                    user.setPermission("group." + primaryGroup, true);
+                } catch (ObjectAlreadyHasException ignored) {}
+                user.setPrimaryGroup(primaryGroup);
+                try {
+                    user.unsetPermission("group.default");
+                } catch (ObjectLacksException ignored) {}
+            }
+
+            plugin.getStorage().saveUser(user);
            plugin.getUserManager().cleanup(user);
        }

@@ -20,22 +20,24 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.commands.migration.subcommands;
+package me.lucko.luckperms.bukkit.migration;

-import me.lucko.luckperms.LuckPermsPlugin;
 import me.lucko.luckperms.api.Logger;
+import me.lucko.luckperms.api.MetaUtils;
 import me.lucko.luckperms.api.PlatformType;
-import me.lucko.luckperms.commands.CommandResult;
-import me.lucko.luckperms.commands.Predicate;
-import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
-import me.lucko.luckperms.constants.Constants;
-import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.data.LogEntry;
+import me.lucko.luckperms.common.LuckPermsPlugin;
+import me.lucko.luckperms.common.commands.Arg;
+import me.lucko.luckperms.common.commands.CommandException;
+import me.lucko.luckperms.common.commands.CommandResult;
+import me.lucko.luckperms.common.commands.SubCommand;
+import me.lucko.luckperms.common.commands.sender.Sender;
+import me.lucko.luckperms.common.constants.Constants;
+import me.lucko.luckperms.common.constants.Permission;
+import me.lucko.luckperms.common.data.LogEntry;
+import me.lucko.luckperms.common.groups.Group;
+import me.lucko.luckperms.common.users.User;
+import me.lucko.luckperms.common.utils.Predicates;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
-import me.lucko.luckperms.groups.Group;
-import me.lucko.luckperms.users.User;
-import me.lucko.luckperms.utils.ArgumentChecker;
 import ru.tehkode.permissions.NativeInterface;
 import ru.tehkode.permissions.PermissionGroup;
 import ru.tehkode.permissions.PermissionManager;
@@ -43,20 +45,20 @@ import ru.tehkode.permissions.PermissionUser;
 import ru.tehkode.permissions.bukkit.PermissionsEx;

 import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
 import java.util.List;
 import java.util.UUID;
 import java.util.stream.Collectors;

 public class MigrationPermissionsEx extends SubCommand<Object> {
    public MigrationPermissionsEx() {
-        super("permissionsex", "Migration from PermissionsEx", "/%s migration permissionsex [world names]",
-                Permission.MIGRATION, Predicate.alwaysFalse());
+        super("permissionsex", "Migration from PermissionsEx", Permission.MIGRATION, Predicates.alwaysFalse(),
+                Arg.list(Arg.create("world names...", false, "a list of worlds to migrate permissions from"))
+        );
    }

    @SuppressWarnings("deprecation")
    @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) {
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) throws CommandException {
        final Logger log = plugin.getLog();
        if (!plugin.isPluginLoaded("PermissionsEx")) {
            log.severe("PermissionsEx Migration: Error -> PermissionsEx is not loaded.");
@@ -74,13 +76,7 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
                .collect(Collectors.toList());

        PermissionsEx pex = (PermissionsEx) plugin.getPlugin("PermissionsEx");
-        PermissionManager manager; // The compiler complains if you call the method directly, as Bukkit is not in this module.
-        try {
-            manager = (PermissionManager) PermissionsEx.class.getMethod("getPermissionsManager").invoke(pex);
-        } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
-            e.printStackTrace();
-            return CommandResult.FAILURE;
-        }
+        PermissionManager manager = pex.getPermissionsManager();

        NativeInterface ni;
        try {
@@ -104,7 +100,7 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
            maxGroupWeight = Math.max(maxGroupWeight, groupWeight);

            final String name = group.getName().toLowerCase();
-            plugin.getDatastore().createAndLoadGroup(name);
+            plugin.getStorage().createAndLoadGroup(name).join();
            Group lpGroup = plugin.getGroupManager().get(name);
            try {
                LogEntry.build()
@@ -118,7 +114,7 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
            try {
                for (String node : group.getOwnPermissions(null)) {
                    boolean value = true;
-                    if (node.startsWith("!")) {
+                    if (node.startsWith("-")) {
                        node = node.substring(1);
                        value = false;
                    }
@@ -143,7 +139,7 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
                for (String world : worlds) {
                    for (String node : group.getOwnPermissions(world)) {
                        boolean value = true;
-                        if (node.startsWith("!")) {
+                        if (node.startsWith("-")) {
                            node = node.substring(1);
                            value = false;
                        }
@@ -199,7 +195,7 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
            String suffix = group.getOwnSuffix();

            if (prefix != null && !prefix.equals("")) {
-                prefix = ArgumentChecker.escapeCharacters(prefix);
+                prefix = MetaUtils.escapeCharacters(prefix);
                try {
                    lpGroup.setPermission("prefix." + groupWeight + "." + prefix, true);
                    LogEntry.build()
@@ -214,7 +210,7 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
            }

            if (suffix != null && !suffix.equals("")) {
-                suffix = ArgumentChecker.escapeCharacters(suffix);
+                suffix = MetaUtils.escapeCharacters(suffix);
                try {
                    lpGroup.setPermission("suffix." + groupWeight + "." + suffix, true);
                    LogEntry.build()
@@ -228,7 +224,7 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
                }
            }

-            plugin.getDatastore().saveGroup(lpGroup);
+            plugin.getStorage().saveGroup(lpGroup);

        }

@@ -256,13 +252,13 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
            }

            userCount++;
-            plugin.getDatastore().loadUser(u, "null");
+            plugin.getStorage().loadUser(u, "null").join();
            User lpUser = plugin.getUserManager().get(u);

            try {
                for (String node : user.getOwnPermissions(null)) {
                    boolean value = true;
-                    if (node.startsWith("!")) {
+                    if (node.startsWith("-")) {
                        node = node.substring(1);
                        value = false;
                    }
@@ -287,7 +283,7 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
                for (String world : worlds) {
                    for (String node : user.getOwnPermissions(world)) {
                        boolean value = true;
-                        if (node.startsWith("!")) {
+                        if (node.startsWith("-")) {
                            node = node.substring(1);
                            value = false;
                        }
@@ -343,7 +339,7 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
            String suffix = user.getOwnSuffix();

            if (prefix != null && !prefix.equals("")) {
-                prefix = ArgumentChecker.escapeCharacters(prefix);
+                prefix = MetaUtils.escapeCharacters(prefix);
                try {
                    lpUser.setPermission("prefix." + maxGroupWeight + "." + prefix, true);
                    LogEntry.build()
@@ -358,7 +354,7 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
            }

            if (suffix != null && !suffix.equals("")) {
-                suffix = ArgumentChecker.escapeCharacters(suffix);
+                suffix = MetaUtils.escapeCharacters(suffix);
                try {
                    lpUser.setPermission("suffix." + maxGroupWeight + "." + suffix, true);
                    LogEntry.build()
@@ -389,7 +385,7 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
            }

            plugin.getUserManager().cleanup(lpUser);
-            plugin.getDatastore().saveUser(lpUser);
+            plugin.getStorage().saveUser(lpUser);
        }

        log.info("PermissionsEx Migration: Migrated " + userCount + " users.");
@@ -0,0 +1,612 @@
+/*
+ * 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.migration;
+
+import com.github.cheesesoftware.PowerfulPermsAPI.*;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.zaxxer.hikari.HikariDataSource;
+import lombok.Cleanup;
+import me.lucko.luckperms.api.Logger;
+import me.lucko.luckperms.api.data.Callback;
+import me.lucko.luckperms.bukkit.migration.utils.LPResultRunnable;
+import me.lucko.luckperms.common.LuckPermsPlugin;
+import me.lucko.luckperms.common.commands.Arg;
+import me.lucko.luckperms.common.commands.CommandException;
+import me.lucko.luckperms.common.commands.CommandResult;
+import me.lucko.luckperms.common.commands.SubCommand;
+import me.lucko.luckperms.common.commands.sender.Sender;
+import me.lucko.luckperms.common.constants.Constants;
+import me.lucko.luckperms.common.core.PermissionHolder;
+import me.lucko.luckperms.common.data.LogEntry;
+import me.lucko.luckperms.common.users.User;
+import me.lucko.luckperms.common.utils.Predicates;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.util.*;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
+
+import static me.lucko.luckperms.common.constants.Permission.MIGRATION;
+
+@SuppressWarnings("unchecked")
+public class MigrationPowerfulPerms extends SubCommand<Object> {
+    /* <sadness>
+        The PowerfulPerms API is a complete joke. Seriously, it would probably be easier reflecting into the actual plugin.
+        Methods move about randomly every version...
+
+        What kind of API requires reflection to function with multiple versions...
+        Doesn't that just defeat the whole god damn point of having an API in the first place?
+        Whatever happened to depreciation?
+    </sadness> */
+
+    private static Method getPlayerPermissionsMethod = null;
+    private static Method getPlayerGroupsMethod = null;
+    private static Method getGroupMethod = null;
+
+    // lol
+    private static boolean superLegacy = false;
+    private static boolean legacy = false;
+
+    static {
+        try {
+            Class.forName("com.github.cheesesoftware.PowerfulPermsAPI.ResponseRunnable");
+            legacy = true;
+        } catch (ClassNotFoundException ignored) {}
+
+        if (legacy) {
+            try {
+                getPlayerPermissionsMethod = PermissionManager.class.getMethod("getPlayerOwnPermissions", UUID.class, ResultRunnable.class);
+                getPlayerPermissionsMethod.setAccessible(true);
+            } catch (NoSuchMethodException ignored) {}
+        } else {
+            try {
+                getPlayerPermissionsMethod = PermissionManager.class.getMethod("getPlayerOwnPermissions", UUID.class);
+                getPlayerPermissionsMethod.setAccessible(true);
+            } catch (NoSuchMethodException ignored) {}
+        }
+
+        try {
+            getGroupMethod = CachedGroup.class.getMethod("getGroup");
+            getGroupMethod.setAccessible(true);
+            superLegacy = true;
+        } catch (NoSuchMethodException ignored) {}
+
+        if (!legacy) {
+            try {
+                getPlayerGroupsMethod = PermissionManager.class.getMethod("getPlayerOwnGroups", UUID.class);
+                getPlayerGroupsMethod.setAccessible(true);
+            } catch (NoSuchMethodException e) {
+                e.printStackTrace();
+            }
+        } else {
+            try {
+                getPlayerGroupsMethod = PermissionManager.class.getMethod("getPlayerOwnGroups", UUID.class, ResultRunnable.class);
+                getPlayerGroupsMethod.setAccessible(true);
+            } catch (NoSuchMethodException e) {
+                try {
+                    getPlayerGroupsMethod = PermissionManager.class.getMethod("getPlayerGroups", UUID.class, ResultRunnable.class);
+                    getPlayerGroupsMethod.setAccessible(true);
+                } catch (NoSuchMethodException e1) {
+                    e1.printStackTrace();
+                }
+            }
+        }
+    }
+
+
+    public MigrationPowerfulPerms() {
+        super("powerfulperms", "Migration from PowerfulPerms", MIGRATION, Predicates.not(5),
+                Arg.list(
+                        Arg.create("address", true, "the address of the PP database"),
+                        Arg.create("database", true, "the name of the PP database"),
+                        Arg.create("username", true, "the username to log into the DB"),
+                        Arg.create("password", true, "the password to log into the DB"),
+                        Arg.create("db table", true, "the name of the PP table where player data is stored")
+                )
+        );
+    }
+
+    @Override
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) throws CommandException {
+        try {
+            return run(plugin, args);
+        } catch (Throwable t) {
+            t.printStackTrace();
+            return CommandResult.FAILURE;
+        }
+    }
+
+    private static void getPlayerPermissions(PermissionManager manager, UUID uuid, Callback<List<Permission>> callback) {
+        if (legacy) {
+            try {
+                getPlayerPermissionsMethod.invoke(manager, uuid, new LPResultRunnable<List<Permission>>() {
+                    @Override
+                    public void run() {
+                        callback.onComplete(getResult());
+                    }
+                });
+            } catch (IllegalAccessException | InvocationTargetException e) {
+                e.printStackTrace();
+            }
+        } else {
+            try {
+                ListenableFuture<List<Permission>> lf = (ListenableFuture<List<Permission>>) getPlayerPermissionsMethod.invoke(manager, uuid);
+                try {
+                    if (lf.isDone()) {
+                        callback.onComplete(lf.get());
+                    } else {
+                        lf.addListener(() -> {
+                            try {
+                                callback.onComplete(lf.get());
+                            } catch (InterruptedException | ExecutionException e) {
+                                e.printStackTrace();
+                            }
+                        }, Runnable::run);
+                    }
+                } catch (InterruptedException | ExecutionException e) {
+                    e.printStackTrace();
+                }
+            } catch (IllegalAccessException | InvocationTargetException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    private CommandResult run(LuckPermsPlugin plugin, List<String> args) {
+        final Logger log = plugin.getLog();
+        if (!plugin.isPluginLoaded("PowerfulPerms")) {
+            log.severe("PowerfulPerms Migration: Error -> PowerfulPerms is not loaded.");
+            return CommandResult.STATE_ERROR;
+        }
+
+        final String address = args.get(0);
+        final String database = args.get(1);
+        final String username = args.get(2);
+        final String password = args.get(3);
+        final String dbTable = args.get(4);
+
+        // Find a list of UUIDs
+        log.info("PowerfulPerms Migration: Getting a list of UUIDs to migrate.");
+
+        @Cleanup HikariDataSource hikari = new HikariDataSource();
+        hikari.setMaximumPoolSize(2);
+        hikari.setDataSourceClassName("com.mysql.jdbc.jdbc2.optional.MysqlDataSource");
+        hikari.addDataSourceProperty("serverName", address.split(":")[0]);
+        hikari.addDataSourceProperty("port", address.split(":")[1]);
+        hikari.addDataSourceProperty("databaseName", database);
+        hikari.addDataSourceProperty("user", username);
+        hikari.addDataSourceProperty("password", password);
+
+        Set<UUID> uuids = new HashSet<>();
+
+        try {
+            @Cleanup Connection connection = hikari.getConnection();
+            DatabaseMetaData meta = connection.getMetaData();
+
+            @Cleanup ResultSet tables = meta.getTables(null, null, dbTable, null);
+            if (!tables.next()) {
+                log.severe("PowerfulPerms Migration: Error - Couldn't find table.");
+                return CommandResult.FAILURE;
+
+            } else {
+                @Cleanup PreparedStatement columnPs = connection.prepareStatement("SELECT COLUMN_NAME, COLUMN_TYPE FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME=?");
+                columnPs.setString(1, dbTable);
+                @Cleanup ResultSet columnRs = columnPs.executeQuery();
+
+                log.info("Found table: " + dbTable);
+                while (columnRs.next()) {
+                    log.info("" + columnRs.getString("COLUMN_NAME") + " - " + columnRs.getString("COLUMN_TYPE"));
+                }
+
+                @Cleanup PreparedStatement preparedStatement = connection.prepareStatement("SELECT `uuid` FROM " + dbTable);
+                @Cleanup ResultSet resultSet = preparedStatement.executeQuery();
+
+                while (resultSet.next()) {
+                    uuids.add(UUID.fromString(resultSet.getString("uuid")));
+                }
+            }
+
+        } catch (Exception e) {
+            e.printStackTrace();
+            return CommandResult.FAILURE;
+        }
+
+        if (uuids.isEmpty()) {
+            log.severe("PowerfulPerms Migration: Error - Unable to find any UUIDs to migrate.");
+            return CommandResult.FAILURE;
+        }
+
+        log.info("PowerfulPerms Migration: Found " + uuids.size() + " uuids. Starting migration.");
+
+        PowerfulPermsPlugin ppPlugin = (PowerfulPermsPlugin) plugin.getPlugin("PowerfulPerms");
+        PermissionManager pm = ppPlugin.getPermissionManager();
+
+        // Groups first.
+        log.info("PowerfulPerms Migration: Starting group migration.");
+        Map<Integer, Group> groups = pm.getGroups(); // All versions
+        for (Group g : groups.values()) {
+            plugin.getStorage().createAndLoadGroup(g.getName().toLowerCase()).join();
+            final me.lucko.luckperms.common.groups.Group group = plugin.getGroupManager().get(g.getName().toLowerCase());
+            try {
+                LogEntry.build()
+                        .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                        .acted(group).action("create")
+                        .build().submit(plugin);
+            } catch (Exception ex) {
+                ex.printStackTrace();
+            }
+
+            for (Permission p : g.getOwnPermissions()) { // All versions
+                applyPerm(group, p, plugin);
+            }
+
+            for (Group parent : g.getParents()) { // All versions
+                try {
+                    group.setPermission("group." + parent.getName().toLowerCase(), true);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(group).action("setinherit " + parent.getName().toLowerCase()) // All versions
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            }
+
+            plugin.getStorage().saveGroup(group);
+        }
+        log.info("PowerfulPerms Migration: Group migration complete.");
+
+        // Now users.
+        log.info("PowerfulPerms Migration: Starting user migration.");
+        final Map<UUID, CountDownLatch> progress = new HashMap<>();
+
+        // Migrate all users and their groups
+        for (UUID uuid : uuids) {
+            progress.put(uuid, new CountDownLatch(2));
+
+            // Create a LuckPerms user for the UUID
+            plugin.getStorage().loadUser(uuid, "null").join();
+            User user = plugin.getUserManager().get(uuid);
+
+            // Get a list of Permissions held by the user from the PP API.
+            getPlayerPermissions(pm, uuid, perms -> { // Changes each version
+                perms.forEach(p -> applyPerm(user, p, plugin));
+
+                // Update the progress so the user can be saved and unloaded.
+                synchronized (progress) {
+                    progress.get(uuid).countDown();
+                    if (progress.get(uuid).getCount() == 0) {
+                        plugin.getStorage().saveUser(user);
+                        plugin.getUserManager().cleanup(user);
+                    }
+                }
+            });
+
+            // Migrate the user's groups to LuckPerms from PP.
+            Callback<Map<String, List<CachedGroup>>> callback = groups1 -> {
+                for (Map.Entry<String, List<CachedGroup>> e : groups1.entrySet()) {
+                    final String server;
+                    if (e.getKey() != null && (e.getKey().equals("") || e.getKey().equalsIgnoreCase("all"))) {
+                        server = null;
+                    } else {
+                        server = e.getKey();
+                    }
+
+                    if (superLegacy) {
+                        e.getValue().stream()
+                                .filter(cg -> !cg.isNegated())
+                                .map(cg -> {
+                                    try {
+                                        return (Group) getGroupMethod.invoke(cg);
+                                    } catch (IllegalAccessException | InvocationTargetException e1) {
+                                        e1.printStackTrace();
+                                        return null;
+                                    }
+                                })
+                                .forEach(g -> {
+                                    if (g != null) {
+                                        if (server == null) {
+                                            try {
+                                                user.setPermission("group." + g.getName().toLowerCase(), true);
+                                                LogEntry.build()
+                                                        .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                                                        .acted(user).action("addgroup " + g.getName().toLowerCase())
+                                                        .build().submit(plugin);
+                                            } catch (Exception ex) {
+                                                if (!(ex instanceof ObjectAlreadyHasException)) {
+                                                    ex.printStackTrace();
+                                                }
+                                            }
+                                        } else {
+                                            try {
+                                                user.setPermission("group." + g.getName().toLowerCase(), true, server);
+                                                LogEntry.build()
+                                                        .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                                                        .acted(user).action("addgroup " + g.getName().toLowerCase() + " " + server)
+                                                        .build().submit(plugin);
+                                            } catch (Exception ex) {
+                                                if (!(ex instanceof ObjectAlreadyHasException)) {
+                                                    ex.printStackTrace();
+                                                }
+                                            }
+                                        }
+                                    }
+                                });
+                    } else {
+                        e.getValue().stream()
+                                .filter(g -> !g.hasExpired() && !g.isNegated())
+                                .forEach(g -> {
+                                    final Group group = pm.getGroup(g.getGroupId());
+                                    if (g.willExpire()) {
+                                        if (server == null) {
+                                            try {
+                                                user.setPermission("group." + group.getName().toLowerCase(), true, g.getExpirationDate().getTime() / 1000L);
+                                                LogEntry.build()
+                                                        .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                                                        .acted(user).action("addtempgroup " + group.getName().toLowerCase() + " " + g.getExpirationDate().getTime() / 1000L)
+                                                        .build().submit(plugin);
+                                            } catch (Exception ex) {
+                                                if (!(ex instanceof ObjectAlreadyHasException)) {
+                                                    ex.printStackTrace();
+                                                }
+                                            }
+                                        } else {
+                                            try {
+                                                user.setPermission("group." + group.getName().toLowerCase(), true, server, g.getExpirationDate().getTime() / 1000L);
+                                                LogEntry.build()
+                                                        .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                                                        .acted(user).action("addtempgroup " + group.getName().toLowerCase() + " " + g.getExpirationDate().getTime() / 1000L + " " + server)
+                                                        .build().submit(plugin);
+                                            } catch (Exception ex) {
+                                                if (!(ex instanceof ObjectAlreadyHasException)) {
+                                                    ex.printStackTrace();
+                                                }
+                                            }
+                                        }
+
+                                    } else {
+                                        if (server == null) {
+                                            try {
+                                                user.setPermission("group." + group.getName().toLowerCase(), true);
+                                                LogEntry.build()
+                                                        .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                                                        .acted(user).action("addgroup " + group.getName().toLowerCase())
+                                                        .build().submit(plugin);
+                                            } catch (Exception ex) {
+                                                if (!(ex instanceof ObjectAlreadyHasException)) {
+                                                    ex.printStackTrace();
+                                                }
+                                            }
+                                        } else {
+                                            try {
+                                                user.setPermission("group." + group.getName().toLowerCase(), true, server);
+                                                LogEntry.build()
+                                                        .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                                                        .acted(user).action("addgroup " + group.getName().toLowerCase() + " " + server)
+                                                        .build().submit(plugin);
+                                            } catch (Exception ex) {
+                                                if (!(ex instanceof ObjectAlreadyHasException)) {
+                                                    ex.printStackTrace();
+                                                }
+                                            }
+                                        }
+                                    }
+                                });
+                    }
+                }
+
+                // Update the progress so the user can be saved and unloaded.
+                synchronized (progress) {
+                    progress.get(uuid).countDown();
+                    if (progress.get(uuid).getCount() == 0) {
+                        plugin.getStorage().saveUser(user);
+                        plugin.getUserManager().cleanup(user);
+                    }
+                }
+            };
+
+            if (!legacy) {
+                try {
+                    ListenableFuture<LinkedHashMap<String, List<CachedGroup>>> future = (ListenableFuture<LinkedHashMap<String, List<CachedGroup>>>) getPlayerGroupsMethod.invoke(pm, uuid);
+                    try {
+                        if (future.isDone()) {
+                            callback.onComplete(future.get());
+                        } else {
+                            future.addListener(() -> {
+                                try {
+                                    callback.onComplete(future.get());
+                                } catch (InterruptedException | ExecutionException e) {
+                                    e.printStackTrace();
+                                }
+                            }, Runnable::run);
+                        }
+                    } catch (InterruptedException | ExecutionException e) {
+                        e.printStackTrace();
+                    }
+                } catch (IllegalAccessException | InvocationTargetException e) {
+                    log.info("PowerfulPerms Migration: Error");
+                    e.printStackTrace();
+                }
+            } else {
+                try {
+                    getPlayerGroupsMethod.invoke(pm, uuid, new LPResultRunnable<LinkedHashMap<String, List<CachedGroup>>>() {
+                        @Override
+                        public void run() {
+                            callback.onComplete(getResult());
+                        }
+                    });
+                } catch (IllegalAccessException | InvocationTargetException e) {
+                    log.info("PowerfulPerms Migration: Error");
+                    e.printStackTrace();
+                }
+            }
+        }
+
+        // All groups are migrated, but there may still be some users being migrated.
+        // This block will wait for all users to be completed.
+        log.info("PowerfulPerms Migration: Waiting for user migration to complete. This may take some time");
+        boolean sleep = true;
+        while (sleep) {
+            sleep = false;
+
+            for (Map.Entry<UUID, CountDownLatch> e : progress.entrySet()) {
+                if (e.getValue().getCount() != 0) {
+                    sleep = true;
+                    break;
+                }
+            }
+
+            if (sleep) {
+                try {
+                    Thread.sleep(5000);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+
+        }
+
+        // We done.
+        log.info("PowerfulPerms Migration: Success! Completed without any errors.");
+        return CommandResult.SUCCESS;
+    }
+
+    private void applyPerm(PermissionHolder holder, Permission p, LuckPermsPlugin plugin) {
+        String node = p.getPermissionString();
+        boolean value = true;
+        if (node.startsWith("!")) {
+            node = node.substring(1);
+            value = false;
+        }
+
+        String server = p.getServer();
+        if (server != null && server.equalsIgnoreCase("all")) {
+            server = null;
+        }
+
+        String world = p.getWorld();
+        if (world != null && world.equalsIgnoreCase("all")) {
+            world = null;
+        }
+
+        long expireAt = 0L;
+        if (!superLegacy) {
+            if (p.willExpire()) {
+                expireAt = p.getExpirationDate().getTime() / 1000L;
+            }
+        }
+
+        if (world != null && server == null) {
+            server = "global";
+        }
+
+        if (world != null) {
+            if (expireAt == 0L) {
+                try {
+                    holder.setPermission(node, value, server, world);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(holder).action("set " + node + " " + value + " " + server + " " + world)
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            } else {
+                try {
+                    holder.setPermission(node, value, server, world, expireAt);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(holder).action("settemp " + node + " " + value + " " + expireAt + " " + server + " " + world)
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            }
+
+        } else if (server != null) {
+            if (expireAt == 0L) {
+                try {
+                    holder.setPermission(node, value, server);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(holder).action("set " + node + " " + value + " " + server)
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            } else {
+                try {
+                    holder.setPermission(node, value, server, expireAt);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(holder).action("settemp " + node + " " + value + " " + expireAt + " " + server)
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            }
+        } else {
+            if (expireAt == 0L) {
+                try {
+                    holder.setPermission(node, value);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(holder).action("set " + node + " " + value)
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            } else {
+                try {
+                    holder.setPermission(node, value, expireAt);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(holder).action("settemp " + node + " " + value + " " + expireAt)
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            }
+        }
+    }
+}
@@ -20,22 +20,24 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.commands.migration.subcommands;
+package me.lucko.luckperms.bukkit.migration;

-import me.lucko.luckperms.LuckPermsPlugin;
 import me.lucko.luckperms.api.Logger;
-import me.lucko.luckperms.commands.CommandResult;
-import me.lucko.luckperms.commands.Predicate;
-import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
-import me.lucko.luckperms.constants.Constants;
-import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.data.LogEntry;
+import me.lucko.luckperms.api.MetaUtils;
+import me.lucko.luckperms.common.LuckPermsPlugin;
+import me.lucko.luckperms.common.commands.Arg;
+import me.lucko.luckperms.common.commands.CommandException;
+import me.lucko.luckperms.common.commands.CommandResult;
+import me.lucko.luckperms.common.commands.SubCommand;
+import me.lucko.luckperms.common.commands.sender.Sender;
+import me.lucko.luckperms.common.constants.Constants;
+import me.lucko.luckperms.common.constants.Permission;
+import me.lucko.luckperms.common.data.LogEntry;
+import me.lucko.luckperms.common.groups.Group;
+import me.lucko.luckperms.common.tracks.Track;
+import me.lucko.luckperms.common.users.User;
+import me.lucko.luckperms.common.utils.Predicates;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
-import me.lucko.luckperms.groups.Group;
-import me.lucko.luckperms.tracks.Track;
-import me.lucko.luckperms.users.User;
-import me.lucko.luckperms.utils.ArgumentChecker;
 import org.tyrannyofheaven.bukkit.zPermissions.ZPermissionsService;

 import java.util.List;
@@ -43,18 +45,15 @@ import java.util.Map;
 import java.util.UUID;
 import java.util.stream.Collectors;

-/**
- * <3 <3  zPermissions  <3 <3
- * Finally a permissions plugin with a decent API. *sigh*
- */
 public class MigrationZPermissions extends SubCommand<Object> {
    public MigrationZPermissions() {
-        super("zpermissions", "Migration from zPermissions", "/%s migration zpermissions [world names]",
-                Permission.MIGRATION, Predicate.alwaysFalse());
+        super("zpermissions", "Migration from zPermissions", Permission.MIGRATION, Predicates.alwaysFalse(),
+                Arg.list(Arg.create("world names...", false, "a list of worlds to migrate permissions from"))
+        );
    }

    @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) {
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) throws CommandException {
        final Logger log = plugin.getLog();
        if (!plugin.isPluginLoaded("zPermissions")) {
            log.severe("zPermissions Migration: Error -> zPermissions is not loaded.");
@@ -74,7 +73,7 @@ public class MigrationZPermissions extends SubCommand<Object> {
        // Migrate all groups
        log.info("zPermissions Migration: Starting group migration.");
        for (String g : service.getAllGroups()) {
-            plugin.getDatastore().createAndLoadGroup(g.toLowerCase());
+            plugin.getStorage().createAndLoadGroup(g.toLowerCase()).join();
            Group group = plugin.getGroupManager().get(g.toLowerCase());
            try {
                LogEntry.build()
@@ -117,13 +116,13 @@ public class MigrationZPermissions extends SubCommand<Object> {
                }
            }

-            plugin.getDatastore().saveGroup(group);
+            plugin.getStorage().saveGroup(group);
        }

        // Migrate all tracks
        log.info("zPermissions Migration: Starting track migration.");
        for (String t : service.getAllTracks()) {
-            plugin.getDatastore().createAndLoadTrack(t.toLowerCase());
+            plugin.getStorage().createAndLoadTrack(t.toLowerCase()).join();
            Track track = plugin.getTrackManager().get(t.toLowerCase());
            try {
                LogEntry.build()
@@ -146,13 +145,13 @@ public class MigrationZPermissions extends SubCommand<Object> {
                }
            }

-            plugin.getDatastore().saveTrack(track);
+            plugin.getStorage().saveTrack(track);
        }

        // Migrate all users.
        log.info("zPermissions Migration: Starting user migration.");
        for (UUID u : service.getAllPlayersUUID()) {
-            plugin.getDatastore().loadUser(u, "null");
+            plugin.getStorage().loadUser(u, "null").join();
            User user = plugin.getUserManager().get(u);

            for (Map.Entry<String, Boolean> e : service.getPlayerPermissions(null, null, u).entrySet()) {
@@ -215,7 +214,7 @@ public class MigrationZPermissions extends SubCommand<Object> {
            String suffix = service.getPlayerSuffix(u);

            if (prefix != null && !prefix.equals("")) {
-                prefix = ArgumentChecker.escapeCharacters(prefix);
+                prefix = MetaUtils.escapeCharacters(prefix);
                try {
                    user.setPermission("prefix.100." + prefix, true);
                    LogEntry.build()
@@ -230,7 +229,7 @@ public class MigrationZPermissions extends SubCommand<Object> {
            }

            if (suffix != null && !suffix.equals("")) {
-                suffix = ArgumentChecker.escapeCharacters(suffix);
+                suffix = MetaUtils.escapeCharacters(suffix);
                try {
                    user.setPermission("suffix.100." + suffix, true);
                    LogEntry.build()
@@ -245,7 +244,7 @@ public class MigrationZPermissions extends SubCommand<Object> {
            }

            plugin.getUserManager().cleanup(user);
-            plugin.getDatastore().saveUser(user);
+            plugin.getStorage().saveUser(user);
        }

        log.info("zPermissions Migration: Success! Completed without any errors.");
@@ -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.bukkit.migration.utils;
+
+import com.github.cheesesoftware.PowerfulPermsAPI.ResultRunnable;
+
+/**
+ * Overrides the default ResultRunnable, callbacks will always run in the same thread. (an async one, hopefully.)
+ * @param <T> type
+ */
+public abstract class LPResultRunnable<T> extends ResultRunnable<T> {
+    public LPResultRunnable() {
+        super();
+        super.sameThread = true;
+    }
+
+    public T getResult() {
+        return super.result;
+    }
+
+}
@@ -0,0 +1,390 @@
+/*
+ * 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.api.caching.MetaData;
+import me.lucko.luckperms.api.context.ContextSet;
+import me.lucko.luckperms.common.core.NodeBuilder;
+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.chat.Chat;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import static me.lucko.luckperms.api.MetaUtils.escapeCharacters;
+import static me.lucko.luckperms.api.MetaUtils.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.api.MetaUtils#unescapeCharacters(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 NodeBuilder("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 NodeBuilder(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(ContextSet.fromMap(context), perms.isIncludeGlobal(), true, true, true, true, false))) {
+            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);
+    }
+
+}
@@ -20,42 +20,60 @@
 *  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.setIgnoreWorld(plugin.getConfiguration().isVaultIgnoreWorld());
+            permissionHook.setPgo(plugin.getConfiguration().isVaultPrimaryGroupOverrides());
+            permissionHook.setPgoCheckInherited(plugin.getConfiguration().isVaultPrimaryGroupOverridesCheckInherited());
+            permissionHook.setPgoCheckExists(plugin.getConfiguration().isVaultPrimaryGroupOverridesCheckExists());
+            permissionHook.setPgoCheckMemberOf(plugin.getConfiguration().isVaultPrimaryGroupOverridesCheckMemberOf());
+            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;
    }

 }
@@ -0,0 +1,400 @@
+/*
+ * 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.AccessLevel;
+import lombok.Getter;
+import lombok.NonNull;
+import lombok.Setter;
+import me.lucko.luckperms.api.Contexts;
+import me.lucko.luckperms.api.LocalizedNode;
+import me.lucko.luckperms.api.Node;
+import me.lucko.luckperms.api.Tristate;
+import me.lucko.luckperms.api.caching.PermissionData;
+import me.lucko.luckperms.api.context.ContextSet;
+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.HashMap;
+import java.util.Map;
+
+/**
+ * The LuckPerms Vault Permission implementation
+ * Most lookups are cached.
+ */
+@Getter
+@Setter
+public class VaultPermissionHook extends Permission {
+    private LPBukkitPlugin plugin;
+
+    @Setter(value = AccessLevel.NONE)
+    private VaultScheduler scheduler;
+
+    private String server = "global";
+    private boolean includeGlobal = true;
+    private boolean ignoreWorld = false;
+
+    // Primary Group override settings
+    private boolean pgo = false;
+    private boolean pgoCheckInherited = false;
+    private boolean pgoCheckExists = true;
+    private boolean pgoCheckMemberOf = true;
+
+    public void setup() {
+        scheduler = new VaultScheduler(plugin);
+    }
+
+    public void log(String s) {
+        if (plugin.getConfiguration().isVaultDebug()) {
+            plugin.getLog().info("[VAULT] " + s);
+        }
+    }
+
+    @Override
+    public String getName() {
+        return "LuckPerms";
+    }
+
+    @Override
+    public boolean isEnabled() {
+        return plugin.getStorage().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) {
+            plugin.getStorage().saveUser(((User) holder))
+                    .thenRunAsync(() -> ((User) holder).getRefreshBuffer().request(), plugin.getAsyncExecutor());
+        }
+        if (holder instanceof Group) {
+            plugin.getStorage().saveGroup(((Group) holder))
+                    .thenRunAsync(() -> plugin.getUpdateTaskBuffer().request(), plugin.getAsyncExecutor());
+        }
+    }
+
+    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(ContextSet.fromMap(context), isIncludeGlobal(), true, true, true, true, false);
+    }
+
+    @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), 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.setInheritGroup(group, server, finalWorld);
+                } else {
+                    user.setInheritGroup(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.unsetInheritGroup(group, server, finalWorld);
+                } else {
+                    user.unsetInheritGroup(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) {
+        world = ignoreWorld ? null : world; // Correct world value
+        log("Getting primary group of player: " + player);
+        final User user = plugin.getUserManager().get(player);
+
+        if (user == null) {
+            return null;
+        }
+
+        if (!pgo) {
+            return user.getPrimaryGroup();
+        }
+
+        if (pgoCheckInherited) {
+            PermissionData data = user.getUserData().getPermissionData(createContext(server, world));
+            for (Map.Entry<String, Boolean> e : data.getImmutableBacking().entrySet()) {
+                if (!e.getValue()) {
+                    continue;
+                }
+
+                if (!e.getKey().toLowerCase().startsWith("vault.primarygroup.")) {
+                    continue;
+                }
+
+                String group = e.getKey().substring("vault.primarygroup.".length());
+                if (pgoCheckExists) {
+                    if (!plugin.getGroupManager().isLoaded(group)) {
+                        continue;
+                    }
+                }
+
+                if (pgoCheckMemberOf) {
+                    if (data.getPermissionValue("group." + group) != Tristate.TRUE) {
+                        continue;
+                    }
+                }
+
+                return group;
+            }
+        } else {
+            for (LocalizedNode node : user.getPermissions(true)) {
+                if (!node.getValue()) {
+                    continue;
+                }
+
+                if (!node.getPermission().toLowerCase().startsWith("vault.primarygroup.")) {
+                    continue;
+                }
+
+                if (!node.shouldApplyOnServer(server, isIncludeGlobal(), false)) {
+                    continue;
+                }
+
+                if (!node.shouldApplyOnWorld(world, true, false)) {
+                    continue;
+                }
+
+                String group = node.getPermission().substring("vault.primarygroup.".length());
+                if (pgoCheckExists) {
+                    if (!plugin.getGroupManager().isLoaded(group)) {
+                        continue;
+                    }
+                }
+
+                if (pgoCheckMemberOf) {
+                    if (!user.getLocalGroups(server, world, isIncludeGlobal()).contains(group.toLowerCase())) {
+                        continue;
+                    }
+                }
+
+                return group;
+            }
+        }
+
+        // Fallback
+        return user.getPrimaryGroup();
+    }
+
+    @Override
+    public String[] getGroups() {
+        return plugin.getGroupManager().getAll().keySet().toArray(new String[0]);
+    }
+
+    @Override
+    public boolean hasGroupSupport() {
+        return true;
+    }
+}
@@ -20,26 +20,34 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.commands.misc;
+package me.lucko.luckperms.bukkit.vault;

-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.bukkit.LPBukkitPlugin;

+import java.util.ArrayList;
 import java.util.List;

-public class SyncCommand extends SingleMainCommand {
-    public SyncCommand() {
-        super("Sync", "/%s sync", 0, Permission.SYNC);
+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
-    protected CommandResult execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
-        Message.UPDATE_TASK_RUN.send(sender);
-        plugin.runUpdateTask();
-        return CommandResult.SUCCESS;
+    public void run() {
+        List<Runnable> toRun = new ArrayList<>();
+        synchronized (tasks) {
+            toRun.addAll(tasks);
+            tasks.clear();
+        }
+
+        toRun.forEach(Runnable::run);
    }
 }
@@ -1,128 +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.AllArgsConstructor;
-import lombok.EqualsAndHashCode;
-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 org.bukkit.permissions.PermissionAttachment;
-
-import java.lang.reflect.Field;
-import java.util.Map;
-import java.util.UUID;
-
-public class BukkitUser extends User {
-    private static Field permissionsField = null;
-    public static Field getPermissionsField() {
-        if (permissionsField == null) {
-            try {
-                permissionsField = PermissionAttachment.class.getDeclaredField("permissions");
-                permissionsField.setAccessible(true);
-            } catch (SecurityException | NoSuchFieldException e) {
-                e.printStackTrace();
-            }
-        }
-        return permissionsField;
-    }
-
-
-    private final LPBukkitPlugin plugin;
-
-    @Getter
-    @Setter
-    private PermissionAttachmentHolder attachment = 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 void refreshPermissions() {
-        if (attachment == 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(
-                getPlugin().getConfiguration().getServer(),
-                plugin.getUserManager().getWorldCache().get(getUuid()),
-                null,
-                plugin.getConfiguration().getIncludeGlobalPerms(),
-                true,
-                plugin.getPossiblePermissions()
-        );
-
-        try {
-            // The map in the LP PermissionAttachment is a ConcurrentHashMap. We can modify and iterate over its contents async.
-            Map<String, Boolean> existing = attachment.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();
-            existing.putAll(toApply);
-
-            /* Must be called sync, as #recalculatePermissions is an unmodified Bukkit API call that is absolutely not thread safe.
-               Shouldn't be too taxing on the server. This only gets called when permissions have actually changed,
-               which is like once per user per login, assuming their permissions don't get modified. */
-            plugin.doSync(() -> {
-                attachment.getAttachment().getPermissible().recalculatePermissions();
-                plugin.getApiProvider().fireEventAsync(new UserPermissionRefreshEvent(new UserLink(this)));
-            });
-
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-
-    @Getter
-    @EqualsAndHashCode
-    @AllArgsConstructor
-    public static class PermissionAttachmentHolder {
-        private final PermissionAttachment attachment;
-        private final Map<String, Boolean> permissions;
-    }
-}
@@ -1,89 +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 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;
-
-            if (u.getAttachment() != null) {
-                Player player = plugin.getServer().getPlayer(plugin.getUuidCache().getExternalUUID(u.getUuid()));
-
-                if (player != null) {
-                    player.removeAttachment(u.getAttachment().getAttachment());
-                }
-                u.setAttachment(null);
-            }
-        }
-    }
-
-    @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")));
-        });
-    }
-}
@@ -5,53 +5,105 @@
 # +------------------------------------------------------------------------+ #
 ##############################################################################

+# +------------------------------------------------------------------------+ #
+# |                               General                                  | #
+# +------------------------------------------------------------------------+ #
+
 # The name of the server, used for server specific permissions. Set to 'global' to disable.
 server: global

-# If users on this server should have their global permissions/groups applied.
+# If users on this server should have their global permissions applied.
+# If set to false, only server specific permissions will apply for users on this server
 include-global: true

+# If users on this server should have their global world permissions applied.
+# If set to false, only world specific permissions will apply for users on this server
+include-global-world: true
+
+# If users on this server should have global (non-server specific) groups applied
+apply-global-groups: true
+
+# If users on this server should have global (non-world specific) groups applied
+apply-global-world-groups: true
+
 # If this server is in offline or online mode.
 # This setting allows a player to have the same UUID across a network of offline mode/mixed servers.
-
+#
 # You should generally reflect the setting in server.properties here. Except when...
-
+#
 # 1. You have Spigot servers connected to a BungeeCord proxy, with online-mode set to false, but 'bungeecord' set to true in the spigot.yml
 #    AND 'ip-forward' set to true in the BungeeCord config.yml
 #    In this case, set online-mode in LuckPerms to true, despite the server being in offline mode.
-
+#
 # 2. You are only running one server instance using LuckPerms, (not a network)
 #    In this case, set online-mode to true no matter what is set in server.properties. (we can just fallback to the servers uuid cache)
-
+#
 # 3. If your proxy is running in offline mode, and you are using PaperSpigot (https://ci.destroystokyo.com/job/PaperSpigot/),
 #    you should set "bungee-online-mode" to false in the paper.yml, and set "online-mode" to true in all LuckPerms configs.
 #    This approach is thoroughly recommended for offline mode networks.
 online-mode: true

+# If the plugin should send log notifications to users whenever permissions are modified.
+log-notify: true
+
+
+
+
+# +------------------------------------------------------------------------+ #
+# |                        Permission Calculation                          | #
+# +------------------------------------------------------------------------+ #
+
 # If the plugin should apply wildcard permissions.
 # If set to true, LuckPerms will detect wildcard permissions, and resolve & apply all registered permissions matching
-# the wildcard. This will only work for plugins that define all of their permissions to the server.
+# the wildcard.
 apply-wildcards: true

 # If the plugin should parse regex permissions.
 # If set to true, LuckPerms will detect regex permissions, marked with "r=" at the start of the node, and resolve &
-# apply all registered permissions matching the regex. This will only work for plugins that define all of their
-# permissions to the server.
+# apply all registered permissions matching the regex.
 apply-regex: true

 # If the plugin should complete and apply shorthand permissions.
 # If set to true, LuckPerms will detect and expand shorthand node patterns.
 apply-shorthand: true

-# If the plugin should send log notifications to users whenever permissions are modified.
-log-notify: true
+# Define special group weights for this server.
+# Default is just 0.
+group-weight:
+#  admin: 10
+
+
+
+
+# +------------------------------------------------------------------------+ #
+# |                    OP (Server Operator) Settings                       | #
+# +------------------------------------------------------------------------+ #

 # If the vanilla OP system is enabled. If set to false, all users will be de-opped, and the op/deop commands will be disabled.
 enable-ops: true

-# If opped players should be allowed to use LuckPerms commands. Set to false to only allow users with the permission access
+# If set to true, any user with the permission "luckperms.autoop" will automatically be granted server operator status.
+# This permission can be inherited, or set on specific servers/worlds, temporarily, etc.
+# Additionally, setting this to true will force the "enable-ops" option above to false. All users will be de-opped unless
+# they have the permission node, and the op/deop commands will be disabled.
+#
+# It is important to note that this setting is only checked when a player first joins the server, and when they switch
+# worlds. Therefore, simply removing this permission from a user will not automatically de-op them. A player needs to
+# relog to have the change take effect.
+#
+# It is recommended that you use this option instead of assigning a single '*' permission.
+auto-op: false
+
+# If opped players should be allowed to use LuckPerms commands. Set to false to only allow users who have the permissions access to the commands
 commands-allow-op: true

+
+
+
+# +------------------------------------------------------------------------+ #
+# |                                Vault                                   | #
+# +------------------------------------------------------------------------+ #
+
 # The name of the server used within Vault operations. If you don't want Vault operations to be server specific, set this
 # to "global".
 vault-server: global
@@ -59,14 +111,48 @@ 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
+
+# This block controls the Primary Group override feature
+# See the wiki for more information.
+vault-primary-groups-overrides:
+  # If the feature is enabled
+  enabled: false
+  # If the check should query the user's inherited permissions.
+  # (a value of false only checks the permissions they explicitly have)
+  check-inherited-permissions: false
+  # If LuckPerms should check if the group exists
+  check-group-exists: true
+  # If LuckPerms should check if the user is actually a member of the group
+  check-user-member-of: true
+
+# If LuckPerms should print debugging info to console when a plugin uses a Vault function
+vault-debug: 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
+
+
+
+
+# +------------------------------------------------------------------------+ #
+# |                               Storage                                  | #
+# +------------------------------------------------------------------------+ #
+
 # 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:
@@ -81,7 +167,98 @@ data:
  database: minecraft
  username: root
  password: ''
+  pool-size: 10 # The size of the MySQL connection pool.

  # Set to -1 to disable. If this is the only instance accessing the datastore, you can disable syncing.
  # e.g. if you're using sqlite or flatfile, this can be set to -1 to save resources.
-  sync-minutes: 3
+  sync-minutes: 3
+
+# Settings for Redis.
+#
+# If enabled and configured, LuckPerms will use the Redis PubSub system to inform other
+# connected servers of changes. Use the command "/luckperms networksync" to push changes.
+# Data is NOT stored on redis. It is only used as a messaging platform.
+#
+# If you decide to enable this feature, you should set "sync-minutes" to -1, as there is no need for LuckPerms
+# to poll the database for changes.
+redis:
+  enabled: false
+  address: localhost:6379
+  password: ''
+
+
+
+
+# +------------------------------------------------------------------------+ #
+# |                         Default Assignments                            | #
+# +------------------------------------------------------------------------+ #
+
+# This section allows you to define defaults to give users whenever they connect to the server.
+# The default assignments are highly configurable and conditional.
+#
+# There is one default assignment built into LuckPerms, which will add all users to the "default" group if they
+# are not a member of any other group. This setting cannot be disabled. However, you can use this section to add more of
+# your own.
+#
+# IMPORTANT:
+# In order to save storage space, LuckPerms does not store users who have no permissions defined, and are only a member
+# of the default group. Adding default assignments to this section will negate this effect. It is HIGHLY RECCOMENDED
+# that instead of assigning defaults here, you add permissions to the "default" group, or set the "default" group to inherit
+# other groups, and then use the group-name-rewrite rule above.
+#
+# It is also important to note that these rules are considered every time a player logs into the server, and are applied
+# directly to the user's data. Simply removing a rule here will not reserse the effect of that rule on any users who have
+# already had it applied to them.
+#
+# The "has" and "lacks" conditions below support standard boolean logic, using the 'and' & 'or' characters used in Java.
+# e.g. "(some.other.permission | some.permission.other) & some.thing.else" == a user has 'some.other.permission', or
+# 'some.permission.other', and they also have 'some.thing.else'
+#
+# Groups are represented by the permission node: group.<group name>
+# Per server and per world nodes are represented by: "server-world/permission" or "server/permission"
+#
+# Within conditions, permission nodes MUST be escaped using "<" and ">". See the example below.
+#
+# Explaination of the examples below: (they're just to demonstrate the features & use cases)
+#
+# rule1:
+# If a user is either in the vip or vip+ group, and they have the "titles.titlecollector" permission set to true, and the
+# "some.random.permission" set to false... if they're not in the group "prison_titlepack" on the "prison" server, then
+# give add them to the "prison_titlepack" group on the "prison" server, and remove "some.random.permission".
+#
+# rule2:
+# If the user isn't in any of the following groups on the skyblock server: sb_level1, sb_level2, sb_level3, then add
+# them to sb_level1 on the skyblock server.
+#
+# rule3:
+# If the user is a member of the default group, remove them from default, add them to member, and set their primary group
+# to member.
+#
+# WARNING: Unlike internal commands, this system does not ensure that a group exists before adding a user to it.
+# It also does not unsure that a user is a member of a group before making that group their primary group.
+#
+# Before you use "give: group.<name>" or "set-primary-group", make sure that the group exists, and that the user is
+# a member of the group.
+default-assignments:
+#  rule1:
+#    if:
+#      has-true: (<group.vip> | <group.vip+>) & <titles.tilecollector>
+#      has-false: <some.random.permission>
+#      lacks: <prison/group.prison_titlepack>
+#    give:
+#      - prison/group.prison_titlepack
+#    take:
+#      - some.random.permission
+#  rule2:
+#    if:
+#      lacks: <skyblock/group.sb_level1> & <skyblock/group.sb_level2> & <skyblock/group.sb_level3>
+#    give:
+#      - skyblock/group.sb_level1
+#  rule3:
+#    if:
+#      has-true: <group.default>
+#    take:
+#      - group.default
+#    give:
+#      - group.member
+#    set-primary-group: member
@@ -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:
@@ -5,7 +5,7 @@
    <parent>
        <artifactId>luckperms</artifactId>
        <groupId>me.lucko.luckperms</groupId>
-        <version>2.8-SNAPSHOT</version>
+        <version>2.14-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

@@ -69,6 +69,18 @@
                                    <pattern>org.sqlite</pattern>
                                    <shadedPattern>me.lucko.luckperms.lib.sqlite</shadedPattern>
                                </relocation>
+                                <relocation>
+                                    <pattern>redis.clients.jedis</pattern>
+                                    <shadedPattern>me.lucko.luckperms.lib.jedis.jedis</shadedPattern>
+                                </relocation>
+                                <relocation>
+                                    <pattern>redis.clients.util</pattern>
+                                    <shadedPattern>me.lucko.luckperms.lib.jedis.util</shadedPattern>
+                                </relocation>
+                                <relocation>
+                                    <pattern>org.apache.commons.pool2</pattern>
+                                    <shadedPattern>me.lucko.luckperms.lib.jedis.pool2</shadedPattern>
+                                </relocation>
                            </relocations>
                        </configuration>
                    </execution>
@@ -121,6 +133,13 @@
            <version>1.16.10</version>
            <scope>provided</scope>
        </dependency>
+        <!-- **************Migration Plugins************** -->
+        <dependency>
+            <groupId>net.alpenblock</groupId>
+            <artifactId>BungeePerms</artifactId>
+            <version>3.0-dev-52</version>
+            <scope>provided</scope>
+        </dependency>
    </dependencies>

 </project>
@@ -1,216 +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;
-
-import lombok.Getter;
-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.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 net.md_5.bungee.api.connection.ProxiedPlayer;
-import net.md_5.bungee.api.plugin.Plugin;
-
-import java.io.File;
-import java.util.Collections;
-import java.util.List;
-import java.util.Set;
-import java.util.UUID;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.TimeUnit;
-import java.util.stream.Collectors;
-
-@Getter
-public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
-    private final Set<UUID> ignoringLogs = ConcurrentHashMap.newKeySet();
-    private LPConfiguration configuration;
-    private UserManager userManager;
-    private GroupManager groupManager;
-    private TrackManager trackManager;
-    private Datastore datastore;
-    private UuidCache uuidCache;
-    private ApiProvider apiProvider;
-    private Logger log;
-    private Importer importer;
-    private ConsecutiveExecutor consecutiveExecutor;
-
-    @Override
-    public void onEnable() {
-        log = LogFactory.wrap(getLogger());
-
-        getLog().info("Loading configuration...");
-        configuration = new BungeeConfig(this);
-
-        // register events
-        getProxy().getPluginManager().registerListener(this, new BungeeListener(this));
-
-        // register commands
-        getLog().info("Registering commands...");
-        CommandManager commandManager = new CommandManager(this);
-        getProxy().getPluginManager().registerCommand(this, new BungeeCommand(commandManager));
-
-        // disable the default Bungee /perms command so it gets handled by the Bukkit plugin
-        getProxy().getDisabledCommands().add("perms");
-
-        datastore = StorageFactory.getDatastore(this, "h2");
-
-        getLog().info("Loading internal permission managers...");
-        uuidCache = new UuidCache(getConfiguration().getOnlineMode());
-        userManager = new BungeeUserManager(this);
-        groupManager = new GroupManager(this);
-        trackManager = new TrackManager();
-        importer = new Importer(commandManager);
-        consecutiveExecutor = new ConsecutiveExecutor(commandManager);
-
-        int mins = getConfiguration().getSyncTime();
-        if (mins > 0) {
-            getProxy().getScheduler().schedule(this, new UpdateTask(this), mins, mins, TimeUnit.MINUTES);
-        }
-
-        // 20 times per second (once per "tick")
-        getProxy().getScheduler().schedule(this, BungeeSenderFactory.get(), 50L, 50L, TimeUnit.MILLISECONDS);
-        getProxy().getScheduler().schedule(this, 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);
-
-        // Run update task to refresh any online users
-        getLog().info("Scheduling Update Task to refresh any online users.");
-        try {
-            new UpdateTask(this).run();
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-
-        getLog().info("Successfully loaded.");
-    }
-
-    @Override
-    public void onDisable() {
-        getLog().info("Closing datastore...");
-        datastore.shutdown();
-
-        getLog().info("Unregistering API...");
-        LuckPerms.unregisterProvider();
-    }
-
-    @Override
-    public String getVersion() {
-        return getDescription().getVersion();
-    }
-
-    @Override
-    public PlatformType getType() {
-        return PlatformType.BUNGEE;
-    }
-
-    @Override
-    public File getMainDir() {
-        return getDataFolder();
-    }
-
-    @Override
-    public Message getPlayerStatus(UUID uuid) {
-        return getProxy().getPlayer(getUuidCache().getExternalUUID(uuid)) != null ? Message.PLAYER_ONLINE : Message.PLAYER_OFFLINE;
-    }
-
-    @Override
-    public int getPlayerCount() {
-        return getProxy().getOnlineCount();
-    }
-
-    @Override
-    public List<String> getPlayerList() {
-        return getProxy().getPlayers().stream().map(ProxiedPlayer::getName).collect(Collectors.toList());
-    }
-
-    @Override
-    public List<Sender> getSenders() {
-        return getProxy().getPlayers().stream().map(p -> BungeeSenderFactory.get().wrap(p)).collect(Collectors.toList());
-    }
-
-    @Override
-    public Sender getConsoleSender() {
-        return BungeeSenderFactory.get().wrap(getProxy().getConsole());
-    }
-
-    @Override
-    public List<String> getPossiblePermissions() {
-        // No such thing on Bungee. Wildcards are processed in the listener instead.
-        return Collections.emptyList();
-    }
-
-    @Override
-    public Object getPlugin(String name) {
-        return getProxy().getPluginManager().getPlugin(name);
-    }
-
-    @Override
-    public Object getService(Class clazz) {
-        return null;
-    }
-
-    @Override
-    public UUID getUUID(String playerName) {
-        return null; // Not needed on Bungee
-    }
-
-    @Override
-    public boolean isPluginLoaded(String name) {
-        return getProxy().getPluginManager().getPlugins().stream()
-                .filter(p -> p.getDescription().getName().equalsIgnoreCase(name))
-                .findAny()
-                .isPresent();
-    }
-
-    @Override
-    public void runUpdateTask() {
-        doAsync(new UpdateTask(this));
-    }
-
-    @Override
-    public void doAsync(Runnable r) {
-        getProxy().getScheduler().runAsync(this, r);
-    }
-
-    @Override
-    public void doSync(Runnable r) {
-        r.run();
-    }
-}
@@ -0,0 +1,67 @@
+/*
+ * 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 me.lucko.luckperms.api.context.MutableContextSet;
+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 MutableContextSet giveApplicableContext(ProxiedPlayer subject, MutableContextSet accumulator) {
+        String server = getServer(subject);
+
+        if (server != null) {
+            accumulator.add(Maps.immutableEntry(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());
+    }
+}
@@ -20,41 +20,29 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.users;
+package me.lucko.luckperms.bungee;

-import me.lucko.luckperms.LPBungeePlugin;
+import com.google.common.collect.ImmutableList;
+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;
-
-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) {
+        ImmutableList.Builder<PermissionProcessor> processors = ImmutableList.builder();
+        processors.add(new MapProcessor());
+        if (plugin.getConfiguration().isApplyingWildcards()) {
+            processors.add(new WildcardProcessor());
+        }
+        if (plugin.getConfiguration().isApplyingRegex()) {
+            processors.add(new RegexProcessor());
        }
-    }

-    @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(), processors.build());
    }
 }
@@ -20,10 +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.common.commands.CommandManager;
+import me.lucko.luckperms.common.commands.utils.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;
@@ -31,20 +35,27 @@ import net.md_5.bungee.api.plugin.TabExecutor;
 import java.util.Arrays;

 class BungeeCommand extends Command implements TabExecutor {
+    private final LPBungeePlugin plugin;
    private final CommandManager manager;

-    BungeeCommand(CommandManager manager) {
+    BungeeCommand(LPBungeePlugin plugin, CommandManager manager) {
        super("luckpermsbungee", null, "bperms", "lpb", "bpermissions", "bp", "bperm");
+        this.plugin = plugin;
        this.manager = manager;
    }

    @Override
    public void execute(CommandSender sender, String[] args) {
-        manager.onCommand(BungeeSenderFactory.get().wrap(sender), "bperms", Arrays.asList(args), Callback.empty());
+        manager.onCommand(
+                plugin.getSenderFactory().wrap(sender),
+                "bperms",
+                Util.stripQuotes(Splitter.on(Patterns.COMMAND_SEPARATOR).omitEmptyStrings().splitToList(Joiner.on(' ').join(args))),
+                Callback.empty()
+        );
    }

    @Override
    public Iterable<String> onTabComplete(CommandSender sender, String[] args) {
-        return manager.onTabComplete(BungeeSenderFactory.get().wrap(sender), Arrays.asList(args));
+        return manager.onTabComplete(plugin.getSenderFactory().wrap(sender), Arrays.asList(args));
    }
 }
@@ -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,13 @@ import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.file.Files;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;

-class BungeeConfig extends LPConfiguration<LPBungeePlugin> {
+class BungeeConfig extends AbstractConfiguration<LPBungeePlugin> {
    private Configuration configuration;

    BungeeConfig(LPBungeePlugin plugin) {
@@ -62,11 +67,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 +81,34 @@ class BungeeConfig extends LPConfiguration<LPBungeePlugin> {
    protected boolean getBoolean(String path, boolean def) {
        return configuration.getBoolean(path, def);
    }
+
+    @Override
+    protected List<String> getList(String path, List<String> def) {
+        return Optional.ofNullable(configuration.getStringList(path)).orElse(def);
+    }
+
+    @Override
+    protected List<String> getObjectList(String path, List<String> def) {
+        Configuration section = configuration.getSection(path);
+        if (section == null) {
+            return def;
+        }
+
+        return Optional.ofNullable(section.getKeys().stream().collect(Collectors.toList())).orElse(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;
+    }
 }
@@ -20,21 +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 net.md_5.bungee.event.EventPriority;

-import java.util.Collections;
-import java.util.Map;
 import java.util.UUID;
 import java.util.concurrent.TimeUnit;

@@ -51,25 +55,36 @@ public class BungeeListener extends AbstractListener implements Listener {
    @EventHandler
    public void onPlayerPermissionCheck(PermissionCheckEvent e) {
        if (!(e.getSender() instanceof ProxiedPlayer)) {
+            e.setHasPermission(true);
            return;
        }

        final ProxiedPlayer player = ((ProxiedPlayer) e.getSender());
-        final User user = plugin.getUserManager().get(plugin.getUuidCache().getUUID(player.getUniqueId()));
-        if (user == null) return;

-
-        final String server = player.getServer() == null ? null : (player.getServer().getInfo() == null ? null : player.getServer().getInfo().getName());
-        Map<String, Boolean> local = user.getLocalPermissions(plugin.getConfiguration().getServer(), server, null, Collections.singletonList(e.getPermission()));
-        for (Map.Entry<String, Boolean> en : local.entrySet()) {
-            if (en.getKey().equalsIgnoreCase(e.getPermission())) {
-                e.setHasPermission(en.getValue());
-                return;
-            }
+        User user = plugin.getUserManager().get(plugin.getUuidCache().getUUID(player.getUniqueId()));
+        if (user == null) {
+            return;
        }
+
+        if (user.getUserData() == null) {
+            plugin.getLog().warn("Player " + player.getName() + " does not have any user data setup.");
+            return;
+        }
+
+        Contexts contexts = new Contexts(
+                plugin.getContextManager().getApplicableContext(player),
+                plugin.getConfiguration().isIncludingGlobalPerms(),
+                plugin.getConfiguration().isIncludingGlobalWorldPerms(),
+                true,
+                plugin.getConfiguration().isApplyingGlobalGroups(),
+                plugin.getConfiguration().isApplyingGlobalWorldGroups(),
+                false
+        );
+
+        e.setHasPermission(user.getUserData().getPermissionData(contexts).getPermissionValue(e.getPermission()).asBoolean());
    }

-    @EventHandler
+    @EventHandler(priority = EventPriority.LOWEST)
    public void onPlayerLogin(LoginEvent e) {
        /* Delay the login here, as we want to cache UUID data before the player is connected to a backend bukkit server.
           This means that a player will have the same UUID across the network, even if parts of the network are running in
@@ -81,22 +96,35 @@ public class BungeeListener extends AbstractListener implements Listener {
            final PendingConnection c = e.getConnection();

            if (!cache.isOnlineMode()) {
-                UUID uuid = plugin.getDatastore().getUUID(c.getName());
+                UUID uuid = plugin.getStorage().getUUID(c.getName()).join();
                if (uuid != null) {
                    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());
+                    plugin.getStorage().force().saveUUIDData(c.getName(), c.getUniqueId()).join();
                }
            } else {
+                UUID uuid = plugin.getStorage().getUUID(c.getName()).join();
+                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());
+                plugin.getStorage().force().saveUUIDData(c.getName(), c.getUniqueId()).join();
            }

            // 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());
+            plugin.getStorage().force().loadUser(cache.getUUID(c.getUniqueId()), c.getName()).join();
+            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.");
@@ -112,8 +140,6 @@ public class BungeeListener extends AbstractListener implements Listener {

        if (user == null) {
            plugin.getProxy().getScheduler().schedule(plugin, () -> player.sendMessage(WARN_MESSAGE), 3, TimeUnit.SECONDS);
-        } else {
-            user.refreshPermissions();
        }
    }

@@ -121,9 +147,4 @@ public class BungeeListener extends AbstractListener implements Listener {
    public void onPlayerQuit(PlayerDisconnectEvent e) {
        onLeave(e.getPlayer().getUniqueId());
    }
-
-    @EventHandler
-    public void onPlayerServerSwitch(ServerSwitchEvent e) {
-        refreshPlayer(e.getPlayer().getUniqueId());
-    }
 }
@@ -20,26 +20,20 @@
 *  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.sender.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 BungeeSenderFactory get() {
-        if (instance == null){
-            instance = new BungeeSenderFactory();
-        }
-        return instance;
+    public BungeeSenderFactory(LuckPermsPlugin plugin) {
+        super(plugin);
    }

    @Override
@@ -0,0 +1,325 @@
+/*
+ * 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 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.context.ContextSet;
+import me.lucko.luckperms.api.context.MutableContextSet;
+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.Sender;
+import me.lucko.luckperms.common.config.LPConfiguration;
+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.messaging.RedisMessaging;
+import me.lucko.luckperms.common.runnables.ExpireTemporaryTask;
+import me.lucko.luckperms.common.runnables.UpdateTask;
+import me.lucko.luckperms.common.storage.Storage;
+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.BufferedRequest;
+import me.lucko.luckperms.common.utils.DebugHandler;
+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;
+
+import java.io.File;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+@Getter
+public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
+    private Executor executor;
+
+    private final Set<UUID> ignoringLogs = ConcurrentHashMap.newKeySet();
+    private LPConfiguration configuration;
+    private UserManager userManager;
+    private GroupManager groupManager;
+    private TrackManager trackManager;
+    private Storage storage;
+    private RedisMessaging redisMessaging = null;
+    private UuidCache uuidCache;
+    private ApiProvider apiProvider;
+    private Logger log;
+    private Importer importer;
+    private ConsecutiveExecutor consecutiveExecutor;
+    private LocaleManager localeManager;
+    private ContextManager<ProxiedPlayer> contextManager;
+    private CalculatorFactory calculatorFactory;
+    private BufferedRequest<Void> updateTaskBuffer;
+    private DebugHandler debugHandler;
+    private BungeeSenderFactory senderFactory;
+
+    @Override
+    public void onEnable() {
+        executor = r -> getProxy().getScheduler().runAsync(this, r);
+        log = LogFactory.wrap(getLogger());
+        debugHandler = new DebugHandler();
+        senderFactory = new BungeeSenderFactory(this);
+
+        getLog().info("Loading configuration...");
+        configuration = new BungeeConfig(this);
+
+        // register events
+        getProxy().getPluginManager().registerListener(this, new BungeeListener(this));
+
+        // initialise datastore
+        storage = StorageFactory.getInstance(this, "h2");
+
+        // initialise redis
+        if (getConfiguration().isRedisEnabled()) {
+            getLog().info("Loading redis...");
+            redisMessaging = new RedisMessaging(this);
+            try {
+                redisMessaging.init(getConfiguration().getRedisAddress(), getConfiguration().getRedisPassword());
+                getLog().info("Loaded redis successfully...");
+            } catch (Exception e) {
+                getLog().info("Couldn't load redis...");
+                e.printStackTrace();
+            }
+        }
+
+        // setup the update task buffer
+        updateTaskBuffer = new BufferedRequest<Void>(1000L, this::doAsync) {
+            @Override
+            protected Void perform() {
+                new UpdateTask(LPBungeePlugin.this).run();
+                return null;
+            }
+        };
+
+        // load locale
+        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 commands
+        getLog().info("Registering commands...");
+        CommandManager commandManager = new CommandManager(this);
+        getProxy().getPluginManager().registerCommand(this, new BungeeCommand(this, commandManager));
+
+        // disable the default Bungee /perms command so it gets handled by the Bukkit plugin
+        getProxy().getDisabledCommands().add("perms");
+
+        // load internal managers
+        getLog().info("Loading internal permission managers...");
+        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()));
+
+        // register with the LP API
+        getLog().info("Registering API...");
+        apiProvider = new ApiProvider(this);
+        ApiHandler.registerProvider(apiProvider);
+
+        // schedule update tasks
+        int mins = getConfiguration().getSyncTime();
+        if (mins > 0) {
+            getProxy().getScheduler().schedule(this, new UpdateTask(this), mins, mins, TimeUnit.MINUTES);
+        }
+
+        // run an update instantly.
+        updateTaskBuffer.requestDirectly();
+
+        // register tasks
+        getProxy().getScheduler().schedule(this, new ExpireTemporaryTask(this), 3L, 3L, TimeUnit.SECONDS);
+        getProxy().getScheduler().schedule(this, consecutiveExecutor, 1L, 1L, TimeUnit.SECONDS);
+
+        getLog().info("Successfully loaded.");
+    }
+
+    @Override
+    public void onDisable() {
+        getLog().info("Closing datastore...");
+        storage.shutdown();
+
+        if (redisMessaging != null) {
+            getLog().info("Closing redis...");
+            redisMessaging.shutdown();
+        }
+
+        getLog().info("Unregistering API...");
+        ApiHandler.unregisterProvider();
+    }
+
+    @Override
+    public String getVersion() {
+        return getDescription().getVersion();
+    }
+
+    @Override
+    public PlatformType getType() {
+        return PlatformType.BUNGEE;
+    }
+
+    @Override
+    public File getMainDir() {
+        return getDataFolder();
+    }
+
+    @Override
+    public int getPlayerCount() {
+        return getProxy().getOnlineCount();
+    }
+
+    @Override
+    public List<String> getPlayerList() {
+        return getProxy().getPlayers().stream().map(ProxiedPlayer::getName).collect(Collectors.toList());
+    }
+
+    @Override
+    public Set<UUID> getOnlinePlayers() {
+        return getProxy().getPlayers().stream().map(ProxiedPlayer::getUniqueId).collect(Collectors.toSet());
+    }
+
+    @Override
+    public boolean isOnline(UUID external) {
+        return getProxy().getPlayer(external) != null;
+    }
+
+    @Override
+    public List<Sender> getSenders() {
+        return getProxy().getPlayers().stream()
+                .map(p -> getSenderFactory().wrap(p))
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    public Sender getConsoleSender() {
+        return getSenderFactory().wrap(getProxy().getConsole());
+    }
+
+    @Override
+    public Set<Contexts> getPreProcessContexts(boolean op) {
+        Set<ContextSet> c = new HashSet<>();
+        c.add(ContextSet.empty());
+        c.add(ContextSet.singleton("server", getConfiguration().getServer()));
+        c.addAll(getProxy().getServers().values().stream()
+                .map(ServerInfo::getName)
+                .map(s -> {
+                    MutableContextSet set = new MutableContextSet();
+                    set.add("server", getConfiguration().getServer());
+                    set.add("world", s);
+                    return set.makeImmutable();
+                })
+                .collect(Collectors.toList())
+        );
+
+        return c.stream()
+                .map(set -> new Contexts(
+                        set,
+                        getConfiguration().isIncludingGlobalPerms(),
+                        getConfiguration().isIncludingGlobalWorldPerms(),
+                        true,
+                        getConfiguration().isApplyingGlobalGroups(),
+                        getConfiguration().isApplyingGlobalWorldGroups(),
+                        false
+                ))
+                .collect(Collectors.toSet());
+    }
+
+    @Override
+    public Object getPlugin(String name) {
+        return getProxy().getPluginManager().getPlugin(name);
+    }
+
+    @Override
+    public Object getService(Class clazz) {
+        return null;
+    }
+
+    @Override
+    public UUID getUUID(String playerName) {
+        return null; // Not needed on Bungee
+    }
+
+    @Override
+    public boolean isPluginLoaded(String name) {
+        return getProxy().getPluginManager().getPlugins().stream()
+                .filter(p -> p.getDescription().getName().equalsIgnoreCase(name))
+                .findAny()
+                .isPresent();
+    }
+
+    @Override
+    public void doAsync(Runnable r) {
+        getProxy().getScheduler().runAsync(this, r);
+    }
+
+    @Override
+    public void doSync(Runnable r) {
+        doAsync(r);
+    }
+
+    @Override
+    public Executor getSyncExecutor() {
+        return executor;
+    }
+
+    @Override
+    public Executor getAsyncExecutor() {
+        return executor;
+    }
+
+    @Override
+    public void doAsyncRepeating(Runnable r, long interval) {
+        long millis = interval * 50L; // convert from ticks to milliseconds
+        getProxy().getScheduler().schedule(this, r, millis, millis, TimeUnit.MILLISECONDS);
+    }
+}
@@ -20,19 +20,20 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.commands.migration.subcommands;
+package me.lucko.luckperms.bungee.migration;

-import me.lucko.luckperms.LuckPermsPlugin;
 import me.lucko.luckperms.api.Logger;
-import me.lucko.luckperms.commands.CommandResult;
-import me.lucko.luckperms.commands.Predicate;
-import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
-import me.lucko.luckperms.constants.Constants;
-import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.data.LogEntry;
+import me.lucko.luckperms.api.MetaUtils;
+import me.lucko.luckperms.common.LuckPermsPlugin;
+import me.lucko.luckperms.common.commands.CommandException;
+import me.lucko.luckperms.common.commands.CommandResult;
+import me.lucko.luckperms.common.commands.SubCommand;
+import me.lucko.luckperms.common.commands.sender.Sender;
+import me.lucko.luckperms.common.constants.Constants;
+import me.lucko.luckperms.common.constants.Permission;
+import me.lucko.luckperms.common.data.LogEntry;
+import me.lucko.luckperms.common.utils.Predicates;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
-import me.lucko.luckperms.utils.ArgumentChecker;
 import net.alpenblock.bungeeperms.*;

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

    @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) {
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) throws CommandException {
        final Logger log = plugin.getLog();

        BungeePerms bp = BungeePerms.getInstance();
@@ -61,11 +61,11 @@ public class MigrationBungeePerms extends SubCommand<Object> {
        log.info("BungeePerms Migration: Starting group migration.");
        int groupCount = 0;
        for (Group g : bp.getPermissionsManager().getBackEnd().loadGroups()) {
-            groupCount ++;
+            groupCount++;

            // Make a LuckPerms group for the one being migrated
-            plugin.getDatastore().createAndLoadGroup(g.getName().toLowerCase());
-            me.lucko.luckperms.groups.Group group = plugin.getGroupManager().get(g.getName().toLowerCase());
+            plugin.getStorage().createAndLoadGroup(g.getName().toLowerCase()).join();
+            me.lucko.luckperms.common.groups.Group group = plugin.getGroupManager().get(g.getName().toLowerCase());
            try {
                LogEntry.build()
                        .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
@@ -145,7 +145,7 @@ public class MigrationBungeePerms extends SubCommand<Object> {
            String suffix = g.getSuffix();

            if (prefix != null && !prefix.equals("")) {
-                prefix = ArgumentChecker.escapeCharacters(prefix);
+                prefix = MetaUtils.escapeCharacters(prefix);
                try {
                    group.setPermission("prefix.50." + prefix, true);
                    LogEntry.build()
@@ -160,7 +160,7 @@ public class MigrationBungeePerms extends SubCommand<Object> {
            }

            if (suffix != null && !suffix.equals("")) {
-                suffix = ArgumentChecker.escapeCharacters(suffix);
+                suffix = MetaUtils.escapeCharacters(suffix);
                try {
                    group.setPermission("suffix.50." + suffix, true);
                    LogEntry.build()
@@ -174,7 +174,7 @@ public class MigrationBungeePerms extends SubCommand<Object> {
                }
            }

-            plugin.getDatastore().saveGroup(group);
+            plugin.getStorage().saveGroup(group);
        }

        log.info("BungeePerms Migration: Migrated " + groupCount + " groups");
@@ -188,8 +188,8 @@ public class MigrationBungeePerms extends SubCommand<Object> {
            userCount++;

            // Make a LuckPerms user for the one being migrated.
-            plugin.getDatastore().loadUser(u.getUUID(), "null");
-            me.lucko.luckperms.users.User user = plugin.getUserManager().get(u.getUUID());
+            plugin.getStorage().loadUser(u.getUUID(), "null").join();
+            me.lucko.luckperms.common.users.User user = plugin.getUserManager().get(u.getUUID());

            // Migrate global perms
            for (String perm : u.getPerms()) {
@@ -260,7 +260,7 @@ public class MigrationBungeePerms extends SubCommand<Object> {
            String suffix = u.getSuffix();

            if (prefix != null && !prefix.equals("")) {
-                prefix = ArgumentChecker.escapeCharacters(prefix);
+                prefix = MetaUtils.escapeCharacters(prefix);
                try {
                    user.setPermission("prefix.100." + prefix, true);
                    LogEntry.build()
@@ -275,7 +275,7 @@ public class MigrationBungeePerms extends SubCommand<Object> {
            }

            if (suffix != null && !suffix.equals("")) {
-                suffix = ArgumentChecker.escapeCharacters(suffix);
+                suffix = MetaUtils.escapeCharacters(suffix);
                try {
                    user.setPermission("suffix.100." + suffix, true);
                    LogEntry.build()
@@ -289,7 +289,7 @@ public class MigrationBungeePerms extends SubCommand<Object> {
                }
            }

-            plugin.getDatastore().saveUser(user);
+            plugin.getStorage().saveUser(user);
            plugin.getUserManager().cleanup(user);
        }

@@ -5,46 +5,89 @@
 # +------------------------------------------------------------------------+ #
 ##############################################################################

+# +------------------------------------------------------------------------+ #
+# |                               General                                  | #
+# +------------------------------------------------------------------------+ #
+
 # The name of the server, used for server specific permissions. Set to 'global' to disable.
 server: bungee

-# If users on this server should have their global permissions/groups applied.
+# If users on this server should have their global permissions applied.
+# If set to false, only server specific permissions will apply for users on this server
 include-global: false

+# If users on this server should have their global world permissions applied.
+# If set to false, only world specific permissions will apply for users on this server
+include-global-world: true
+
+# If users on this server should have global (non-server specific) groups applied
+apply-global-groups: true
+
+# If users on this server should have global (non-world specific) groups applied
+apply-global-world-groups: true
+
 # If this server is in offline or online mode.
 # This setting allows a player to have the same UUID across a network of offline mode/mixed servers.
-
+#
 # You should generally reflect the setting in server.properties here. Except when...
-
+#
 # 1. You have Spigot servers connected to a BungeeCord proxy, with online-mode set to false, but 'bungeecord' set to true in the spigot.yml
 #    AND 'ip-forward' set to true in the BungeeCord config.yml
 #    In this case, set online-mode in LuckPerms to true, despite the server being in offline mode.
-
+#
 # 2. You are only running one server instance using LuckPerms, (not a network)
 #    In this case, set online-mode to true no matter what is set in server.properties. (we can just fallback to the servers uuid cache)
-
+#
 # 3. If your proxy is running in offline mode, and you are using PaperSpigot (https://ci.destroystokyo.com/job/PaperSpigot/),
 #    you should set "bungee-online-mode" to false in the paper.yml, and set "online-mode" to true in all LuckPerms configs.
 #    This approach is thoroughly recommended for offline mode networks.
 online-mode: true

+# If the plugin should send log notifications to users whenever permissions are modified.
+log-notify: true
+
+# Mirrors world names. Whenever LuckPerms checks what world a user is in, if the world name is in this list, the value assigned
+# will be sent forward for permission calculation instead.
+world-rewrite:
+#  world_nether: world
+#  world_the_end: world
+
+# Rewrites group names. The underlying name of the group does not change, just the output in commands / placeholders / Vault.
+group-name-rewrite:
+#  default: Member
+
+
+
+
+# +------------------------------------------------------------------------+ #
+# |                        Permission Calculation                          | #
+# +------------------------------------------------------------------------+ #
+
 # If the plugin should apply wildcard permissions.
 # If set to true, LuckPerms will detect wildcard permissions, and resolve & apply all registered permissions matching
-# the wildcard. This will only work for plugins that define all of their permissions to the server.
+# the wildcard.
 apply-wildcards: true

 # If the plugin should parse regex permissions.
 # If set to true, LuckPerms will detect regex permissions, marked with "r=" at the start of the node, and resolve &
-# apply all registered permissions matching the regex. This will only work for plugins that define all of their
-# permissions to the server.
+# apply all registered permissions matching the regex.
 apply-regex: true

 # If the plugin should complete and apply shorthand permissions.
 # If set to true, LuckPerms will detect and expand shorthand node patterns.
 apply-shorthand: true

-# If the plugin should send log notifications to users whenever permissions are modified.
-log-notify: true
+# Define special group weights for this server.
+# Default is just 0.
+group-weight:
+#  admin: 10
+
+
+
+
+# +------------------------------------------------------------------------+ #
+# |                               Storage                                  | #
+# +------------------------------------------------------------------------+ #

 # Which storage method the plugin should use.
 # Currently supported: mysql, sqlite, h2, json, yaml, mongodb
@@ -52,8 +95,6 @@ log-notify: true
 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:
@@ -68,7 +109,98 @@ data:
  database: minecraft
  username: root
  password: ''
+  pool-size: 10 # The size of the MySQL connection pool.

  # Set to -1 to disable. If this is the only instance accessing the datastore, you can disable syncing.
  # e.g. if you're using sqlite or flatfile, this can be set to -1 to save resources.
-  sync-minutes: 3
+  sync-minutes: 3
+
+# Settings for Redis.
+#
+# If enabled and configured, LuckPerms will use the Redis PubSub system to inform other
+# connected servers of changes. Use the command "/luckpermsbungee networksync" to push changes.
+# Data is NOT stored on redis. It is only used as a messaging platform.
+#
+# If you decide to enable this feature, you should set "sync-minutes" to -1, as there is no need for LuckPerms
+# to poll the database for changes.
+redis:
+  enabled: false
+  address: localhost:6379
+  password: ''
+
+
+
+
+# +------------------------------------------------------------------------+ #
+# |                         Default Assignments                            | #
+# +------------------------------------------------------------------------+ #
+
+# This section allows you to define defaults to give users whenever they connect to the server.
+# The default assignments are highly configurable and conditional.
+#
+# There is one default assignment built into LuckPerms, which will add all users to the "default" group if they
+# are not a member of any other group. This setting cannot be disabled. However, you can use this section to add more of
+# your own.
+#
+# IMPORTANT:
+# In order to save storage space, LuckPerms does not store users who have no permissions defined, and are only a member
+# of the default group. Adding default assignments to this section will negate this effect. It is HIGHLY RECCOMENDED
+# that instead of assigning defaults here, you add permissions to the "default" group, or set the "default" group to inherit
+# other groups, and then use the group-name-rewrite rule above.
+#
+# It is also important to note that these rules are considered every time a player logs into the server, and are applied
+# directly to the user's data. Simply removing a rule here will not reserse the effect of that rule on any users who have
+# already had it applied to them.
+#
+# The "has" and "lacks" conditions below support standard boolean logic, using the 'and' & 'or' characters used in Java.
+# e.g. "(some.other.permission | some.permission.other) & some.thing.else" == a user has 'some.other.permission', or
+# 'some.permission.other', and they also have 'some.thing.else'
+#
+# Groups are represented by the permission node: group.<group name>
+# Per server and per world nodes are represented by: "server-world/permission" or "server/permission"
+#
+# Within conditions, permission nodes MUST be escaped using "<" and ">". See the example below.
+#
+# Explaination of the examples below: (they're just to demonstrate the features & use cases)
+#
+# rule1:
+# If a user is either in the vip or vip+ group, and they have the "titles.titlecollector" permission set to true, and the
+# "some.random.permission" set to false... if they're not in the group "prison_titlepack" on the "prison" server, then
+# give add them to the "prison_titlepack" group on the "prison" server, and remove "some.random.permission".
+#
+# rule2:
+# If the user isn't in any of the following groups on the skyblock server: sb_level1, sb_level2, sb_level3, then add
+# them to sb_level1 on the skyblock server.
+#
+# rule3:
+# If the user is a member of the default group, remove them from default, add them to member, and set their primary group
+# to member.
+#
+# WARNING: Unlike internal commands, this system does not ensure that a group exists before adding a user to it.
+# It also does not unsure that a user is a member of a group before making that group their primary group.
+#
+# Before you use "give: group.<name>" or "set-primary-group", make sure that the group exists, and that the user is
+# a member of the group.
+default-assignments:
+#  rule1:
+#    if:
+#      has-true: (<group.vip> | <group.vip+>) & <titles.tilecollector>
+#      has-false: <some.random.permission>
+#      lacks: <prison/group.prison_titlepack>
+#    give:
+#      - prison/group.prison_titlepack
+#    take:
+#      - some.random.permission
+#  rule2:
+#    if:
+#      lacks: <skyblock/group.sb_level1> & <skyblock/group.sb_level2> & <skyblock/group.sb_level3>
+#    give:
+#      - skyblock/group.sb_level1
+#  rule3:
+#    if:
+#      has-true: <group.default>
+#    take:
+#      - group.default
+#    give:
+#      - group.member
+#    set-primary-group: member
@@ -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
@@ -5,7 +5,7 @@
    <parent>
        <artifactId>luckperms</artifactId>
        <groupId>me.lucko.luckperms</groupId>
-        <version>2.8-SNAPSHOT</version>
+        <version>2.14-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

@@ -36,7 +36,14 @@
        <dependency>
            <groupId>com.zaxxer</groupId>
            <artifactId>HikariCP</artifactId>
-            <version>2.4.7</version>
+            <version>2.5.1</version>
+            <scope>compile</scope>
+        </dependency>
+        <!-- Jedis -->
+        <dependency>
+            <groupId>redis.clients</groupId>
+            <artifactId>jedis</artifactId>
+            <version>2.8.1</version>
            <scope>compile</scope>
        </dependency>
        <!-- SQLite -->
@@ -95,53 +102,6 @@
            <version>1.16.10</version>
            <scope>provided</scope>
        </dependency>
-        <!-- **************Migration Plugins************** -->
-        <dependency>
-            <groupId>org.tyrannyofheaven.bukkit</groupId>
-            <artifactId>zPermissions</artifactId>
-            <version>1.3</version>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>ru.tehkode</groupId>
-            <artifactId>PermissionsEx</artifactId>
-            <version>1.23</version>
-            <scope>provided</scope>
-            <exclusions>
-                <exclusion>
-                    <groupId>org.bukkit</groupId>
-                    <artifactId>bukkit</artifactId>
-                </exclusion>
-                <exclusion>
-                    <groupId>net.gravitydevelopment.updater</groupId>
-                    <artifactId>updater</artifactId>
-                </exclusion>
-            </exclusions>
-        </dependency>
-        <dependency>
-            <groupId>com.github.cheesesoftware</groupId>
-            <artifactId>PowerfulPermsAPI</artifactId>
-            <version>1.0.1</version>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.anjocaido</groupId>
-            <artifactId>GroupManager</artifactId>
-            <version>1.4</version>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>net.alpenblock</groupId>
-            <artifactId>BungeePerms</artifactId>
-            <version>3.0-dev-52</version>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>de.bananaco</groupId>
-            <artifactId>bpermissions-api</artifactId>
-            <version>2.12</version>
-            <scope>provided</scope>
-        </dependency>
    </dependencies>

 </project>
@@ -0,0 +1,37 @@
+/*
+ * 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;
+
+import me.lucko.luckperms.api.LuckPermsApi;
+
+public class ApiHandler {
+
+    public static void registerProvider(LuckPermsApi luckPermsApi) {
+        LuckPerms.registerProvider(luckPermsApi);
+    }
+
+    public static void unregisterProvider() {
+        LuckPerms.unregisterProvider();
+    }
+
+}
@@ -1,170 +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;
-
-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 java.io.File;
-import java.util.List;
-import java.util.Set;
-import java.util.UUID;
-
-/**
- * Main internal interface for LuckPerms plugins, allowing the luckperms-common module to bind with the plugin instance.
- * All plugin platforms implement this interface.
- */
-public interface LuckPermsPlugin {
-
-    /*
-     * Access to all of the main internal manager classes
-     */
-    UserManager getUserManager();
-    GroupManager getGroupManager();
-    TrackManager getTrackManager();
-    LPConfiguration getConfiguration();
-    Datastore getDatastore();
-    Logger getLog();
-    UuidCache getUuidCache();
-    ApiProvider getApiProvider();
-    Importer getImporter();
-    ConsecutiveExecutor getConsecutiveExecutor();
-
-    /**
-     * @return the version of the plugin
-     */
-    String getVersion();
-
-    /**
-     * @return the platform type
-     */
-    PlatformType getType();
-
-    /**
-     * @return the main plugin directory
-     */
-    File getMainDir();
-
-    /**
-     * @return the platforms data folder
-     */
-    File getDataFolder();
-
-    /**
-     * Returns a colored string indicating the status of a player
-     * @param uuid The player's uuid
-     * @return a formatted status string
-     */
-    Message getPlayerStatus(UUID uuid);
-
-    /**
-     * Gets the number of users online on the platform
-     * @return the number of users
-     */
-    int getPlayerCount();
-
-    /**
-     * Gets the usernames of the users online on the platform
-     * @return a {@link List} of usernames
-     */
-    List<String> getPlayerList();
-
-    /**
-     * @return a {@link List} of senders online on the platform
-     */
-    List<Sender> getSenders();
-
-    /**
-     * @return the console sender of the instance
-     */
-    Sender getConsoleSender();
-
-    /**
-     * Gets all possible permission nodes, used for resolving wildcards
-     * @return a {@link List} of permission nodes
-     */
-    List<String> getPossiblePermissions();
-
-    /**
-     * Gets a set of players ignoring logging output
-     * @return a {@link Set} of uuids
-     */
-    Set<UUID> getIgnoringLogs();
-
-    /**
-     * Gets a loaded plugins instance from the platform
-     * @param name the name of the plugin
-     * @return a plugin instance
-     */
-    Object getPlugin(String name);
-
-    /**
-     * Gets a provided service from the platform.
-     * @param clazz the class of the service
-     * @return the service instance, if it is provided for
-     */
-    Object getService(Class clazz);
-
-    /**
-     * Used as a backup for migration
-     * @param playerName the players name
-     * @return a uuid if found, or null if not
-     */
-    UUID getUUID(String playerName);
-
-    /**
-     * Checks if a plugin is loaded on the platform
-     * @param name the name of the plugin
-     * @return true if the plugin is loaded
-     */
-    boolean isPluginLoaded(String name);
-
-    /**
-     * Runs an update task
-     */
-    void runUpdateTask();
-
-    /**
-     * Execute a runnable asynchronously
-     * @param r the task to run
-     */
-    void doAsync(Runnable r);
-
-    /**
-     * Execute a runnable synchronously
-     * @param r the task to run
-     */
-    void doSync(Runnable r);
-
-}
@@ -1,185 +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;
-
-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 java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Optional;
-import java.util.stream.Collectors;
-
-@AllArgsConstructor
-public class CommandManager {
-    private final LuckPermsPlugin plugin;
-
-    @Getter
-    private final List<MainCommand> mainCommands = ImmutableList.<MainCommand>builder()
-            .add(new UserMainCommand())
-            .add(new GroupMainCommand())
-            .add(new TrackMainCommand())
-            .add(new LogMainCommand())
-            .add(new SyncCommand())
-            .add(new InfoCommand())
-            .add(new DebugCommand())
-            .add(new ImportCommand())
-            .add(new QueueCommand())
-            .add(new MigrationMainCommand())
-            .add(new CreateGroup())
-            .add(new DeleteGroup())
-            .add(new ListGroups())
-            .add(new CreateTrack())
-            .add(new DeleteTrack())
-            .add(new ListTracks())
-            .build();
-
-
-    /**
-     * Generic on command method to be called from the command executor object of the platform
-     * Unlike {@link #onCommand(Sender, String, List)}, this method is called in a new thread
-     * @param sender who sent the command
-     * @param label the command label used
-     * @param args the arguments provided
-     * @param result the callback to be called when the command has fully executed
-     */
-    public void onCommand(Sender sender, String label, List<String> args, Callback<CommandResult> result) {
-        plugin.doAsync(() -> {
-            CommandResult r = onCommand(sender, label, args);
-            plugin.doSync(() -> result.onComplete(r));
-        });
-    }
-
-    /**
-     * Generic on command method to be called from the command executor object of the platform
-     * @param sender who sent the command
-     * @param label the command label used
-     * @param args the arguments provided
-     * @return if the command was successful
-     */
-    public CommandResult onCommand(Sender sender, String label, List<String> args) {
-        if (args.size() == 0) {
-            sendCommandUsage(sender, label);
-            return CommandResult.INVALID_ARGS;
-        }
-
-        Optional<MainCommand> o = mainCommands.stream()
-                .filter(m -> m.getName().equalsIgnoreCase(args.get(0)))
-                .limit(1)
-                .findAny();
-
-        if (!o.isPresent()) {
-            sendCommandUsage(sender, label);
-            return CommandResult.INVALID_ARGS;
-        }
-
-        final MainCommand main = o.get();
-        if (!main.isAuthorized(sender)) {
-            sendCommandUsage(sender, label);
-            return CommandResult.NO_PERMISSION;
-        }
-
-        if (main.getRequiredArgsLength() == 0) {
-            try {
-                return main.execute(plugin, sender, null, label);
-            } catch (Exception e) {
-                e.printStackTrace();
-                return CommandResult.FAILURE;
-            }
-        }
-
-        if (args.size() == 1) {
-            main.sendUsage(sender, label);
-            return CommandResult.INVALID_ARGS;
-        }
-
-        try {
-            return main.execute(plugin, sender, new ArrayList<>(args.subList(1, args.size())), label);
-        } catch (Exception e) {
-            e.printStackTrace();
-            return CommandResult.FAILURE;
-        }
-    }
-
-    /**
-     * Generic tab complete method to be called from the command executor object of the platform
-     * @param sender who is tab completing
-     * @param args the arguments provided so far
-     * @return a list of suggestions
-     */
-    @SuppressWarnings("unchecked")
-    public List<String> onTabComplete(Sender sender, List<String> args) {
-        final List<MainCommand> mains = mainCommands.stream()
-                .filter(m -> m.isAuthorized(sender))
-                .collect(Collectors.toList());
-
-        if (args.size() <= 1) {
-            if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) {
-                return mains.stream()
-                        .map(m -> m.getName().toLowerCase())
-                        .collect(Collectors.toList());
-            }
-
-            return mains.stream()
-                    .map(m -> m.getName().toLowerCase())
-                    .filter(s -> s.startsWith(args.get(0).toLowerCase()))
-                    .collect(Collectors.toList());
-        }
-
-        Optional<MainCommand> o = mains.stream()
-                .filter(m -> m.getName().equalsIgnoreCase(args.get(0)))
-                .limit(1)
-                .findAny();
-
-        if (!o.isPresent()) {
-            return Collections.emptyList();
-        }
-
-        return o.get().onTabComplete(sender, args.subList(1, args.size()), plugin);
-    }
-
-    private void sendCommandUsage(Sender sender, String label) {
-        Message.INFO_BRIEF.send(sender, plugin.getVersion());
-
-        mainCommands.stream()
-                .filter(c -> c.isAuthorized(sender))
-                .forEach(c -> Util.sendPluginMessage(sender, "&e-> &d" + String.format(c.getUsage(), label)));
-    }
-}
@@ -1,116 +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;
-
-import com.google.common.collect.ImmutableMap;
-import lombok.Getter;
-import me.lucko.luckperms.constants.Constants;
-import me.lucko.luckperms.constants.Permission;
-
-import java.lang.ref.WeakReference;
-import java.util.*;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.stream.Collectors;
-
-/**
- * Factory class to make a thread-safe sender instance
- * @param <T> the command sender type
- */
-public abstract class SenderFactory<T> implements Runnable {
-    private final Map<T, List<String>> messages = new HashMap<>();
-    private final AtomicBoolean shouldSend = new AtomicBoolean(false);
-    private final SenderFactory<T> factory = this;
-
-    protected abstract String getName(T t);
-    protected abstract UUID getUuid(T t);
-    protected abstract void sendMessage(T t, String s);
-    protected abstract boolean hasPermission(T t, String node);
-
-    public final Sender wrap(T t) {
-        return new SenderImp(t);
-    }
-
-    @Override
-    public final void run() {
-        if (!shouldSend.getAndSet(false)) {
-            return;
-        }
-
-        synchronized (messages) {
-            for (Map.Entry<T, List<String>> e : messages.entrySet()) {
-                for (String s : e.getValue()) {
-                    factory.sendMessage(e.getKey(), s);
-                }
-            }
-
-            messages.clear();
-        }
-    }
-
-    private class SenderImp implements Sender {
-        private final WeakReference<T> tRef;
-
-        // Cache these permissions, so they can be accessed async
-        private Map<Permission, Boolean> perms;
-
-        @Getter
-        private final String name;
-
-        @Getter
-        private final UUID uuid;
-
-        private final boolean console;
-
-        private SenderImp(T t) {
-            this.tRef = new WeakReference<>(t);
-            this.name = factory.getName(t);
-            this.uuid = factory.getUuid(t);
-            this.console = this.uuid.equals(Constants.getConsoleUUID()) || this.uuid.equals(Constants.getImporterUUID());
-
-            if (!this.console) {
-                this.perms = ImmutableMap.copyOf(Arrays.stream(Permission.values())
-                        .collect(Collectors.toMap(p -> p, p -> factory.hasPermission(t, p.getNode()))));
-            }
-        }
-
-        @Override
-        public void sendMessage(String s) {
-            final T t = tRef.get();
-            if (t != null) {
-                synchronized (messages) {
-                    if (!messages.containsKey(t)) {
-                        messages.put(t, new ArrayList<>());
-                    }
-
-                    messages.get(t).add(s);
-                }
-                shouldSend.set(true);
-            }
-        }
-
-        @Override
-        public boolean hasPermission(Permission permission) {
-            return console || perms.get(permission);
-        }
-    }
-}
@@ -1,77 +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;
-
-import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.constants.Permission;
-
-import java.util.Collections;
-import java.util.List;
-
-/**
- * An extension of {@link MainCommand} for implementations without any subcommands
- */
-public class SingleMainCommand extends MainCommand<Object> {
-    private final Permission permission;
-
-    public SingleMainCommand(String name, String usage, int requiredArgsLength, Permission permission) {
-        super(name, usage, requiredArgsLength);
-        this.permission = permission;
-    }
-
-    @Override
-    protected CommandResult execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
-        // Do nothing, allow the implementation to override this
-        return null;
-    }
-
-    @Override
-    protected Object getTarget(String target, LuckPermsPlugin plugin, Sender sender) {
-        return null;
-    }
-
-    @Override
-    protected void cleanup(Object o, LuckPermsPlugin plugin) {
-        // Do nothing
-    }
-
-    @Override
-    protected List<String> getObjects(LuckPermsPlugin plugin) {
-        return Collections.emptyList();
-    }
-
-    @Override
-    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
-        return Collections.emptyList();
-    }
-
-    @Override
-    public List<SubCommand<Object>> getSubCommands() {
-        return Collections.emptyList();
-    }
-
-    @Override
-    protected boolean isAuthorized(Sender sender) {
-        return permission.isAuthorized(sender);
-    }
-}
@@ -1,177 +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;
-
-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 java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.function.Predicate;
-import java.util.stream.Collectors;
-
-/**
- * Abstract SubCommand class
- */
-@Getter
-@AllArgsConstructor
-public abstract class SubCommand<T> {
-
-    /**
-     * The name of the sub command
-     */
-    private final String name;
-
-    /**
-     * A brief description of what the sub command does
-     */
-    private final String description;
-
-    /**
-     * The command usage
-     */
-    private final String usage;
-
-    /**
-     * The permission needed to use this command
-     */
-    private final Permission permission;
-
-    /**
-     * Predicate to test if the argument length given is invalid
-     */
-    private final Predicate<? super Integer> isArgumentInvalid;
-
-    /**
-     * Called when this sub command is ran
-     * @param plugin a link to the main plugin instance
-     * @param sender the sender to executed the command
-     * @param t the object the command is operating on
-     * @param args the stripped arguments given
-     * @param label the command label used
-     */
-    public abstract CommandResult execute(LuckPermsPlugin plugin, Sender sender, T t, List<String> args, String label);
-
-    /**
-     * Returns a list of suggestions, which are empty by default. Sub classes that give tab complete suggestions override
-     * this method to give their own list.
-     * @param plugin the plugin instance
-     * @param sender who is tab completing
-     * @param args the arguments so far
-     * @return a list of suggestions
-     */
-    public List<String> onTabComplete(LuckPermsPlugin plugin, Sender sender, List<String> args) {
-        return Collections.emptyList();
-    }
-
-    /**
-     * 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));
-    }
-
-    /**
-     * If a sender has permission to use this command
-     * @param sender the sender trying to use the command
-     * @return true if the sender can use the command
-     */
-    public boolean isAuthorized(Sender sender) {
-        return permission.isAuthorized(sender);
-    }
-
-
-    /*
-     * ----------------------------------------------------------------------------------
-     * Utility methods used by #onTabComplete and #execute implementations in sub classes
-     * ----------------------------------------------------------------------------------
-     */
-
-    protected static List<String> getGroupTabComplete(List<String> args, LuckPermsPlugin plugin) {
-        return getTabComplete(new ArrayList<>(plugin.getGroupManager().getAll().keySet()), args);
-    }
-
-    protected static List<String> getTrackTabComplete(List<String> args, LuckPermsPlugin plugin) {
-        return getTabComplete(new ArrayList<>(plugin.getTrackManager().getAll().keySet()), args);
-    }
-
-    protected static List<String> getBoolTabComplete(List<String> args) {
-        if (args.size() == 2) {
-            return Arrays.asList("true", "false");
-        } else {
-            return Collections.emptyList();
-        }
-    }
-
-    private static List<String> getTabComplete(List<String> options, List<String> args) {
-        if (args.size() <= 1) {
-            if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) {
-                return options;
-            }
-
-            return options.stream().filter(s -> s.toLowerCase().startsWith(args.get(0).toLowerCase())).collect(Collectors.toList());
-        }
-
-        return Collections.emptyList();
-    }
-
-    protected static void save(User user, Sender sender, LuckPermsPlugin plugin) {
-        if (plugin.getDatastore().saveUser(user)) {
-            Message.USER_SAVE_SUCCESS.send(sender);
-        } else {
-            Message.USER_SAVE_ERROR.send(sender);
-        }
-
-        user.refreshPermissions();
-    }
-
-    protected static void save(Group group, Sender sender, LuckPermsPlugin plugin) {
-        if (plugin.getDatastore().saveGroup(group)) {
-            Message.GROUP_SAVE_SUCCESS.send(sender);
-        } else {
-            Message.GROUP_SAVE_ERROR.send(sender);
-        }
-
-        plugin.runUpdateTask();
-    }
-
-    protected static void save(Track track, Sender sender, LuckPermsPlugin plugin) {
-        if (plugin.getDatastore().saveTrack(track)) {
-            Message.TRACK_SAVE_SUCCESS.send(sender);
-        } else {
-            Message.TRACK_SAVE_ERROR.send(sender);
-        }
-
-        plugin.runUpdateTask();
-    }
-}
@@ -1,202 +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;
-
-import lombok.experimental.UtilityClass;
-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 java.util.*;
-
-@UtilityClass
-public class Util {
-
-    public static void sendPluginMessage(Sender sender, String message) {
-        sender.sendMessage(color(Message.PREFIX + message));
-    }
-
-    public static String color(String s) {
-        return translateAlternateColorCodes('&', s);
-    }
-
-    public static String translateAlternateColorCodes(char altColorChar, String textToTranslate) {
-        // Stolen from Bukkit :>
-        char[] b = textToTranslate.toCharArray();
-
-        for (int i = 0; i < b.length - 1; ++i) {
-            if (b[i] == altColorChar && "0123456789AaBbCcDdEeFfKkLlMmNnOoRr".indexOf(b[i + 1]) > -1) {
-                b[i] = 167;
-                b[i + 1] = Character.toLowerCase(b[i + 1]);
-            }
-        }
-
-        return new String(b);
-    }
-
-    public static String stripColor(String s) {
-        return s == null ? null : Patterns.STRIP_COLOR_PATTERN.matcher(s).replaceAll("");
-    }
-
-    public static String formatBoolean(boolean b) {
-        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 listToCommaSep(List<String> strings) {
-        if (strings.isEmpty()) return "&6None";
-
-        StringBuilder sb = new StringBuilder();
-        strings.forEach(s -> sb.append("&6").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";
-
-        StringBuilder sb = new StringBuilder();
-        for (String s : strings) {
-            if (s.equalsIgnoreCase(highlight)) {
-                sb.append("&e").append(s).append("&7 ---> ");
-            } else {
-                sb.append("&6").append(s).append("&7 ---> ");
-            }
-        }
-        return sb.delete(sb.length() - 6, sb.length()).toString();
-    }
-
-    public static String listToArrowSep(List<String> strings, String highlightFirst, String highlightSecond, boolean reversed) {
-        if (strings.isEmpty()) return "&6None";
-
-        StringBuilder sb = new StringBuilder();
-        for (String s : strings) {
-            if (s.equalsIgnoreCase(highlightFirst)) {
-                sb.append("&e").append(s).append("&4").append(reversed ? " <--- " : " ---> ");
-            } else if (s.equalsIgnoreCase(highlightSecond)) {
-                sb.append("&e").append(s).append("&7").append(reversed ? " <--- " : " ---> ");
-            } else {
-                sb.append("&6").append(s).append("&7").append(reversed ? " <--- " : " ---> ");
-            }
-        }
-        return sb.delete(sb.length() - 6, sb.length()).toString();
-    }
-
-    public static String listToArrowSep(List<String> strings) {
-        if (strings.isEmpty()) return "&6None";
-
-        StringBuilder sb = new StringBuilder();
-        strings.forEach(s -> sb.append("&6").append(s).append("&e ---> "));
-        return sb.delete(sb.length() - 6, sb.length()).toString();
-    }
-
-    public static String permNodesToString(SortedSet<Node> nodes) {
-        StringBuilder sb = new StringBuilder();
-        for (Node node : nodes) {
-            if (node.isTemporary()) {
-                continue;
-            }
-
-            sb.append("&6-> ").append(node.getValue() ? "&a" : "&c");
-            sb.append(node.getPermission());
-            if (node.isServerSpecific()) {
-                sb.append(" &7(&f").append(node.getServer().get()).append("&7)");
-            }
-            if (node.isWorldSpecific()) {
-                sb.append(" &7(&f").append(node.getWorld().get()).append("&7)");
-            }
-            sb.append("\n");
-        }
-
-        if (sb.length() == 0) {
-            return "&6None";
-        }
-
-        return sb.toString();
-    }
-
-    public static String tempNodesToString(SortedSet<Node> nodes) {
-        StringBuilder sb = new StringBuilder();
-
-        for (Node node : nodes) {
-            if (!node.isTemporary()) {
-                continue;
-            }
-
-            sb.append("&6-> ").append(node.getValue() ? "&a" : "&c");
-            sb.append(node.getPermission());
-            if (node.isServerSpecific()) {
-                sb.append(" &7(&f").append(node.getServer().get()).append("&7)");
-            }
-            if (node.isWorldSpecific()) {
-                sb.append(" &7(&f").append(node.getWorld().get()).append("&7)");
-            }
-
-            sb.append("&6 - expires in ").append(DateUtil.formatDateDiff(node.getExpiryUnixTime())).append("\n");
-        }
-
-        if (sb.length() == 0) {
-            return "&6None";
-        }
-
-        return sb.toString();
-    }
-
-    public static UUID parseUuid(String s) {
-        try {
-            return UUID.fromString(s);
-        } catch (IllegalArgumentException e) {
-            try {
-                return UUID.fromString(s.replaceAll(
-                        "(\\w{8})(\\w{4})(\\w{4})(\\w{4})(\\w{12})",
-                        "$1-$2-$3-$4-$5"));
-            } catch (IllegalArgumentException e1) {
-                return null;
-            }
-        }
-    }
-
-    public static synchronized MetaComparator getMetaComparator() {
-        if (metaComparator == null) {
-            metaComparator = new MetaComparator();
-        }
-        return metaComparator;
-    }
-
-
-    private static MetaComparator metaComparator = null;
-    public class MetaComparator implements Comparator<Map.Entry<Integer, String>> {
-
-        @Override
-        public int compare(Map.Entry<Integer, String> o1, Map.Entry<Integer, String> o2) {
-            int result = Integer.compare(o1.getKey(), o2.getKey());
-            if (result == 0) {
-                result = o1.getValue().compareTo(o2.getValue());
-            }
-            return result;
-        }
-    }
-}
@@ -1,51 +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;
-
-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 java.util.ArrayList;
-import java.util.List;
-
-public class ListGroups extends SingleMainCommand {
-    public ListGroups() {
-        super("ListGroups", "/%s listgroups", 0, Permission.LIST_GROUPS);
-    }
-
-    @Override
-    protected CommandResult execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
-        if (!plugin.getDatastore().loadAllGroups()) {
-            Message.GROUPS_LOAD_ERROR.send(sender);
-            return CommandResult.LOADING_ERROR;
-        }
-
-        Message.GROUPS_LIST.send(sender, Util.listToCommaSep(new ArrayList<>(plugin.getGroupManager().getAll().keySet())));
-        return CommandResult.SUCCESS;
-    }
-}
@@ -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.ObjectAlreadyHasException;
-import me.lucko.luckperms.groups.Group;
-import me.lucko.luckperms.utils.ArgumentChecker;
-
-import java.util.List;
-
-public class GroupAddPrefix extends SubCommand<Group> {
-    public GroupAddPrefix() {
-        super("addprefix", "Adds a prefix to the group", "/%s group <group> addprefix <priority> <prefix> [server] [world]",
-                Permission.GROUP_ADDPREFIX, 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.setPermission(node, true, server);
-                    Message.ADDPREFIX_SERVER_SUCCESS.send(sender, group.getName(), prefix, priority, server);
-                    LogEntry.build().actor(sender).acted(group)
-                            .action("addprefix " + priority + " " + args.get(1) + " " + server)
-                            .build().submit(plugin, sender);
-                } else {
-                    final String world = args.get(3).toLowerCase();
-                    group.setPermission(node, true, server, world);
-                    Message.ADDPREFIX_SERVER_WORLD_SUCCESS.send(sender, group.getName(), prefix, priority, server, world);
-                    LogEntry.build().actor(sender).acted(group)
-                            .action("addprefix " + priority + " " + args.get(1) + " " + server + " " + world)
-                            .build().submit(plugin, sender);
-                }
-
-            } else {
-                group.setPermission(node, true);
-                Message.ADDPREFIX_SUCCESS.send(sender, group.getName(), prefix, priority);
-                LogEntry.build().actor(sender).acted(group)
-                        .action("addprefix " + priority + " " + args.get(1))
-                        .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;
-        }
-    }
-}
@@ -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.ObjectAlreadyHasException;
-import me.lucko.luckperms.groups.Group;
-import me.lucko.luckperms.utils.ArgumentChecker;
-
-import java.util.List;
-
-public class GroupAddSuffix extends SubCommand<Group> {
-    public GroupAddSuffix() {
-        super("addsuffix", "Adds a suffix to the group", "/%s group <group> addsuffix <priority> <suffix> [server] [world]",
-                Permission.GROUP_ADDSUFFIX, 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.setPermission(node, true, server);
-                    Message.ADDSUFFIX_SERVER_SUCCESS.send(sender, group.getName(), suffix, priority, server);
-                    LogEntry.build().actor(sender).acted(group)
-                            .action("addsuffix " + priority + " " + args.get(1) + " " + server)
-                            .build().submit(plugin, sender);
-                } else {
-                    final String world = args.get(3).toLowerCase();
-                    group.setPermission(node, true, server, world);
-                    Message.ADDSUFFIX_SERVER_WORLD_SUCCESS.send(sender, group.getName(), suffix, priority, server, world);
-                    LogEntry.build().actor(sender).acted(group)
-                            .action("addsuffix " + priority + " " + args.get(1) + " " + server + " " + world)
-                            .build().submit(plugin, sender);
-                }
-
-            } else {
-                group.setPermission(node, true);
-                Message.ADDSUFFIX_SUCCESS.send(sender, group.getName(), suffix, priority);
-                LogEntry.build().actor(sender).acted(group)
-                        .action("addsuffix " + priority + " " + args.get(1))
-                        .build().submit(plugin, sender);
-            }
-
-            save(group, sender, plugin);
-            return CommandResult.SUCCESS;
-        } catch (ObjectAlreadyHasException e) {
-            Message.ALREADY_HAS_SUFFIX.send(sender, group.getName());
-            return CommandResult.STATE_ERROR;
-        }
-    }
-}
@@ -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;
-        }
-    }
-}
@@ -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 GroupAddTempSuffix extends SubCommand<Group> {
-    public GroupAddTempSuffix() {
-        super("addtempsuffix", "Adds a suffix to the group temporarily", "/%s group <group> addtempsuffix <priority> <suffix> <duration> [server] [world]",
-                Permission.GROUP_ADD_TEMP_SUFFIX, Predicate.notInRange(3, 5));
-    }
-
-    @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;
-        }
-
-        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) {
-                    group.setPermission(node, true, server, duration);
-                    Message.ADD_TEMP_SUFFIX_SERVER_SUCCESS.send(sender, group.getName(), suffix, priority, server, DateUtil.formatDateDiff(duration));
-                    LogEntry.build().actor(sender).acted(group)
-                            .action("addtempsuffix " + priority + " " + args.get(1) + " " + duration + " " + server)
-                            .build().submit(plugin, sender);
-                } else {
-                    final String world = args.get(4).toLowerCase();
-                    group.setPermission(node, true, server, world, duration);
-                    Message.ADD_TEMP_SUFFIX_SERVER_WORLD_SUCCESS.send(sender, group.getName(), suffix, priority, server, world, DateUtil.formatDateDiff(duration));
-                    LogEntry.build().actor(sender).acted(group)
-                            .action("addtempsuffix " + priority + " " + args.get(1) + " " + duration + " " + server + " " + world)
-                            .build().submit(plugin, sender);
-                }
-
-            } else {
-                group.setPermission(node, true, duration);
-                Message.ADD_TEMP_SUFFIX_SUCCESS.send(sender, group.getName(), suffix, priority, DateUtil.formatDateDiff(duration));
-                LogEntry.build().actor(sender).acted(group)
-                        .action("addtempsuffix " + priority + " " + args.get(1) + " " + duration)
-                        .build().submit(plugin, sender);
-            }
-
-            save(group, sender, plugin);
-            return CommandResult.SUCCESS;
-        } catch (ObjectAlreadyHasException e) {
-            Message.ALREADY_HAS_SUFFIX.send(sender, group.getName());
-            return CommandResult.STATE_ERROR;
-        }
-    }
-}
@@ -1,89 +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.api.Node;
-import me.lucko.luckperms.commands.*;
-import me.lucko.luckperms.constants.Message;
-import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.groups.Group;
-
-import java.util.*;
-
-public class GroupChatMeta extends SubCommand<Group> {
-    public GroupChatMeta() {
-        super("chatmeta", "Displays a groups chat meta", "/%s group <group> chatmeta", Permission.GROUP_CHATMETA,
-                Predicate.alwaysFalse());
-    }
-
-    @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, 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 : group.getAllNodes(null)) {
-            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 AbstractMap.SimpleEntry<>(node.getPrefix().getKey(), sb.toString()));
-            }
-
-            if (node.isSuffix()) {
-                sb.append(node.getSuffix().getValue());
-                suffixes.add(new AbstractMap.SimpleEntry<>(node.getSuffix().getKey(), sb.toString()));
-            }
-        }
-
-        if (prefixes.isEmpty()) {
-            Message.CHAT_META_PREFIX_NONE.send(sender, group.getName());
-        } else {
-            Message.CHAT_META_PREFIX_HEADER.send(sender, group.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, group.getName());
-        } else {
-            Message.CHAT_META_SUFFIX_HEADER.send(sender, group.getName());
-            for (Map.Entry<Integer, String> e : suffixes) {
-                Message.CHAT_META_ENTRY.send(sender, e.getKey(), e.getValue());
-            }
-        }
-
-        return CommandResult.SUCCESS;
-    }
-}
@@ -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 GroupHasPerm extends SubCommand<Group> {
-    public GroupHasPerm() {
-        super("haspermission", "Checks to see if a group has a certain permission node",
-                "/%s group <group> haspermission <node> [server] [world]", Permission.GROUP_HASPERMISSION,
-                Predicate.notInRange(1, 3));
-    }
-
-    @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.hasPermission(args.get(0), true, args.get(1)));
-            } else {
-                Util.sendBoolean(sender, args.get(0), group.hasPermission(args.get(0), true, args.get(1), args.get(2)));
-            }
-
-        } else {
-            Util.sendBoolean(sender, args.get(0), group.hasPermission(args.get(0), true, "global"));
-        }
-        return CommandResult.SUCCESS;
-    }
-}
@@ -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;
-    }
-}
@@ -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;
-        }
-    }
-}
@@ -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;
-        }
-    }
-}
@@ -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;
-        }
-    }
-}
@@ -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;
-        }
-    }
-}
@@ -1,109 +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 java.util.List;
-
-public class GroupSetInherit extends SubCommand<Group> {
-    public GroupSetInherit() {
-        super("setinherit", "Sets another group for this group to inherit permissions from",
-                "/%s group <group> setinherit <group> [server] [world]", Permission.GROUP_SETINHERIT,
-                Predicate.notInRange(1, 3));
-    }
-
-    @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
-        String groupName = args.get(0).toLowerCase();
-
-        if (ArgumentChecker.checkNode(groupName)) {
-            sendUsage(sender, label);
-            return CommandResult.INVALID_ARGS;
-        }
-
-        if (!plugin.getDatastore().loadGroup(groupName)) {
-            Message.GROUP_DOES_NOT_EXIST.send(sender);
-            return CommandResult.INVALID_ARGS;
-        }
-
-        Group group1 = plugin.getGroupManager().get(groupName);
-        if (group1 == null) {
-            Message.GROUP_DOES_NOT_EXIST.send(sender);
-            return CommandResult.LOADING_ERROR;
-        }
-
-        try {
-            if (args.size() >= 2) {
-                final String server = args.get(1).toLowerCase();
-                if (ArgumentChecker.checkServer(server)) {
-                    Message.SERVER_INVALID_ENTRY.send(sender);
-                    return CommandResult.INVALID_ARGS;
-                }
-
-                if (args.size() == 2) {
-                    group.setInheritGroup(group1, server);
-                    Message.GROUP_SETINHERIT_SERVER_SUCCESS.send(sender, group.getName(), group1.getName(), server);
-                    LogEntry.build().actor(sender).acted(group)
-                            .action("setinherit " + group1.getName() + " " + server)
-                            .build().submit(plugin, sender);
-                } else {
-                    final String world = args.get(2).toLowerCase();
-                    group.setInheritGroup(group1, server, world);
-                    Message.GROUP_SETINHERIT_SERVER_WORLD_SUCCESS.send(sender, group.getName(), group1.getName(), server, world);
-                    LogEntry.build().actor(sender).acted(group)
-                            .action("setinherit " + group1.getName() + " " + server + " " + world)
-                            .build().submit(plugin, sender);
-                }
-
-            } else {
-                group.setInheritGroup(group1);
-                Message.GROUP_SETINHERIT_SUCCESS.send(sender, group.getName(), group1.getName());
-                LogEntry.build().actor(sender).acted(group)
-                        .action("setinherit " + group1.getName())
-                        .build().submit(plugin, sender);
-            }
-
-            save(group, sender, plugin);
-            return CommandResult.SUCCESS;
-        } catch (ObjectAlreadyHasException e) {
-            Message.GROUP_ALREADY_INHERITS.send(sender, group.getName(), group1.getName());
-            return CommandResult.STATE_ERROR;
-        }
-    }
-
-    @Override
-    public List<String> onTabComplete(LuckPermsPlugin plugin, Sender sender, List<String> args) {
-        return getGroupTabComplete(args, plugin);
-    }
-}
@@ -1,111 +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.Patterns;
-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 java.util.List;
-
-public class GroupSetPermission extends SubCommand<Group> {
-    public GroupSetPermission() {
-        super("set", "Sets a permission for a group", "/%s group <group> set <node> <true|false> [server] [world]",
-                Permission.GROUP_SETPERMISSION, Predicate.notInRange(2, 4));
-    }
-
-    @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
-        String node = args.get(0).replace("{SPACE}", " ");
-        String bool = args.get(1).toLowerCase();
-
-        if (ArgumentChecker.checkNode(node)) {
-            sendUsage(sender, label);
-            return CommandResult.INVALID_ARGS;
-        }
-
-        if (Patterns.GROUP_MATCH.matcher(node).matches()) {
-            Message.GROUP_USE_INHERIT.send(sender);
-            return CommandResult.INVALID_ARGS;
-        }
-
-        if (!bool.equalsIgnoreCase("true") && !bool.equalsIgnoreCase("false")) {
-            sendUsage(sender, label);
-            return CommandResult.INVALID_ARGS;
-        }
-
-        boolean b = Boolean.parseBoolean(bool);
-
-        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.setPermission(node, b, server);
-                    Message.SETPERMISSION_SERVER_SUCCESS.send(sender, node, bool, group.getName(), server);
-                    LogEntry.build().actor(sender).acted(group)
-                            .action("set " + node + " " + b + " " + server)
-                            .build().submit(plugin, sender);
-                } else {
-                    final String world = args.get(3).toLowerCase();
-                    group.setPermission(node, b, server, world);
-                    Message.SETPERMISSION_SERVER_WORLD_SUCCESS.send(sender, node, bool, group.getName(), server, world);
-                    LogEntry.build().actor(sender).acted(group)
-                            .action("set " + node + " " + b + " " + server + " " + world)
-                            .build().submit(plugin, sender);
-                }
-
-            } else {
-                group.setPermission(node, b);
-                Message.SETPERMISSION_SUCCESS.send(sender, node, bool, group.getName());
-                LogEntry.build().actor(sender).acted(group)
-                        .action("set " + node + " " + b)
-                        .build().submit(plugin, sender);
-            }
-
-            save(group, sender, plugin);
-            return CommandResult.SUCCESS;
-        } catch (ObjectAlreadyHasException e) {
-            Message.ALREADY_HASPERMISSION.send(sender, group.getName());
-            return CommandResult.STATE_ERROR;
-        }
-    }
-
-    @Override
-    public List<String> onTabComplete(LuckPermsPlugin plugin, Sender sender, List<String> args) {
-        return getBoolTabComplete(args);
-    }
-}
@@ -1,129 +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 GroupSetTempInherit extends SubCommand<Group> {
-    public GroupSetTempInherit() {
-        super("settempinherit", "Sets another group for this group to inherit permissions from temporarily",
-                "/%s group <group> settempinherit <group> <duration> [server] [world]",
-                Permission.GROUP_SET_TEMP_INHERIT, Predicate.notInRange(2, 4));
-    }
-
-    @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
-        String groupName = args.get(0).toLowerCase();
-
-        if (ArgumentChecker.checkNode(groupName)) {
-            sendUsage(sender, label);
-            return CommandResult.INVALID_ARGS;
-        }
-
-        long duration;
-        try {
-            duration = Long.parseLong(args.get(1));
-        } catch (NumberFormatException e) {
-            try {
-                duration = DateUtil.parseDateDiff(args.get(1), true);
-            } catch (DateUtil.IllegalDateException e1) {
-                Message.ILLEGAL_DATE_ERROR.send(sender, args.get(1));
-                return CommandResult.INVALID_ARGS;
-            }
-        }
-
-        if (DateUtil.shouldExpire(duration)) {
-            Message.PAST_DATE_ERROR.send(sender);
-            return CommandResult.INVALID_ARGS;
-        }
-
-        if (!plugin.getDatastore().loadGroup(groupName)) {
-            Message.GROUP_DOES_NOT_EXIST.send(sender);
-            return CommandResult.INVALID_ARGS;
-        }
-
-        Group group1 = plugin.getGroupManager().get(groupName);
-        if (group1 == null) {
-            Message.GROUP_DOES_NOT_EXIST.send(sender);
-            return CommandResult.INVALID_ARGS;
-        }
-
-        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.setInheritGroup(group1, server, duration);
-                    Message.GROUP_SET_TEMP_INHERIT_SERVER_SUCCESS.send(sender, group.getName(), group1.getName(), server,
-                            DateUtil.formatDateDiff(duration));
-                    LogEntry.build().actor(sender).acted(group)
-                            .action("settempinherit " + group1.getName() + " " + duration + " " + server)
-                            .build().submit(plugin, sender);
-                } else {
-                    final String world = args.get(3).toLowerCase();
-                    group.setInheritGroup(group1, server, world, duration);
-                    Message.GROUP_SET_TEMP_INHERIT_SERVER_WORLD_SUCCESS.send(sender, group.getName(), group1.getName(), server,
-                            world, DateUtil.formatDateDiff(duration));
-                    LogEntry.build().actor(sender).acted(group)
-                            .action("settempinherit " + group1.getName() + " " + duration + " " + server + " " + world)
-                            .build().submit(plugin, sender);
-                }
-
-            } else {
-                group.setInheritGroup(group1, duration);
-                Message.GROUP_SET_TEMP_INHERIT_SUCCESS.send(sender, group.getName(), group1.getName(), DateUtil.formatDateDiff(duration));
-                LogEntry.build().actor(sender).acted(group)
-                        .action("settempinherit " + group1.getName() + " " + duration)
-                        .build().submit(plugin, sender);
-            }
-
-            save(group, sender, plugin);
-            return CommandResult.SUCCESS;
-        } catch (ObjectAlreadyHasException e) {
-            Message.USER_ALREADY_TEMP_MEMBER_OF.send(sender, group.getName(), group1.getName());
-            return CommandResult.STATE_ERROR;
-        }
-    }
-
-    @Override
-    public List<String> onTabComplete(LuckPermsPlugin plugin, Sender sender, List<String> args) {
-        return getGroupTabComplete(args, plugin);
-    }
-}
@@ -1,132 +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.Patterns;
-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 GroupSetTempPermission extends SubCommand<Group> {
-    public GroupSetTempPermission() {
-        super("settemp", "Sets a temporary permission for a group",
-                "/%s group <group> settemp <node> <true|false> <duration> [server] [world]",
-                Permission.GROUP_SET_TEMP_PERMISSION, Predicate.notInRange(3, 5));
-    }
-
-    @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
-        String node = args.get(0).replace("{SPACE}", " ");
-        String bool = args.get(1).toLowerCase();
-
-        if (ArgumentChecker.checkNode(node)) {
-            sendUsage(sender, label);
-            return CommandResult.INVALID_ARGS;
-        }
-
-        if (Patterns.GROUP_MATCH.matcher(node).matches()) {
-            Message.GROUP_USE_INHERIT.send(sender);
-            return CommandResult.INVALID_ARGS;
-        }
-
-        if (!bool.equalsIgnoreCase("true") && !bool.equalsIgnoreCase("false")) {
-            sendUsage(sender, label);
-            return CommandResult.INVALID_ARGS;
-        }
-
-        boolean b = Boolean.parseBoolean(bool);
-
-        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;
-        }
-
-        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, b, server, duration);
-                    Message.SETPERMISSION_TEMP_SERVER_SUCCESS.send(sender, node, bool, group.getName(), server,
-                            DateUtil.formatDateDiff(duration));
-                    LogEntry.build().actor(sender).acted(group)
-                            .action("settemp " + node + " " + b + " " + duration + " " + server)
-                            .build().submit(plugin, sender);
-                } else {
-                    final String world = args.get(4).toLowerCase();
-                    group.setPermission(node, b, server, world, duration);
-                    Message.SETPERMISSION_TEMP_SERVER_WORLD_SUCCESS.send(sender, node, bool, group.getName(), server,
-                            world, DateUtil.formatDateDiff(duration));
-                    LogEntry.build().actor(sender).acted(group)
-                            .action("settemp " + node + " " + b + " " + duration + " " + server + " " + world)
-                            .build().submit(plugin, sender);
-                }
-
-            } else {
-                group.setPermission(node, b, duration);
-                Message.SETPERMISSION_TEMP_SUCCESS.send(sender, node, bool, group.getName(), DateUtil.formatDateDiff(duration));
-                LogEntry.build().actor(sender).acted(group)
-                        .action("settemp " + node + " " + b + " " + duration)
-                        .build().submit(plugin, sender);
-            }
-
-            save(group, sender, plugin);
-            return CommandResult.SUCCESS;
-        } catch (ObjectAlreadyHasException e) {
-            Message.ALREADY_HAS_TEMP_PERMISSION.send(sender, group.getName());
-            return CommandResult.STATE_ERROR;
-        }
-    }
-
-    @Override
-    public List<String> onTabComplete(LuckPermsPlugin plugin, Sender sender, List<String> args) {
-        return getBoolTabComplete(args);
-    }
-}
@@ -1,98 +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.Patterns;
-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 GroupUnSetPermission extends SubCommand<Group> {
-    public GroupUnSetPermission() {
-        super("unset", "Unsets a permission for a group", "/%s group <group> unset <node> [server] [world]",
-                Permission.GROUP_UNSETPERMISSION, Predicate.notInRange(1, 3));
-    }
-
-    @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
-        String node = args.get(0).replace("{SPACE}", " ");
-
-        if (ArgumentChecker.checkNode(node)) {
-            sendUsage(sender, label);
-            return CommandResult.INVALID_ARGS;
-        }
-
-        if (Patterns.GROUP_MATCH.matcher(node).matches()) {
-            Message.GROUP_USE_UNINHERIT.send(sender);
-            return CommandResult.INVALID_ARGS;
-        }
-
-        try {
-            if (args.size() >= 2) {
-                final String server = args.get(1).toLowerCase();
-                if (ArgumentChecker.checkServer(server)) {
-                    Message.SERVER_INVALID_ENTRY.send(sender);
-                    return CommandResult.INVALID_ARGS;
-                }
-
-                if (args.size() == 2) {
-                    group.unsetPermission(node, server);
-                    Message.UNSETPERMISSION_SERVER_SUCCESS.send(sender, node, group.getName(), server);
-                    LogEntry.build().actor(sender).acted(group)
-                            .action("unset " + node + " " + server)
-                            .build().submit(plugin, sender);
-                } else {
-                    final String world = args.get(2).toLowerCase();
-                    group.unsetPermission(node, server, world);
-                    Message.UNSETPERMISSION_SERVER_WORLD_SUCCESS.send(sender, node, group.getName(), server, world);
-                    LogEntry.build().actor(sender).acted(group)
-                            .action("unset " + node + " " + server + " " + world)
-                            .build().submit(plugin, sender);
-                }
-
-            } else {
-                group.unsetPermission(node);
-                Message.UNSETPERMISSION_SUCCESS.send(sender, node, group.getName());
-                LogEntry.build().actor(sender).acted(group)
-                        .action("unset " + node)
-                        .build().submit(plugin, sender);
-            }
-
-            save(group, sender, plugin);
-            return CommandResult.SUCCESS;
-        } catch (ObjectLacksException e) {
-            Message.DOES_NOT_HAVEPERMISSION.send(sender, group.getName());
-            return CommandResult.STATE_ERROR;
-        }
-    }
-}
Author	SHA1	Message	Date
Luck	563dd4683d	Changes for & release of API 2.14	2016-11-12 14:10:42 +00:00
Luck	e9131f729a	add methods for older sponge api versions	2016-11-11 22:54:09 +00:00
Luck	c4ea626e33	Fix PM migration	2016-11-11 20:43:05 +00:00
Luck	fefba7976b	Actually register new migration command	2016-11-11 20:35:11 +00:00
Luck	2ce8555692	Add Sponge PermissionManager migration support	2016-11-11 20:31:42 +00:00
Luck	9fe9c386bb	Sponge: rely less on dummy subjects	2016-11-11 19:32:25 +00:00
Luck	e8cd2c7548	More command refactors	2016-11-10 22:13:53 +00:00
Luck	158d8b086a	Command refactor	2016-11-10 19:19:43 +00:00
Luck	1c534d7475	More cleanup	2016-11-08 20:46:29 +00:00
Luck	90f8dbe243	Refactor commands	2016-11-07 22:02:48 +00:00
Luck	0c33b26fa9	Refactor meta accumulation	2016-11-07 19:01:15 +00:00
Luck	d320679f69	Implement proper meta inheritance handling	2016-11-07 17:32:17 +00:00
Luck	8d5398b5a3	Make nodes with more contexts take priority over nodes with less	2016-11-06 16:15:45 +00:00
Luck	6cd8593fa5	Fix vault primary group override feature	2016-11-06 15:11:28 +00:00
Luck	5ebbc178a5	Remove messenger system & more cleanup	2016-11-06 14:56:13 +00:00
Luck	4f6e229943	Small cleanup	2016-11-05 23:23:08 +00:00
Luck	3e846d9527	Maybe fix split storage - closes #38	2016-11-05 21:43:48 +00:00
Luck	981d745b74	Fix verbose system	2016-11-05 19:19:29 +00:00
Luck	2dd0858960	Allow multiple verbose filters	2016-11-05 19:01:06 +00:00
Luck	f72819a664	Try to reduce contention in PermissionHolder	2016-11-05 17:49:52 +00:00
Luck	5361b1e87b	Implement group weights	2016-11-05 09:04:26 +00:00
Luck	e15d03ed4e	Fix parents being cleared on promote/demote	2016-11-05 07:53:18 +00:00
Luck	6c9041ce40	Improve meta info command	2016-11-04 19:13:39 +00:00
Luck	8da96e6e48	Re-add showtracks/showpos commands	2016-11-04 18:36:32 +00:00
Luck	385aa6d438	Add set "none" command as an alternative to unset	2016-11-04 16:40:55 +00:00
Luck	79f24a5944	Improve track functionality. Resolves #39	2016-11-01 21:34:54 +00:00
Luck	80570717f9	Fix slow datastore performance when using the API	2016-11-01 19:41:40 +00:00
Luck	ebab79c4ca	Maybe fix blocking issue with #getPermissions	2016-11-01 19:38:08 +00:00
Luck	42882ebe11	Update some ugly messages	2016-10-31 22:25:42 +00:00
Luck	d2de26f765	Move hasperm/inheritsperm commands & add parent set command. Resolves #40	2016-10-31 19:27:04 +00:00
Luck	e2cebfbd16	Refactor Node class	2016-10-31 18:18:31 +00:00
Luck	a58cc6bdf3	Refactor PermissionHolder	2016-10-30 21:29:14 +00:00
Luck	36bc1553c0	Implement Sponge timings	2016-10-30 19:35:11 +00:00
Luck	17b06c39e9	Ignore negated primary group override nodes & fix broken message	2016-10-30 15:29:55 +00:00
Luck	ba2f6eb7be	Update .gitignore	2016-10-30 13:37:25 +00:00
Luck	b93145f26d	Change some listener priorities	2016-10-30 13:23:45 +00:00
Luck	e88ea9c13d	Don't fully unload Sponge user subjects	2016-10-30 13:21:43 +00:00
Luck	1275d0023d	Listen to PlayerQuit on monitor priority	2016-10-29 22:58:06 +01:00
Luck	27f6f225c9	whoops	2016-10-29 21:56:55 +01:00
Luck	41362aa34a	Use a temporary executor until the bukkit one has started	2016-10-29 21:54:13 +01:00
Luck	a99609e016	Don't wrap buffer tasks in scheduler calls	2016-10-29 21:23:30 +01:00
Luck	c0ea2d8ec3	Fix data not being loaded sync when the plugin starts	2016-10-29 21:14:59 +01:00
Luck	bb6b31d715	change Sponge listener priorities	2016-10-29 21:12:55 +01:00
Luck	21695dd2cb	Implement support for Bukkit child permissions	2016-10-28 19:16:32 +01:00
Luck	531835c948	Fix GroupManager primary group migration	2016-10-28 18:00:18 +01:00
Luck	77e3b351fd	Fix GroupManager user migration	2016-10-28 17:58:36 +01:00
Luck	66f756575a	Remove redundant config option	2016-10-27 18:48:38 +01:00
Luck	7acc8bc7ed	Add verbose command	2016-10-27 17:46:44 +01:00
Luck	0a4d337a53	Cache context lookups & refactor Sponge subjects	2016-10-27 16:32:14 +01:00
Luck	0198068a13	Improve permission lookup speed (slightly)	2016-10-26 21:35:44 +01:00
Luck	1c15f8462f	Don't run commands through the buffer system	2016-10-26 19:52:03 +01:00
Luck	3929ce0dfc	Fix compile	2016-10-26 19:32:41 +01:00
Luck	7deeaf305d	Experimental: Run I/O after commands in a new thread	2016-10-26 17:55:38 +01:00
Luck	0f04c06e13	Remove redundant method	2016-10-26 17:19:56 +01:00
Luck	d1863fa714	Implement more customizable primary groups	2016-10-26 17:19:33 +01:00
Luck	46b122a167	Fix memory leak preventing users from being unloaded	2016-10-25 18:44:11 +01:00
Luck	ee3db1e5c5	Maybe fix GroupManager primary group migration	2016-10-25 15:02:49 +01:00
Luck	bd830617c9	Small cleanup	2016-10-25 11:14:56 +01:00
Luck	a9b6493091	A few small optimizations	2016-10-24 18:48:39 +01:00
Luck	9894e45516	Fix issue with Vault lookups not being preprocessed	2016-10-24 15:57:05 +01:00
Luck	2cfc82f3aa	Implement support for instant data propagation with Redis	2016-10-24 14:38:12 +01:00
Luck	bb9eab0989	Lower sync wait buffer & fix export command	2016-10-24 13:02:26 +01:00
Luck	dc87ec1c82	Update placeholder expansion	2016-10-24 09:57:29 +01:00
Luck	98b7b65ce7	Remove PEX dependency	2016-10-24 09:22:53 +01:00
Luck	9f8f32b33e	Fix suffixes not being applied	2016-10-23 22:02:48 +01:00
Luck	a80ec6d893	Implement PermissionsEx 2.0 migration for Sponge	2016-10-23 20:42:58 +01:00
Luck	4d85930f5a	Refactor migration classes	2016-10-23 20:42:25 +01:00
Luck	f722f4112d	Update default-lang.yml	2016-10-23 17:59:34 +01:00
Luck	383276f47a	Refactor contexts, expose cached data in the API & release 2.13	2016-10-23 16:46:53 +01:00
Luck	33c78e4a17	Use LoadingCache instead of a regular map + more datastore fixes	2016-10-22 20:39:26 +01:00
Luck	55a0de7899	Lower buffer time to 1 second. Should resolve any issues with changes being overridden. (related: #32 )	2016-10-22 18:52:51 +01:00
Luck	6b3aab66bf	Fix some #saveX methods being waited for, when they can just be ran async	2016-10-22 09:35:11 +01:00
Luck	77e70ef8d3	Fix deadlocks caused by waiting for async operations to complete before the scheduler has started	2016-10-22 09:21:30 +01:00
Luck	9b92143501	prevent logins until the plugin has started	2016-10-22 00:07:30 +01:00
Luck	87f94f6b8f	add started value to bukkit plugin	2016-10-22 00:05:33 +01:00
Luck	5d955e77b6	Make the max pool size configurable	2016-10-21 22:22:06 +01:00
Luck	270a276b98	Refactor SQL storage to not hold onto connections for as long	2016-10-21 22:07:14 +01:00
Luck	be7d914e39	Finish the buffering refactor - still WIP. Towards #32	2016-10-21 18:34:53 +01:00
Luck	37fc00cce8	Refactoring storage - WIP. Towards #32	2016-10-20 21:55:34 +01:00
Luck	0d515abadb	Cleanup some bad code in SQLDatastore. Might help #32	2016-10-19 23:30:30 +01:00
Luck	daef01194e	Shade MySQL connector into Sponge jar. Resolves #31	2016-10-19 22:23:43 +01:00
Luck	258bf1cc41	small cleanup	2016-10-19 20:57:53 +01:00
Luck	ce3d7829d7	Update internal permissions to match the new command layouts	2016-10-19 20:14:16 +01:00
Luck	c66a01c1a6	Fix temporary permission expirations never persisting. Fixes #30	2016-10-19 17:37:26 +01:00
Luck	d113a92ce5	Cleanup permission calculation	2016-10-18 20:48:59 +01:00
Luck	7b655d12df	Add set-primary-group option to the default assignments	2016-10-17 18:23:41 +01:00
Luck	a4c872f1e8	Fix per-world permissions not working until a user switches worlds	2016-10-17 17:10:02 +01:00
Luck	0e7d9bf9c1	Bump hikari version	2016-10-16 21:05:25 +01:00
Luck	6252a5bc75	Fix invalid property	2016-10-16 20:53:12 +01:00
Luck	e4e80c9c31	Update to SpongeAPI 5.0.0 release	2016-10-16 18:13:55 +01:00
Luck	165c5610c3	Add extra Hikari flag	2016-10-16 17:24:02 +01:00
Luck	13fbc7dd39	Implement default assignment system (#25 )	2016-10-16 13:58:57 +01:00
Luck	02a75fc32a	Reimplement autoop on Bukkit & other misc fixes	2016-10-15 21:04:04 +01:00
Luck	699c4d107b	Swap the javaassist maven plugin with a better method	2016-10-15 08:59:49 +01:00
Luck	e4810302e1	Implement meta / Sponge option commands & fix meta caching system. Fully resolves #23	2016-10-14 22:49:32 +01:00
Luck	73f10cad66	Make the recent command changes backwards compatible	2016-10-14 20:42:00 +01:00
Luck	f1d670dc46	refactor permission commands	2016-10-14 19:55:22 +01:00
Luck	045539c752	refactor inheritance commands	2016-10-14 19:19:57 +01:00
Luck	782c09b686	Refine bulk group edit primary group check	2016-10-13 21:29:30 +01:00
Luck	6109718c67	Cleanup some remaining TODOs	2016-10-13 21:16:34 +01:00
Luck	cd758d7e48	Bump minor version	2016-10-13 20:40:09 +01:00
Luck	fcb0fcadeb	Fix StackOverflowException	2016-10-13 20:36:08 +01:00
Luck	26fb506560	Reorganize packages	2016-10-13 20:07:10 +01:00
Luck	b6c4239322	Fix NPE	2016-10-13 19:43:48 +01:00
Luck	74f9283f18	Silence exception on #giveDefaultIfNeeded. Resolves #26	2016-10-13 19:25:31 +01:00
Luck	60e6ae6e23	Fix Sponge implementation, remove standalone module	2016-10-13 19:13:34 +01:00
Luck	83d9229295	Refactor caching system (WIP) - still working towards #23	2016-10-12 21:57:57 +01:00
Luck	e079b0f3ed	Fix meta command showing when a user doesn't have permission to use it	2016-10-11 21:17:04 +01:00
Luck	d433a5461d	Refactor meta commands, working towards #23	2016-10-11 21:12:10 +01:00
Luck	2c43f6bf21	Fix global permissions and groups sometimes not applying	2016-10-11 19:31:55 +01:00
Luck	ac57509a29	Fix prefix/suffix priorities being ignored	2016-10-11 19:31:26 +01:00
Luck	c5ce655cf6	Add Vault chat debug messages	2016-10-11 19:06:18 +01:00
Luck	9fe05efb4e	Don't force the default group	2016-10-11 18:54:42 +01:00
Luck	dcf207f5e5	Fix exception, resolves #20 and #22	2016-10-10 22:39:24 +01:00
Luck	11facab71c	Fix NPE, resolves #19	2016-10-10 22:26:39 +01:00
Luck	5b4975f34c	Implement persisting subjects (+ defaults)	2016-10-10 18:58:43 +01:00
Luck	069e535f1a	Avoid odd behavior where Sponge prevents User subjects from being GCed	2016-10-09 21:34:05 +01:00
Luck	1eb053447e	Make refresh calls in SpongeListener run async	2016-10-09 20:49:17 +01:00
Luck	93c7c06b2d	Cleanup some Sponge subject classes	2016-10-09 13:14:58 +01:00
Luck	b0085bc1e1	Update readme	2016-10-09 10:58:14 +01:00
Luck	9133951446	I'm dumb	2016-10-08 16:45:18 +01:00
Luck	7853d4686a	Fix NPE with LPPermissibles & refreshing users	2016-10-08 16:43:57 +01:00
Luck	ed5892eb56	add option to ignore vault world parameters	2016-10-08 15:01:54 +01:00
Luck	687804de2c	small change to BukkitConfig	2016-10-08 09:05:48 +01:00
Luck	9d166041ab	Account for inheritance and wildcards in SimpleSubject	2016-10-07 18:11:59 +01:00
Luck	924041bff4	Add server and world args to clear command, and add clearmeta command	2016-10-06 21:23:27 +01:00
Luck	e9216d3e0f	Allow the prefix to be modified by the lang file	2016-10-06 19:54:52 +01:00
Luck	db8f1bca66	Fix API javadoc & fix Bukkit legacy build	2016-10-06 17:21:04 +01:00
Luck	2429831153	API changes for 2.11	2016-10-05 21:40:54 +01:00
Luck	80d2246634	Fix exporting users not in the default group	2016-10-04 20:48:58 +01:00
Luck	56df2477ca	Fix UnsupportedOperationExceptions with #getPermissions	2016-10-04 17:30:27 +01:00
Luck	9b4384dc33	Revert: Merge dummy implementations	2016-10-04 17:15:10 +01:00
Luck	bc65857831	Fix CME	2016-10-04 17:13:32 +01:00
Luck	de462d2385	Merge dummy implementations	2016-10-04 16:58:54 +01:00
Luck	90150428be	Inject a dummy on quit instead of a real PermBase instance	2016-10-04 16:19:41 +01:00
Luck	2a7f951f4f	Fix NPE / crash on player quit	2016-10-04 16:10:06 +01:00
Luck	82789328c1	Pre-process permissions and apply immediately on login events	2016-10-04 14:57:00 +01:00
Luck	13bccd1d3f	Fix users not receiving permission updates	2016-10-03 21:41:47 +01:00
Luck	43c514132d	Cache node deserialization	2016-10-03 21:18:59 +01:00
Luck	9e0fdcbfee	Fix memory leak, woops	2016-10-03 20:43:36 +01:00
Luck	008dc3fc52	Move some classes around	2016-10-03 20:42:11 +01:00
Luck	9fde237d9b	Swap slow get method	2016-10-03 19:53:43 +01:00
Luck	d626c08b4c	Small fix for #getAllWithPermission	2016-10-03 16:45:52 +01:00
Luck	58e223e74b	Implement bulk prefix/suffix removal	2016-10-02 21:17:59 +01:00
Luck	1da1df156e	Fix issues related to Node comparisons	2016-10-02 15:44:46 +01:00
Luck	3442372281	Cleanup random debug messages	2016-10-02 15:43:44 +01:00
Luck	1b3b50c113	Refactor PermissionHolder & Sponge subjects	2016-10-02 15:05:53 +01:00
Luck	18e126b781	Fix issue with permissions sometimes not being removed	2016-10-02 10:33:58 +01:00
Luck	c88600adda	Make User constructor protected. Closes #18 .	2016-10-01 22:56:57 +01:00
Luck	4787361e66	Implement locks to hopefully resolve race conditions with I/O - experimental	2016-10-01 19:03:05 +01:00
Luck	b5ece8b5bd	Fix exception	2016-09-30 22:26:39 +01:00
Luck	7ee3116f29	Maybe fix broken inheritance	2016-09-30 20:43:08 +01:00
Luck	1fc0d77971	Cache & fix (and maybe break) Vault Chat implementation	2016-09-30 20:08:59 +01:00
Luck	a32ab4bf7f	Show where a permission was inherited from in the inheritsperm command	2016-09-30 19:21:19 +01:00
Luck	2d8083bf18	Another Vault fix & cleanup User / Group classes	2016-09-30 17:45:29 +01:00
Luck	63b9be9845	Change Vault behavior & cleanup Node class	2016-09-30 17:09:19 +01:00
Luck	85a83d8c71	Add logging output to Vault	2016-09-29 22:04:46 +01:00
Luck	71b33a296c	Calculate Sponge defaults using context	2016-09-29 20:38:03 +01:00
Luck	becdfd6f03	Silence subject load errors unless debug-permission-checks is true	2016-09-29 20:02:38 +01:00
Luck	41744f9416	Add clone commands	2016-09-29 18:07:41 +01:00
Luck	cb89a92ba9	Message colour changes and standardization	2016-09-28 21:16:07 +01:00
Luck	93d54373c6	Add detailed command info system	2016-09-28 20:59:08 +01:00
Luck	385addfe08	cleanup	2016-09-27 20:21:13 +01:00
Luck	4c21957b04	Cache Vault lookups & properly sort listnodes output	2016-09-27 20:18:06 +01:00
Luck	ab6b011225	Fix permission lookups being case sensitive	2016-09-26 18:52:01 +01:00
Luck	e72d91503c	Maybe nicer looking messages	2016-09-26 18:42:46 +01:00
Luck	b9ee206908	Add some more bulk edit commands	2016-09-25 21:23:48 +01:00
Luck	4c9abba5fa	Maybe fix vault (again)	2016-09-25 19:26:36 +01:00
Luck	3424b0542a	Release 2.10	2016-09-25 17:32:58 +01:00
Luck	fec90b8958	Add bulkchange commands	2016-09-25 17:29:11 +01:00
Luck	4da7fe4ff9	Small fixes to context system	2016-09-25 16:55:14 +01:00
Luck	c53623dd67	Make command usage output easier to read	2016-09-25 14:34:27 +01:00
Luck	6540ffa4dd	Refactor storage	2016-09-25 12:47:15 +01:00
Luck	5ee6db02ff	Proper context implementation - WIP	2016-09-25 10:19:36 +01:00
Luck	d8221f466a	Fix messages not being formatted correctly	2016-09-24 17:22:33 +01:00
Luck	462bea2a09	Remove broken repo, maybe fix build	2016-09-24 16:58:45 +01:00
Luck	f452a97278	fix typo	2016-09-23 22:19:17 +01:00
Luck	eb9d2be587	Add locale file support	2016-09-23 22:14:40 +01:00
Luck	df1e747861	Add commands to view inherited groups	2016-09-23 19:23:31 +01:00
Luck	f48595b1ff	Add world and group name rewriting, refactor configs	2016-09-23 18:58:19 +01:00
Luck	12cd4e19cb	Update config comments	2016-09-22 18:25:49 +01:00
Luck	a195e94522	Calculate defaults after all plugins have loaded	2016-09-22 17:34:51 +01:00
Luck	02abb39dc2	Change #isPermissionSet to be more like the Bukkit impl	2016-09-21 22:04:18 +01:00
Luck	f7a0b1ef78	Refactor default permissions to be less bad	2016-09-21 21:30:42 +01:00
Luck	7678f25879	Fix default permissions not properly applying on Bukkit	2016-09-21 17:40:05 +01:00
Luck	fa9324bda8	Implement basic standalone base, working towards #9	2016-09-20 21:50:28 +01:00
Luck	1e72f9d8fe	Listen on lowest priority, may fix issues with plugins checking for permissions on login events	2016-09-20 21:04:53 +01:00
Luck	50fd954599	Use a BiMap in UuidCache	2016-09-19 21:13:45 +01:00
Luck	b1e34b55f8	Re-add regex permissions & actually take note of the config options	2016-09-19 21:00:23 +01:00
Luck	cff1b8a411	Separate PermissionProcessor into own class	2016-09-19 20:45:37 +01:00
Luck	6ffa6720be	Make more specific wildcards take priority over less specific ones	2016-09-19 20:36:52 +01:00
Luck	f52a106165	Order nodes alphabetically after other priority rules have been applied	2016-09-19 17:31:00 +01:00
Luck	bf247b71e1	Fix possible race condition & maybe use better Hikari flags	2016-09-18 23:13:20 +01:00
Luck	66818e4c82	Fix build	2016-09-17 23:46:11 +01:00
Luck	23d53d39b4	Refactor permission calculation	2016-09-17 23:15:07 +01:00
Luck	30ea5a5b69	Fix no permissions applying when include-global is false, and better support per-server/per-world groups	2016-09-17 19:05:56 +01:00
Luck	e7a210dc06	Update default configs	2016-09-16 22:09:55 +01:00
Luck	497de9824a	Actually pass on a single wildcard node so it gets applied	2016-09-16 21:46:55 +01:00
Luck	be74b50762	Fixes for offline mode servers	2016-09-16 21:24:25 +01:00
Luck	f2e06b56e7	Cache permission lookups	2016-09-16 21:11:12 +01:00
Luck	f6aa20c300	Fix compile	2016-09-15 17:12:19 +01:00
Luck	5e16134f6f	Provide prefixes and suffixes through the PS options	2016-09-15 17:06:27 +01:00
Luck	6165fcbb21	Fix #getDefaults for users	2016-09-15 16:54:12 +01:00
Luck	831e882db0	Actually apply default permissions on Sponge	2016-09-15 16:53:03 +01:00
Luck	feb8bf4bd3	Update readme	2016-09-14 20:16:36 +01:00
Luck	ce3ee866ca	Sponge fixes	2016-09-14 19:37:20 +01:00
Luck	d29dd35689	Support the latest powerfulperms so-called "api"	2016-09-13 20:14:16 +01:00
Luck	3a0a89853f	Apply negated wildcards	2016-09-13 17:23:16 +01:00
Luck	e7ca79d251	Use Splitter instead of Patterns, don't split arguments in quotes	2016-09-12 19:00:37 +01:00
Luck	22426bab33	Update placeholders to use the latest API version	2016-09-11 15:36:19 +01:00
Luck	116094ea96	Maybe fix an issue with per-server prefixes/suffixes	2016-09-11 14:34:38 +01:00
Luck	9df39a9545	Inject PermissibleBase instead of using attachments. Resolves #14	2016-09-11 11:50:59 +01:00
Luck	b8f44df723	Add missing headers	2016-09-10 22:40:36 +01:00
Luck	74f275eb69	Add more info the importer error output	2016-09-10 22:08:07 +01:00
Luck	1142cbcb2c	Add platform type to the info command	2016-09-10 21:54:31 +01:00
Luck	37749e5829	Don't apply the default group when exporting users	2016-09-10 16:53:04 +01:00
Luck	f9025c7a51	fix #getUniqueUsers for SQL storage types	2016-09-10 16:38:37 +01:00
Luck	c7bfc38477	Build an extra jar with guava and gson shaded to support 1.7	2016-09-10 16:32:37 +01:00
Luck	7ca394d7b9	Add some extra console output to the debug command	2016-09-10 14:35:12 +01:00
Luck	31884ea59d	Maybe fix race condition with messages not sending	2016-09-10 14:31:42 +01:00
Luck	e79b7c7023	Update readme	2016-09-10 09:04:59 +01:00
Luck	1fdb4e8ade	Merge pull request #11 from HeroCC/patch-1 Fix PermissionsEx false node migration	2016-09-09 21:49:43 +01:00
HeroCC	53db8c5928	Fix PermissionsEx false node migration PermissionsEx false nodes begin with a '-' not a '!'	2016-09-09 16:39:13 -04:00
Luck	07514000a4	Fix global groups not being migrated from GroupManager	2016-09-09 18:41:15 +01:00
Luck	f28721e55a	Possible fix for permissions not applying on BungeeCord	2016-09-09 18:32:50 +01:00
Luck	fc230291d3	Fix ops not receiving all permission nodes	2016-09-09 18:00:38 +01:00
Luck	89ff4cfa40	Add a much better system for exporting data	2016-09-08 21:01:37 +01:00
Luck	d786b6abb2	Fix removing negative nodes	2016-09-08 17:28:31 +01:00
Luck	fb0e694155	Add auto-op. Closes #8	2016-09-07 23:21:24 +01:00
Luck	cd6cac1fb6	Fix bad grammar in config option comment	2016-09-07 21:01:03 +01:00