Sponge support

README.md

@@ -1,5 +1,9 @@
-# LuckPerms
-A permissions implementation for Bukkit/BungeeCord.
+# 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.
+
+## Links
+* **Development Builds** - <https://ci.lucko.me/job/LuckPerms>
+* **Javadocs** - <https://jd.lucko.me/LuckPerms>
 
 ## Features
 * **Group inheritance** - users can be members of multiple groups, groups can inherit other groups
@@ -19,11 +23,12 @@ A permissions implementation for Bukkit/BungeeCord.
 * **Well documented** - API methods have comprehensive Java docs, it's clear what each method does.
 * **Efficient/lightweight** - maybe? Who knows, it might be.
 * **Open Sourced, Free...** - you shouldn't have to pay $10+ for a "powerful" permissions plugin.
-* **BungeeCord compatible** - permissions, users and groups are synced across Bukkit/BungeeCord instances
+* **BungeeCord compatible** - permissions, users and groups are synced across all LuckPerms instances
+* **Sponge compatible** - permissions, users and groups are synced across all LuckPerms instances (bukkit --> sponge, for example)
 * **Support for MySQL, SQLite & Flatfile (JSON)** - other storage methods coming soon (maybe)
 
 ## Setup
-All configuration options are in the **config.yml** file, which is generated automagically when the plugin first starts.
+All configuration options are in the **config.yml/luckperms.conf** file, which is generated automagically when the plugin first starts.
 
 You can define the settings for per-server permissions, the storage method and credentials within this file.
 
@@ -53,11 +58,20 @@ Temporary permissions are checked each time a user/group is loaded, and when the
 The only way around this is to decrease the sync interval.
 
 ## API
-LuckPerms has an extensive API, allowing for easy integration with other projects. To use the Api, you need to obtain an instance of the `LuckPermsApi` interface. This can be done in two ways, (one way on BungeeCord).
+LuckPerms has an extensive API, allowing for easy integration with other projects. To use the Api, you need to obtain an instance of the `LuckPermsApi` interface. This can be done in a number of ways.
 
 ```java
+// On all platforms
 final LuckPermsApi api = LuckPerms.getApi();
+
+// On Bukkit/Spigot
 final LuckPermsApi api = Bukkit.getServicesManager().getRegistration(LuckPermsApi.class).getProvider();
+
+// On Sponge
+Optional<LuckPermsApi> provider = Sponge.getServiceManager().provide(LuckPermsApi.class);
+if (provider.isPresent()) {
+    final LuckPermsApi api = provider.get();
+}
 ```
 
 If you want to use LuckPerms in your onEnable method, you need to add the following to your plugins `plugin.yml`.
