Merge pull request #2667 from Multiverse/content-display-improvements

A few tweaks to ContentDisplay and friends.

src/main/java/com/onarandombox/MultiverseCore/commands/CreateCommand.java

@@ -8,12 +8,7 @@
 package com.onarandombox.MultiverseCore.commands;
 
 import com.onarandombox.MultiverseCore.MultiverseCore;
-import com.onarandombox.MultiverseCore.api.Core;
 import com.onarandombox.MultiverseCore.api.MVWorldManager;
-import com.onarandombox.MultiverseCore.commandtools.flag.CoreFlags;
-import com.onarandombox.MultiverseCore.commandtools.flag.FlagGroup;
-import com.onarandombox.MultiverseCore.commandtools.flag.FlagParseFailedException;
-import com.onarandombox.MultiverseCore.commandtools.flag.FlagResult;
 import com.pneumaticraft.commandhandler.CommandHandler;
 import org.bukkit.ChatColor;
 import org.bukkit.World.Environment;
@@ -31,16 +26,7 @@ import java.util.List;
  * Creates a new world and loads it.
  */
 public class CreateCommand extends MultiverseCommand {
-
-    private static final FlagGroup FLAG_GROUP = FlagGroup.of(
-            CoreFlags.SEED,
-            CoreFlags.WORLD_TYPE,
-            CoreFlags.GENERATOR,
-            CoreFlags.GENERATE_STRUCTURES,
-            CoreFlags.SPAWN_ADJUST
-    );
-
-    private final MVWorldManager worldManager;
+    private MVWorldManager worldManager;
 
     public CreateCommand(MultiverseCore plugin) {
         super(plugin);
@@ -64,7 +50,22 @@ public class CreateCommand extends MultiverseCommand {
     @Override
     public void runCommand(CommandSender sender, List<String> args) {
         String worldName = args.get(0);
+        File worldFile = new File(this.plugin.getServer().getWorldContainer(), worldName);
         String env = args.get(1);
+        String seed = CommandHandler.getFlag("-s", args);
+        String generator = CommandHandler.getFlag("-g", args);
+        boolean allowStructures = true;
+        String structureString = CommandHandler.getFlag("-a", args);
+        if (structureString != null) {
+            allowStructures = Boolean.parseBoolean(structureString);
+        }
+        String typeString = CommandHandler.getFlag("-t", args);
+        boolean useSpawnAdjust = true;
+        for (String s : args) {
+            if (s.equalsIgnoreCase("-n")) {
+                useSpawnAdjust = false;
+            }
+        }
 
         if (this.worldManager.isMVWorld(worldName)) {
             sender.sendMessage(ChatColor.RED + "Multiverse cannot create " + ChatColor.GOLD + ChatColor.UNDERLINE
@@ -72,7 +73,6 @@ public class CreateCommand extends MultiverseCommand {
             return;
         }
 
-        File worldFile = new File(this.plugin.getServer().getWorldContainer(), worldName);
         if (worldFile.exists()) {
             sender.sendMessage(ChatColor.RED + "A Folder/World already exists with this name!");
             sender.sendMessage(ChatColor.RED + "If you are confident it is a world you can import with /mvimport");
@@ -86,28 +86,35 @@ public class CreateCommand extends MultiverseCommand {
             return;
         }
 
-        FlagResult flags;
-        try {
-            flags = FLAG_GROUP.calculateResult(args.subList(2, args.size()).toArray(new String[0]));
-        } catch (FlagParseFailedException e) {
-            sender.sendMessage(String.format("%sError: %s", ChatColor.RED, e.getMessage()));
+        // If they didn't specify a type, default to NORMAL
+        if (typeString == null) {
+            typeString = "NORMAL";
+        }
+        WorldType type = EnvironmentCommand.getWorldTypeFromString(typeString);
+        if (type == null) {
+            sender.sendMessage(ChatColor.RED + "That is not a valid World Type.");
+            EnvironmentCommand.showWorldTypes(sender);
             return;
         }
-
+        // Determine if the generator is valid. #918
+        if (generator != null) {
+            List<String> genarray = new ArrayList<String>(Arrays.asList(generator.split(":")));
+            if (genarray.size() < 2) {
+                // If there was only one arg specified, pad with another empty one.
+                genarray.add("");
+            }
+            if (this.worldManager.getChunkGenerator(genarray.get(0), genarray.get(1), "test") == null) {
+                // We have an invalid generator.
+                sender.sendMessage("Invalid generator! '" + generator + "'. " + ChatColor.RED + "Aborting world creation.");
+                return;
+            }
+        }
         Command.broadcastCommandMessage(sender, "Starting creation of world '" + worldName + "'...");
 
-        if (this.worldManager.addWorld(
-                worldName,
-                environment,
-                flags.getValue(CoreFlags.SEED),
-                flags.getValue(CoreFlags.WORLD_TYPE),
-                flags.getValue(CoreFlags.GENERATE_STRUCTURES),
-                flags.getValue(CoreFlags.GENERATOR),
-                flags.getValue(CoreFlags.SPAWN_ADJUST))) {
-
+        if (this.worldManager.addWorld(worldName, environment, seed, type, allowStructures, generator, useSpawnAdjust)) {
             Command.broadcastCommandMessage(sender, "Complete!");
-            return;
+        } else {
+            Command.broadcastCommandMessage(sender, "FAILED.");
         }
-        Command.broadcastCommandMessage(sender, "FAILED.");
     }
 }

src/main/java/com/onarandombox/MultiverseCore/commands/GamerulesCommand.java

@@ -8,6 +8,9 @@
 package com.onarandombox.MultiverseCore.commands;
 
 import com.onarandombox.MultiverseCore.MultiverseCore;
+import com.onarandombox.MultiverseCore.display.ColorAlternator;
+import com.onarandombox.MultiverseCore.display.ContentDisplay;
+import com.onarandombox.MultiverseCore.display.settings.MapDisplaySettings;
 import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
 import org.bukkit.GameRule;
@@ -16,7 +19,9 @@ import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 import org.bukkit.permissions.PermissionDefault;
 
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 /**
  * Allows management of Anchor Destinations.
@@ -68,15 +73,23 @@ public class GamerulesCommand extends MultiverseCommand {
             }
         }
 
-        final StringBuilder gameRules = new StringBuilder();
-        for (final String gameRule : world.getGameRules()) {
-            if (gameRules.length() != 0) {
-                gameRules.append(ChatColor.WHITE).append(", ");
+        ContentDisplay.forContent(getGameRuleMap(world))
+                .header("=== Gamerules for %s%s%s ===", ChatColor.AQUA, world.getName(), ChatColor.WHITE)
+                .colorTool(ColorAlternator.with(ChatColor.GREEN, ChatColor.GOLD))
+                .setting(MapDisplaySettings.OPERATOR, ": ")
+                .show(sender);
+    }
+
+    private Map<String, Object> getGameRuleMap(World world) {
+        Map<String, Object> gameRuleMap = new HashMap<>();
+        for (GameRule<?> rule : GameRule.values()) {
+            Object value = world.getGameRuleValue(rule);
+            if (value == null) {
+                gameRuleMap.put(rule.getName(), "null");
+                continue;
             }
-            gameRules.append(ChatColor.AQUA).append(gameRule).append(ChatColor.WHITE).append(": ");
-            gameRules.append(ChatColor.GREEN).append(world.getGameRuleValue(GameRule.getByName(gameRule)));
+            gameRuleMap.put(rule.getName(), value);
         }
-        sender.sendMessage("=== Gamerules for " + ChatColor.AQUA + world.getName() + ChatColor.WHITE + " ===");
-        sender.sendMessage(gameRules.toString());
+        return gameRuleMap;
     }
 }

src/main/java/com/onarandombox/MultiverseCore/commands/ListCommand.java

@@ -9,122 +9,111 @@ package com.onarandombox.MultiverseCore.commands;
 
 import com.onarandombox.MultiverseCore.MultiverseCore;
 import com.onarandombox.MultiverseCore.api.MultiverseWorld;
+import com.onarandombox.MultiverseCore.display.ColorAlternator;
+import com.onarandombox.MultiverseCore.display.ContentDisplay;
+import com.onarandombox.MultiverseCore.display.ContentFilter;
+import com.onarandombox.MultiverseCore.display.DisplayHandlers;
+import com.onarandombox.MultiverseCore.display.settings.PagedDisplaySettings;
 import org.bukkit.ChatColor;
-import org.bukkit.World.Environment;
+import org.bukkit.World;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 import org.bukkit.permissions.PermissionDefault;
+import org.jetbrains.annotations.NotNull;
 
-import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
+import java.util.stream.Collectors;
 
 /**
  * Displays a listing of all worlds that a player can enter.
  */
-public class ListCommand extends PaginatedCoreCommand<String> {
+public class ListCommand extends MultiverseCommand {
 
     public ListCommand(MultiverseCore plugin) {
         super(plugin);
         this.setName("World Listing");
-        this.setCommandUsage("/mv list [page]");
+        this.setCommandUsage("/mv list [filter] [page]");
         this.setArgRange(0, 2);
         this.addKey("mvlist");
         this.addKey("mvl");
         this.addKey("mv list");
         this.setPermission("multiverse.core.list.worlds", "Displays a listing of all worlds that you can enter.", PermissionDefault.OP);
-        this.setItemsPerPage(8); // SUPPRESS CHECKSTYLE: MagicNumberCheck
-    }
-
-    private List<String> getFancyWorldList(Player p) {
-        List<String> worldList = new ArrayList<String>();
-        for (MultiverseWorld world : this.plugin.getMVWorldManager().getMVWorlds()) {
-
-            if (p != null && (!this.plugin.getMVPerms().canEnterWorld(p, world))) {
-                continue;
-            }
-
-            ChatColor color = ChatColor.GOLD;
-            Environment env = world.getEnvironment();
-            if (env == Environment.NETHER) {
-                color = ChatColor.RED;
-            } else if (env == Environment.NORMAL) {
-                color = ChatColor.GREEN;
-            } else if (env == Environment.THE_END) {
-                color = ChatColor.AQUA;
-            }
-            StringBuilder builder = new StringBuilder();
-            builder.append(world.getColoredWorldString()).append(ChatColor.WHITE);
-            builder.append(" - ").append(color).append(world.getEnvironment());
-            if (world.isHidden()) {
-                if (p == null || this.plugin.getMVPerms().hasPermission(p, "multiverse.core.modify", true)) {
-                    // Prefix hidden worlds with an "[H]"
-                    worldList.add(ChatColor.GRAY + "[H]" + builder.toString());
-                }
-            } else {
-                worldList.add(builder.toString());
-            }
-        }
-        for (String name : this.plugin.getMVWorldManager().getUnloadedWorlds()) {
-            if (p == null || this.plugin.getMVPerms().hasPermission(p, "multiverse.access." + name, true)) {
-                worldList.add(ChatColor.GRAY + name + " - UNLOADED");
-            }
-        }
-        return worldList;
-    }
-
-    @Override
-    protected List<String> getFilteredItems(List<String> availableItems, String filter) {
-        List<String> filtered = new ArrayList<String>();
-
-        for (String s : availableItems) {
-            if (s.matches("(?i).*" + filter + ".*")) {
-                filtered.add(s);
-            }
-        }
-        return filtered;
-    }
-
-    @Override
-    protected String getItemText(String item) {
-        return item;
     }
 
     @Override
     public void runCommand(CommandSender sender, List<String> args) {
-        sender.sendMessage(ChatColor.LIGHT_PURPLE + "====[ Multiverse World List ]====");
-        Player p = null;
-        if (sender instanceof Player) {
-            p = (Player) sender;
-        }
+        ContentFilter filter = ContentFilter.DEFAULT;
+        int page = 1;
 
-
-        FilterObject filterObject = this.getPageAndFilter(args);
-
-        List<String> availableWorlds = new ArrayList<String>(this.getFancyWorldList(p));
-        if (filterObject.getFilter().length() > 0) {
-            availableWorlds = this.getFilteredItems(availableWorlds, filterObject.getFilter());
-            if (availableWorlds.size() == 0) {
-                sender.sendMessage(ChatColor.RED + "Sorry... " + ChatColor.WHITE
-                        + "No worlds matched your filter: " + ChatColor.AQUA + filterObject.getFilter());
-                return;
+        // Either page or filter.
+        if (args.size() == 1) {
+            try {
+                page = Integer.parseInt(args.get(0));
+            } catch (NumberFormatException ignore) {
+                filter = new ContentFilter(args.get(0));
             }
         }
 
-        if (!(sender instanceof Player)) {
-            for (String c : availableWorlds) {
-                sender.sendMessage(c);
+        // Filter then page.
+        if (args.size() == 2) {
+            filter = new ContentFilter(args.get(0));
+            try {
+                page = Integer.parseInt(args.get(1));
+            } catch (NumberFormatException ignore) {
+                sender.sendMessage(ChatColor.RED + args.get(1) + " is not valid number!");
             }
-            return;
         }
 
-        int totalPages = (int) Math.ceil(availableWorlds.size() / (this.itemsPerPage + 0.0));
+        ContentDisplay.forContent(getListContents(sender))
+                .header("%s====[ Multiverse World List ]====", ChatColor.GOLD)
+                .displayHandler(DisplayHandlers.PAGE_LIST)
+                .colorTool(ColorAlternator.with(ChatColor.AQUA, ChatColor.GOLD))
+                .filter(filter)
+                .setting(PagedDisplaySettings.SHOW_PAGE, page)
+                .show(sender);
+    }
 
-        if (filterObject.getPage() > totalPages) {
-            filterObject.setPage(totalPages);
+    private Collection<String> getListContents(@NotNull CommandSender sender) {
+        Player player = (sender instanceof Player) ? (Player) sender : null;
+
+        List<String> worldList = this.plugin.getMVWorldManager().getMVWorlds().stream()
+                .filter(world -> player == null || plugin.getMVPerms().canEnterWorld(player, world))
+                .filter(world -> canSeeWorld(player, world))
+                .map(world -> hiddenText(world) + world.getColoredWorldString() + " - " + parseColouredEnvironment(world.getEnvironment()))
+                .collect(Collectors.toList());
+
+        this.plugin.getMVWorldManager().getUnloadedWorlds().stream()
+                .filter(world -> plugin.getMVPerms().hasPermission(sender, "multiverse.access." + world, true))
+                .map(world -> ChatColor.GRAY + world + " - UNLOADED")
+                .forEach(worldList::add);
+        
+        return worldList;
+    }
+
+    private boolean canSeeWorld(Player player, MultiverseWorld world) {
+        return !world.isHidden()
+                || player == null
+                || this.plugin.getMVPerms().hasPermission(player, "multiverse.core.modify", true);
+    }
+
+    private String hiddenText(MultiverseWorld world) {
+        return (world.isHidden()) ? String.format("%s[H] ", ChatColor.GRAY) : "";
+    }
+
+    private String parseColouredEnvironment(World.Environment env) {
+        ChatColor color = ChatColor.GOLD;
+        switch (env) {
+            case NETHER:
+                color = ChatColor.RED;
+                break;
+            case NORMAL:
+                color = ChatColor.GREEN;
+                break;
+            case THE_END:
+                color = ChatColor.AQUA;
+                break;
         }
-
-        sender.sendMessage(ChatColor.AQUA + " Page " + filterObject.getPage() + " of " + totalPages);
-
-        this.showPage(filterObject.getPage(), sender, availableWorlds);
+        return color + env.toString();
     }
 }

src/main/java/com/onarandombox/MultiverseCore/commandtools/flag/CommandFlag.java

@@ -1,136 +0,0 @@
-package com.onarandombox.MultiverseCore.commandtools.flag;
-
-import org.jetbrains.annotations.NotNull;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-
-/**
- * <p>Represents a flag that can be used in commands. This works as a key value pair.</p>
- *
- * <p>Key is the {@link #identifier} and {@link #aliases} set.</p>
- * <p>Value is the {@link T} parsed based on 3 scenarios during command input:</p>
- * <ol>
- *     <li>Flag completely not present. {@link #getDefaultValue()}</li>
- *     <li>Flag key present but no value. {@link #getValue()}</li>
- *     <li>Flag key and value present. {@link #getValue(String)}</li>
- * </ol>
- *
- * @param <T>   The flag Type.
- */
-public abstract class CommandFlag<T> {
-
-    protected final String name;
-    protected final String identifier;
-    protected final Class<T> type;
-    protected final Collection<String> aliases;
-
-    /**
-     * @param name          Readable name for the flag.
-     * @param identifier    Unique key to identify the flag in command arguments.
-     * @param type          The type of value this flag represents.
-     */
-    protected CommandFlag(@NotNull String name,
-                          @NotNull String identifier,
-                          @NotNull Class<T> type) {
-
-        this.name = name;
-        this.identifier = identifier;
-        this.type = type;
-        this.aliases = new ArrayList<>();
-    }
-
-    /**
-     * Gets name of the Command Flag.
-     *
-     * @return The Command Flag name.
-     */
-    @NotNull
-    public String getName() {
-        return this.name;
-    }
-
-    /**
-     * Gets identifier of the Command Flag.
-     *
-     * @return The Command Flag identifier.
-     */
-    @NotNull
-    public String getIdentifier() {
-        return this.identifier;
-    }
-
-    /**
-     * Gets {@link T} Type of the Command Flag.
-     *
-     * @return The Command Flag type.
-     */
-    @NotNull
-    public Class<T> getType() {
-        return this.type;
-    }
-
-    /**
-     * Gets all the alternative key identifiers set for this Command Flag.
-     *
-     * @return Collection of aliases.
-     */
-    @NotNull
-    public Collection<String> getAliases() {
-        return this.aliases;
-    }
-
-    /**
-     * Add alternative key identifiers for this Command Flag.
-     *
-     * @param aliases   Alias(es) to be added.
-     * @return A {@link CommandFlag}.
-     */
-    public CommandFlag<T> addAliases(String...aliases) {
-        Collections.addAll(this.aliases, aliases);
-        return this;
-    }
-
-    /**
-     * Tab-complete suggestion for this Command Flag values.
-     *
-     * @return Collection of suggested values available.
-     */
-    public abstract Collection<String> suggestValue();
-
-    /**
-     * When this Command Flag can get value by a user input.
-     *
-     * @return The {@link T} value.
-     */
-    public abstract T getValue(@NotNull String input) throws FlagParseFailedException;
-
-    /**
-     * When this Command Flag user input value is null/not present.
-     *
-     * @return The {@link T} value.
-     */
-    public T getValue() throws FlagParseFailedException {
-        return null;
-    }
-
-    /**
-     * When this Command Flag is not present in command input.
-     *
-     * @return The {@link T} value.
-     */
-    public T getDefaultValue() {
-        return null;
-    }
-
-    @Override
-    public String toString() {
-        return "CommandFlag{" +
-                "name='" + name + '\'' +
-                ", identifier='" + identifier + '\'' +
-                ", type=" + type +
-                ", aliases=" + aliases +
-                '}';
-    }
-}

src/main/java/com/onarandombox/MultiverseCore/commandtools/flag/CoreFlags.java

@@ -1,217 +0,0 @@
-package com.onarandombox.MultiverseCore.commandtools.flag;
-
-import com.onarandombox.MultiverseCore.MultiverseCore;
-import com.onarandombox.MultiverseCore.utils.webpaste.PasteServiceType;
-import org.bukkit.Bukkit;
-import org.bukkit.WorldType;
-import org.bukkit.plugin.Plugin;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Random;
-import java.util.stream.Collectors;
-
-public class CoreFlags {
-
-    private static MultiverseCore multiverse;
-
-    public static void setCoreInstance(MultiverseCore plugin) {
-        multiverse = plugin;
-    }
-
-    /**
-     * Flag for custom seed.
-     */
-    public static final CommandFlag<String> SEED = new RequiredCommandFlag<String>
-            ("Seed", "--seed", String.class) {
-        @Override
-        public Collection<String> suggestValue() {
-            return Collections.singleton(String.valueOf(new Random().nextLong()));
-        }
-
-        @Override
-        public String getValue(@NotNull String input) throws FlagParseFailedException {
-            return input;
-        }
-    }.addAliases("-s");
-
-    /**
-     * Flag for custom seed. No value means random seed.
-     */
-    public static final CommandFlag<String> RANDOM_SEED = new OptionalCommandFlag<String>
-            ("Seed", "--seed", String.class) {
-        @Override
-        public Collection<String> suggestValue() {
-            return Collections.singletonList(String.valueOf(new Random().nextLong()));
-        }
-
-        @Override
-        public String getValue(@NotNull String input) throws FlagParseFailedException {
-            return input;
-        }
-    }.addAliases("-s");
-
-    /**
-     * Flag for world type used.
-     */
-    public static final CommandFlag<WorldType> WORLD_TYPE = new RequiredCommandFlag<WorldType>
-            ("WorldType", "--type", WorldType.class) {
-
-        private final Map<String, String> typeAlias = new HashMap<String, String>(4){{
-            put("normal", "NORMAL");
-            put("flat", "FLAT");
-            put("largebiomes", "LARGE_BIOMES");
-            put("amplified", "AMPLIFIED");
-        }};
-
-        @Override
-        public Collection<String> suggestValue() {
-            return typeAlias.keySet();
-        }
-
-        @Override
-        public WorldType getValue(@NotNull String input) throws FlagParseFailedException {
-            String typeName = typeAlias.getOrDefault(input, input);
-            try {
-                return WorldType.valueOf(input.toUpperCase());
-            }
-            catch (IllegalArgumentException e) {
-                throw new FlagParseFailedException("'%s' is not a valid World Type. See /mv env for available World Types.", input);
-            }
-        }
-
-        @Override
-        public WorldType getDefaultValue() {
-            return WorldType.NORMAL;
-        }
-    }.addAliases("-t");
-
-    /**
-     * Flag for world generator.
-     */
-    public static final CommandFlag<String> GENERATOR = new RequiredCommandFlag<String>
-            ("Generator", "--gen", String.class) {
-        @Override
-        public Collection<String> suggestValue() {
-            return Arrays.stream(Bukkit.getServer().getPluginManager().getPlugins())
-                    .filter(Plugin::isEnabled)
-                    .filter(plugin -> multiverse.getUnsafeCallWrapper().wrap(
-                            () -> plugin.getDefaultWorldGenerator("world", ""),
-                            plugin.getName(),
-                            "Get generator"
-                    ) != null)
-                    .map(plugin -> plugin.getDescription().getName())
-                    .collect(Collectors.toList());
-        }
-
-        @Override
-        public String getValue(@NotNull String input) throws FlagParseFailedException {
-            String[] genArray = input.split(":");
-            String generator = genArray[0];
-            String generatorId = (genArray.length > 1) ? genArray[1] : "";
-            try {
-                if (multiverse.getMVWorldManager().getChunkGenerator(generator, generatorId, "test") == null) {
-                    throw new Exception();
-                }
-            } catch (Exception e) {
-                throw new FlagParseFailedException("Invalid generator string '%s'. See /mv gens for available generators.", input);
-            }
-            return input;
-        }
-    }.addAliases("-g");
-
-    /**
-     * Flag to toggle if world should generate structures.
-     */
-    public static final CommandFlag<Boolean> GENERATE_STRUCTURES = new RequiredCommandFlag<Boolean>
-            ("GenerateStructures", "--structures", Boolean.class) {
-        @Override
-        public Collection<String> suggestValue() {
-            return Arrays.asList("true", "false");
-        }
-
-        @Override
-        public Boolean getValue(@NotNull String input) throws FlagParseFailedException {
-            return input.equalsIgnoreCase("true");
-        }
-
-        @Override
-        public Boolean getDefaultValue() {
-            return true;
-        }
-    }.addAliases("--structure", "-a");
-
-    /**
-     * Flag to toggle if world spawn should be adjusted.
-     */
-    public static final CommandFlag<Boolean> SPAWN_ADJUST = new NoValueCommandFlag<Boolean>
-            ("AdjustSpawn", "--dont-adjust-spawn", Boolean.class) {
-        @Override
-        public Boolean getValue() throws FlagParseFailedException {
-            return false;
-        }
-
-        @Override
-        public Boolean getDefaultValue() {
-            return true;
-        }
-    }.addAliases("-n");
-
-    /**
-     * Flag to specify a paste service.
-     */
-    public static final CommandFlag<PasteServiceType> PASTE_SERVICE_TYPE = new OptionalCommandFlag<PasteServiceType>
-            ("PasteServiceType", "--paste", PasteServiceType.class) {
-
-        private final List<String> pasteTypes = Arrays.stream(PasteServiceType.values())
-                .filter(pt -> pt != PasteServiceType.NONE)
-                .map(p -> p.toString().toLowerCase())
-                .collect(Collectors.toList());
-
-        @Override
-        public Collection<String> suggestValue() {
-            return pasteTypes;
-        }
-
-        @Override
-        public PasteServiceType getValue(@NotNull String input) throws FlagParseFailedException {
-            try {
-                return PasteServiceType.valueOf(input.toUpperCase());
-            }
-            catch (IllegalArgumentException e) {
-                throw new FlagParseFailedException(String.format("Invalid paste service type '%s'.", input));
-            }
-        }
-
-        @Override
-        public PasteServiceType getValue() throws FlagParseFailedException {
-            return PasteServiceType.PASTEGG;
-        }
-
-        @Override
-        public PasteServiceType getDefaultValue() {
-            return PasteServiceType.NONE;
-        }
-    }.addAliases("-p");
-
-    /**
-     * Flag to toggle if plugin list should be included.
-     */
-    public static final CommandFlag<Boolean> INCLUDE_PLUGIN_LIST = new NoValueCommandFlag<Boolean>
-            ("IncludePlugins", "--include-plugin-list", Boolean.class) {
-        @Override
-        public Boolean getValue() throws FlagParseFailedException {
-            return true;
-        }
-
-        @Override
-        public Boolean getDefaultValue() {
-            return true;
-        }
-    }.addAliases("-pl");
-}

src/main/java/com/onarandombox/MultiverseCore/commandtools/flag/FlagGroup.java

@@ -1,96 +0,0 @@
-package com.onarandombox.MultiverseCore.commandtools.flag;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * A group of {@link CommandFlag}, with indexed keys for efficient lookup.
- */
-public class FlagGroup {
-
-    /**
-     * Create a new Flag Group with multiple {@link CommandFlag}.
-     *
-     * @param flags Multiple flags.
-     * @return A new {@link FlagGroup} generated from the flags.
-     */
-    public static FlagGroup of(CommandFlag<?>...flags) {
-        return new FlagGroup(flags);
-    }
-
-    private final List<String> identifiers;
-    private final Map<String, CommandFlag<?>> keyMap;
-
-    /**
-     * Create a new Flag Group with multiple {@link CommandFlag}.
-     *
-     * @param commandFlags Array of flags
-     */
-    public FlagGroup(CommandFlag<?>[] commandFlags) {
-        this.identifiers = new ArrayList<>(commandFlags.length);
-        this.keyMap = new HashMap<>();
-        for (CommandFlag<?> flag : commandFlags) {
-            addFlag(flag);
-        }
-    }
-
-    /**
-     * Add and indexes a flag.
-     *
-     * @param flag  The flag to add.
-     */
-    private void addFlag(CommandFlag<?> flag) {
-        this.identifiers.add(flag.getIdentifier());
-        this.keyMap.put(flag.getIdentifier(), flag);
-        for (String flagAlias : flag.getAliases()) {
-            this.keyMap.put(flagAlias, flag);
-        }
-    }
-
-    /**
-     * Parse the arguments to get it's flag values.
-     *
-     * @param args  The arguments to parse.
-     * @return A {@link FlagResult} containing value results.
-     * @throws FlagParseFailedException When there is an error parsing, such as invalid format.
-     */
-    @NotNull
-    public FlagResult calculateResult(String[] args) throws FlagParseFailedException {
-        return FlagResult.parse(args,this);
-    }
-
-    /**
-     * Gets flag from pre-indexed key mapping.
-     *
-     * @param key   The target key.
-     * @return A {@link CommandFlag} if found, else null.
-     */
-    @Nullable
-    public CommandFlag<?> getByKey(String key) {
-        return this.keyMap.get(key);
-    }
-
-    /**
-     * Suggest possible identifiers available for this Flag Group.
-     *
-     * @return A collection of identifier strings.
-     */
-    @NotNull
-    public Collection<String> suggestIdentifiers() {
-        return identifiers;
-    }
-
-    @Override
-    public String toString() {
-        return "FlagGroup{" +
-                "flagIdentifiers=" + identifiers +
-                ", keyFlagMap=" + keyMap +
-                '}';
-    }
-}

src/main/java/com/onarandombox/MultiverseCore/commandtools/flag/FlagParseFailedException.java

@@ -1,27 +0,0 @@
-package com.onarandombox.MultiverseCore.commandtools.flag;
-
-/**
- * Thrown when there is an issue with parsing flags from string arguments.
- */
-//TODO: extend this from ACF CommandArgumentFailed exception class.
-public class FlagParseFailedException extends Exception {
-
-    public FlagParseFailedException() {
-    }
-
-    public FlagParseFailedException(String message, Object...replacements) {
-        super(String.format(message, replacements));
-    }
-
-    public FlagParseFailedException(String message, Throwable cause) {
-        super(message, cause);
-    }
-
-    public FlagParseFailedException(Throwable cause) {
-        super(cause);
-    }
-
-    public FlagParseFailedException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
-        super(message, cause, enableSuppression, writableStackTrace);
-    }
-}

src/main/java/com/onarandombox/MultiverseCore/commandtools/flag/FlagResult.java

@@ -1,198 +0,0 @@
-package com.onarandombox.MultiverseCore.commandtools.flag;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * Represents the value result parsed from command arguments.
- */
-public class FlagResult {
-
-    /**
-     * Parse arguments into its flag key and values.
-     *
-     * @param args      The arguments to parse.
-     * @param flagGroup The flags available to parse into.
-     * @return The {@link FlagResult} from the parse.
-     * @throws FlagParseFailedException there is an issue with parsing flags from string arguments.
-     */
-    public static FlagResult parse(@Nullable String[] args,
-                                   @NotNull FlagGroup flagGroup) throws FlagParseFailedException {
-
-        FlagResult flagResult = new FlagResult();
-
-        // No args to parse.
-        if (args == null || args.length <= 0) {
-            return flagResult;
-        }
-
-        // First arg must be a flag.
-        CommandFlag<?> currentFlag = flagGroup.getByKey(args[0]);
-        boolean completed = false;
-
-        // Parse the arguments.
-        for (int i = 1, argsLength = args.length; i <= argsLength; i++) {
-            if (currentFlag == null) {
-                throw new FlagParseFailedException("%s is not a valid flag.", args[i-1]);
-            }
-            // This ensures that flag is not null during final parse.
-            if (i >= argsLength) {
-                break;
-            }
-
-            String arg = args[i];
-            if (arg == null) {
-                throw new FlagParseFailedException("Arguments cannot be null!");
-            }
-
-            CommandFlag<?> nextFlag = flagGroup.getByKey(arg);
-
-            // Arg must be a flag key.
-            if (currentFlag instanceof NoValueCommandFlag) {
-                flagResult.add(currentFlag, currentFlag.getValue(), false);
-                currentFlag = nextFlag;
-                continue;
-            }
-
-            // Arg can be a flag key or value.
-            if (currentFlag instanceof OptionalCommandFlag) {
-                if (nextFlag != null) {
-                    // It's a key.
-                    flagResult.add(currentFlag, currentFlag.getValue(), false);
-                    currentFlag = nextFlag;
-                    continue;
-                }
-                // It's a value.
-                flagResult.add(currentFlag, currentFlag.getValue(arg), true);
-                if (i == argsLength - 1) {
-                    completed = true;
-                    break;
-                }
-                currentFlag = flagGroup.getByKey(args[++i]);
-                continue;
-            }
-
-            // Arg must be a flag value.
-            if (currentFlag instanceof RequiredCommandFlag) {
-                if (nextFlag != null) {
-                    // It's a key, error!
-                    throw new FlagParseFailedException("%s flag '%s' requires a value input.",
-                            currentFlag.getName(), currentFlag.getIdentifier());
-                }
-                // It's a value.
-                flagResult.add(currentFlag, currentFlag.getValue(arg), true);
-                if (i == argsLength - 1) {
-                    completed = true;
-                    break;
-                }
-                currentFlag = flagGroup.getByKey(args[++i]);
-            }
-        }
-
-        // Parse last flag.
-        if (!completed) {
-            if (currentFlag instanceof RequiredCommandFlag) {
-                throw new FlagParseFailedException("%s flag '%s' requires a value input.",
-                        currentFlag.getName(), currentFlag.getIdentifier());
-            }
-            flagResult.add(currentFlag, currentFlag.getValue(), false);
-        }
-
-        return flagResult;
-    }
-
-    private final Map<CommandFlag<?>, SingleFlagResult<?>> resultMap;
-
-    private FlagResult() {
-        resultMap = new HashMap<>();
-    }
-
-    /**
-     * Add a new value result from parsing arguments.
-     *
-     * @param flag      The flag that the value represents.
-     * @param value     The value of the flag.
-     * @param fromInput Denotes if flag was parsed by a user input.
-     */
-    private void add(CommandFlag<?> flag, Object value, boolean fromInput) {
-        resultMap.put(flag, new SingleFlagResult<>(value, fromInput));
-    }
-
-    /**
-     * Gets value of a flag.
-     *
-     * @param flag  The flag to get value from.
-     * @param <T>   The type of value.
-     * @return The value which is associated with the flag.
-     */
-    public <T> T getValue(CommandFlag<T> flag) {
-        SingleFlagResult<?> result = resultMap.get(flag);
-        if (result == null) {
-            return flag.getDefaultValue();
-        }
-        return (T) result.value;
-    }
-
-    /**
-     * Gets if the flag value is by a user input.
-     *
-     * @param flag  The flag to check against.
-     * @return True if value is by user input, else false.
-     */
-    public boolean isByUserInput(CommandFlag<?> flag) {
-        SingleFlagResult<?> result = resultMap.get(flag);
-        if (result == null) {
-            return false;
-        }
-        return result.isFromUserInput;
-    }
-
-    /**
-     * Gets if the flag is a default value, and key was not present in user's command arguments.
-     * i.e. Not in the {@link #resultMap}.
-     *
-     * @param flag  The flag to check against.
-     * @return True if flag was not present in user's command arguments, else false.
-     */
-    public boolean isDefaulted(CommandFlag<?> flag) {
-        return resultMap.get(flag) != null;
-    }
-
-    @Override
-    public String toString() {
-        return "FlagResult{" +
-                "resultMap=" + resultMap +
-                '}';
-    }
-
-    /**
-     * Represents a single value result parsed.
-     * Stores value and addition data such as if value is by user input.
-     *
-     * @param <T>   The type of value.
-     */
-    private static class SingleFlagResult<T> {
-        private final T value;
-        private final boolean isFromUserInput;
-
-        /**
-         * @param value     The resultant value from argument parsing.
-         * @param fromInput Indicates if value is parsed by user input.
-         */
-        private SingleFlagResult(T value, boolean fromInput) {
-            this.value = value;
-            this.isFromUserInput = fromInput;
-        }
-
-        @Override
-        public String toString() {
-            return "SingleFlagResult{" +
-                    "value=" + value +
-                    ", isFromUserInput=" + isFromUserInput +
-                    '}';
-        }
-    }
-}

src/main/java/com/onarandombox/MultiverseCore/commandtools/flag/NoValueCommandFlag.java

@@ -1,39 +0,0 @@
-package com.onarandombox.MultiverseCore.commandtools.flag;
-
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Collection;
-import java.util.Collections;
-
-/**
- * This flag will always not require a user input to parse value.
- *
- * @param <T>   The flag Type.
- */
-public abstract class NoValueCommandFlag<T> extends CommandFlag<T> {
-
-    /**
-     * {@inheritDoc}
-     */
-    public NoValueCommandFlag(String name, String identifier, Class<T> type) {
-        super(name, identifier, type);
-    }
-
-    /**
-     * {@link NoValueCommandFlag} will always not require a user input to parse value.
-     * Thus, no value suggestion needed.
-     */
-    @Override
-    public final Collection<String> suggestValue() {
-        return Collections.emptyList();
-    }
-
-    /**
-     * {@link NoValueCommandFlag} will always not require a user input to parse value.
-     * Thus, this operation is not allowed.
-     */
-    @Override
-    public final T getValue(@NotNull String input) throws FlagParseFailedException {
-        throw new FlagParseFailedException("%s flag '%s' does not require a value.", this.name, this.identifier);
-    }
-}

src/main/java/com/onarandombox/MultiverseCore/commandtools/flag/OptionalCommandFlag.java

@@ -1,16 +0,0 @@
-package com.onarandombox.MultiverseCore.commandtools.flag;
-
-/**
- * Command Flag that optionally allows a user input value.
- *
- * @param <T>   The flag Type.
- */
-public abstract class OptionalCommandFlag<T> extends CommandFlag<T> {
-
-    /**
-     * {@inheritDoc}
-     */
-    public OptionalCommandFlag(String name, String identifier, Class<T> type) {
-        super(name, identifier, type);
-    }
-}

src/main/java/com/onarandombox/MultiverseCore/commandtools/flag/RequiredCommandFlag.java

@@ -1,25 +0,0 @@
-package com.onarandombox.MultiverseCore.commandtools.flag;
-
-/**
- * This flag will always require a user input to parse value.
- *
- * @param <T>   The flag Type.
- */
-public abstract class RequiredCommandFlag<T> extends CommandFlag<T> {
-
-    /**
-     * {@inheritDoc}
-     */
-    public RequiredCommandFlag(String name, String identifier, Class<T> type) {
-        super(name, identifier, type);
-    }
-
-    /**
-     * {@link RequiredCommandFlag} will always require a user input to parse value.
-     * Thus, this operation is not allowed.
-     */
-    @Override
-    public final T getValue() throws FlagParseFailedException {
-        throw new FlagParseFailedException("%s flag '%s' requires a value input.", this.name, this.identifier);
-    }
-}

src/main/java/com/onarandombox/MultiverseCore/display/ColorAlternator.java

@@ -0,0 +1,62 @@
+package com.onarandombox.MultiverseCore.display;
+
+import org.bukkit.ChatColor;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Helper class to switch between 2 {@link ChatColor}.
+ */
+public class ColorAlternator implements ColorTool {
+
+    /**
+     * Creates a new {@link ColorAlternator} with 2 {@link ChatColor}s.
+     *
+     * @param colorThis The first color.
+     * @param colorThat The second color.
+     * @return The {@link ColorAlternator} created for you.
+     */
+    public static ColorAlternator with(@NotNull ChatColor colorThis,
+                                       @NotNull ChatColor colorThat) {
+
+        return new ColorAlternator(colorThis, colorThat);
+    }
+
+    private boolean switcher;
+    private final ChatColor thisColor;
+    private final ChatColor thatColor;
+
+    /**
+     * @param colorThis The first color.
+     * @param colorThat The second color.
+     */
+    public ColorAlternator(@NotNull ChatColor colorThis,
+                           @NotNull ChatColor colorThat) {
+
+        this.thisColor = colorThis;
+        this.thatColor = colorThat;
+    }
+
+    /**
+     * Gets the color. Everytime this method is called, it swaps the color that it returns.
+     *
+     * @return The color.
+     */
+    @Override
+    public ChatColor get() {
+        return (this.switcher ^= true) ? this.thisColor : this.thatColor;
+    }
+
+    /**
+     * @return The first color.
+     */
+    public ChatColor getThisColor() {
+        return thisColor;
+    }
+
+    /**
+     * @return The second color.
+     */
+    public ChatColor getThatColor() {
+        return thatColor;
+    }
+}

src/main/java/com/onarandombox/MultiverseCore/display/ColorTool.java

@@ -0,0 +1,22 @@
+package com.onarandombox.MultiverseCore.display;
+
+import org.bukkit.ChatColor;
+
+/**
+ * Tools to allow customisation.
+ */
+@FunctionalInterface
+public interface ColorTool {
+
+    /**
+     * Gets a chat color.
+     *
+     * @return The color.
+     */
+    ChatColor get();
+
+    /**
+     * Default implementation of this interface. Returns a default white color.
+     */
+    ColorTool DEFAULT = () -> ChatColor.WHITE;
+}

src/main/java/com/onarandombox/MultiverseCore/display/ContentDisplay.java

@@ -0,0 +1,268 @@
+package com.onarandombox.MultiverseCore.display;
+
+import com.onarandombox.MultiverseCore.display.settings.DisplaySetting;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Objects;
+import java.util.WeakHashMap;
+
+/**
+ * Helps to display contents such as list and maps in a nicely formatted fashion.
+ *
+ * @param <T>   Type of content to display.
+ */
+public class ContentDisplay<T> {
+
+    public static final String LINE_BREAK = "%br%";
+
+    /**
+     * Creates a ContentDisplay.Builder for the given content.
+     *
+     * @param content The content to be displayed.
+     * @param <T> The type of the content which can be inferred.
+     * @return A new Builder.
+     */
+    public static <T> Builder<T> forContent(T content) {
+        return new Builder<>(content);
+    }
+
+    /**
+     * Creates a ContentDisplay.Builder for the given collection of content.
+     *
+     * @param content The content to be displayed.
+     * @return A new Builder.
+     */
+    public static Builder<Collection<String>> forContent(Collection<String> content) {
+        return new Builder<>(content).displayHandler(DisplayHandlers.LIST);
+    }
+
+    /**
+     * Creates a ContentDisplay.Builder for the given map of content.
+     *
+     * @param content The content to be displayed.
+     * @return A new Builder.
+     */
+    public static Builder<Map<String, Object>> forContent(Map<String, Object> content) {
+        return new Builder<>(content).displayHandler(DisplayHandlers.INLINE_MAP);
+    }
+
+    private final T contents;
+
+    private String header;
+    private String emptyMessage = "No matching content to display.";
+    private DisplayHandler<T> displayHandler;
+    private ColorTool colorTool = ColorTool.DEFAULT;
+    private ContentFilter filter = ContentFilter.DEFAULT;
+    private final Map<DisplaySetting<?>, Object> settingsMap = new WeakHashMap<>();
+
+    private ContentDisplay(T contents) {
+        this.contents = contents;
+    }
+
+    /**
+     * Do the actual displaying of contents to the sender.
+     *
+     * @param sender The CommandSender to show the display to.
+     */
+    public void show(@NotNull CommandSender sender) {
+        Collection<String> formattedContent;
+        try {
+            formattedContent = (this.contents == null) ? null : this.displayHandler.format(sender, this);
+        } catch (DisplayFormatException e) {
+            sender.sendMessage(String.format("%sError: %s", ChatColor.RED, e.getMessage()));
+            return;
+        }
+        this.displayHandler.sendHeader(sender, this);
+        this.displayHandler.sendSubHeader(sender, this);
+        this.displayHandler.sendBody(sender, this, formattedContent);
+    }
+
+    /**
+     * @return Gets the header to display.
+     */
+    public String getHeader() {
+        return header;
+    }
+
+    /**
+     * Sets the header text.
+     */
+    public void setHeader(@NotNull String header) {
+        this.header = header;
+    }
+
+    /**
+     * @return Gets the contents to display.
+     */
+    public T getContents() {
+        return contents;
+    }
+
+    /**
+     * @return Gets the message to display when no content is shown.
+     */
+    @NotNull
+    public String getEmptyMessage() {
+        return emptyMessage;
+    }
+
+    /**
+     * @return Gets the display handler that formats and sends content to sender.
+     */
+    @NotNull
+    public DisplayHandler<T> getDisplayHandler() {
+        return displayHandler;
+    }
+
+    /**
+     * @return Gets the color tool used.
+     */
+    @NotNull
+    public ColorTool getColorTool() {
+        return colorTool;
+    }
+
+    /**
+     * @return Gets the filter used.
+     */
+    @NotNull
+    public ContentFilter getFilter() {
+        return filter;
+    }
+
+    /**
+     * Gets the value for a given setting option.
+     *
+     * @param setting   The setting option.
+     * @param <S>       The setting type.
+     * @return Value set for the given setting.
+     */
+    public <S> S getSetting(@NotNull DisplaySetting<S> setting) {
+        return (S) settingsMap.getOrDefault(setting, setting.defaultValue());
+    }
+
+    /**
+     * Sets other specific settings that may be used by the {@link DisplayHandler}.
+     *
+     * @param setting   The settings option.
+     * @param value     The value to set.
+     * @param <S>       The type of setting.
+     */
+    public <S> void setSetting(@NotNull DisplaySetting<S> setting, S value) {
+        this.settingsMap.put(setting, value);
+    }
+
+    /**
+     * Builds a {@link ContentDisplay}.
+     *
+     * @param <T>   Type of content to display.
+     */
+    public static class Builder<T> {
+
+        private final ContentDisplay<T> display;
+
+        private Builder(T content) {
+            this.display = new ContentDisplay<>(content);
+        }
+
+        /**
+         * Sets header to be displayed.
+         *
+         * @param header        The header text.
+         * @param replacements  String formatting replacements.
+         * @return The builder.
+         */
+        @NotNull
+        public Builder<T> header(@NotNull String header, Object...replacements) {
+            this.display.header = String.format(header, replacements);
+            return this;
+        }
+
+        /**
+         * Sets the message to show when no content is available for display.
+         *
+         * @param emptyMessage  The message text.
+         * @param replacements  String formatting replacements.
+         * @return The builder.
+         */
+        @NotNull
+        public Builder<T> emptyMessage(@NotNull String emptyMessage, Object...replacements) {
+            this.display.emptyMessage = String.format(emptyMessage, replacements);
+            return this;
+        }
+
+        /**
+         * Sets the display handler that does the formatting and sending of content. <b>Required.</b>
+         *
+         * @param displayHandler    The display handler for the given content type.
+         * @return The builder.
+         */
+        @NotNull
+        public Builder<T> displayHandler(@NotNull DisplayHandler<T> displayHandler) {
+            this.display.displayHandler = displayHandler;
+            return this;
+        }
+
+        /**
+         * Sets the color tool used to make messages more colourful.
+         *
+         * @param colorTool The color tool to use.
+         * @return The builder.
+         */
+        @NotNull
+        public Builder<T> colorTool(@NotNull ColorTool colorTool) {
+            this.display.colorTool = colorTool;
+            return this;
+        }
+
+        /**
+         * Sets content filter used to match specific content to be displayed.
+         *
+         * @param filter    The filter to use.
+         * @return The builder.
+         */
+        @NotNull
+        public Builder<T> filter(@NotNull ContentFilter filter) {
+            this.display.filter = filter;
+            return this;
+        }
+
+        /**
+         * Sets other specific settings that may be used by the {@link DisplayHandler}.
+         *
+         * @param setting   The settings option.
+         * @param value     The value to set.
+         * @param <S>       The type of setting.
+         * @return The builder.
+         */
+        @NotNull
+        public <S> Builder<T> setting(@NotNull DisplaySetting<S> setting, S value) {
+            this.display.settingsMap.put(setting, value);
+            return this;
+        }
+
+        /**
+         * Validates and build the content display.
+         *
+         * @return The content display.
+         */
+        @NotNull
+        public ContentDisplay<T> build() {
+            Objects.requireNonNull(this.display.displayHandler);
+            return this.display;
+        }
+
+        /**
+         * Build and show the content to the sender.
+         *
+         * @param sender The CommandSender to show the display to.
+         */
+        public void show(CommandSender sender) {
+            this.build().show(sender);
+        }
+    }
+}

src/main/java/com/onarandombox/MultiverseCore/display/ContentFilter.java

@@ -0,0 +1,153 @@
+package com.onarandombox.MultiverseCore.display;
+
+import com.dumptruckman.minecraft.util.Logging;
+import org.bukkit.ChatColor;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.regex.Pattern;
+import java.util.regex.PatternSyntaxException;
+
+/**
+ * <p>Filter content and text based on regex matching.</p>
+ *
+ * <p>Compile regex pattern based on {@link ContentFilter#filterString}. When prefixed with 'r=',
+ * use {@link ContentFilter#filterString} as the full regex pattern. Else, set to any match that
+ * contains the {@link ContentFilter#filterString}.<p>
+ */
+public class ContentFilter {
+
+    public static final ContentFilter DEFAULT = new ContentFilter();
+    private static final Pattern REGEX_SPECIAL_CHARS = Pattern.compile("[.+*?\\[^\\]$(){}=!<>|:-\\\\]");
+
+    private String filterString;
+    private Pattern filterPattern;
+    private boolean exactMatch;
+
+    private ContentFilter() {
+    }
+
+    /**
+     * @param filterString  The text to do matching, either plaintext or regex.
+     */
+    public ContentFilter(@NotNull String filterString) {
+        this(filterString, false);
+    }
+
+    /**
+     * @param filterString  The text to do matching, else plaintext or regex.
+     * @param exactMatch    Should check for exact match when doing regex matching.
+     */
+    public ContentFilter(@NotNull String filterString,
+                         boolean exactMatch) {
+
+        this.filterString = filterString;
+        this.exactMatch = exactMatch;
+        parseFilter();
+    }
+
+    private void parseFilter() {
+        if (filterString == null) {
+            return;
+        }
+        if (filterString.startsWith("r=")) {
+            convertToMatcher(filterString.substring(2));
+            return;
+        }
+        String cleanedFilter = REGEX_SPECIAL_CHARS.matcher(filterString.toLowerCase()).replaceAll("\\\\$0");
+        convertToMatcher("(?i).*" + cleanedFilter + ".*");
+    }
+
+    /**
+     * Compile and store the regex into a {@link Pattern}.
+     *
+     * @param regex The regex text.
+     */
+    private void convertToMatcher(@NotNull String regex) {
+        try {
+            this.filterPattern = Pattern.compile(regex);
+            Logging.finest("Parsed regex pattern: %s", this.filterPattern.toString());
+        }
+        catch (PatternSyntaxException ignored) {
+            Logging.warning("Error parsing regex: %s", filterString);
+        }
+    }
+
+    /**
+     * Do regex matching.
+     *
+     * @param text String to check regex on.
+     * @return True of matches regex pattern, false otherwise.
+     */
+    public boolean checkMatch(@Nullable Object text) {
+        if (!hasFilter()) {
+            return true;
+        }
+        if (text == null || !hasValidPattern()) {
+            return false;
+        }
+        text = ChatColor.stripColor(String.valueOf(text));
+        return (exactMatch)
+                ? filterPattern.matcher((CharSequence) text).matches()
+                : filterPattern.matcher((CharSequence) text).find();
+    }
+
+    /**
+     * Checks if a filter string is present.
+     *
+     * @return True if there is a filter string, else false.
+     */
+    public boolean hasFilter() {
+        return filterString != null;
+    }
+
+    /**
+     * Checks if regex pattern syntax is valid.
+     *
+     * @return True if valid, else false.
+     */
+    public boolean hasValidPattern() {
+        return filterPattern != null;
+    }
+
+    /**
+     * @return The filter string.
+     */
+    @Nullable
+    public String getString() {
+        return filterString;
+    }
+
+    /**
+     * @return The regex pattern.
+     */
+    @Nullable
+    public Pattern getPattern() {
+        return filterPattern;
+    }
+
+    /**
+     * @return True if filter is set to do exact matching, else false.
+     */
+    public boolean isExactMatch() {
+        return exactMatch;
+    }
+
+    /**
+     * Nicely format the filter string to be used for showing the sender.
+     *
+     * @return The formatted filter string.
+     */
+    public @NotNull String getFormattedString() {
+        return String.format("%sFilter: '%s'", ChatColor.ITALIC, filterString);
+    }
+
+    @Override
+    public String toString() {
+        return "ContentFilter{" +
+                "filterString='" + filterString + '\'' +
+                ", filterPattern=" + filterPattern +
+                ", exactMatch=" + exactMatch +
+                '}';
+    }
+}

src/main/java/com/onarandombox/MultiverseCore/display/DisplayFormatException.java

@@ -0,0 +1,25 @@
+package com.onarandombox.MultiverseCore.display;
+
+/**
+ * Thrown when an issue occur while formatting content.
+ */
+public class DisplayFormatException extends Exception {
+    public DisplayFormatException() {
+    }
+
+    public DisplayFormatException(String message) {
+        super(message);
+    }
+
+    public DisplayFormatException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public DisplayFormatException(Throwable cause) {
+        super(cause);
+    }
+
+    public DisplayFormatException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
+        super(message, cause, enableSuppression, writableStackTrace);
+    }
+}

src/main/java/com/onarandombox/MultiverseCore/display/DisplayHandler.java

@@ -0,0 +1,68 @@
+package com.onarandombox.MultiverseCore.display;
+
+import com.google.common.base.Strings;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collection;
+
+/**
+ * Handles the formatting and sending of all content by the {@link ContentDisplay}.
+ *
+ * @param <T>   Type of content to display.
+ */
+@FunctionalInterface
+public interface DisplayHandler<T> {
+
+    /**
+     * Formats the raw content into a {@link Collection<String>} for displaying to the given sender.
+     *
+     * @param sender The {@link CommandSender} who will the content will be displayed to.
+     * @param display The responsible {@link ContentDisplay}.
+     * @return The formatted content.
+     * @throws DisplayFormatException Issue occurred while formatting content. E.g. invalid page.
+     */
+    Collection<String> format(@NotNull CommandSender sender, @NotNull ContentDisplay<T> display)
+            throws DisplayFormatException;
+
+    /**
+     * Sends the header.
+     *
+     * @param sender The {@link CommandSender} who will the header will be displayed to.
+     * @param display The responsible {@link ContentDisplay}.
+     */
+    default void sendHeader(@NotNull CommandSender sender, @NotNull ContentDisplay<T> display) {
+        if (!Strings.isNullOrEmpty(display.getHeader())) {
+            sender.sendMessage(display.getHeader());
+        }
+    }
+
+    /**
+     * Sends info such as filter and page.
+     *
+     * @param sender The {@link CommandSender} who will the sub header will be displayed to.
+     * @param display The responsible {@link ContentDisplay}.
+     */
+    default void sendSubHeader(@NotNull CommandSender sender, @NotNull ContentDisplay<T> display) {
+        if (display.getFilter().hasFilter()) {
+            sender.sendMessage(String.format("%s[ %s ]", ChatColor.GRAY, display.getFilter().getFormattedString()));
+        }
+    }
+
+    /**
+     * Sends the content.
+     *
+     * @param sender The {@link CommandSender} who will the body will be displayed to.
+     * @param display The responsible {@link ContentDisplay}.
+     * @param formattedContent The content after being formatted by {@link #format(CommandSender, ContentDisplay)}
+     */
+    default void sendBody(@NotNull CommandSender sender, @NotNull ContentDisplay<T> display,
+                          Collection<String> formattedContent) {
+        if (formattedContent == null || formattedContent.size() == 0) {
+            sender.sendMessage(display.getEmptyMessage());
+            return;
+        }
+        sender.sendMessage(formattedContent.toArray(new String[0]));
+    }
+}

src/main/java/com/onarandombox/MultiverseCore/display/DisplayHandlers.java

@@ -0,0 +1,47 @@
+package com.onarandombox.MultiverseCore.display;
+
+import com.onarandombox.MultiverseCore.display.handlers.InlineListDisplayHandler;
+import com.onarandombox.MultiverseCore.display.handlers.InlineMapDisplayHandler;
+import com.onarandombox.MultiverseCore.display.handlers.ListDisplayHandler;
+import com.onarandombox.MultiverseCore.display.handlers.PagedListDisplayHandler;
+import com.onarandombox.MultiverseCore.display.settings.InlineDisplaySettings;
+import com.onarandombox.MultiverseCore.display.settings.PagedDisplaySettings;
+import com.onarandombox.MultiverseCore.display.settings.MapDisplaySettings;
+
+import java.util.Collection;
+import java.util.Map;
+
+/**
+ * Various implementations of {@link DisplayHandler}.
+ */
+public class DisplayHandlers {
+
+    /**
+     * Standard list display.
+     *
+     * Supported settings: none.
+     */
+    public static final DisplayHandler<Collection<String>> LIST = new ListDisplayHandler();
+
+    /**
+     * List display with paging.
+     *
+     * Supported settings: {@link PagedDisplaySettings#SHOW_PAGE}, {@link PagedDisplaySettings#LINES_PER_PAGE},
+     * {@link PagedDisplaySettings#PAGE_IN_CONSOLE}, {@link PagedDisplaySettings#DO_END_PADDING}.
+     */
+    public static final DisplayHandler<Collection<String>> PAGE_LIST = new PagedListDisplayHandler();
+
+    /**
+     * Display a list inline.
+     *
+     * Supported settings: {@link InlineDisplaySettings#SEPARATOR}.
+     */
+    public static final DisplayHandler<Collection<String>> INLINE_LIST = new InlineListDisplayHandler();
+
+    /**
+     * Display key value pair inline.
+     *
+     * Supported settings: {@link InlineDisplaySettings#SEPARATOR}, {@link MapDisplaySettings#OPERATOR}.
+     */
+    public static final DisplayHandler<Map<String, Object>> INLINE_MAP = new InlineMapDisplayHandler();
+}

src/main/java/com/onarandombox/MultiverseCore/display/handlers/InlineListDisplayHandler.java

@@ -0,0 +1,36 @@
+package com.onarandombox.MultiverseCore.display.handlers;
+
+import com.onarandombox.MultiverseCore.display.ContentDisplay;
+import com.onarandombox.MultiverseCore.display.DisplayFormatException;
+import com.onarandombox.MultiverseCore.display.DisplayHandler;
+import com.onarandombox.MultiverseCore.display.settings.InlineDisplaySettings;
+import org.bukkit.command.CommandSender;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+
+public class InlineListDisplayHandler implements DisplayHandler<Collection<String>> {
+
+    @Override
+    public Collection<String> format(@NotNull CommandSender sender, @NotNull ContentDisplay<Collection<String>> display)
+            throws DisplayFormatException {
+        StringBuilder builder = new StringBuilder();
+        String separator = display.getSetting(InlineDisplaySettings.SEPARATOR);
+
+        for (Iterator<String> iterator = display.getContents().iterator(); iterator.hasNext(); ) {
+            String content = iterator.next();
+            if (!display.getFilter().checkMatch(content)) {
+                continue;
+            }
+            builder.append(display.getColorTool().get()).append(content);
+            if (iterator.hasNext()) {
+                builder.append(separator);
+            }
+        }
+        return (builder.length() == 0)
+                ? Collections.singletonList(display.getEmptyMessage())
+                : Collections.singleton(builder.toString());
+    }
+}

src/main/java/com/onarandombox/MultiverseCore/display/handlers/InlineMapDisplayHandler.java

@@ -0,0 +1,44 @@
+package com.onarandombox.MultiverseCore.display.handlers;
+
+import com.onarandombox.MultiverseCore.display.ContentDisplay;
+import com.onarandombox.MultiverseCore.display.DisplayFormatException;
+import com.onarandombox.MultiverseCore.display.DisplayHandler;
+import com.onarandombox.MultiverseCore.display.settings.InlineDisplaySettings;
+import com.onarandombox.MultiverseCore.display.settings.MapDisplaySettings;
+import org.bukkit.command.CommandSender;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Map;
+
+public class InlineMapDisplayHandler implements DisplayHandler<Map<String, Object>> {
+
+    @Override
+    public Collection<String> format(@NotNull CommandSender sender,
+                                     @NotNull ContentDisplay<Map<String, Object>> display)
+            throws DisplayFormatException {
+        StringBuilder builder = new StringBuilder();
+        String separator = display.getSetting(InlineDisplaySettings.SEPARATOR);
+        String operator = display.getSetting(MapDisplaySettings.OPERATOR);
+
+        for (Iterator<Map.Entry<String, Object>> iterator = display.getContents().entrySet().iterator(); iterator.hasNext(); ) {
+            Map.Entry<String, Object> entry = iterator.next();
+            if (!display.getFilter().checkMatch(entry.getKey()) && !display.getFilter().checkMatch(entry.getValue())) {
+                continue;
+            }
+            builder.append(display.getColorTool().get())
+                    .append(entry.getKey())
+                    .append(operator)
+                    .append(display.getColorTool().get())
+                    .append(entry.getValue());
+            if (iterator.hasNext()) {
+                builder.append(separator);
+            }
+        }
+        return (builder.length() == 0)
+                ? Collections.singletonList(display.getEmptyMessage())
+                : Collections.singleton(builder.toString());
+    }
+}

src/main/java/com/onarandombox/MultiverseCore/display/handlers/ListDisplayHandler.java

@@ -0,0 +1,22 @@
+package com.onarandombox.MultiverseCore.display.handlers;
+
+import com.onarandombox.MultiverseCore.display.ContentDisplay;
+import com.onarandombox.MultiverseCore.display.DisplayFormatException;
+import com.onarandombox.MultiverseCore.display.DisplayHandler;
+import org.bukkit.command.CommandSender;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collection;
+import java.util.stream.Collectors;
+
+public class ListDisplayHandler implements DisplayHandler<Collection<String>> {
+
+    @Override
+    public Collection<String> format(@NotNull CommandSender sender, @NotNull ContentDisplay<Collection<String>> display)
+            throws DisplayFormatException {
+        return display.getContents().stream()
+                .filter(display.getFilter()::checkMatch)
+                .map(s -> (ContentDisplay.LINE_BREAK.equals(s)) ? "" : display.getColorTool().get() + s)
+                .collect(Collectors.toList());
+    }
+}

src/main/java/com/onarandombox/MultiverseCore/display/handlers/PagedListDisplayHandler.java

@@ -0,0 +1,105 @@
+package com.onarandombox.MultiverseCore.display.handlers;
+
+import com.onarandombox.MultiverseCore.display.ContentDisplay;
+import com.onarandombox.MultiverseCore.display.DisplayFormatException;
+import com.onarandombox.MultiverseCore.display.settings.PagedDisplaySettings;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.ConsoleCommandSender;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.IntStream;
+
+public class PagedListDisplayHandler extends ListDisplayHandler {
+
+    @Override
+    public Collection<String> format(@NotNull CommandSender sender, @NotNull ContentDisplay<Collection<String>> display)
+            throws DisplayFormatException {
+        if (dontNeedPaging(sender, display)) {
+            return super.format(sender, display);
+        }
+
+        int pages = 1;
+        int currentLength = 0;
+        int targetPage = display.getSetting(PagedDisplaySettings.SHOW_PAGE);
+        int linesPerPage = display.getSetting(PagedDisplaySettings.LINES_PER_PAGE);
+        List<String> content = new ArrayList<>(linesPerPage);
+
+        // Calculate the paging.
+        for (String line : display.getContents()) {
+            if (!display.getFilter().checkMatch(line)) {
+                continue;
+            }
+            // When it's the next page.
+            boolean isLineBreak = ContentDisplay.LINE_BREAK.equals(line);
+            if (isLineBreak || ++currentLength > linesPerPage) {
+                pages++;
+                currentLength = 0;
+                if (isLineBreak) {
+                    continue;
+                }
+            }
+            if (pages == targetPage) {
+                // Let first line be the header when no header is defined.
+                if (display.getHeader() == null) {
+                    display.setHeader(line);
+                    currentLength--;
+                    continue;
+                }
+                content.add(display.getColorTool().get() + line);
+            }
+        }
+
+        // Page out of range.
+        if (targetPage < 1 || targetPage > pages) {
+            if (pages == 1) {
+                throw new DisplayFormatException("There is only 1 page!");
+            }
+            throw new DisplayFormatException("Please enter a page from 1 to " + pages + ".");
+        }
+
+        // No content
+        if (content.size() == 0) {
+            content.add(display.getEmptyMessage());
+        }
+
+        // Add empty lines to make output length consistent.
+        if (display.getSetting(PagedDisplaySettings.DO_END_PADDING)) {
+            IntStream.range(0, linesPerPage - content.size()).forEach(i -> content.add(""));
+        }
+        display.setSetting(PagedDisplaySettings.TOTAL_PAGE, pages);
+
+        return content;
+    }
+
+    @Override
+    public void sendSubHeader(@NotNull CommandSender sender, @NotNull ContentDisplay<Collection<String>> display) {
+        if (dontNeedPaging(sender, display)) {
+            super.sendSubHeader(sender, display);
+            return;
+        }
+
+        if (display.getFilter().hasFilter()) {
+            sender.sendMessage(String.format("%s[ Page %s of %s, %s ]",
+                    ChatColor.GRAY,
+                    display.getSetting(PagedDisplaySettings.SHOW_PAGE),
+                    display.getSetting(PagedDisplaySettings.TOTAL_PAGE),
+                    display.getFilter().getFormattedString())
+            );
+            return;
+        }
+        sender.sendMessage(String.format("%s[ Page %s of %s ]",
+                ChatColor.GRAY,
+                display.getSetting(PagedDisplaySettings.SHOW_PAGE),
+                display.getSetting(PagedDisplaySettings.TOTAL_PAGE))
+        );
+    }
+
+    private boolean dontNeedPaging(CommandSender sender, ContentDisplay<Collection<String>> display) {
+        return sender instanceof ConsoleCommandSender
+                && !display.getSetting(PagedDisplaySettings.PAGE_IN_CONSOLE);
+    }
+}

src/main/java/com/onarandombox/MultiverseCore/display/settings/DisplaySetting.java

@@ -0,0 +1,19 @@
+package com.onarandombox.MultiverseCore.display.settings;
+
+import com.onarandombox.MultiverseCore.display.DisplayHandler;
+
+/**
+ * Represents a setting option that can be used by {@link DisplayHandler}.
+ *
+ * @param <T>
+ */
+@FunctionalInterface
+public interface DisplaySetting<T> {
+
+     /**
+      * Gets the default value of this Display Setting.
+      *
+      * @return The default value.
+      */
+     T defaultValue();
+}

src/main/java/com/onarandombox/MultiverseCore/display/settings/InlineDisplaySettings.java

@@ -0,0 +1,15 @@
+package com.onarandombox.MultiverseCore.display.settings;
+
+import com.onarandombox.MultiverseCore.display.DisplayHandler;
+import org.bukkit.ChatColor;
+
+/**
+ * Collection of {@link DisplaySetting} that are used by various {@link DisplayHandler}.
+ */
+public class InlineDisplaySettings {
+
+    /**
+     * Inline separator. E.g. '1, 2, 3'
+     */
+    public static final DisplaySetting<String> SEPARATOR = () -> ChatColor.WHITE + ", ";
+}

src/main/java/com/onarandombox/MultiverseCore/display/settings/MapDisplaySettings.java

@@ -0,0 +1,15 @@
+package com.onarandombox.MultiverseCore.display.settings;
+
+import com.onarandombox.MultiverseCore.display.DisplayHandler;
+import org.bukkit.ChatColor;
+
+/**
+ * Collection of {@link DisplaySetting} that are used by various {@link DisplayHandler}.
+ */
+public class MapDisplaySettings {
+
+    /**
+     * The thing between a key value pair. E.g. 'Me = Smart'
+     */
+    public static final DisplaySetting<String> OPERATOR = () -> ChatColor.WHITE + " = ";
+}

src/main/java/com/onarandombox/MultiverseCore/display/settings/PagedDisplaySettings.java

@@ -0,0 +1,30 @@
+package com.onarandombox.MultiverseCore.display.settings;
+
+public class PagedDisplaySettings {
+
+    /**
+     * Page to display.
+     */
+    public static final DisplaySetting<Integer> SHOW_PAGE = () -> 1;
+
+    /**
+     * Total pages available to display.
+     */
+    public static final DisplaySetting<Integer> TOTAL_PAGE = () -> 1;
+
+    /**
+     * The max number of lines per page. This excludes header.
+     */
+    public static final DisplaySetting<Integer> LINES_PER_PAGE = () -> 8;
+
+    /**
+     * Should add empty lines if content lines shown is less that {@link #LINES_PER_PAGE}.
+     */
+    public static final DisplaySetting<Boolean> DO_END_PADDING = () -> true;
+
+    /**
+     * Should display with paging when it's sent to console.
+     */
+    public static final DisplaySetting<Boolean> PAGE_IN_CONSOLE = () -> false;
+
+}

src/main/java/com/onarandombox/MultiverseCore/utils/webpaste/PasteServiceType.java

@@ -22,9 +22,5 @@ public enum PasteServiceType {
     /**
      * @see GitHubPasteService
      */
-    GITHUB,
-    /**
-     * No paste service used.
-     */
-    NONE
+    GITHUB
 }

src/test/java/com/onarandombox/MultiverseCore/TestWorldStuff.java

@@ -207,7 +207,7 @@ public class TestWorldStuff {
         assertEquals(0, creator.getCore().getMVWorldManager().getMVWorlds().size());
 
         // Verify
-        verify(mockCommandSender).sendMessage("§cError: Invalid generator string 'BogusGen'. See /mv gens for available generators.");
+        verify(mockCommandSender).sendMessage("Invalid generator! 'BogusGen'. " + ChatColor.RED + "Aborting world creation.");
     }
 
     @Test