@@ -66,6 +80,24 @@ depend: [LuckPerms]
 ```
 All of the available methods can be seen in the various interfaces in the `luckperms-api` module.
 
+You can add LuckPerms as a Maven dependency by adding the following to your projects `pom.xml`.
+````xml
+<repositories>
+    <repository>
+        <id>luck-repo</id>
+        <url>https://repo.lucko.me/</url>
+    </repository>
+</repositories>
+
+<dependencies>
+    <dependency>
+        <groupId>me.lucko.luckperms</groupId>
+        <artifactId>luckperms-api</artifactId>
+        <version>1.5</version>
+    </dependency>
+</dependencies>
+````
+
 ## Commands
 
 Command usage is printed to the console/chat whenever invalid arguments are provided. Simply typing /perms will list all commands a user has permission to use.
@@ -147,4 +179,4 @@ Additionally, you can use wildcards to grant users access to a selection of comm
 *  /perms track \<track\> clear - luckperms.track.clear
 
 ## License
-See LICENSE.md.
+See LICENSE.md.

api/pom.xml

@@ -4,11 +4,12 @@
          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</groupId>
-        <version>${global.version}</version>
+        <groupId>me.lucko.luckperms</groupId>
+        <version>1.5</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
+    <version>1.5</version>
     <artifactId>luckperms-api</artifactId>
     <build>
         <plugins>

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

@@ -158,6 +158,7 @@ public interface Group extends PermissionObject {
     /**
      * Get a {@link List} of the groups the group inherits on a specific server
      * @param server the server to check
+     * @param world the world to check
      * @return a {@link List} of group names
      */
     List<String> getLocalGroups(String server, String world);

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

@@ -0,0 +1,9 @@
+package me.lucko.luckperms.api;
+
+public interface Logger {
+
+    void info(String s);
+    void warn(String s);
+    void severe(String s);
+
+}

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

@@ -9,6 +9,7 @@ public interface LuckPermsApi {
     String getVersion();
 
     Datastore getDatastore();
+    Logger getLogger();
 
     User getUser(UUID uuid);
     User getUser(String name);

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

@@ -182,6 +182,7 @@ public interface User extends PermissionObject {
     /**
      * Get a {@link List} of the groups the user is a member of on a specific server
      * @param server the server to check
+     * @param world the world to check
      * @return a {@link List} of group names
      */
     List<String> getLocalGroups(String server, String world);

bukkit/pom.xml

@@ -4,13 +4,13 @@
          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</groupId>
-        <version>${global.version}</version>
+        <groupId>me.lucko.luckperms</groupId>
+        <version>1.5</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
     <artifactId>luckperms-bukkit</artifactId>
-    <version>$(project.parent.version)</version>
+    <version>1.5</version>
     <packaging>jar</packaging>
     <name>LuckPerms</name>
 
@@ -65,22 +65,22 @@
         <dependency>
             <groupId>net.milkbowl.vault</groupId>
             <artifactId>VaultAPI</artifactId>
-            <version>1.5</version>
+            <version>1.6</version>
             <scope>provided</scope>
         </dependency>
         <!-- LuckPerms Common -->
         <dependency>
-            <groupId>me.lucko</groupId>
+            <groupId>me.lucko.luckperms</groupId>
             <artifactId>luckperms-common</artifactId>
-            <version>${project.parent.version}</version>
+            <version>1.5</version>
             <scope>compile</scope>
         </dependency>
         <!-- LuckPerms API -->
         <dependency>
-            <groupId>me.lucko</groupId>
+            <groupId>me.lucko.luckperms</groupId>
             <artifactId>luckperms-api</artifactId>
-            <version>${project.parent.version}</version>
+            <version>1.5</version>
             <scope>compile</scope>
         </dependency>
     </dependencies>
-</project>
+</project>

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

@@ -11,8 +11,8 @@ import java.lang.ref.WeakReference;
 import java.util.Arrays;
 import java.util.List;
 
-class CommandManagerBukkit extends CommandManager implements CommandExecutor, TabExecutor {
-    CommandManagerBukkit(LuckPermsPlugin plugin) {
+class BukkitCommand extends CommandManager implements CommandExecutor, TabExecutor {
+    BukkitCommand(LuckPermsPlugin plugin) {
         super(plugin);
     }
 

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

@@ -1,11 +1,11 @@
 package me.lucko.luckperms;
 
 import lombok.Getter;
+import me.lucko.luckperms.api.Logger;
 import me.lucko.luckperms.api.LuckPermsApi;
 import me.lucko.luckperms.api.implementation.ApiProvider;
 import me.lucko.luckperms.api.vault.VaultHook;
 import me.lucko.luckperms.data.Datastore;
-import me.lucko.luckperms.data.MySQLConfiguration;
 import me.lucko.luckperms.data.methods.FlatfileDatastore;
 import me.lucko.luckperms.data.methods.MySQLDatastore;
 import me.lucko.luckperms.data.methods.SQLiteDatastore;
@@ -16,6 +16,7 @@ import me.lucko.luckperms.tracks.TrackManager;
 import me.lucko.luckperms.users.BukkitUserManager;
 import me.lucko.luckperms.users.UserManager;
 import me.lucko.luckperms.utils.LPConfiguration;
+import me.lucko.luckperms.utils.LogUtil;
 import me.lucko.luckperms.utils.UuidCache;
 import org.bukkit.Bukkit;
 import org.bukkit.command.PluginCommand;
@@ -41,7 +42,7 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
 
     @Override
     public void onEnable() {
-        getLogger().info("Loading configuration...");
+        getLog().info("Loading configuration...");
         configuration = new BukkitConfig(this);
 
         // register events
@@ -49,45 +50,40 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
         pm.registerEvents(new PlayerListener(this), this);
 
         // register commands
-        getLogger().info("Registering commands...");
-        CommandManagerBukkit commandManager = new CommandManagerBukkit(this);
+        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"));
 
-        getLogger().info("Detecting storage method...");
+        getLog().info("Detecting storage method...");
         final String storageMethod = configuration.getStorageMethod();
         if (storageMethod.equalsIgnoreCase("mysql")) {
-            getLogger().info("Using MySQL as storage method.");
-            datastore = new MySQLDatastore(this, new MySQLConfiguration(
-                    configuration.getDatabaseValue("address"),
-                    configuration.getDatabaseValue("database"),
-                    configuration.getDatabaseValue("username"),
-                    configuration.getDatabaseValue("password")
-            ));
+            getLog().info("Using MySQL as storage method.");
+            datastore = new MySQLDatastore(this, configuration.getDatabaseValues());
         } else if (storageMethod.equalsIgnoreCase("sqlite")) {
-            getLogger().info("Using SQLite as storage method.");
+            getLog().info("Using SQLite as storage method.");
             datastore = new SQLiteDatastore(this, new File(getDataFolder(), "luckperms.sqlite"));
         } else if (storageMethod.equalsIgnoreCase("flatfile")) {
-            getLogger().info("Using Flatfile (JSON) as storage method.");
+            getLog().info("Using Flatfile (JSON) as storage method.");
             datastore = new FlatfileDatastore(this, getDataFolder());
         } else {
-            getLogger().severe("Storage method '" + storageMethod + "' was not recognised. Using SQLite as fallback.");
+            getLog().severe("Storage method '" + storageMethod + "' was not recognised. Using SQLite as fallback.");
             datastore = new SQLiteDatastore(this, new File(getDataFolder(), "luckperms.sqlite"));
         }
 
-        getLogger().info("Initialising datastore...");
+        getLog().info("Initialising datastore...");
         datastore.init();
 
-        getLogger().info("Loading internal permission managers...");
+        getLog().info("Loading internal permission managers...");
         uuidCache = new UuidCache(getConfiguration().getOnlineMode());
         userManager = new BukkitUserManager(this);
         groupManager = new GroupManager(this);
         trackManager = new TrackManager();
 
         // Run update task to refresh any online users
-        getLogger().info("Scheduling 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) {
@@ -101,33 +97,33 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
         }
 
         // Provide vault support
-        getLogger().info("Attempting to hook into Vault...");
+        getLog().info("Attempting to hook into Vault...");
         try {
             if (getServer().getPluginManager().isPluginEnabled("Vault")) {
                 VaultHook.hook(this);
-                getLogger().info("Registered Vault permission & chat hook.");
+                getLog().info("Registered Vault permission & chat hook.");
             } else {
-                getLogger().info("Vault not found.");
+                getLog().info("Vault not found.");
             }
         } catch (Exception e) {
-            getLogger().severe("Error occurred whilst hooking into Vault.");
+            getLog().severe("Error occurred whilst hooking into Vault.");
             e.printStackTrace();
         }
 
-        getLogger().info("Registering API...");
+        getLog().info("Registering API...");
         final ApiProvider provider = new ApiProvider(this);
         LuckPerms.registerProvider(provider);
         getServer().getServicesManager().register(LuckPermsApi.class, provider, this, ServicePriority.Normal);
 
-        getLogger().info("Successfully loaded.");
+        getLog().info("Successfully loaded.");
     }
 
     @Override
     public void onDisable() {
-        getLogger().info("Closing datastore...");
+        getLog().info("Closing datastore...");
         datastore.shutdown();
 
-        getLogger().info("Unregistering API...");
+        getLog().info("Unregistering API...");
         LuckPerms.unregisterProvider();
         getServer().getServicesManager().unregisterAll(this);
     }
@@ -142,6 +138,11 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
         Bukkit.getScheduler().runTask(this, r);
     }
 
+    @Override
+    public Logger getLog() {
+        return LogUtil.wrap(getLogger());
+    }
+
     @Override
     public String getVersion() {
         return getDescription().getVersion();

bukkit/src/main/java/me/lucko/luckperms/listeners/PlayerListener.java

@@ -21,6 +21,7 @@ public class PlayerListener implements Listener {
 
     @EventHandler
     public void onPlayerPreLogin(AsyncPlayerPreLoginEvent e) {
+        final long startTime = System.currentTimeMillis();
         if (!plugin.getDatastore().isAcceptingLogins()) {
             // Datastore is disabled, prevent players from joining the server
             e.disallow(AsyncPlayerPreLoginEvent.Result.KICK_OTHER, KICK_MESSAGE);
@@ -43,12 +44,16 @@ public class PlayerListener implements Listener {
         }
 
         plugin.getDatastore().loadOrCreateUser(cache.getUUID(e.getUniqueId()), e.getName());
+        final long time = System.currentTimeMillis() - startTime;
+        if (time >= 1000) {
+            plugin.getLog().warn("Processing login for " + e.getName() + " took " + time + "ms.");
+        }
     }
 
     @EventHandler
     public void onPlayerLogin(PlayerLoginEvent e) {
         final Player player = e.getPlayer();
-        final User user = plugin.getUserManager().getUser(plugin.getUuidCache().getUUID(e.getPlayer().getUniqueId()));
+        final User user = plugin.getUserManager().getUser(plugin.getUuidCache().getUUID(player.getUniqueId()));
 
         if (user == null) {
             e.disallow(PlayerLoginEvent.Result.KICK_OTHER, KICK_MESSAGE);
@@ -69,6 +74,11 @@ public class PlayerListener implements Listener {
         refreshPlayer(e.getPlayer());
     }
 
+    @EventHandler
+    public void onPlayerChangedWorld(PlayerChangedWorldEvent e) {
+        refreshPlayer(e.getPlayer());
+    }
+
     @EventHandler
     public void onPlayerQuit(PlayerQuitEvent e) {
         final Player player = e.getPlayer();
@@ -81,11 +91,6 @@ public class PlayerListener implements Listener {
         plugin.getUserManager().unloadUser(user);
     }
 
-    @EventHandler
-    public void onPlayerChangedWorld(PlayerChangedWorldEvent e) {
-        refreshPlayer(e.getPlayer());
-    }
-
     private void refreshPlayer(Player p) {
         final User user = plugin.getUserManager().getUser(plugin.getUuidCache().getUUID(p.getUniqueId()));
         if (user != null) {

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

@@ -34,7 +34,7 @@ public class BukkitUser extends User {
             if (player == null) return;
 
             if (attachment == null) {
-                getPlugin().getLogger().warning("User " + getName() + " does not have a permissions attachment defined.");
+                getPlugin().getLog().warn("User " + getName() + " does not have a permissions attachment defined.");
                 setAttachment(player.addAttachment(plugin));
             }
 

bukkit/src/main/resources/config.yml

@@ -16,7 +16,7 @@ include-global: true
 
 # 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, dispite the server being in offline mode.
+#    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)

bukkit/src/main/resources/plugin.yml

@@ -1,6 +1,6 @@
 name: LuckPerms
 author: Luck
-version: ${global.version}
+version: ${project.version}
 main: me.lucko.luckperms.LPBukkitPlugin
 softdepend: [Vault]
 description: A permissions plugin

bungee/pom.xml

@@ -4,19 +4,19 @@
          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</groupId>
-        <version>${global.version}</version>
+        <groupId>me.lucko.luckperms</groupId>
+        <version>1.5</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
     <artifactId>luckperms-bungee</artifactId>
-    <version>$(project.parent.version)</version>
+    <version>1.5</version>
     <packaging>jar</packaging>
     <name>LuckPerms</name>
 
     <build>
         <defaultGoal>clean package</defaultGoal>
-        <finalName>LuckPerms</finalName>
+        <finalName>LuckPermsBungee</finalName>
         <sourceDirectory>${basedir}/src/main/java</sourceDirectory>
         <resources>
             <resource>
@@ -63,18 +63,18 @@
         </dependency>
         <!-- LuckPerms Common -->
         <dependency>
-            <groupId>me.lucko</groupId>
+            <groupId>me.lucko.luckperms</groupId>
             <artifactId>luckperms-common</artifactId>
-            <version>${project.parent.version}</version>
+            <version>1.5</version>
             <scope>compile</scope>
         </dependency>
         <!-- LuckPerms API -->
         <dependency>
-            <groupId>me.lucko</groupId>
+            <groupId>me.lucko.luckperms</groupId>
             <artifactId>luckperms-api</artifactId>
-            <version>${project.parent.version}</version>
+            <version>1.5</version>
             <scope>compile</scope>
         </dependency>
     </dependencies>
 
-</project>
+</project>

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

@@ -10,10 +10,10 @@ import net.md_5.bungee.api.plugin.TabExecutor;
 import java.lang.ref.WeakReference;
 import java.util.Arrays;
 
-class MainCommand extends Command implements TabExecutor {
+class BungeeCommand extends Command implements TabExecutor {
     private final CommandManager manager;
 
-    public MainCommand(CommandManager manager) {
+    public BungeeCommand(CommandManager manager) {
         super("luckpermsbungee", null, "bperms", "lpb", "bpermissions", "bp", "bperm");
         this.manager = manager;
     }

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

@@ -1,10 +1,10 @@
 package me.lucko.luckperms;
 
 import lombok.Getter;
+import me.lucko.luckperms.api.Logger;
 import me.lucko.luckperms.api.implementation.ApiProvider;
 import me.lucko.luckperms.commands.CommandManager;
 import me.lucko.luckperms.data.Datastore;
-import me.lucko.luckperms.data.MySQLConfiguration;
 import me.lucko.luckperms.data.methods.FlatfileDatastore;
 import me.lucko.luckperms.data.methods.MySQLDatastore;
 import me.lucko.luckperms.groups.GroupManager;
@@ -14,6 +14,7 @@ import me.lucko.luckperms.tracks.TrackManager;
 import me.lucko.luckperms.users.BungeeUserManager;
 import me.lucko.luckperms.users.UserManager;
 import me.lucko.luckperms.utils.LPConfiguration;
+import me.lucko.luckperms.utils.LogUtil;
 import me.lucko.luckperms.utils.UuidCache;
 import net.md_5.bungee.api.connection.ProxiedPlayer;
 import net.md_5.bungee.api.plugin.Plugin;
@@ -34,48 +35,43 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
 
     @Override
     public void onEnable() {
-        getLogger().info("Loading configuration...");
+        getLog().info("Loading configuration...");
         configuration = new BungeeConfig(this);
 
         // register events
         getProxy().getPluginManager().registerListener(this, new PlayerListener(this));
 
         // register commands
-        getLogger().info("Registering commands...");
-        getProxy().getPluginManager().registerCommand(this, new MainCommand(new CommandManager(this)));
+        getLog().info("Registering commands...");
+        getProxy().getPluginManager().registerCommand(this, new BungeeCommand(new CommandManager(this)));
 
         // disable the default Bungee /perms command so it gets handled by the Bukkit plugin
         getProxy().getDisabledCommands().add("perms");
 
-        getLogger().info("Detecting storage method...");
+        getLog().info("Detecting storage method...");
         final String storageMethod = configuration.getStorageMethod();
         if (storageMethod.equalsIgnoreCase("mysql")) {
-            getLogger().info("Using MySQL as storage method.");
-            datastore = new MySQLDatastore(this, new MySQLConfiguration(
-                    configuration.getDatabaseValue("address"),
-                    configuration.getDatabaseValue("database"),
-                    configuration.getDatabaseValue("username"),
-                    configuration.getDatabaseValue("password")
-            ));
+            getLog().info("Using MySQL as storage method.");
+            datastore = new MySQLDatastore(this, configuration.getDatabaseValues());
         } else if (storageMethod.equalsIgnoreCase("flatfile")) {
-            getLogger().info("Using Flatfile (JSON) as storage method.");
+            getLog().info("Using Flatfile (JSON) as storage method.");
             datastore = new FlatfileDatastore(this, getDataFolder());
         } else {
-            getLogger().severe("Storage method '" + storageMethod + "' was not recognised. Using Flatfile as fallback.");
+            getLog().severe("Storage method '" + storageMethod + "' was not recognised. Using Flatfile as fallback.");
             datastore = new FlatfileDatastore(this, getDataFolder());
         }
 
-        getLogger().info("Initialising datastore...");
+        getLog().info("Initialising datastore...");
         datastore.init();
 
-        getLogger().info("Loading internal permission managers...");
+        getLog().info("Loading internal permission managers...");
         uuidCache = new UuidCache(getConfiguration().getOnlineMode());
         userManager = new BungeeUserManager(this);
         groupManager = new GroupManager(this);
         trackManager = new TrackManager();
 
         // Run update task to refresh any online users
-        getLogger().info("Scheduling 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) {
@@ -87,21 +83,26 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
             getProxy().getScheduler().schedule(this, new UpdateTask(this), mins, mins, TimeUnit.MINUTES);
         }
 
-        getLogger().info("Registering API...");
+        getLog().info("Registering API...");
         LuckPerms.registerProvider(new ApiProvider(this));
 
-        getLogger().info("Successfully loaded.");
+        getLog().info("Successfully loaded.");
     }
 
     @Override
     public void onDisable() {
-        getLogger().info("Closing datastore...");
+        getLog().info("Closing datastore...");
         datastore.shutdown();
 
-        getLogger().info("Unregistering API...");
+        getLog().info("Unregistering API...");
         LuckPerms.unregisterProvider();
     }
 
+    @Override
+    public Logger getLog() {
+        return LogUtil.wrap(getLogger());
+    }
+
     @Override
     public String getVersion() {
         return getDescription().getVersion();

bungee/src/main/java/me/lucko/luckperms/listeners/PlayerListener.java

@@ -34,6 +34,7 @@ public class PlayerListener implements Listener {
            Offline mode. */
         e.registerIntent(plugin);
         plugin.doAsync(() -> {
+            final long startTime = System.currentTimeMillis();
             final UuidCache cache = plugin.getUuidCache();
             final PendingConnection c = e.getConnection();
 
@@ -54,6 +55,10 @@ public class PlayerListener implements Listener {
             // We have to make a new user on this thread whilst the connection is being held, or we get concurrency issues as the Bukkit server
             // and the BungeeCord server try to make a new user at the same time.
             plugin.getDatastore().loadOrCreateUser(cache.getUUID(c.getUniqueId()), c.getName());
+            final long time = System.currentTimeMillis() - startTime;
+            if (time >= 1000) {
+                plugin.getLog().warn("Processing login for " + c.getName() + " took " + time + "ms.");
+            }
             e.completeIntent(plugin);
         });
     }

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

@@ -9,7 +9,6 @@ import java.util.Map;
 import java.util.UUID;
 
 public class BungeeUser extends User {
-
     private final LPBungeePlugin plugin;
 
     BungeeUser(UUID uuid, LPBungeePlugin plugin) {

bungee/src/main/resources/config.yml

@@ -16,7 +16,7 @@ include-global: false
 
 # 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, dispite the server being in offline mode.
+#    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)

bungee/src/main/resources/plugin.yml

@@ -1,5 +1,5 @@
 name: LuckPerms
 author: Luck
-version: ${global.version}
+version: ${project.version}
 main: me.lucko.luckperms.LPBungeePlugin
 description: A permissions plugin

common/pom.xml

@@ -4,11 +4,12 @@
          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</groupId>
-        <version>${global.version}</version>
+        <groupId>me.lucko.luckperms</groupId>
+        <version>1.5</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
+    <version>1.5</version>
     <artifactId>luckperms-common</artifactId>
     <build>
         <plugins>
@@ -27,11 +28,11 @@
     <dependencies>
         <!-- LuckPerms API -->
         <dependency>
-            <groupId>me.lucko</groupId>
+            <groupId>me.lucko.luckperms</groupId>
             <artifactId>luckperms-api</artifactId>
-            <version>${project.parent.version}</version>
+            <version>1.5</version>
             <scope>compile</scope>
         </dependency>
     </dependencies>
 
-</project>
+</project>

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

@@ -1,5 +1,6 @@
 package me.lucko.luckperms;
 
+import me.lucko.luckperms.api.Logger;
 import me.lucko.luckperms.data.Datastore;
 import me.lucko.luckperms.groups.GroupManager;
 import me.lucko.luckperms.tracks.TrackManager;
@@ -9,7 +10,6 @@ import me.lucko.luckperms.utils.UuidCache;
 
 import java.util.List;
 import java.util.UUID;
-import java.util.logging.Logger;
 
 public interface LuckPermsPlugin {
 
@@ -47,7 +47,7 @@ public interface LuckPermsPlugin {
      * Retrieves the {@link Logger} for the plugin
      * @return the plugin's {@link Logger}
      */
-    Logger getLogger();
+    Logger getLog();
 
     /**
      * Retrieves the {@link UuidCache} for the plugin

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

@@ -33,6 +33,11 @@ public class ApiProvider implements LuckPermsApi {
         return new DatastoreLink(plugin.getDatastore());
     }
 
+    @Override
+    public Logger getLogger() {
+        return plugin.getLog();
+    }
+
     @Override
     public User getUser(@NonNull UUID uuid) {
         final me.lucko.luckperms.users.User user = plugin.getUserManager().getUser(uuid);

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

@@ -23,7 +23,6 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
-import java.util.logging.Level;
 import java.util.stream.Collectors;
 
 public class CommandManager {
@@ -96,8 +95,9 @@ public class CommandManager {
     /**
      * 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 (hint: it always is :> )
+     * @return if the command was successful
      */
     public boolean onCommand(Sender sender, String label, List<String> args) {
         if (args.size() == 0) {
@@ -113,7 +113,7 @@ public class CommandManager {
         }
 
         final MainCommand main = o.get();
-        if (!main.canUse(sender)) {
+        if (!main.isAuthorized(sender)) {
             sendCommandUsage(sender, label);
             return true;
         }
@@ -139,8 +139,9 @@ public class CommandManager {
      * @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.canUse(sender)).collect(Collectors.toList());
+        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("")) {
@@ -160,7 +161,7 @@ public class CommandManager {
     }
 
     private void registerMainCommand(MainCommand command) {
-        plugin.getLogger().log(Level.INFO, "[CommandManager] Registered main command '" + command.getName() + "'");
+        plugin.getLog().info("[CommandManager] Registered main command '" + command.getName() + "'");
         mainCommands.add(command);
     }
 
@@ -168,7 +169,7 @@ public class CommandManager {
         Message.INFO_BRIEF.send(sender, plugin.getVersion());
 
         mainCommands.stream()
-                .filter(c -> c.canUse(sender))
+                .filter(c -> c.isAuthorized(sender))
                 .forEach(c -> Util.sendPluginMessage(sender, "&e-> &d" + String.format(c.getUsage(), label)));
     }
 }

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

@@ -1,27 +1,103 @@
 package me.lucko.luckperms.commands;
 
-import lombok.AllArgsConstructor;
 import lombok.Getter;
+import lombok.RequiredArgsConstructor;
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.data.Callback;
 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;
 
 @Getter
-@AllArgsConstructor
-public abstract class MainCommand {
+@RequiredArgsConstructor
+public abstract class MainCommand<T> {
 
+    /**
+     * The name of the main command
+     */
     private final String name;
+
+    /**
+     * The command usage
+     */
     private final String usage;
+
+    /**
+     * How many arguments are required for the command to run
+     */
     private final int requiredArgsLength;
 
-    protected abstract void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label);
-    protected abstract List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin);
-    public abstract List<? extends SubCommand> getSubCommands();
+    /**
+     * A list of the sub commands under this main command
+     */
+    @Getter
+    private final List<SubCommand<T>> subCommands = new ArrayList<>();
 
+    /**
+     * Called when this main command is ran
+     * @param plugin a link to the main plugin instance
+     * @param sender the sender to executed the command
+     * @param args the stripped arguments given
+     * @param label the command label used
+     */
+    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
+        if (args.size() < 2) {
+            sendUsage(sender, label);
+            return;
+        }
+
+        Optional<SubCommand<T>> o = subCommands.stream().filter(s -> s.getName().equalsIgnoreCase(args.get(1))).limit(1).findAny();
+
+        if (!o.isPresent()) {
+            Message.COMMAND_NOT_RECOGNISED.send(sender);
+            return;
+        }
+
+        final SubCommand<T> sub = o.get();
+        if (!sub.isAuthorized(sender)) {
+            Message.COMMAND_NO_PERMISSION.send(sender);
+            return;
+        }
+
+        List<String> strippedArgs = new ArrayList<>();
+        if (args.size() > 2) {
+            strippedArgs.addAll(args.subList(2, args.size()));
+        }
+
+        if (sub.getIsArgumentInvalid().test(strippedArgs.size())) {
+            sub.sendUsage(sender, label);
+            return;
+        }
+
+        final String name = args.get(0).toLowerCase();
+        getTarget(name, plugin, sender, t -> sub.execute(plugin, sender, t, strippedArgs, label));
+    }
+
+    /**
+     * Gets the object the command is acting upon, and runs the callback if successful
+     * @param target the name of the object to be looked up
+     * @param plugin a link to the main plugin instance
+     * @param sender the user who send the command (used to send error messages if the lookup was unsuccessful)
+     * @param onSuccess the callback to run when the lookup is completed
+     */
+    protected abstract void getTarget(String target, LuckPermsPlugin plugin, Sender sender, Callback<T> onSuccess);
+
+    /**
+     * Get a list of objects for tab completion
+     * @param plugin a link to the main plugin instance
+     * @return a list of strings
+     */
+    protected abstract List<String> getObjects(LuckPermsPlugin plugin);
+
+    /**
+     * Send the command usage to a sender
+     * @param sender the sender to send the usage to
+     * @param label the command label used
+     */
     protected void sendUsage(Sender sender, String label) {
         if (getSubCommands().isEmpty()) {
             Util.sendPluginMessage(sender, "&e-> &d" + String.format(getUsage(), label));
@@ -41,12 +117,27 @@ public abstract class MainCommand {
         }
     }
 
-    protected boolean canUse(Sender sender) {
+    /**
+     * 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
+     */
+    protected boolean isAuthorized(Sender sender) {
         return getSubCommands().stream().filter(sc -> sc.isAuthorized(sender)).count() != 0;
     }
 
-    protected List<String> onAbstractTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
-        final List<SubCommand> subs = getSubCommands().stream().filter(s -> s.isAuthorized(sender)).collect(Collectors.toList());
+    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        final List<String> objects = getObjects(plugin);
+
+        if (args.size() <= 1) {
+            if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) {
+                return objects;
+            }
+
+            return objects.stream().filter(s -> s.toLowerCase().startsWith(args.get(0).toLowerCase())).collect(Collectors.toList());
+        }
+
+        final List<SubCommand<T>> subs = getSubCommands().stream().filter(s -> s.isAuthorized(sender)).collect(Collectors.toList());
         if (args.size() == 2) {
             if (args.get(1).equalsIgnoreCase("")) {
                 return subs.stream().map(SubCommand::getName).map(String::toLowerCase).collect(Collectors.toList());
@@ -56,11 +147,15 @@ public abstract class MainCommand {
                     .filter(s -> s.toLowerCase().startsWith(args.get(1).toLowerCase())).collect(Collectors.toList());
         }
 
-        Optional<SubCommand> o = subs.stream().filter(s -> s.getName().equalsIgnoreCase(args.get(1))).limit(1).findAny();
+        Optional<SubCommand<T>> o = subs.stream().filter(s -> s.getName().equalsIgnoreCase(args.get(1))).limit(1).findAny();
         if (!o.isPresent()) {
             return Collections.emptyList();
         }
 
         return o.get().onTabComplete(sender, args.subList(2, args.size()), plugin);
     }
+
+    public void registerSubCommand(SubCommand<T> subCommand) {
+        subCommands.add(subCommand);
+    }
 }

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

@@ -0,0 +1,53 @@
+package me.lucko.luckperms.commands;
+
+import lombok.experimental.UtilityClass;
+
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+@UtilityClass
+public class Predicate {
+    public static <T> java.util.function.Predicate<T> alwaysFalse() {
+        return t -> false;
+    }
+
+    public static <T> java.util.function.Predicate<T> alwaysTrue() {
+        return t -> true;
+    }
+
+    public static java.util.function.Predicate<Integer> notInRange(Integer start, Integer end) {
+        return inverse(inRange(start, end));
+    }
+
+    public static java.util.function.Predicate<Integer> inRange(Integer start, Integer end) {
+        return isOneOf(IntStream.rangeClosed(start, end).boxed().collect(Collectors.toSet()));
+    }
+
+    public static <T> java.util.function.Predicate<T> notOneOf(Set<T> ts) {
+        return inverse(isOneOf(ts));
+    }
+
+    public static <T> java.util.function.Predicate<T> isOneOf(Set<T> ta) {
+        return t -> {
+            for (T i : ta) {
+                if (i == t) {
+                    return true;
+                }
+            }
+            return false;
+        };
+    }
+
+    public static <T> java.util.function.Predicate<T> not(T t) {
+        return inverse(is(t));
+    }
+
+    public static <T> java.util.function.Predicate<T> is(T t) {
+        return t2 -> t == t2;
+    }
+
+    public static <T> java.util.function.Predicate<T> inverse(java.util.function.Predicate<T> t) {
+        return t2 -> !t.test(t2);
+    }
+}

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

@@ -0,0 +1,50 @@
+package me.lucko.luckperms.commands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.data.Callback;
+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 void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
+        // Do nothing, allow the implementation to override this
+    }
+
+    @Override
+    protected void getTarget(String target, LuckPermsPlugin plugin, Sender sender, Callback onSuccess) {
+        // Do nothing, don't run callback
+    }
+
+    @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);
+    }
+}

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

@@ -3,49 +3,97 @@ 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
- * Doesn't declare any abstract onCommand methods, as sub classes declare their own with parameters unique to the sub command type.
- * For example, see: {@link me.lucko.luckperms.commands.user.UserSubCommand#execute(LuckPermsPlugin, Sender, User, List, String)}
- *
- * SubCommand #execute methods are always called from the {@link MainCommand} class related to them, so abstraction is not needed.
  */
 @Getter
 @AllArgsConstructor
-public abstract class SubCommand {
+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;
 
-    public abstract boolean isArgLengthInvalid(int argLength);
+    /**
+     * Predicate to test if the argument length given is invalid
+     */
+    private final Predicate<? super Integer> isArgumentInvalid;
 
-    public boolean isAuthorized(Sender sender) {
-        return permission.isAuthorized(sender);
-    }
+    /**
+     * 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 void execute(LuckPermsPlugin plugin, Sender sender, T t, List<String> args, String label);
 
+    /**
+     * 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);
+    }
+
     /**
      * 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 sender who is tab completing
+     * @param args the arguments so far
+     * @param plugin the plugin instance
+     * @return a list of suggestions
      */
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return Collections.emptyList();
     }
 
-    /* Utility methods used by #onTabComplete implementations in sub classes  */
+    /*
+        ----------------------------------------------------------------------------------
+        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().getGroups().keySet()), args);
     }
@@ -73,4 +121,40 @@ public abstract class SubCommand {
 
         return Collections.emptyList();
     }
+
+    protected static void saveUser(User user, Sender sender, LuckPermsPlugin plugin) {
+        user.refreshPermissions();
+
+        plugin.getDatastore().saveUser(user, success -> {
+            if (success) {
+                Message.USER_SAVE_SUCCESS.send(sender);
+            } else {
+                Message.USER_SAVE_ERROR.send(sender);
+            }
+        });
+    }
+
+    protected static void saveGroup(Group group, Sender sender, LuckPermsPlugin plugin) {
+        plugin.getDatastore().saveGroup(group, success -> {
+            if (success) {
+                Message.GROUP_SAVE_SUCCESS.send(sender);
+            } else {
+                Message.GROUP_SAVE_ERROR.send(sender);
+            }
+
+            plugin.runUpdateTask();
+        });
+    }
+
+    protected static void saveTrack(Track track, Sender sender, LuckPermsPlugin plugin) {
+        plugin.getDatastore().saveTrack(track, success -> {
+            if (success) {
+                Message.TRACK_SAVE_SUCCESS.send(sender);
+            } else {
+                Message.TRACK_SAVE_ERROR.send(sender);
+            }
+
+            plugin.runUpdateTask();
+        });
+    }
 }

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

@@ -1,19 +1,17 @@
 package me.lucko.luckperms.commands.group;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.MainCommand;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.SingleMainCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.utils.Patterns;
 
-import java.util.Collections;
 import java.util.List;
 
-public class CreateGroup extends MainCommand {
+public class CreateGroup extends SingleMainCommand {
     public CreateGroup() {
-        super("CreateGroup", "/%s creategroup <group>", 1);
+        super("CreateGroup", "/%s creategroup <group>", 1, Permission.CREATE_GROUP);
     }
 
     @Override
@@ -50,19 +48,4 @@ public class CreateGroup extends MainCommand {
             }
         });
     }
-
-    @Override
-    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
-        return Collections.emptyList();
-    }
-
-    @Override
-    public List<SubCommand> getSubCommands() {
-        return Collections.emptyList();
-    }
-
-    @Override
-    protected boolean canUse(Sender sender) {
-        return Permission.CREATE_GROUP.isAuthorized(sender);
-    }
 }

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

@@ -1,9 +1,8 @@
 package me.lucko.luckperms.commands.group;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.MainCommand;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.SingleMainCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.groups.Group;
@@ -14,9 +13,9 @@ import java.util.Collections;
 import java.util.List;
 import java.util.stream.Collectors;
 
-public class DeleteGroup extends MainCommand {
+public class DeleteGroup extends SingleMainCommand {
     public DeleteGroup() {
-        super("DeleteGroup", "/%s deletegroup <group>", 1);
+        super("DeleteGroup", "/%s deletegroup <group>", 1, Permission.DELETE_GROUP);
     }
 
     @Override
@@ -74,14 +73,4 @@ public class DeleteGroup extends MainCommand {
 
         return Collections.emptyList();
     }
-
-    @Override
-    public List<SubCommand> getSubCommands() {
-        return Collections.emptyList();
-    }
-
-    @Override
-    protected boolean canUse(Sender sender) {
-        return Permission.DELETE_GROUP.isAuthorized(sender);
-    }
 }

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

@@ -1,101 +1,46 @@
 package me.lucko.luckperms.commands.group;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.data.Callback;
 import me.lucko.luckperms.commands.MainCommand;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.utils.Patterns;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Optional;
-import java.util.stream.Collectors;
-
-public class GroupMainCommand extends MainCommand {
-
-    private final List<GroupSubCommand> subCommands = new ArrayList<>();
 
+public class GroupMainCommand extends MainCommand<Group> {
     public GroupMainCommand() {
         super("Group", "/%s group <group>", 2);
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
-        if (args.size() < 2) {
-            sendUsage(sender, label);
-            return;
-        }
-
-        Optional<GroupSubCommand> o = subCommands.stream().filter(s -> s.getName().equalsIgnoreCase(args.get(1))).limit(1).findAny();
-
-        if (!o.isPresent()) {
-            Message.COMMAND_NOT_RECOGNISED.send(sender);
-            return;
-        }
-
-        final GroupSubCommand sub = o.get();
-        if (!sub.isAuthorized(sender)) {
-            Message.COMMAND_NO_PERMISSION.send(sender);
-            return;
-        }
-
-        List<String> strippedArgs = new ArrayList<>();
-        if (args.size() > 2) {
-            strippedArgs.addAll(args.subList(2, args.size()));
-        }
-
-        if (sub.isArgLengthInvalid(strippedArgs.size())) {
-            sub.sendUsage(sender, label);
-            return;
-        }
-
-        final String groupName = args.get(0).toLowerCase();
-
-        if (Patterns.NON_ALPHA_NUMERIC.matcher(groupName).find()) {
+    protected void getTarget(String target, LuckPermsPlugin plugin, Sender sender, Callback<Group> onSuccess) {
+        if (Patterns.NON_ALPHA_NUMERIC.matcher(target).find()) {
             Message.GROUP_INVALID_ENTRY.send(sender);
             return;
         }
 
-        plugin.getDatastore().loadGroup(groupName, success -> {
+        plugin.getDatastore().loadGroup(target, success -> {
             if (!success) {
                 Message.GROUP_NOT_FOUND.send(sender);
                 return;
             }
 
-            Group group = plugin.getGroupManager().getGroup(groupName);
+            Group group = plugin.getGroupManager().getGroup(target);
             if (group == null) {
                 Message.GROUP_NOT_FOUND.send(sender);
                 return;
             }
 
-            sub.execute(plugin, sender, group, strippedArgs, label);
+            onSuccess.onComplete(group);
         });
     }
 
     @Override
-    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
-        final List<String> groups = new ArrayList<>(plugin.getGroupManager().getGroups().keySet());
-
-        if (args.size() <= 1) {
-            if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) {
-                return groups;
-            }
-
-            return groups.stream().filter(s -> s.toLowerCase().startsWith(args.get(0).toLowerCase())).collect(Collectors.toList());
-        }
-
-        return onAbstractTabComplete(sender, args, plugin);
+    protected List<String> getObjects(LuckPermsPlugin plugin) {
+        return new ArrayList<>(plugin.getGroupManager().getGroups().keySet());
     }
-
-    @Override
-    public List<? extends SubCommand> getSubCommands() {
-        return subCommands;
-    }
-
-    public void registerSubCommand(GroupSubCommand subCommand) {
-        subCommands.add(subCommand);
-    }
-
 }

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

@@ -1,30 +0,0 @@
-package me.lucko.luckperms.commands.group;
-
-import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
-import me.lucko.luckperms.constants.Message;
-import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.groups.Group;
-
-import java.util.List;
-
-public abstract class GroupSubCommand extends SubCommand {
-    protected GroupSubCommand(String name, String description, String usage, Permission permission) {
-        super(name, description, usage, permission);
-    }
-
-    protected abstract void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label);
-
-    protected void saveGroup(Group group, Sender sender, LuckPermsPlugin plugin) {
-        plugin.getDatastore().saveGroup(group, success -> {
-            if (success) {
-                Message.GROUP_SAVE_SUCCESS.send(sender);
-            } else {
-                Message.GROUP_SAVE_ERROR.send(sender);
-            }
-
-            plugin.runUpdateTask();
-        });
-    }
-}

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

@@ -1,20 +1,18 @@
 package me.lucko.luckperms.commands.group;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.MainCommand;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.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.Collections;
 import java.util.List;
 
-public class ListGroups extends MainCommand {
+public class ListGroups extends SingleMainCommand {
     public ListGroups() {
-        super("ListGroups", "/%s listgroups", 0);
+        super("ListGroups", "/%s listgroups", 0, Permission.LIST_GROUPS);
     }
 
     @Override
@@ -27,19 +25,4 @@ public class ListGroups extends MainCommand {
             }
         });
     }
-
-    @Override
-    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
-        return Collections.emptyList();
-    }
-
-    @Override
-    public List<SubCommand> getSubCommands() {
-        return Collections.emptyList();
-    }
-
-    @Override
-    protected boolean canUse(Sender sender) {
-        return Permission.LIST_GROUPS.isAuthorized(sender);
-    }
 }

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

@@ -1,29 +1,26 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.groups.Group;
 
 import java.util.List;
 
-public class GroupClear extends GroupSubCommand {
+public class GroupClear extends SubCommand<Group> {
     public GroupClear() {
-        super("clear", "Clears a groups permissions", "/%s group <group> clear", Permission.GROUP_CLEAR);
+        super("clear", "Clears a groups permissions", "/%s group <group> clear", Permission.GROUP_CLEAR,
+                Predicate.alwaysFalse());
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         group.clearNodes();
         Message.CLEAR_SUCCESS.send(sender, group.getName());
 
         saveGroup(group, sender, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return false;
-    }
 }

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

@@ -1,9 +1,10 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.commands.group.GroupSubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.groups.Group;
@@ -11,14 +12,15 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class GroupHasPerm extends GroupSubCommand {
+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);
+                "/%s group <group> haspermission <node> [server] [world]", Permission.GROUP_HASPERMISSION,
+                Predicate.notInRange(1, 3));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         if (args.size() >= 2) {
             if (Patterns.NON_ALPHA_NUMERIC.matcher(args.get(1)).find()) {
                 Message.SERVER_INVALID_ENTRY.send(sender);
@@ -35,9 +37,4 @@ public class GroupHasPerm extends GroupSubCommand {
             Util.sendBoolean(sender, args.get(0), group.hasPermission(args.get(0), true, "global"));
         }
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1 && argLength != 2 && argLength != 3;
-    }
 }

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

@@ -1,27 +1,24 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.groups.Group;
 
 import java.util.List;
 
-public class GroupInfo extends GroupSubCommand {
+public class GroupInfo extends SubCommand<Group> {
     public GroupInfo() {
-        super("info", "Gives info about the group", "/%s group <group> info", Permission.GROUP_INFO);
+        super("info", "Gives info about the group", "/%s group <group> info", Permission.GROUP_INFO,
+                Predicate.alwaysFalse());
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         Message.GROUP_INFO.send(sender, group.getName(), group.getPermanentNodes().keySet().size(),
                 group.getTemporaryNodes().keySet().size(), label, group.getName());
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return false;
-    }
 }

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

@@ -1,9 +1,10 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.commands.group.GroupSubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.groups.Group;
@@ -11,14 +12,15 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class GroupInheritsPerm extends GroupSubCommand {
+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);
+                "/%s group <group> inheritspermission <node> [server] [world]", Permission.GROUP_INHERITSPERMISSION,
+                Predicate.notInRange(1, 3));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         if (args.size() >= 2) {
             if (Patterns.NON_ALPHA_NUMERIC.matcher(args.get(1)).find()) {
                 Message.SERVER_INVALID_ENTRY.send(sender);
@@ -35,9 +37,4 @@ public class GroupInheritsPerm extends GroupSubCommand {
             Util.sendBoolean(sender, args.get(0), group.inheritsPermission(args.get(0), true));
         }
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1 && argLength != 2 && argLength != 3;
-    }
 }

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

@@ -1,29 +1,25 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.commands.group.GroupSubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.groups.Group;
 
 import java.util.List;
 
-public class GroupListNodes extends GroupSubCommand {
+public class GroupListNodes extends SubCommand<Group> {
     public GroupListNodes() {
         super("listnodes", "Lists the permission nodes the group has", "/%s group <group> listnodes",
-                Permission.GROUP_LISTNODES);
+                Permission.GROUP_LISTNODES, Predicate.alwaysFalse());
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         Message.LISTNODES.send(sender, group.getName(), Util.permNodesToString(group.getPermanentNodes()));
         Message.LISTNODES_TEMP.send(sender, group.getName(), Util.tempNodesToString(group.getTemporaryNodes()));
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return false;
-    }
 }

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

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
@@ -11,14 +12,15 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class GroupSetInherit extends GroupSubCommand {
+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);
+                "/%s group <group> setinherit <group> [server] [world]", Permission.GROUP_SETINHERIT,
+                Predicate.notInRange(1, 3));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         String groupName = args.get(0).toLowerCase();
 
         if (groupName.contains("/") || groupName.contains("$")) {
@@ -64,9 +66,4 @@ public class GroupSetInherit extends GroupSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getGroupTabComplete(args, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1 && argLength != 2 && argLength != 3;
-    }
 }

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

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
@@ -11,14 +12,14 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class GroupSetPermission extends GroupSubCommand {
+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);
+                Permission.GROUP_SETPERMISSION, Predicate.notInRange(2, 4));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         String node = args.get(0);
         String bool = args.get(1).toLowerCase();
 
@@ -71,9 +72,4 @@ public class GroupSetPermission extends GroupSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getBoolTabComplete(args);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 2 && argLength != 3 && argLength != 4;
-    }
 }

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

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
@@ -12,14 +13,15 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class GroupSetTempInherit extends GroupSubCommand {
+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);
+                "/%s group <group> settempinherit <group> <duration> [server] [world]",
+                Permission.GROUP_SET_TEMP_INHERIT, Predicate.notInRange(2, 4));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         String groupName = args.get(0).toLowerCase();
 
         if (groupName.contains("/") || groupName.contains("$")) {
@@ -80,9 +82,4 @@ public class GroupSetTempInherit extends GroupSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getGroupTabComplete(args, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 2 && argLength != 3 && argLength != 4;
-    }
 }

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

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
@@ -12,14 +13,15 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class GroupSetTempPermission extends GroupSubCommand {
+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);
+                "/%s group <group> settemp <node> <true|false> <duration> [server] [world]",
+                Permission.GROUP_SET_TEMP_PERMISSION, Predicate.notInRange(3, 5));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         String node = args.get(0);
         String bool = args.get(1).toLowerCase();
 
@@ -87,9 +89,4 @@ public class GroupSetTempPermission extends GroupSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getBoolTabComplete(args);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 3 && argLength != 4 && argLength != 5;
-    }
 }

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

@@ -1,9 +1,10 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.commands.group.GroupSubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.groups.Group;
@@ -12,13 +13,14 @@ import me.lucko.luckperms.tracks.Track;
 import java.util.List;
 import java.util.stream.Collectors;
 
-public class GroupShowTracks extends GroupSubCommand {
+public class GroupShowTracks extends SubCommand<Group> {
     public GroupShowTracks() {
-        super("showtracks", "Lists the tracks that this group features on", "/%s group <group> showtracks", Permission.GROUP_SHOWTRACKS);
+        super("showtracks", "Lists the tracks that this group features on", "/%s group <group> showtracks",
+                Permission.GROUP_SHOWTRACKS, Predicate.alwaysFalse());
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         plugin.getDatastore().loadAllTracks(success -> {
             if (!success) {
                 Message.TRACKS_LOAD_ERROR.send(sender);
@@ -29,9 +31,4 @@ public class GroupShowTracks extends GroupSubCommand {
                     plugin.getTrackManager().getApplicableTracks(group.getName()).stream().map(Track::getName).collect(Collectors.toList())));
         });
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return false;
-    }
 }

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

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
@@ -11,14 +12,14 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class GroupUnSetPermission extends GroupSubCommand {
+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);
+        super("unset", "Unsets a permission for a group", "/%s group <group> unset <node> [server] [world]",
+                Permission.GROUP_UNSETPERMISSION, Predicate.notInRange(1, 3));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         String node = args.get(0);
 
         if (node.contains("/") || node.contains("$")) {
@@ -58,9 +59,4 @@ public class GroupUnSetPermission extends GroupSubCommand {
             Message.DOES_NOT_HAVEPERMISSION.send(sender, group.getName());
         }
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1 && argLength != 2 && argLength != 3;
-    }
 }

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

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
@@ -11,14 +12,15 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class GroupUnsetInherit extends GroupSubCommand {
+public class GroupUnsetInherit extends SubCommand<Group> {
     public GroupUnsetInherit() {
         super("unsetinherit", "Unsets another group for this group to inherit permissions from",
-                "/%s group <group> unsetinherit <group> [server] [world]", Permission.GROUP_UNSETINHERIT);
+                "/%s group <group> unsetinherit <group> [server] [world]", Permission.GROUP_UNSETINHERIT,
+                Predicate.notInRange(1, 3));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         String groupName = args.get(0).toLowerCase();
 
         if (groupName.contains("/") || groupName.contains("$")) {
@@ -58,9 +60,4 @@ public class GroupUnsetInherit extends GroupSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getGroupTabComplete(args, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1 && argLength != 2 && argLength != 3;
-    }
 }

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

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
@@ -11,14 +12,15 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class GroupUnsetTempInherit extends GroupSubCommand {
+public class GroupUnsetTempInherit extends SubCommand<Group> {
     public GroupUnsetTempInherit() {
         super("unsettempinherit", "Unsets another group for this group to inherit permissions from",
-                "/%s group <group> unsettempinherit <group> [server] [world]", Permission.GROUP_UNSET_TEMP_INHERIT);
+                "/%s group <group> unsettempinherit <group> [server] [world]", Permission.GROUP_UNSET_TEMP_INHERIT,
+                Predicate.notInRange(1, 3));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         String groupName = args.get(0).toLowerCase();
 
         if (groupName.contains("/") || groupName.contains("$")) {
@@ -58,9 +60,4 @@ public class GroupUnsetTempInherit extends GroupSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getGroupTabComplete(args, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1 && argLength != 2 && argLength != 3;
-    }
 }

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

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
@@ -11,14 +12,15 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class GroupUnsetTempPermission extends GroupSubCommand {
+public class GroupUnsetTempPermission extends SubCommand<Group> {
     public GroupUnsetTempPermission() {
         super("unsettemp", "Unsets a temporary permission for a group",
-                "/%s group <group> unsettemp <node> [server] [world]", Permission.GROUP_UNSET_TEMP_PERMISSION);
+                "/%s group <group> unsettemp <node> [server] [world]", Permission.GROUP_UNSET_TEMP_PERMISSION,
+                Predicate.notInRange(1, 3));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         String node = args.get(0);
 
         if (node.contains("/") || node.contains("$")) {
@@ -58,9 +60,4 @@ public class GroupUnsetTempPermission extends GroupSubCommand {
             Message.DOES_NOT_HAVE_TEMP_PERMISSION.send(sender, group.getName());
         }
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1 && argLength != 2 && argLength != 3;
-    }
 }

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

@@ -1,18 +1,16 @@
 package me.lucko.luckperms.commands.misc;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.MainCommand;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.SingleMainCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 
-import java.util.Collections;
 import java.util.List;
 
-public class DebugCommand extends MainCommand {
+public class DebugCommand extends SingleMainCommand {
     public DebugCommand() {
-        super("Debug", "/%s debug", 0);
+        super("Debug", "/%s debug", 0, Permission.DEBUG);
     }
 
     @Override
@@ -21,19 +19,4 @@ public class DebugCommand extends MainCommand {
                 plugin.getGroupManager().getGroups().size(), plugin.getTrackManager().getTracks().size()
         );
     }
-
-    @Override
-    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
-        return Collections.emptyList();
-    }
-
-    @Override
-    public List<? extends SubCommand> getSubCommands() {
-        return Collections.emptyList();
-    }
-
-    @Override
-    protected boolean canUse(Sender sender) {
-        return Permission.DEBUG.isAuthorized(sender);
-    }
 }

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

@@ -1,19 +1,17 @@
 package me.lucko.luckperms.commands.misc;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.MainCommand;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.SingleMainCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.utils.LPConfiguration;
 
-import java.util.Collections;
 import java.util.List;
 
-public class InfoCommand extends MainCommand {
+public class InfoCommand extends SingleMainCommand {
     public InfoCommand() {
-        super("Info", "/%s info", 0);
+        super("Info", "/%s info", 0, Permission.INFO);
     }
 
     @Override
@@ -22,19 +20,4 @@ public class InfoCommand extends MainCommand {
         Message.INFO.send(sender, plugin.getVersion(), plugin.getDatastore().getName(), c.getServer(),
                 c.getDefaultGroupName(), c.getSyncTime(), c.getIncludeGlobalPerms(), c.getOnlineMode());
     }
-
-    @Override
-    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
-        return Collections.emptyList();
-    }
-
-    @Override
-    public List<? extends SubCommand> getSubCommands() {
-        return Collections.emptyList();
-    }
-
-    @Override
-    protected boolean canUse(Sender sender) {
-        return Permission.INFO.isAuthorized(sender);
-    }
 }

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

@@ -1,18 +1,16 @@
 package me.lucko.luckperms.commands.misc;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.MainCommand;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.SingleMainCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 
-import java.util.Collections;
 import java.util.List;
 
-public class SyncCommand extends MainCommand {
+public class SyncCommand extends SingleMainCommand {
     public SyncCommand() {
-        super("Sync", "/%s sync", 0);
+        super("Sync", "/%s sync", 0, Permission.SYNC);
     }
 
     @Override
@@ -20,19 +18,4 @@ public class SyncCommand extends MainCommand {
         Message.UPDATE_TASK_RUN.send(sender);
         plugin.runUpdateTask();
     }
-
-    @Override
-    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
-        return Collections.emptyList();
-    }
-
-    @Override
-    public List<? extends SubCommand> getSubCommands() {
-        return Collections.emptyList();
-    }
-
-    @Override
-    protected boolean canUse(Sender sender) {
-        return Permission.SYNC.isAuthorized(sender);
-    }
 }

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

@@ -1,19 +1,17 @@
 package me.lucko.luckperms.commands.track;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.MainCommand;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.SingleMainCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.utils.Patterns;
 
-import java.util.Collections;
 import java.util.List;
 
-public class CreateTrack extends MainCommand {
+public class CreateTrack extends SingleMainCommand {
     public CreateTrack() {
-        super("CreateTrack", "/%s createtrack <track>", 1);
+        super("CreateTrack", "/%s createtrack <track>", 1, Permission.CREATE_TRACK);
     }
 
     @Override
@@ -50,19 +48,4 @@ public class CreateTrack extends MainCommand {
             }
         });
     }
-
-    @Override
-    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
-        return Collections.emptyList();
-    }
-
-    @Override
-    public List<? extends SubCommand> getSubCommands() {
-        return Collections.emptyList();
-    }
-
-    @Override
-    protected boolean canUse(Sender sender) {
-        return Permission.CREATE_TRACK.isAuthorized(sender);
-    }
 }

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

@@ -1,9 +1,8 @@
 package me.lucko.luckperms.commands.track;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.MainCommand;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.SingleMainCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.tracks.Track;
@@ -14,9 +13,9 @@ import java.util.Collections;
 import java.util.List;
 import java.util.stream.Collectors;
 
-public class DeleteTrack extends MainCommand {
+public class DeleteTrack extends SingleMainCommand {
     public DeleteTrack() {
-        super("DeleteTrack", "/%s deletetrack <track>", 1);
+        super("DeleteTrack", "/%s deletetrack <track>", 1, Permission.DELETE_TRACK);
     }
 
     @Override
@@ -69,14 +68,4 @@ public class DeleteTrack extends MainCommand {
 
         return Collections.emptyList();
     }
-
-    @Override
-    public List<SubCommand> getSubCommands() {
-        return Collections.emptyList();
-    }
-
-    @Override
-    protected boolean canUse(Sender sender) {
-        return Permission.DELETE_TRACK.isAuthorized(sender);
-    }
 }

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

@@ -1,20 +1,18 @@
 package me.lucko.luckperms.commands.track;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.MainCommand;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.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.Collections;
 import java.util.List;
 
-public class ListTracks extends MainCommand {
+public class ListTracks extends SingleMainCommand {
     public ListTracks() {
-        super("ListTracks", "/%s listtracks", 0);
+        super("ListTracks", "/%s listtracks", 0, Permission.LIST_TRACKS);
     }
 
     @Override
@@ -27,19 +25,4 @@ public class ListTracks extends MainCommand {
             }
         });
     }
-
-    @Override
-    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
-        return Collections.emptyList();
-    }
-
-    @Override
-    public List<SubCommand> getSubCommands() {
-        return Collections.emptyList();
-    }
-
-    @Override
-    protected boolean canUse(Sender sender) {
-        return Permission.LIST_TRACKS.isAuthorized(sender);
-    }
 }

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

@@ -1,101 +1,40 @@
 package me.lucko.luckperms.commands.track;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.data.Callback;
 import me.lucko.luckperms.commands.MainCommand;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.tracks.Track;
-import me.lucko.luckperms.utils.Patterns;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Optional;
-import java.util.stream.Collectors;
-
-public class TrackMainCommand extends MainCommand {
-
-    private final List<TrackSubCommand> subCommands = new ArrayList<>();
 
+public class TrackMainCommand extends MainCommand<Track> {
     public TrackMainCommand() {
         super("Track", "/%s track <track>", 2);
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
-        if (args.size() < 2) {
-            sendUsage(sender, label);
-            return;
-        }
-
-        Optional<TrackSubCommand> o = subCommands.stream().filter(s -> s.getName().equalsIgnoreCase(args.get(1))).limit(1).findAny();
-
-        if (!o.isPresent()) {
-            Message.COMMAND_NOT_RECOGNISED.send(sender);
-            return;
-        }
-
-        final TrackSubCommand sub = o.get();
-        if (!sub.isAuthorized(sender)) {
-            Message.COMMAND_NO_PERMISSION.send(sender);
-            return;
-        }
-
-        List<String> strippedArgs = new ArrayList<>();
-        if (args.size() > 2) {
-            strippedArgs.addAll(args.subList(2, args.size()));
-        }
-
-        if (sub.isArgLengthInvalid(strippedArgs.size())) {
-            sub.sendUsage(sender, label);
-            return;
-        }
-
-        final String trackName = args.get(0).toLowerCase();
-
-        if (Patterns.NON_ALPHA_NUMERIC.matcher(trackName).find()) {
-            Message.TRACK_INVALID_ENTRY.send(sender);
-            return;
-        }
-
-        plugin.getDatastore().loadTrack(trackName, success -> {
+    protected void getTarget(String target, LuckPermsPlugin plugin, Sender sender, Callback<Track> onSuccess) {
+        plugin.getDatastore().loadTrack(target, success -> {
             if (!success) {
                 Message.TRACK_NOT_FOUND.send(sender);
                 return;
             }
 
-            Track track = plugin.getTrackManager().getTrack(trackName);
+            Track track = plugin.getTrackManager().getTrack(target);
             if (track == null) {
                 Message.TRACK_NOT_FOUND.send(sender);
                 return;
             }
 
-            sub.execute(plugin, sender, track, strippedArgs, label);
+            onSuccess.onComplete(track);
         });
     }
 
     @Override
-    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
-        final List<String> tracks = new ArrayList<>(plugin.getTrackManager().getTracks().keySet());
-
-        if (args.size() <= 1) {
-            if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) {
-                return tracks;
-            }
-
-            return tracks.stream().filter(s -> s.toLowerCase().startsWith(args.get(0).toLowerCase())).collect(Collectors.toList());
-        }
-
-        return onAbstractTabComplete(sender, args, plugin);
+    protected List<String> getObjects(LuckPermsPlugin plugin) {
+        return new ArrayList<>(plugin.getTrackManager().getTracks().keySet());
     }
-
-    @Override
-    public List<? extends SubCommand> getSubCommands() {
-        return subCommands;
-    }
-
-    public void registerSubCommand(TrackSubCommand subCommand) {
-        subCommands.add(subCommand);
-    }
-
 }

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

@@ -1,30 +0,0 @@
-package me.lucko.luckperms.commands.track;
-
-import me.lucko.luckperms.LuckPermsPlugin;
-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.tracks.Track;
-
-import java.util.List;
-
-public abstract class TrackSubCommand extends SubCommand {
-    public TrackSubCommand(String name, String description, String usage, Permission permission) {
-        super(name, description, usage, permission);
-    }
-
-    protected abstract void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label);
-
-    protected void saveTrack(Track track, Sender sender, LuckPermsPlugin plugin) {
-        plugin.getDatastore().saveTrack(track, success -> {
-            if (success) {
-                Message.TRACK_SAVE_SUCCESS.send(sender);
-            } else {
-                Message.TRACK_SAVE_ERROR.send(sender);
-            }
-
-            plugin.runUpdateTask();
-        });
-    }
-}

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

@@ -1,9 +1,10 @@
 package me.lucko.luckperms.commands.track.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.commands.track.TrackSubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
@@ -12,13 +13,14 @@ import me.lucko.luckperms.tracks.Track;
 
 import java.util.List;
 
-public class TrackAppend extends TrackSubCommand {
+public class TrackAppend extends SubCommand<Track> {
     public TrackAppend() {
-        super("append", "Appends a group onto the end of the track", "/%s track <track> append <group>", Permission.TRACK_APPEND);
+        super("append", "Appends a group onto the end of the track", "/%s track <track> append <group>",
+                Permission.TRACK_APPEND, Predicate.not(1));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
         String groupName = args.get(0).toLowerCase();
 
         plugin.getDatastore().loadGroup(groupName, success -> {
@@ -47,9 +49,4 @@ public class TrackAppend extends TrackSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getGroupTabComplete(args, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1;
-    }
 }

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

@@ -1,28 +1,25 @@
 package me.lucko.luckperms.commands.track.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.track.TrackSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.tracks.Track;
 
 import java.util.List;
 
-public class TrackClear extends TrackSubCommand {
+public class TrackClear extends SubCommand<Track> {
     public TrackClear() {
-        super("clear", "Clears the groups on the track", "/%s track <track> clear", Permission.TRACK_CLEAR);
+        super("clear", "Clears the groups on the track", "/%s track <track> clear", Permission.TRACK_CLEAR,
+                Predicate.alwaysFalse());
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
         track.clearGroups();
         Message.TRACK_CLEAR.send(sender, track.getName());
         saveTrack(track, sender, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return false;
-    }
 }

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

@@ -1,27 +1,24 @@
 package me.lucko.luckperms.commands.track.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.commands.track.TrackSubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.tracks.Track;
 
 import java.util.List;
 
-public class TrackInfo extends TrackSubCommand {
+public class TrackInfo extends SubCommand<Track> {
     public TrackInfo() {
-        super("info", "Gives info about the track", "/%s track <track> info", Permission.TRACK_INFO);
+        super("info", "Gives info about the track", "/%s track <track> info", Permission.TRACK_INFO,
+                Predicate.alwaysFalse());
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
         Message.TRACK_INFO.send(sender, track.getName(), Util.listToArrowSep(track.getGroups()));
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return false;
-    }
 }

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

@@ -1,9 +1,10 @@
 package me.lucko.luckperms.commands.track.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.commands.track.TrackSubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
@@ -12,14 +13,14 @@ import me.lucko.luckperms.tracks.Track;
 
 import java.util.List;
 
-public class TrackInsert extends TrackSubCommand {
+public class TrackInsert extends SubCommand<Track> {
     public TrackInsert() {
         super("insert", "Inserts a group at a given position along the track",
-                "/%s track <track> insert <group> <position>", Permission.TRACK_INSERT);
+                "/%s track <track> insert <group> <position>", Permission.TRACK_INSERT, Predicate.not(2));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
         String groupName = args.get(0).toLowerCase();
         int pos;
         try {
@@ -57,9 +58,4 @@ public class TrackInsert extends TrackSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getGroupTabComplete(args, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 2;
-    }
 }

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

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.track.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.track.TrackSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
@@ -10,13 +11,14 @@ import me.lucko.luckperms.tracks.Track;
 
 import java.util.List;
 
-public class TrackRemove extends TrackSubCommand {
+public class TrackRemove extends SubCommand<Track> {
     public TrackRemove() {
-        super("remove", "Removes a group from the track", "/%s track <track> remove <group>", Permission.TRACK_REMOVE);
+        super("remove", "Removes a group from the track", "/%s track <track> remove <group>", Permission.TRACK_REMOVE,
+                Predicate.not(1));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
         String groupName = args.get(0).toLowerCase();
         try {
             track.removeGroup(groupName);
@@ -31,9 +33,4 @@ public class TrackRemove extends TrackSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getGroupTabComplete(args, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1;
-    }
 }

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

@@ -1,104 +1,53 @@
 package me.lucko.luckperms.commands.user;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.data.Callback;
 import me.lucko.luckperms.commands.MainCommand;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.users.User;
 import me.lucko.luckperms.utils.Patterns;
 
-import java.util.ArrayList;
 import java.util.List;
-import java.util.Optional;
 import java.util.UUID;
-import java.util.stream.Collectors;
-
-public class UserMainCommand extends MainCommand {
-
-    private final List<UserSubCommand> subCommands = new ArrayList<>();
 
+public class UserMainCommand extends MainCommand<User> {
     public UserMainCommand() {
         super("User", "/%s user <user>", 2);
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
-        if (args.size() < 2) {
-            sendUsage(sender, label);
-            return;
-        }
-
-        Optional<UserSubCommand> o = subCommands.stream().filter(s -> s.getName().equalsIgnoreCase(args.get(1))).limit(1).findAny();
-
-        if (!o.isPresent()) {
-            Message.COMMAND_NOT_RECOGNISED.send(sender);
-            return;
-        }
-
-        final UserSubCommand sub = o.get();
-        if (!sub.isAuthorized(sender)) {
-            Message.COMMAND_NO_PERMISSION.send(sender);
-            return;
-        }
-
-        // The arguments to be passed onto the sub command
-        List<String> strippedArgs = new ArrayList<>();
-        if (args.size() > 2) {
-            strippedArgs.addAll(args.subList(2, args.size()));
-        }
-
-        if (sub.isArgLengthInvalid(strippedArgs.size())) {
-            sub.sendUsage(sender, label);
-            return;
-        }
-
-        final String user = args.get(0);
-
-        if (Patterns.NON_USERNAME.matcher(user).find()) {
-            Message.USER_INVALID_ENTRY.send(sender, user);
-            return;
-        }
-
-        UUID u = Util.parseUuid(user);
+    protected void getTarget(String target, LuckPermsPlugin plugin, Sender sender, Callback<User> onSuccess) {
+        UUID u = Util.parseUuid(target);
         if (u != null) {
-            runSub(plugin, sender, u, sub, strippedArgs, label);
+            runSub(plugin, sender, u, onSuccess);
             return;
         }
 
-        if (user.length() <= 16) {
+        if (target.length() <= 16) {
+            if (Patterns.NON_USERNAME.matcher(target).find()) {
+                Message.USER_INVALID_ENTRY.send(sender, target);
+                return;
+            }
+
             Message.USER_ATTEMPTING_LOOKUP.send(sender);
 
-            plugin.getDatastore().getUUID(user, uuid -> {
+            plugin.getDatastore().getUUID(target, uuid -> {
                 if (uuid == null) {
                     Message.USER_NOT_FOUND.send(sender);
                     return;
                 }
-                runSub(plugin, sender, uuid, sub, strippedArgs, label);
+
+                runSub(plugin, sender, uuid, onSuccess);
             });
             return;
         }
 
-        Message.USER_INVALID_ENTRY.send(sender, user);
+        Message.USER_INVALID_ENTRY.send(sender, target);
     }
 
-    @Override
-    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
-        final List<String> onlinePlayers = plugin.getPlayerList();
-
-        if (args.size() <= 1) {
-            if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) {
-                return onlinePlayers;
-            }
-
-            return onlinePlayers.stream().filter(s -> s.toLowerCase().startsWith(args.get(0).toLowerCase())).collect(Collectors.toList());
-        }
-
-        return onAbstractTabComplete(sender, args, plugin);
-    }
-
-    private void runSub(LuckPermsPlugin plugin, Sender sender, UUID uuid, UserSubCommand command, List<String> strippedArgs, String label) {
+    private void runSub(LuckPermsPlugin plugin, Sender sender, UUID uuid, Callback<User> onSuccess) {
         plugin.getDatastore().loadUser(uuid, success -> {
             if (!success) {
                 Message.USER_NOT_FOUND.send(sender);
@@ -108,19 +57,16 @@ public class UserMainCommand extends MainCommand {
             User user = plugin.getUserManager().getUser(uuid);
             if (user == null) {
                 Message.USER_NOT_FOUND.send(sender);
+                return;
             }
 
-            command.execute(plugin, sender, user, strippedArgs, label);
+            onSuccess.onComplete(user);
             plugin.getUserManager().cleanupUser(user);
         });
     }
 
     @Override
-    public List<? extends SubCommand> getSubCommands() {
-        return subCommands;
-    }
-
-    public void registerSubCommand(UserSubCommand subCommand) {
-        subCommands.add(subCommand);
+    protected List<String> getObjects(LuckPermsPlugin plugin) {
+        return plugin.getPlayerList();
     }
 }

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

@@ -1,30 +0,0 @@
-package me.lucko.luckperms.commands.user;
-
-import me.lucko.luckperms.LuckPermsPlugin;
-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.users.User;
-
-import java.util.List;
-
-public abstract class UserSubCommand extends SubCommand {
-    protected UserSubCommand(String name, String description, String usage, Permission permission) {
-        super(name, description, usage, permission);
-    }
-
-    protected abstract void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label);
-
-    protected void saveUser(User user, Sender sender, LuckPermsPlugin plugin) {
-        user.refreshPermissions();
-
-        plugin.getDatastore().saveUser(user, success -> {
-            if (success) {
-                Message.USER_SAVE_SUCCESS.send(sender);
-            } else {
-                Message.USER_SAVE_ERROR.send(sender);
-            }
-        });
-    }
-}

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

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
@@ -12,13 +13,14 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class UserAddGroup extends UserSubCommand {
+public class UserAddGroup extends SubCommand<User> {
     public UserAddGroup() {
-        super("addgroup", "Adds the user to a group", "/%s user <user> addgroup <group> [server] [world]", Permission.USER_ADDGROUP);
+        super("addgroup", "Adds the user to a group", "/%s user <user> addgroup <group> [server] [world]",
+                Permission.USER_ADDGROUP, Predicate.notInRange(1, 3));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         String groupName = args.get(0).toLowerCase();
 
         if (groupName.contains("/") || groupName.contains("$")) {
@@ -70,9 +72,4 @@ public class UserAddGroup extends UserSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getGroupTabComplete(args, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return (argLength != 1 && argLength != 2 && argLength != 3);
-    }
 }

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

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
@@ -13,14 +14,15 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class UserAddTempGroup extends UserSubCommand {
+public class UserAddTempGroup extends SubCommand<User> {
     public UserAddTempGroup() {
         super("addtempgroup", "Adds the user to a group temporarily",
-                "/%s user <user> addtempgroup <group> <duration> [server] [world]", Permission.USER_ADDTEMPGROUP);
+                "/%s user <user> addtempgroup <group> <duration> [server] [world]", Permission.USER_ADDTEMPGROUP,
+                Predicate.notInRange(2, 4));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         String groupName = args.get(0).toLowerCase();
 
         if (groupName.contains("/") || groupName.contains("$")) {
@@ -87,9 +89,4 @@ public class UserAddTempGroup extends UserSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getGroupTabComplete(args, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return (argLength != 2 && argLength != 3 && argLength != 4);
-    }
 }

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

@@ -1,30 +1,27 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.users.User;
 
 import java.util.List;
 
-public class UserClear extends UserSubCommand {
+public class UserClear extends SubCommand<User> {
     public UserClear() {
-        super("clear", "Clears a users permissions and groups", "/%s user <user> clear", Permission.USER_CLEAR);
+        super("clear", "Clears a users permissions and groups", "/%s user <user> clear", Permission.USER_CLEAR,
+                Predicate.alwaysFalse());
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         user.clearNodes();
         plugin.getUserManager().giveDefaults(user);
         Message.CLEAR_SUCCESS.send(sender, user.getName());
 
         saveUser(user, sender, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return false;
-    }
 }

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

@@ -1,9 +1,10 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.commands.user.UserSubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
@@ -14,13 +15,14 @@ import me.lucko.luckperms.users.User;
 
 import java.util.List;
 
-public class UserDemote extends UserSubCommand {
+public class UserDemote extends SubCommand<User> {
     public UserDemote() {
-        super("demote", "Demotes a user along a track", "/%s user <user> demote <track>", Permission.USER_DEMOTE);
+        super("demote", "Demotes a user along a track", "/%s user <user> demote <track>", Permission.USER_DEMOTE,
+                Predicate.not(1));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         final String trackName = args.get(0).toLowerCase();
 
         plugin.getDatastore().loadTrack(trackName, success -> {
@@ -85,9 +87,4 @@ public class UserDemote extends UserSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getTrackTabComplete(args, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1;
-    }
 }

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

@@ -1,26 +1,23 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.users.User;
 
 import java.util.List;
 
-public class UserGetUUID extends UserSubCommand {
+public class UserGetUUID extends SubCommand<User> {
     public UserGetUUID() {
-        super("getuuid", "Get the UUID of a user", "/%s user <user> getuuid", Permission.USER_GETUUID);
+        super("getuuid", "Get the UUID of a user", "/%s user <user> getuuid", Permission.USER_GETUUID,
+                Predicate.alwaysFalse());
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         Message.USER_GETUUID.send(sender, user.getName(), user.getUuid().toString());
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return false;
-    }
 }

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

@@ -1,9 +1,10 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.commands.user.UserSubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.users.User;
@@ -11,14 +12,15 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class UserHasPerm extends UserSubCommand {
+public class UserHasPerm extends SubCommand<User> {
     public UserHasPerm() {
         super("haspermission", "Checks to see if a user has a certain permission node",
-                "/%s user <user> haspermission <node> [server] [world]", Permission.USER_HASPERMISSION);
+                "/%s user <user> haspermission <node> [server] [world]", Permission.USER_HASPERMISSION,
+                Predicate.notInRange(1, 3));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         if (args.size() >= 2) {
             if (Patterns.NON_ALPHA_NUMERIC.matcher(args.get(1)).find()) {
                 Message.SERVER_INVALID_ENTRY.send(sender);
@@ -35,9 +37,4 @@ public class UserHasPerm extends UserSubCommand {
             Util.sendBoolean(sender, args.get(0), user.hasPermission(args.get(0), true, "global"));
         }
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1 && argLength != 2 && argLength != 3;
-    }
 }

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

@@ -1,30 +1,26 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.commands.user.UserSubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.users.User;
 
 import java.util.List;
 
-public class UserInfo extends UserSubCommand {
+public class UserInfo extends SubCommand<User> {
     public UserInfo() {
-        super("info", "Gives info about the user", "/%s user <user> info", Permission.USER_INFO);
+        super("info", "Gives info about the user", "/%s user <user> info", Permission.USER_INFO, Predicate.alwaysFalse());
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         Message.USER_INFO.send(sender, user.getName(), user.getUuid(), plugin.getPlayerStatus(user.getUuid()),
                 Util.listToCommaSep(user.getGroupNames()), user.getPrimaryGroup(),
                 user.getPermanentNodes().keySet().size(), user.getTemporaryNodes().keySet().size(), label, user.getName()
         );
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return false;
-    }
 }

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

@@ -1,9 +1,10 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.commands.user.UserSubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.users.User;
@@ -11,14 +12,15 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class UserInheritsPerm extends UserSubCommand {
+public class UserInheritsPerm extends SubCommand<User> {
     public UserInheritsPerm() {
         super("inheritspermission", "Checks to see if a user inherits a certain permission node",
-                "/%s user <user> inheritspermission <node> [server] [world]", Permission.USER_INHERITSPERMISSION);
+                "/%s user <user> inheritspermission <node> [server] [world]", Permission.USER_INHERITSPERMISSION,
+                Predicate.notInRange(1, 3));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         if (args.size() >= 2) {
             if (Patterns.NON_ALPHA_NUMERIC.matcher(args.get(1)).find()) {
                 Message.SERVER_INVALID_ENTRY.send(sender);
@@ -35,9 +37,4 @@ public class UserInheritsPerm extends UserSubCommand {
             Util.sendBoolean(sender, args.get(0), user.inheritsPermission(args.get(0), true));
         }
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1 && argLength != 2 && argLength != 3;
-    }
 }

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

@@ -1,28 +1,25 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.commands.user.UserSubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.users.User;
 
 import java.util.List;
 
-public class UserListNodes extends UserSubCommand {
+public class UserListNodes extends SubCommand<User> {
     public UserListNodes() {
-        super("listnodes", "Lists the permission nodes the user has", "/%s user <user> listnodes", Permission.USER_LISTNODES);
+        super("listnodes", "Lists the permission nodes the user has", "/%s user <user> listnodes",
+                Permission.USER_LISTNODES, Predicate.alwaysFalse());
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         Message.LISTNODES.send(sender, user.getName(), Util.permNodesToString(user.getPermanentNodes()));
         Message.LISTNODES_TEMP.send(sender, user.getName(), Util.tempNodesToString(user.getTemporaryNodes()));
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return false;
-    }
 }

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

@@ -1,9 +1,10 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.commands.user.UserSubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
@@ -14,13 +15,14 @@ import me.lucko.luckperms.users.User;
 
 import java.util.List;
 
-public class UserPromote extends UserSubCommand {
+public class UserPromote extends SubCommand<User> {
     public UserPromote() {
-        super("promote", "Promotes the user along a track", "/%s user <user> promote <track>", Permission.USER_PROMOTE);
+        super("promote", "Promotes the user along a track", "/%s user <user> promote <track>", Permission.USER_PROMOTE,
+                Predicate.not(1));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         final String trackName = args.get(0).toLowerCase();
 
         plugin.getDatastore().loadTrack(trackName, success -> {
@@ -85,9 +87,4 @@ public class UserPromote extends UserSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getTrackTabComplete(args, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1;
-    }
 }

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

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
@@ -11,13 +12,14 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class UserRemoveGroup extends UserSubCommand {
+public class UserRemoveGroup extends SubCommand<User> {
     public UserRemoveGroup() {
-        super("removegroup", "Removes a user from a group", "/%s user <user> removegroup <group> [server] [world]", Permission.USER_REMOVEGROUP);
+        super("removegroup", "Removes a user from a group", "/%s user <user> removegroup <group> [server] [world]",
+                Permission.USER_REMOVEGROUP, Predicate.notInRange(1, 3));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         String groupName = args.get(0).toLowerCase();
 
         if (groupName.contains("/") || groupName.contains("$")) {
@@ -63,9 +65,4 @@ public class UserRemoveGroup extends UserSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getGroupTabComplete(args, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return (argLength != 1 && argLength != 2 && argLength != 3);
-    }
 }

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

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
@@ -11,14 +12,15 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class UserRemoveTempGroup extends UserSubCommand {
+public class UserRemoveTempGroup extends SubCommand<User> {
     public UserRemoveTempGroup() {
         super("removetempgroup", "Removes a user from a temporary group",
-                "/%s user <user> removetempgroup <group> [server] [world]", Permission.USER_REMOVETEMPGROUP);
+                "/%s user <user> removetempgroup <group> [server] [world]", Permission.USER_REMOVETEMPGROUP,
+                Predicate.notInRange(1, 3));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         String groupName = args.get(0).toLowerCase();
 
         if (groupName.contains("/") || groupName.contains("$")) {
@@ -58,9 +60,4 @@ public class UserRemoveTempGroup extends UserSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getGroupTabComplete(args, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return (argLength != 1 && argLength != 2 && argLength != 3);
-    }
 }

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

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
@@ -11,14 +12,15 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class UserSetPermission extends UserSubCommand {
+public class UserSetPermission extends SubCommand<User> {
     public UserSetPermission() {
         super("set", "Sets a permission for a user",
-                "/%s user <user> set <node> <true|false> [server] [world]", Permission.USER_SETPERMISSION);
+                "/%s user <user> set <node> <true|false> [server] [world]", Permission.USER_SETPERMISSION,
+                Predicate.notInRange(2, 4));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         String node = args.get(0);
         String bool = args.get(1).toLowerCase();
 
@@ -71,9 +73,4 @@ public class UserSetPermission extends UserSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getBoolTabComplete(args);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 2 && argLength != 3 && argLength != 4;
-    }
 }

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

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.groups.Group;
@@ -10,14 +11,14 @@ import me.lucko.luckperms.users.User;
 
 import java.util.List;
 
-public class UserSetPrimaryGroup extends UserSubCommand {
+public class UserSetPrimaryGroup extends SubCommand<User> {
     public UserSetPrimaryGroup() {
         super("setprimarygroup", "Sets a users primary group",
-                "/%s user <user> setprimarygroup <group>", Permission.USER_SETPRIMARYGROUP);
+                "/%s user <user> setprimarygroup <group>", Permission.USER_SETPRIMARYGROUP, Predicate.not(1));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         Group group = plugin.getGroupManager().getGroup(args.get(0).toLowerCase());
         if (group == null) {
             Message.GROUP_DOES_NOT_EXIST.send(sender);
@@ -44,9 +45,4 @@ public class UserSetPrimaryGroup extends UserSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getGroupTabComplete(args, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1;
-    }
 }

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

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
@@ -12,14 +13,15 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class UserSetTempPermission extends UserSubCommand {
+public class UserSetTempPermission extends SubCommand<User> {
     public UserSetTempPermission() {
         super("settemp", "Sets a temporary permission for a user",
-                "/%s user <user> settemp <node> <true|false> <duration> [server] [world]", Permission.USER_SET_TEMP_PERMISSION);
+                "/%s user <user> settemp <node> <true|false> <duration> [server] [world]",
+                Permission.USER_SET_TEMP_PERMISSION, Predicate.notInRange(3, 5));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         String node = args.get(0);
         String bool = args.get(1).toLowerCase();
 
@@ -85,9 +87,4 @@ public class UserSetTempPermission extends UserSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getBoolTabComplete(args);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 3 && argLength != 4 && argLength != 5;
-    }
 }

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

@@ -1,9 +1,10 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.commands.user.UserSubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.tracks.Track;
@@ -11,13 +12,14 @@ import me.lucko.luckperms.users.User;
 
 import java.util.List;
 
-public class UserShowPos extends UserSubCommand {
+public class UserShowPos extends SubCommand<User> {
     public UserShowPos() {
-        super("showpos", "Shows a users position on a track", "/%s user <user> showpos <track>", Permission.USER_SHOWPOS);
+        super("showpos", "Shows a users position on a track", "/%s user <user> showpos <track>", Permission.USER_SHOWPOS,
+                Predicate.not(1));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         final String trackName = args.get(0).toLowerCase();
 
         plugin.getDatastore().loadTrack(trackName, success -> {
@@ -49,9 +51,4 @@ public class UserShowPos extends UserSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getTrackTabComplete(args, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1;
-    }
 }

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

@@ -1,9 +1,10 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.commands.user.UserSubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.tracks.Track;
@@ -12,14 +13,14 @@ import me.lucko.luckperms.users.User;
 import java.util.List;
 import java.util.stream.Collectors;
 
-public class UserShowTracks extends UserSubCommand {
+public class UserShowTracks extends SubCommand<User> {
     public UserShowTracks() {
         super("showtracks", "Lists the tracks that this user's primary group features on", "/%s user <user> showtracks",
-                Permission.USER_SHOWTRACKS);
+                Permission.USER_SHOWTRACKS, Predicate.alwaysFalse());
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         plugin.getDatastore().loadAllTracks(success -> {
             if (!success) {
                 Message.TRACKS_LOAD_ERROR.send(sender);
@@ -31,9 +32,4 @@ public class UserShowTracks extends UserSubCommand {
                     plugin.getTrackManager().getApplicableTracks(user.getPrimaryGroup()).stream().map(Track::getName).collect(Collectors.toList())));
         });
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return false;
-    }
 }

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

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
@@ -11,14 +12,14 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class UserUnSetPermission extends UserSubCommand {
+public class UserUnSetPermission extends SubCommand<User> {
     public UserUnSetPermission() {
         super("unset", "Unsets a permission for a user",
-                "/%s user <user> unset <node> [server] [world]", Permission.USER_UNSETPERMISSION);
+                "/%s user <user> unset <node> [server] [world]", Permission.USER_UNSETPERMISSION, Predicate.notInRange(1, 3));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         String node = args.get(0);
 
         if (node.contains("/") || node.contains("$")) {
@@ -58,9 +59,4 @@ public class UserUnSetPermission extends UserSubCommand {
             Message.DOES_NOT_HAVEPERMISSION.send(sender, user.getName());
         }
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1 && argLength != 2 && argLength != 3;
-    }
 }

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

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
@@ -11,14 +12,15 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class UserUnsetTempPermission extends UserSubCommand {
+public class UserUnsetTempPermission extends SubCommand<User> {
     public UserUnsetTempPermission() {
         super("unsettemp", "Unsets a temporary permission for a user",
-                "/%s user <user> unsettemp <node> [server] [world]", Permission.USER_UNSET_TEMP_PERMISSION);
+                "/%s user <user> unsettemp <node> [server] [world]", Permission.USER_UNSET_TEMP_PERMISSION,
+                Predicate.notInRange(1, 3));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         String node = args.get(0);
 
         if (node.contains("/") || node.contains("$")) {
@@ -58,9 +60,4 @@ public class UserUnsetTempPermission extends UserSubCommand {
             Message.DOES_NOT_HAVE_TEMP_PERMISSION.send(sender, user.getName());
         }
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1 && argLength != 2 && argLength != 3;
-    }
 }

common/src/main/java/me/lucko/luckperms/constants/Message.java

@@ -1,12 +1,14 @@
 package me.lucko.luckperms.constants;
 
+import lombok.AllArgsConstructor;
 import me.lucko.luckperms.commands.Sender;
 import me.lucko.luckperms.commands.Util;
 
 @SuppressWarnings("SpellCheckingInspection")
+@AllArgsConstructor
 public enum Message {
 
-    /**
+    /*
      * General & Commands
      */
     PREFIX("&7&l[&b&lL&a&lP&7&l] &c", false),
@@ -23,7 +25,7 @@ public enum Message {
 
 
 
-    /**
+    /*
      * Loading / Saving
      */
     USER_NOT_FOUND("&eUser could not be found.", true),
@@ -41,7 +43,7 @@ public enum Message {
 
 
 
-    /**
+    /*
      * Command Syntax
      */
     USER_USE_ADDGROUP("Use the addgroup command instead of specifying the node.", true),
@@ -57,7 +59,7 @@ public enum Message {
     SERVER_INVALID_ENTRY("Server names can only contain alphanumeric characters.", true),
 
 
-    /**
+    /*
      * Commands
      */
     CREATE_SUCCESS("&b%s&a was successfully created.", true),
@@ -221,11 +223,6 @@ public enum Message {
     private String message;
     private boolean showPrefix;
 
-    Message(String message, boolean showPrefix) {
-        this.message = Util.color(message);
-        this.showPrefix = showPrefix;
-    }
-
     @Override
     public String toString() {
         return message;
@@ -233,9 +230,9 @@ public enum Message {
 
     public void send(Sender sender, Object... objects) {
         if (showPrefix) {
-            sender.sendMessage(PREFIX + String.format(message, objects));
+            sender.sendMessage(Util.color(PREFIX + String.format(message, objects)));
         } else {
-            sender.sendMessage(String.format(message, objects));
+            sender.sendMessage(Util.color(String.format(message, objects)));
         }
     }
 }

common/src/main/java/me/lucko/luckperms/data/methods/FlatfileDatastore.java

@@ -503,12 +503,14 @@ public class FlatfileDatastore extends Datastore {
 
     @Override
     public boolean saveUUIDData(String username, UUID uuid) {
+        username = username.toLowerCase();
         uuidCache.put(username, uuid.toString());
         return true;
     }
 
     @Override
     public UUID getUUID(String username) {
+        username = username.toLowerCase();
         if (uuidCache.get(username) == null) return null;
         return UUID.fromString(uuidCache.get(username));
     }

common/src/main/java/me/lucko/luckperms/data/methods/MySQLDatastore.java

@@ -1,12 +1,14 @@
 package me.lucko.luckperms.data.methods;
 
 import com.zaxxer.hikari.HikariDataSource;
+import lombok.Cleanup;
 import me.lucko.luckperms.LuckPermsPlugin;
 import me.lucko.luckperms.data.MySQLConfiguration;
 
 import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
 import java.sql.SQLException;
-import java.util.logging.Level;
 
 public class MySQLDatastore extends SQLDatastore {
 
@@ -41,13 +43,53 @@ public class MySQLDatastore extends SQLDatastore {
         hikari.addDataSourceProperty("password", password);
 
         if (!setupTables(CREATETABLE_UUID, CREATETABLE_USERS, CREATETABLE_GROUPS, CREATETABLE_TRACKS)) {
-            plugin.getLogger().log(Level.SEVERE, "Error occurred whilst initialising the database. All connections are disallowed.");
+            plugin.getLog().severe("Error occurred whilst initialising the database. All connections are disallowed.");
             shutdown();
         } else {
             setAcceptingLogins(true);
         }
     }
 
+    @Override
+    boolean runQuery(QueryPS queryPS) {
+        boolean success = false;
+        try {
+            @Cleanup Connection connection = getConnection();
+            if (connection == null || connection.isClosed()) {
+                throw new IllegalStateException("SQL connection is null");
+            }
+
+            @Cleanup PreparedStatement preparedStatement = connection.prepareStatement(queryPS.getQuery());
+            queryPS.onRun(preparedStatement);
+            preparedStatement.execute();
+            success = true;
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+        return success;
+    }
+
+    @Override
+    boolean runQuery(QueryRS queryRS) {
+        boolean success = false;
+        try {
+            @Cleanup Connection connection = getConnection();
+            if (connection == null || connection.isClosed()) {
+                throw new IllegalStateException("SQL connection is null");
+            }
+
+            @Cleanup PreparedStatement preparedStatement = connection.prepareStatement(queryRS.getQuery());
+            queryRS.onRun(preparedStatement);
+            preparedStatement.execute();
+
+            @Cleanup ResultSet resultSet = preparedStatement.executeQuery();
+            success = queryRS.onResult(resultSet);
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+        return success;
+    }
+
     @Override
     public void shutdown() {
         if (hikari != null) {

common/src/main/java/me/lucko/luckperms/data/methods/SQLDatastore.java

@@ -3,7 +3,6 @@ package me.lucko.luckperms.data.methods;
 import com.google.gson.Gson;
 import com.google.gson.reflect.TypeToken;
 import lombok.AllArgsConstructor;
-import lombok.Cleanup;
 import lombok.Getter;
 import me.lucko.luckperms.LuckPermsPlugin;
 import me.lucko.luckperms.data.Datastore;
@@ -58,43 +57,8 @@ abstract class SQLDatastore extends Datastore {
 
     abstract Connection getConnection() throws SQLException;
 
-    private boolean runQuery(QueryPS queryPS) {
-        boolean success = false;
-        try {
-            @Cleanup Connection connection = getConnection();
-            if (connection == null) {
-                throw new IllegalStateException("SQL connection is null");
-            }
-
-            @Cleanup PreparedStatement preparedStatement = connection.prepareStatement(queryPS.getQuery());
-            queryPS.onRun(preparedStatement);
-            preparedStatement.execute();
-            success = true;
-        } catch (SQLException e) {
-            e.printStackTrace();
-        }
-        return success;
-    }
-
-    private boolean runQuery(QueryRS queryRS) {
-        boolean success = false;
-        try {
-            @Cleanup Connection connection = getConnection();
-            if (connection == null) {
-                throw new IllegalStateException("SQL connection is null");
-            }
-
-            @Cleanup PreparedStatement preparedStatement = connection.prepareStatement(queryRS.getQuery());
-            queryRS.onRun(preparedStatement);
-            preparedStatement.execute();
-
-            @Cleanup ResultSet resultSet = preparedStatement.executeQuery();
-            success = queryRS.onResult(resultSet);
-        } catch (SQLException e) {
-            e.printStackTrace();
-        }
-        return success;
-    }
+    abstract boolean runQuery(QueryPS queryPS);
+    abstract boolean runQuery(QueryRS queryRS);
 
     boolean setupTables(String... tableQueries) {
         boolean success = true;
@@ -396,10 +360,11 @@ abstract class SQLDatastore extends Datastore {
 
     @Override
     public boolean saveUUIDData(String username, UUID uuid) {
+        final String u = username.toLowerCase();
         boolean success = runQuery(new QueryRS(UUIDCACHE_SELECT) {
             @Override
             void onRun(PreparedStatement preparedStatement) throws SQLException {
-                preparedStatement.setString(1, username);
+                preparedStatement.setString(1, u);
             }
 
             @Override
@@ -410,14 +375,14 @@ abstract class SQLDatastore extends Datastore {
                         @Override
                         void onRun(PreparedStatement preparedStatement) throws SQLException {
                             preparedStatement.setString(1, uuid.toString());
-                            preparedStatement.setString(2, username);
+                            preparedStatement.setString(2, u);
                         }
                     });
                 } else {
                     success = runQuery(new QueryPS(UUIDCACHE_INSERT) {
                         @Override
                         void onRun(PreparedStatement preparedStatement) throws SQLException {
-                            preparedStatement.setString(1, username);
+                            preparedStatement.setString(1, u);
                             preparedStatement.setString(2, uuid.toString());
                         }
                     });
@@ -431,12 +396,13 @@ abstract class SQLDatastore extends Datastore {
 
     @Override
     public UUID getUUID(String username) {
+        final String u = username.toLowerCase();
         final UUID[] uuid = {null};
 
         boolean success = runQuery(new QueryRS(UUIDCACHE_SELECT) {
             @Override
             void onRun(PreparedStatement preparedStatement) throws SQLException {
-                preparedStatement.setString(1, username);
+                preparedStatement.setString(1, u);
             }
 
             @Override
@@ -465,14 +431,14 @@ abstract class SQLDatastore extends Datastore {
 
     @Getter
     @AllArgsConstructor
-    private abstract class QueryPS {
+    abstract class QueryPS {
         private final String query;
         abstract void onRun(PreparedStatement preparedStatement) throws SQLException;
     }
 
     @Getter
     @AllArgsConstructor
-    private abstract class QueryRS {
+    abstract class QueryRS {
         private final String query;
         abstract void onRun(PreparedStatement preparedStatement) throws SQLException;
         abstract boolean onResult(ResultSet resultSet) throws SQLException;

common/src/main/java/me/lucko/luckperms/data/methods/SQLiteDatastore.java

@@ -1,12 +1,10 @@
 package me.lucko.luckperms.data.methods;
 
+import lombok.Cleanup;
 import me.lucko.luckperms.LuckPermsPlugin;
 
 import java.io.File;
-import java.sql.Connection;
-import java.sql.DriverManager;
-import java.sql.SQLException;
-import java.util.logging.Level;
+import java.sql.*;
 
 public class SQLiteDatastore extends SQLDatastore {
 
@@ -26,13 +24,53 @@ public class SQLiteDatastore extends SQLDatastore {
     @Override
     public void init() {
         if (!setupTables(CREATETABLE_UUID, CREATETABLE_USERS, CREATETABLE_GROUPS, CREATETABLE_TRACKS)) {
-            plugin.getLogger().log(Level.SEVERE, "Error occurred whilst initialising the database. All connections are disallowed.");
+            plugin.getLog().severe("Error occurred whilst initialising the database. All connections are disallowed.");
             shutdown();
         } else {
             setAcceptingLogins(true);
         }
     }
 
+    @Override
+    boolean runQuery(QueryPS queryPS) {
+        boolean success = false;
+        try {
+            Connection connection = getConnection();
+            if (connection == null || connection.isClosed()) {
+                throw new IllegalStateException("SQL connection is null");
+            }
+
+            @Cleanup PreparedStatement preparedStatement = connection.prepareStatement(queryPS.getQuery());
+            queryPS.onRun(preparedStatement);
+            preparedStatement.execute();
+            success = true;
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+        return success;
+    }
+
+    @Override
+    boolean runQuery(QueryRS queryRS) {
+        boolean success = false;
+        try {
+            Connection connection = getConnection();
+            if (connection == null || connection.isClosed()) {
+                throw new IllegalStateException("SQL connection is null");
+            }
+
+            @Cleanup PreparedStatement preparedStatement = connection.prepareStatement(queryRS.getQuery());
+            queryRS.onRun(preparedStatement);
+            preparedStatement.execute();
+
+            @Cleanup ResultSet resultSet = preparedStatement.executeQuery();
+            success = queryRS.onResult(resultSet);
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+        return success;
+    }
+
     @Override
     public void shutdown() {
         try {

common/src/main/java/me/lucko/luckperms/groups/Group.java

@@ -234,6 +234,7 @@ public class Group extends PermissionObject {
     /**
      * Get a {@link List} of the groups the group inherits on a specific server
      * @param server the server to check
+     * @param world the world to check
      * @return a {@link List} of group names
      */
     public List<String> getLocalGroups(String server, String world) {

common/src/main/java/me/lucko/luckperms/runnables/UpdateTask.java

@@ -9,7 +9,7 @@ public class UpdateTask implements Runnable {
 
     @Override
     public void run() {
-        plugin.getLogger().info("Running update task.");
+        plugin.getLog().info("Running update task.");
 
         // Reload all of the groups
         plugin.getDatastore().loadAllGroups();

common/src/main/java/me/lucko/luckperms/users/User.java

@@ -265,6 +265,7 @@ public abstract class User extends PermissionObject {
     /**
      * Get a {@link List} of the groups the user is a member of on a specific server
      * @param server the server to check
+     * @param world the world to check
      * @return a {@link List} of group names
      */
     public List<String> getLocalGroups(String server, String world) {

common/src/main/java/me/lucko/luckperms/users/UserManager.java

@@ -48,7 +48,7 @@ public abstract class UserManager {
     }
 
     /**
-     * Add a user to the {@link #getUsers()} map
+     * Add a user to the users map
      * @param user the user to add
      */
     public void setUser(User user) {
@@ -56,7 +56,7 @@ public abstract class UserManager {
     }
 
     /**
-     * Updates (or sets if the user wasn't already loaded) a user in the {@link #getUsers()} map
+     * Updates (or sets if the user wasn't already loaded) a user in the users map
      * @param user The user to update or set
      */
     public void updateOrSetUser(User user) {

common/src/main/java/me/lucko/luckperms/utils/DateUtil.java

@@ -24,6 +24,7 @@ public class DateUtil {
     /**
      * Converts a time string to a unix timestamp
      * @param time the time string
+     * @param future if the date is in the future, as opposed to the past
      * @return a unix timestamp
      * @throws IllegalDateException if the date input was invalid
      */

common/src/main/java/me/lucko/luckperms/utils/LPConfiguration.java

@@ -3,6 +3,7 @@ package me.lucko.luckperms.utils;
 import lombok.AccessLevel;
 import lombok.Getter;
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.data.MySQLConfiguration;
 
 public abstract class LPConfiguration<T extends LuckPermsPlugin> {
 
@@ -21,14 +22,14 @@ public abstract class LPConfiguration<T extends LuckPermsPlugin> {
         init();
 
         if (Patterns.NON_ALPHA_NUMERIC.matcher(getServer()).find()) {
-            plugin.getLogger().severe("Server name defined in config.yml contains invalid characters. Server names can " +
+            plugin.getLog().severe("Server name defined in config.yml contains invalid characters. Server names can " +
                     "only contain alphanumeric characters.\nDefined server name '" + getServer() + "' will be replaced with '" +
                     defaultServerName + "' (the default)");
             set("server", defaultServerName);
         }
 
         if (Patterns.NON_ALPHA_NUMERIC.matcher(getDefaultGroupName()).find()) {
-            plugin.getLogger().severe("Default group defined in config.yml contains invalid characters. Group names can " +
+            plugin.getLog().severe("Default group defined in config.yml contains invalid characters. Group names can " +
                     "only contain alphanumeric characters.\nDefined default group name '" + getDefaultGroupName() +
                     "' will be replaced with 'default' (the default)");
             set("default-group", "default");
@@ -65,8 +66,13 @@ public abstract class LPConfiguration<T extends LuckPermsPlugin> {
         return getBoolean("online-mode", true);
     }
 
-    public String getDatabaseValue(String value) {
-        return getString("sql." + value, null);
+    public MySQLConfiguration getDatabaseValues() {
+        return new MySQLConfiguration(
+                getString("sql.address", null),
+                getString("sql.database", null),
+                getString("sql.username", null),
+                getString("sql.password", null)
+        );
     }
 
     public String getStorageMethod() {

common/src/main/java/me/lucko/luckperms/utils/LogUtil.java

@@ -0,0 +1,49 @@
+package me.lucko.luckperms.utils;
+
+import lombok.experimental.UtilityClass;
+import me.lucko.luckperms.api.Logger;
+
+@UtilityClass
+public class LogUtil {
+    public static Logger wrap(org.slf4j.Logger l) {
+        return new Logger() {
+            private final org.slf4j.Logger logger = l;
+
+            @Override
+            public void info(String s) {
+                logger.info(s);
+            }
+
+            @Override
+            public void warn(String s) {
+                logger.warn(s);
+            }
+
+            @Override
+            public void severe(String s) {
+                logger.error(s);
+            }
+        };
+    }
+
+    public static Logger wrap(java.util.logging.Logger l) {
+        return new Logger() {
+            private final java.util.logging.Logger logger = l;
+
+            @Override
+            public void info(String s) {
+                logger.info(s);
+            }
+
+            @Override
+            public void warn(String s) {
+                logger.warning(s);
+            }
+
+            @Override
+            public void severe(String s) {
+                logger.severe(s);
+            }
+        };
+    }
+}

common/src/main/java/me/lucko/luckperms/utils/Patterns.java

@@ -6,6 +6,7 @@ import java.util.regex.Pattern;
 
 @UtilityClass
 public class Patterns {
+    public static final Pattern SPACE_SPLIT = Pattern.compile(" ");
     public static final Pattern SERVER_SPLIT = Pattern.compile("\\/");
     public static final Pattern WORLD_SPLIT = Pattern.compile("\\-");
     public static final Pattern TEMP_SPLIT = Pattern.compile("\\$");

common/src/main/java/me/lucko/luckperms/utils/PermissionObject.java

@@ -540,7 +540,7 @@ public abstract class PermissionObject {
             // Could be here if the server was set to global.
             String n = node.getKey();
             if (n.contains("/")) {
-                n = Patterns.SERVER_SPLIT.split(n, 2)[0];
+                n = Patterns.SERVER_SPLIT.split(n, 2)[1];
             }
 
             if (Patterns.GROUP_MATCH.matcher(n).matches()) {
@@ -571,7 +571,6 @@ public abstract class PermissionObject {
             // Add the actual group perm node, so other plugins can hook
             perms.put(groupNode.getKey(), groupNode.getValue());
 
-
             // Don't add negated groups
             if (!groupNode.getValue()) continue;
 
@@ -581,7 +580,7 @@ public abstract class PermissionObject {
                 if (group != null) {
                     perms.putAll(group.getLocalPermissions(server, excludedGroups));
                 } else {
-                    plugin.getLogger().warning("Error whilst refreshing the permissions of '" + objectName + "'." +
+                    plugin.getLog().warn("Error whilst refreshing the permissions of '" + objectName + "'." +
                             "\n The group '" + groupName + "' is not loaded.");
                 }
             }
@@ -604,7 +603,7 @@ public abstract class PermissionObject {
                     if (group != null) {
                         perms.putAll(group.getLocalPermissions(server, excludedGroups));
                     } else {
-                        plugin.getLogger().warning("Error whilst refreshing the permissions of '" + objectName + "'." +
+                        plugin.getLog().warn("Error whilst refreshing the permissions of '" + objectName + "'." +
                                 "\n The group '" + groupName + "' is not loaded.");
                     }
                 }

pom.xml

@@ -5,19 +5,19 @@
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
 
-    <groupId>me.lucko</groupId>
+    <groupId>me.lucko.luckperms</groupId>
     <artifactId>luckperms</artifactId>
-    <version>${global.version}</version>
+    <version>1.5</version>
     <modules>
-        <module>bukkit</module>
         <module>common</module>
-        <module>bungee</module>
         <module>api</module>
+        <module>bukkit</module>
+        <module>bungee</module>
+        <module>sponge</module>
     </modules>
 
     <packaging>pom</packaging>
     <properties>
-        <global.version>1.4</global.version>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     </properties>
 
@@ -31,8 +31,12 @@
             <url>https://oss.sonatype.org/content/repositories/snapshots/</url>
         </repository>
         <repository>
-            <id>vault-repo</id>
-            <url>http://nexus.theyeticave.net/content/repositories/pub_releases</url>
+            <id>luck-repo</id>
+            <url>https://repo.lucko.me/</url>
+        </repository>
+        <repository>
+            <id>sponge-repo</id>
+            <url>https://repo.spongepowered.org/maven</url>
         </repository>
     </repositories>
 

sponge/pom.xml

@@ -0,0 +1,79 @@
+<?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>1.5</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>luckperms-sponge</artifactId>
+    <version>1.5</version>
+    <packaging>jar</packaging>
+    <name>LuckPerms</name>
+
+    <build>
+        <defaultGoal>clean package</defaultGoal>
+        <finalName>LuckPermsSponge</finalName>
+        <sourceDirectory>${basedir}/src/main/java</sourceDirectory>
+        <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>true</minimizeJar>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+
+    <dependencies>
+        <!-- Sponge API -->
+        <dependency>
+            <groupId>org.spongepowered</groupId>
+            <artifactId>spongeapi</artifactId>
+            <version>4.1.0</version>
+            <scope>provided</scope>
+        </dependency>
+        <!-- LuckPerms Common -->
+        <dependency>
+            <groupId>me.lucko.luckperms</groupId>
+            <artifactId>luckperms-common</artifactId>
+            <version>1.5</version>
+            <scope>compile</scope>
+        </dependency>
+        <!-- LuckPerms API -->
+        <dependency>
+            <groupId>me.lucko.luckperms</groupId>
+            <artifactId>luckperms-api</artifactId>
+            <version>1.5</version>
+            <scope>compile</scope>
+        </dependency>
+    </dependencies>
+</project>

sponge/src/main/java/me/lucko/luckperms/LPSpongePlugin.java

@@ -0,0 +1,178 @@
+package me.lucko.luckperms;
+
+import com.google.inject.Inject;
+import lombok.Getter;
+import me.lucko.luckperms.api.LuckPermsApi;
+import me.lucko.luckperms.api.implementation.ApiProvider;
+import me.lucko.luckperms.data.Datastore;
+import me.lucko.luckperms.data.methods.FlatfileDatastore;
+import me.lucko.luckperms.data.methods.MySQLDatastore;
+import me.lucko.luckperms.data.methods.SQLiteDatastore;
+import me.lucko.luckperms.groups.GroupManager;
+import me.lucko.luckperms.listeners.PlayerListener;
+import me.lucko.luckperms.runnables.UpdateTask;
+import me.lucko.luckperms.tracks.TrackManager;
+import me.lucko.luckperms.users.SpongeUserManager;
+import me.lucko.luckperms.users.UserManager;
+import me.lucko.luckperms.utils.LPConfiguration;
+import me.lucko.luckperms.utils.LogUtil;
+import me.lucko.luckperms.utils.UuidCache;
+import org.slf4j.Logger;
+import org.spongepowered.api.Game;
+import org.spongepowered.api.Sponge;
+import org.spongepowered.api.command.CommandManager;
+import org.spongepowered.api.config.ConfigDir;
+import org.spongepowered.api.entity.living.player.Player;
+import org.spongepowered.api.event.Listener;
+import org.spongepowered.api.event.game.state.GamePreInitializationEvent;
+import org.spongepowered.api.event.game.state.GameStoppingServerEvent;
+import org.spongepowered.api.plugin.Plugin;
+import org.spongepowered.api.scheduler.Scheduler;
+
+import java.io.File;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+@Getter
+@Plugin(id = "luckperms", name = "LuckPerms", version = LPSpongePlugin.VERSION)
+public class LPSpongePlugin implements LuckPermsPlugin {
+    static final String VERSION = "1.5"; // TODO load this from pom
+
+    @Inject
+    private Logger logger;
+
+    @Inject
+    private Game game;
+
+    @Inject
+    @ConfigDir(sharedRoot = false)
+    private Path configDir;
+
+    private Scheduler scheduler = Sponge.getScheduler();
+
+    private LPConfiguration configuration;
+    private UserManager userManager;
+    private GroupManager groupManager;
+    private TrackManager trackManager;
+    private Datastore datastore;
+    private UuidCache uuidCache;
+
+    @Listener
+    public void onEnable(GamePreInitializationEvent event) {
+        getLog().info("Loading configuration...");
+        configuration = new SpongeConfig(this);
+
+        // register events
+        Sponge.getEventManager().registerListeners(this, new PlayerListener(this));
+
+        // register commands
+        getLog().info("Registering commands...");
+        CommandManager cmdService = Sponge.getCommandManager();
+        cmdService.register(this, new SpongeCommand(this), "luckperms", "perms", "lp", "permissions", "p", "perm");
+
+        getLog().info("Detecting storage method...");
+        final String storageMethod = configuration.getStorageMethod();
+        if (storageMethod.equalsIgnoreCase("mysql")) {
+            getLog().info("Using MySQL as storage method.");
+            datastore = new MySQLDatastore(this, configuration.getDatabaseValues());
+        } else if (storageMethod.equalsIgnoreCase("sqlite")) {
+            getLog().info("Using SQLite as storage method.");
+            datastore = new SQLiteDatastore(this, new File(getStorageDir(), "luckperms.sqlite"));
+        } else if (storageMethod.equalsIgnoreCase("flatfile")) {
+            getLog().info("Using Flatfile (JSON) as storage method.");
+            datastore = new FlatfileDatastore(this, getStorageDir());
+        } else {
+            getLog().severe("Storage method '" + storageMethod + "' was not recognised. Using SQLite as fallback.");
+            datastore = new SQLiteDatastore(this, new File(getStorageDir(), "luckperms.sqlite"));
+        }
+
+        getLog().info("Initialising datastore...");
+        datastore.init();
+
+        getLog().info("Loading internal permission managers...");
+        uuidCache = new UuidCache(getConfiguration().getOnlineMode());
+        userManager = new SpongeUserManager(this);
+        groupManager = new GroupManager(this);
+        trackManager = new TrackManager();
+
+        // 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();
+        }
+
+        int mins = getConfiguration().getSyncTime();
+        if (mins > 0) {
+            scheduler.createTaskBuilder().async().interval(mins, TimeUnit.MINUTES).execute(new UpdateTask(this))
+                    .submit(LPSpongePlugin.this);
+        }
+
+        getLog().info("Registering API...");
+        final ApiProvider provider = new ApiProvider(this);
+        LuckPerms.registerProvider(provider);
+        Sponge.getServiceManager().setProvider(this, LuckPermsApi.class, provider);
+
+        getLog().info("Successfully loaded.");
+    }
+
+    @Listener
+    public void onDisable(GameStoppingServerEvent event) {
+        getLog().info("Closing datastore...");
+        datastore.shutdown();
+
+        getLog().info("Unregistering API...");
+        LuckPerms.unregisterProvider();
+    }
+
+    private File getStorageDir() {
+        File base = configDir.toFile().getParentFile().getParentFile();
+        File luckperms = new File(base, "luckperms");
+        luckperms.mkdirs();
+        return luckperms;
+    }
+
+    @Override
+    public me.lucko.luckperms.api.Logger getLog() {
+        return LogUtil.wrap(getLogger());
+    }
+
+    @Override
+    public String getVersion() {
+        return VERSION;
+    }
+
+    @Override
+    public String getPlayerStatus(UUID uuid) {
+        return game.getServer().getPlayer(getUuidCache().getExternalUUID(uuid)).isPresent() ? "&aOnline" : "&cOffline";
+    }
+
+    @Override
+    public int getPlayerCount() {
+        return game.getServer().getOnlinePlayers().size();
+    }
+
+    @Override
+    public List<String> getPlayerList() {
+        return game.getServer().getOnlinePlayers().stream().map(Player::getName).collect(Collectors.toList());
+    }
+
+    @Override
+    public void runUpdateTask() {
+        scheduler.createTaskBuilder().async().execute(new UpdateTask(this)).submit(LPSpongePlugin.this);
+    }
+
+    @Override
+    public void doAsync(Runnable r) {
+        scheduler.createTaskBuilder().async().execute(r).submit(LPSpongePlugin.this);
+    }
+
+    @Override
+    public void doSync(Runnable r) {
+        scheduler.createTaskBuilder().execute(r).submit(LPSpongePlugin.this);
+    }
+}

sponge/src/main/java/me/lucko/luckperms/SpongeCommand.java

@@ -0,0 +1,74 @@
+package me.lucko.luckperms;
+
+import me.lucko.luckperms.commands.CommandManager;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.utils.Patterns;
+import org.spongepowered.api.command.CommandCallable;
+import org.spongepowered.api.command.CommandException;
+import org.spongepowered.api.command.CommandResult;
+import org.spongepowered.api.command.CommandSource;
+import org.spongepowered.api.text.Text;
+import org.spongepowered.api.text.serializer.TextSerializers;
+
+import java.lang.ref.WeakReference;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+public class SpongeCommand extends CommandManager implements CommandCallable {
+    public SpongeCommand(LuckPermsPlugin plugin) {
+        super(plugin);
+    }
+
+    @Override
+    public CommandResult process(CommandSource source, String s) throws CommandException {
+        onCommand(makeSender(source), "perms", Arrays.asList(Patterns.SPACE_SPLIT.split(s)));
+        return CommandResult.success();
+    }
+
+    @Override
+    public List<String> getSuggestions(CommandSource source, String s) throws CommandException {
+        return onTabComplete(makeSender(source), Arrays.asList(Patterns.SPACE_SPLIT.split(s)));
+    }
+
+    @Override
+    public boolean testPermission(CommandSource commandSource) {
+        return true;
+    }
+
+    @Override
+    public Optional<? extends Text> getShortDescription(CommandSource commandSource) {
+        return Optional.of(Text.of("LuckPerms main command."));
+    }
+
+    @Override
+    public Optional<? extends Text> getHelp(CommandSource commandSource) {
+        return Optional.of(Text.of("Type /perms for help."));
+    }
+
+    @Override
+    public Text getUsage(CommandSource commandSource) {
+        return Text.of("/perms");
+    }
+
+    private static Sender makeSender(CommandSource source) {
+        return new Sender() {
+            final WeakReference<CommandSource> cs = new WeakReference<>(source);
+
+            @SuppressWarnings("deprecation")
+            @Override
+            public void sendMessage(String s) {
+                final CommandSource c = cs.get();
+                if (c != null) {
+                    c.sendMessage(TextSerializers.LEGACY_FORMATTING_CODE.deserialize(s));
+                }
+            }
+
+            @Override
+            public boolean hasPermission(String node) {
+                final CommandSource c = cs.get();
+                return c != null && c.hasPermission(node);
+            }
+        };
+    }
+}

sponge/src/main/java/me/lucko/luckperms/SpongeConfig.java

@@ -0,0 +1,79 @@
+package me.lucko.luckperms;
+
+import me.lucko.luckperms.utils.LPConfiguration;
+import ninja.leaping.configurate.ConfigurationNode;
+import ninja.leaping.configurate.commented.CommentedConfigurationNode;
+import ninja.leaping.configurate.hocon.HoconConfigurationLoader;
+import ninja.leaping.configurate.loader.ConfigurationLoader;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+class SpongeConfig extends LPConfiguration<LPSpongePlugin> {
+    private ConfigurationNode root;
+
+    SpongeConfig(LPSpongePlugin plugin) {
+        super(plugin, "global", true, "sqlite");
+    }
+
+    @SuppressWarnings("ResultOfMethodCallIgnored")
+    private Path makeFile(Path file) throws IOException {
+        File cfg = file.toFile();
+        cfg.getParentFile().mkdirs();
+
+        if (!cfg.exists()) {
+            try (InputStream is = getPlugin().getClass().getClassLoader().getResourceAsStream("luckperms.conf")) {
+                Files.copy(is, cfg.toPath());
+            }
+        }
+
+        return cfg.toPath();
+    }
+
+    @Override
+    protected void init() {
+        try {
+            ConfigurationLoader<CommentedConfigurationNode> loader = HoconConfigurationLoader.builder()
+                    .setPath(makeFile(getPlugin().getConfigDir().resolve("luckperms.conf")))
+                    .build();
+
+            root = loader.load();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private ConfigurationNode getNode(String path) {
+        String[] paths = path.split("\\.");
+        ConfigurationNode node = root;
+
+        for (String s : paths) {
+            node = node.getNode(s);
+        }
+
+        return node;
+    }
+
+    @Override
+    protected void set(String path, Object value) {
+        getNode(path).setValue(value);
+    }
+
+    @Override
+    protected String getString(String path, String def) {
+        return getNode(path).getString(def);
+    }
+
+    @Override
+    protected int getInt(String path, int def) {
+        return getNode(path).getInt(def);
+    }
+
+    @Override
+    protected boolean getBoolean(String path, boolean def) {
+        return getNode(path).getBoolean(def);
+    }
+}