Set version to 2.9.1

Deprecated getPlugin(), getLink(), and getDescription().
fix javadoc for PlaceholderExpansion class...
closes #22, closes #23

pom.xml

@@ -4,7 +4,7 @@
     <groupId>me.clip</groupId>
     <artifactId>placeholderapi</artifactId>
 
-    <version>2.8.6</version>
+    <version>2.9.1</version>
     <name>PlaceholderAPI</name>
     <description>An awesome placeholder provider!</description>
     <url>http://extendedclip.com</url>

src/main/java/me/clip/placeholderapi/PlaceholderAPI.java

@@ -20,304 +20,375 @@
  */
 package me.clip.placeholderapi;
 
+import static me.clip.placeholderapi.util.Msg.color;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import me.clip.placeholderapi.events.ExpansionRegisterEvent;
 import me.clip.placeholderapi.events.ExpansionUnregisterEvent;
-import me.clip.placeholderapi.events.PlaceholderHookUnloadEvent;
 import me.clip.placeholderapi.expansion.PlaceholderExpansion;
 import me.clip.placeholderapi.expansion.Relational;
 import org.apache.commons.lang.Validate;
 import org.bukkit.Bukkit;
-import org.bukkit.ChatColor;
+import org.bukkit.OfflinePlayer;
 import org.bukkit.entity.Player;
 import org.bukkit.plugin.Plugin;
 
-import java.util.*;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-import java.util.stream.Collectors;
-
 public class PlaceholderAPI {
 
-	private PlaceholderAPI() {
-	}
+  private static final Pattern PLACEHOLDER_PATTERN = Pattern.compile("[%]([^%]+)[%]");
+  private static final Pattern BRACKET_PLACEHOLDER_PATTERN = Pattern.compile("[{]([^{}]+)[}]");
+  private static final Pattern RELATIONAL_PLACEHOLDER_PATTERN = Pattern.compile("[%](rel_)([^%]+)[%]");
+  private static final Map<String, PlaceholderHook> placeholders = new HashMap<>();
+  private PlaceholderAPI() {
+  }
 
-	private final static Pattern PLACEHOLDER_PATTERN = Pattern.compile("[%]([^%]+)[%]");
-	private final static Pattern BRACKET_PLACEHOLDER_PATTERN = Pattern.compile("[{]([^{}]+)[}]");
-	private final static Pattern RELATIONAL_PLACEHOLDER_PATTERN = Pattern.compile("[%](rel_)([^%]+)[%]");
-	private final static Map<String, PlaceholderHook> placeholders = new HashMap<>();
+  /**
+   * check if a specific placeholder identifier is currently registered
+   *
+   * @param identifier to check
+   * @return true if identifier is already registered
+   */
+  public static boolean isRegistered(String identifier) {
+    return getRegisteredIdentifiers().stream().filter(id -> id.equalsIgnoreCase(identifier))
+        .findFirst().orElse(null) != null;
+  }
 
-	/**
-	 * check if a specific placeholder identifier is currently registered
-	 * @param identifier to check
-	 * @return true if identifier is already registered
-	 */
-	public static boolean isRegistered(String identifier) {
-		return !placeholders.isEmpty() && getRegisteredIdentifiers().stream().filter(id -> id.equalsIgnoreCase(identifier)).findFirst().orElse(null) != null;
-	}
-	
-	/**
-	 * Register a new placeholder hook
-	 * @param identifier Identifier of the placeholder -> "%(identifier)_(args...)%
-	 * 
-	 * @param placeholderHook implementing class that contains the onPlaceholderRequest method which is called when a value is needed for the specific placeholder
-	 * @return true if the hook was successfully registered, false if there is already a hook registered for the specified identifier
-	 */
-	public static boolean registerPlaceholderHook(String identifier, PlaceholderHook placeholderHook) {
-		Validate.notNull(identifier, "Identifier can not be null");
-		Validate.notNull(placeholderHook, "Placeholderhook can not be null");
-		if (isRegistered(identifier)) return false;
-		placeholders.put(identifier.toLowerCase(), placeholderHook);
-		return true;
-	}
-	
-	/**
-	 * unregister a placeholder hook by identifier
-	 * @param identifier the identifier for the placeholder hook to unregister
-	 * @return true if the placeholder hook was successfully unregistered, false if there was no placeholder hook registered for the identifier specified
-	 */
-	public static boolean unregisterPlaceholderHook(String identifier) {
-		Validate.notNull(identifier, "Identifier can not be null");		
-		return placeholders.remove(identifier.toLowerCase()) != null;
-	}
-	
-	/**
-	 * Get all registered placeholder identifiers
-	 * @return all registered placeholder identifiers
-	 */
-	public static Set<String> getRegisteredIdentifiers() {
-		if (placeholders.isEmpty()) return new HashSet<>();
-		return new HashSet<>(placeholders.keySet());
-	}
-
-	/**
-	 * Get map of registered placeholders 
-	 * @return copy of the internal placeholder map
-	 */
-	public static Map<String, PlaceholderHook> getPlaceholders() {
-		return new HashMap<>(placeholders);
-	}
-
-	public static Set<PlaceholderExpansion> getExpansions() {
-		return getPlaceholders().values().stream().filter(PlaceholderExpansion.class::isInstance).map(PlaceholderExpansion.class::cast).collect(Collectors.toCollection(HashSet::new));
+  /**
+   * Register a new placeholder hook
+   *
+   * @param identifier Identifier of the placeholder -> "%(identifier)_(args...)%
+   * @param placeholderHook implementing class that contains the onPlaceholderRequest method which
+   * is called when a value is needed for the specific placeholder
+   * @return true if the hook was successfully registered, false if there is already a hook
+   * registered for the specified identifier
+   */
+  public static boolean registerPlaceholderHook(String identifier,
+      PlaceholderHook placeholderHook) {
+    Validate.notNull(identifier, "Identifier can not be null");
+    Validate.notNull(placeholderHook, "Placeholderhook can not be null");
+    if (isRegistered(identifier)) {
+      return false;
     }
+    placeholders.put(identifier.toLowerCase(), placeholderHook);
+    return true;
+  }
 
-	/**
-	 * check if a String contains any PlaceholderAPI placeholders
-	 * @param text String to check 
-	 * @return true if String contains any registered placeholder identifiers, false otherwise
-	 */
-	public static boolean containsPlaceholders(String text) {
-		return text != null && PLACEHOLDER_PATTERN.matcher(text).find();
-	}
+  /**
+   * unregister a placeholder hook by identifier
+   *
+   * @param identifier the identifier for the placeholder hook to unregister
+   * @return true if the placeholder hook was successfully unregistered, false if there was no
+   * placeholder hook registered for the identifier specified
+   */
+  public static boolean unregisterPlaceholderHook(String identifier) {
+    Validate.notNull(identifier, "Identifier can not be null");
+    return placeholders.remove(identifier.toLowerCase()) != null;
+  }
 
-	/**
-	 * check if a String contains any PlaceholderAPI bracket placeholders
-	 * @param text String to check 
-	 * @return true if String contains any registered placeholder identifiers, false otherwise
-	 */
-	public static boolean containsBracketPlaceholders(String text) {
-		return text != null && BRACKET_PLACEHOLDER_PATTERN.matcher(text).find();
-	}
+  /**
+   * Get all registered placeholder identifiers
+   *
+   * @return all registered placeholder identifiers
+   */
+  public static Set<String> getRegisteredIdentifiers() {
+    return ImmutableSet.copyOf(placeholders.keySet());
+  }
 
-	/**
-	 * set placeholders in the list<String> text provided
-	 * placeholders are matched with the pattern {<placeholder>} when set with this method
-	 * @param p Player to parse the placeholders for
-	 * @param text text to set the placeholder values in
-	 * @return modified list with all placeholders set to the corresponding values
-	 */
-	public static List<String> setBracketPlaceholders(Player p, List<String> text) {
-		return setPlaceholders(p, text, BRACKET_PLACEHOLDER_PATTERN);
-	}
+  /**
+   * Get map of registered placeholders
+   *
+   * @return copy of the internal placeholder map
+   */
+  public static Map<String, PlaceholderHook> getPlaceholders() {
+    return ImmutableMap.copyOf(placeholders);
+  }
 
-	/**
-	 * set placeholders in the list<String> text provided
-	 * placeholders are matched with the pattern %(identifier)_(params)>% when set with this method
-	 * @param p Player to parse the placeholders for
-	 * @param text text to parse the placeholder values in
-	 * @return modified list with all placeholders set to the corresponding values
-	 */
-	public static List<String> setPlaceholders(Player p, List<String> text) {
-		return setPlaceholders(p, text, PLACEHOLDER_PATTERN);
-	}
+  public static Set<PlaceholderExpansion> getExpansions() {
+    Set<PlaceholderExpansion> set = getPlaceholders().values().stream()
+        .filter(PlaceholderExpansion.class::isInstance).map(PlaceholderExpansion.class::cast)
+        .collect(Collectors.toCollection(HashSet::new));
+    return ImmutableSet.copyOf(set);
+  }
 
-    /**
-     * set placeholders in the list<String> text provided
-     * placeholders are matched with the pattern %(identifier)_(params)>% when set with this method
-     * @param p Player to parse the placeholders for
-     * @param text text to parse the placeholder values in
-     * @return modified list with all placeholders set to the corresponding values
-     */
-    public static List<String> setPlaceholders(Player p, List<String> text, Pattern pattern) {
-        if (text == null) return null;
-        List<String> temp = new ArrayList<>();
-        text.forEach(line -> {
-            temp.add(setPlaceholders(p, line, pattern));
-        });
-        return temp;
+  /**
+   * check if a String contains any PlaceholderAPI placeholders
+   *
+   * @param text String to check
+   * @return true if String contains any registered placeholder identifiers, false otherwise
+   */
+  public static boolean containsPlaceholders(String text) {
+    return text != null && PLACEHOLDER_PATTERN.matcher(text).find();
+  }
+
+  /**
+   * check if a String contains any PlaceholderAPI bracket placeholders
+   *
+   * @param text String to check
+   * @return true if String contains any registered placeholder identifiers, false otherwise
+   */
+  public static boolean containsBracketPlaceholders(String text) {
+    return text != null && BRACKET_PLACEHOLDER_PATTERN.matcher(text).find();
+  }
+
+  /**
+   * set placeholders in the list<String> text provided placeholders are matched with the pattern
+   * {<placeholder>} when set with this method
+   *
+   * @param p Player to parse the placeholders for
+   * @param text text to set the placeholder values in
+   * @return modified list with all placeholders set to the corresponding values
+   */
+  public static List<String> setBracketPlaceholders(OfflinePlayer p, List<String> text) {
+    return setPlaceholders(p, text, BRACKET_PLACEHOLDER_PATTERN);
+  }
+
+  /**
+   * set placeholders in the list<String> text provided placeholders are matched with the pattern
+   * %(identifier)_(params)>% when set with this method
+   *
+   * @param p Player to parse the placeholders for
+   * @param text text to parse the placeholder values in
+   * @return modified list with all placeholders set to the corresponding values
+   */
+  public static List<String> setPlaceholders(OfflinePlayer p, List<String> text) {
+    return setPlaceholders(p, text, PLACEHOLDER_PATTERN);
+  }
+
+
+  /**
+   * set placeholders in the list<String> text provided placeholders are matched with the pattern
+   * %(identifier)_(params)>% when set with this method
+   *
+   * @param p Player to parse the placeholders for
+   * @param text text to parse the placeholder values in
+   * @return modified list with all placeholders set to the corresponding values
+   */
+  public static List<String> setPlaceholders(OfflinePlayer p, List<String> text, Pattern pattern) {
+    if (text == null) {
+      return null;
     }
+    return text.stream().map(line -> setPlaceholders(p, line, pattern))
+        .collect(Collectors.toList());
+  }
 
-    /**
-     * set placeholders in the text specified
-     * placeholders are matched with the pattern {<placeholder>} when set with this method
-     * @param player Player to parse the placeholders for
-     * @param text text to parse the placeholder values to
-     * @return modified text with all placeholders set to the corresponding values
-     */
-    public static String setBracketPlaceholders(Player player, String text) {
-        return setPlaceholders(player, text, BRACKET_PLACEHOLDER_PATTERN);
+  /**
+   * set placeholders in the text specified placeholders are matched with the pattern
+   * {<placeholder>} when set with this method
+   *
+   * @param player Player to parse the placeholders for
+   * @param text text to parse the placeholder values to
+   * @return modified text with all placeholders set to the corresponding values
+   */
+  public static String setBracketPlaceholders(OfflinePlayer player, String text) {
+    return setPlaceholders(player, text, BRACKET_PLACEHOLDER_PATTERN);
+  }
+
+  /**
+   * set placeholders in the text specified placeholders are matched with the pattern
+   * %<(identifier)_(params)>% when set with this method
+   *
+   * @param player Player to parse the placeholders for
+   * @param text text to parse the placeholder values to
+   * @return text with all placeholders set to the corresponding values
+   */
+  public static String setPlaceholders(OfflinePlayer player, String text) {
+    return setPlaceholders(player, text, PLACEHOLDER_PATTERN);
+  }
+
+  /**
+   * set placeholders in the text specified placeholders are matched with the pattern
+   * %<(identifier)_(params)>% when set with this method
+   *
+   * @param player Player to parse the placeholders for
+   * @param text text to parse the placeholder values to
+   * @param placeholderPattern the pattern to match placeholders to. Capture group 1 must contain an
+   * underscore separating the identifier from the params
+   * @return text with all placeholders set to the corresponding values
+   */
+  public static String setPlaceholders(OfflinePlayer player, String text,
+      Pattern placeholderPattern) {
+    if (text == null) {
+      return null;
     }
-	
-	/**
-	 * set placeholders in the text specified
-	 * placeholders are matched with the pattern %<(identifier)_(params)>% when set with this method
-	 * @param player Player to parse the placeholders for
-	 * @param text text to parse the placeholder values to
-	 * @return text with all placeholders set to the corresponding values
-	 */
-	public static String setPlaceholders(Player player, String text) {
-		return setPlaceholders(player, text, PLACEHOLDER_PATTERN);
-	}
-
-    /**
-     * set placeholders in the text specified
-     * placeholders are matched with the pattern %<(identifier)_(params)>% when set with this method
-     * @param player Player to parse the placeholders for
-     * @param text text to parse the placeholder values to
-     * @param placeholderPattern the pattern to match placeholders to. Capture group 1 must contain an underscore separating the identifier from the params
-     * @return text with all placeholders set to the corresponding values
-     */
-	public static String setPlaceholders(Player player, String text, Pattern placeholderPattern) {
-		if (text == null) return null;
-		if (placeholders.isEmpty()) return colorize(text);
-		Matcher m = placeholderPattern.matcher(text);
-		Map<String, PlaceholderHook> hooks = getPlaceholders();
-		while (m.find()) {
-			String format = m.group(1);
-			int index = format.indexOf("_");
-			if (index <= 0 || index >= format.length()) continue;
-			String identifier = format.substring(0, index).toLowerCase();
-			String params = format.substring(index+1);
-			if (hooks.containsKey(identifier)) {
-				String value = hooks.get(identifier).onPlaceholderRequest(player, params);
-				if (value != null) {
-					text = text.replaceAll(Pattern.quote(m.group()), Matcher.quoteReplacement(value));
-				}
-			}
-		}
-		return colorize(text);
-	}
-	
-	/**
-	 * set relational placeholders in the text specified
-	 * placeholders are matched with the pattern %<rel_(identifier)_(params)>% when set with this method
-	 * @param one Player to compare
-	 * @param two Player to compare
-	 * @param text text to parse the placeholder values to
-	 * @return text with all relational placeholders set to the corresponding values
-	 */
-	public static List<String> setRelationalPlaceholders(Player one, Player two, List<String> text) {
-		if (text == null) return null;
-		List<String> temp = new ArrayList<>();
-		text.forEach(line -> {
-			temp.add(setRelationalPlaceholders(one, two, line));
-		});
-		return temp;
-	}
-	
-	/**
-	 * set relational placeholders in the text specified
-	 * placeholders are matched with the pattern %<rel_(identifier)_(params)>% when set with this method
-	 * @param one Player to compare
-	 * @param two Player to compare
-	 * @param text text to parse the placeholder values to
-	 * @return text with all relational placeholders set to the corresponding values
-	 */
-	public static String setRelationalPlaceholders(Player one, Player two, String text) {
-		if (text == null) return null;
-		if (placeholders.isEmpty()) return colorize(text);
-		Matcher m = RELATIONAL_PLACEHOLDER_PATTERN.matcher(text);
-		Map<String, PlaceholderHook> hooks = getPlaceholders();
-		while (m.find()) {
-			String format = m.group(2);
-			int index = format.indexOf("_");
-		    if (index <= 0 || index >= format.length()) continue;
-		    String identifier = format.substring(0, index).toLowerCase();
-		    String params = format.substring(index+1);
-		    if (hooks.containsKey(identifier)) {
-		    	if (!(hooks.get(identifier) instanceof Relational)) {
-		    		continue;
-		    	}
-		    	Relational rel = (Relational) hooks.get(identifier);
-		    	String value = rel.onPlaceholderRequest(one, two, params);
-				if (value != null) {
-					text = text.replaceAll(Pattern.quote(m.group()), Matcher.quoteReplacement(value));
-				}
-		    }
-		}
-		return colorize(text);
-	}
-
-    /**
-     * unregister ALL placeholder hooks that are currently registered
-     */
-    protected static void unregisterAll() {
-        unregisterAllProvidedExpansions();
-        placeholders.clear();
+    if (placeholders.isEmpty()) {
+      return color(text);
     }
-
-    /**
-     * unregister all expansions provided by PlaceholderAPI
-     */
-    public static void unregisterAllProvidedExpansions() {
-        if (placeholders.isEmpty()) return;
-        getPlaceholders().forEach((key, value) -> {
-            if (value instanceof PlaceholderExpansion) {
-            	PlaceholderExpansion ex = (PlaceholderExpansion) value;
-                if (!ex.persist()) {
-                    unregisterExpansion(ex);
-                }
-            }
-        });
-    }
-
-    public static boolean unregisterExpansion(PlaceholderExpansion ex) {
-        if (unregisterPlaceholderHook(ex.getIdentifier())) {
-            Bukkit.getPluginManager().callEvent(new ExpansionUnregisterEvent(ex));
-            return true;
+    Matcher m = placeholderPattern.matcher(text);
+    Map<String, PlaceholderHook> hooks = getPlaceholders();
+    while (m.find()) {
+      String format = m.group(1);
+      int index = format.indexOf("_");
+      if (index <= 0 || index >= format.length()) {
+        continue;
+      }
+      String identifier = format.substring(0, index).toLowerCase();
+      String params = format.substring(index + 1);
+      if (hooks.containsKey(identifier)) {
+        String value = hooks.get(identifier).onRequest(player, params);
+        if (value != null) {
+          text = text.replaceAll(Pattern.quote(m.group()), Matcher.quoteReplacement(value));
         }
-        return false;
+      }
     }
+    return color(text);
+  }
 
-	public static Pattern getPlaceholderPattern() {
-		return PLACEHOLDER_PATTERN;
-	}
+  /**
+   * set relational placeholders in the text specified placeholders are matched with the pattern
+   * %<rel_(identifier)_(params)>% when set with this method
+   *
+   * @param one Player to compare
+   * @param two Player to compare
+   * @param text text to parse the placeholder values to
+   * @return text with all relational placeholders set to the corresponding values
+   */
+  public static List<String> setRelationalPlaceholders(Player one, Player two, List<String> text) {
+    if (text == null) {
+      return null;
+    }
+    return text.stream().map(line -> setRelationalPlaceholders(one, two, line))
+        .collect(Collectors.toList());
+  }
 
-	public static Pattern getBracketPlaceholderPattern() {
-		return BRACKET_PLACEHOLDER_PATTERN;
-	}
+  /**
+   * set relational placeholders in the text specified placeholders are matched with the pattern
+   * %<rel_(identifier)_(params)>% when set with this method
+   *
+   * @param one Player to compare
+   * @param two Player to compare
+   * @param text text to parse the placeholder values to
+   * @return text with all relational placeholders set to the corresponding values
+   */
+  public static String setRelationalPlaceholders(Player one, Player two, String text) {
+    if (text == null) {
+      return null;
+    }
+    if (placeholders.isEmpty()) {
+      return color(text);
+    }
+    Matcher m = RELATIONAL_PLACEHOLDER_PATTERN.matcher(text);
+    Map<String, PlaceholderHook> hooks = getPlaceholders();
+    while (m.find()) {
+      String format = m.group(2);
+      int index = format.indexOf("_");
+      if (index <= 0 || index >= format.length()) {
+        continue;
+      }
+      String identifier = format.substring(0, index).toLowerCase();
+      String params = format.substring(index + 1);
+      if (hooks.containsKey(identifier)) {
+        if (!(hooks.get(identifier) instanceof Relational)) {
+          continue;
+        }
+        Relational rel = (Relational) hooks.get(identifier);
+        String value = rel.onPlaceholderRequest(one, two, params);
+        if (value != null) {
+          text = text.replaceAll(Pattern.quote(m.group()), Matcher.quoteReplacement(value));
+        }
+      }
+    }
+    return color(text);
+  }
 
-	public static Pattern getRelationalPlaceholderPattern() {
-		return RELATIONAL_PLACEHOLDER_PATTERN;
-	}
+  /**
+   * unregister ALL placeholder hooks that are currently registered
+   */
+  protected static void unregisterAll() {
+    unregisterAllProvidedExpansions();
+    placeholders.clear();
+  }
 
-	public static String colorize(String text) {
-		return ChatColor.translateAlternateColorCodes('&', text);
-	}
+  /**
+   * unregister all expansions provided by PlaceholderAPI
+   */
+  public static void unregisterAllProvidedExpansions() {
+    if (placeholders.isEmpty()) {
+      return;
+    }
+    getPlaceholders().forEach((key, value) -> {
+      if (value instanceof PlaceholderExpansion) {
+        PlaceholderExpansion ex = (PlaceholderExpansion) value;
+        if (!ex.persist()) {
+          unregisterExpansion(ex);
+        }
+      }
+    });
+  }
 
-	@Deprecated
-	public static Set<String> getRegisteredPlaceholderPlugins() {
-		return getRegisteredIdentifiers();
-	}
-	@Deprecated
-	public static Set<String> getExternalPlaceholderPlugins() {
-		return null;
-	}
-	@Deprecated
-	public static boolean registerPlaceholderHook(Plugin plugin, PlaceholderHook placeholderHook) {
-		return plugin != null && registerPlaceholderHook(plugin.getName(), placeholderHook);
-	}
-	@Deprecated
-	public static boolean unregisterPlaceholderHook(Plugin plugin) {
-		return plugin != null && unregisterPlaceholderHook(plugin.getName());
-	}
+  public static boolean registerExpansion(PlaceholderExpansion ex) {
+    if (registerPlaceholderHook(ex.getIdentifier(), ex)) {
+      Bukkit.getPluginManager().callEvent(new ExpansionRegisterEvent(ex));
+      return true;
+    }
+    return false;
+  }
+
+  public static boolean unregisterExpansion(PlaceholderExpansion ex) {
+    if (unregisterPlaceholderHook(ex.getIdentifier())) {
+      Bukkit.getPluginManager().callEvent(new ExpansionUnregisterEvent(ex));
+      return true;
+    }
+    return false;
+  }
+
+  public static Pattern getPlaceholderPattern() {
+    return PLACEHOLDER_PATTERN;
+  }
+
+  public static Pattern getBracketPlaceholderPattern() {
+    return BRACKET_PLACEHOLDER_PATTERN;
+  }
+
+  public static Pattern getRelationalPlaceholderPattern() {
+    return RELATIONAL_PLACEHOLDER_PATTERN;
+  }
+
+  @Deprecated
+  public static Set<String> getRegisteredPlaceholderPlugins() {
+    return getRegisteredIdentifiers();
+  }
+
+  @Deprecated
+  public static Set<String> getExternalPlaceholderPlugins() {
+    return null;
+  }
+
+  @Deprecated
+  public static boolean registerPlaceholderHook(Plugin plugin, PlaceholderHook placeholderHook) {
+    return plugin != null && registerPlaceholderHook(plugin.getName(), placeholderHook);
+  }
+
+  @Deprecated
+  public static boolean unregisterPlaceholderHook(Plugin plugin) {
+    return plugin != null && unregisterPlaceholderHook(plugin.getName());
+  }
+
+  @Deprecated
+  public static String setPlaceholders(Player p, String text) {
+    return setPlaceholders((OfflinePlayer)p, text, PLACEHOLDER_PATTERN);
+  }
+
+  @Deprecated
+  public static List<String> setPlaceholders(Player p, List<String> text) {
+    return setPlaceholders((OfflinePlayer)p, text, PLACEHOLDER_PATTERN);
+  }
+
+  @Deprecated
+  public static String setBracketPlaceholders(Player p, String text) {
+    return setPlaceholders((OfflinePlayer)p, text, BRACKET_PLACEHOLDER_PATTERN);
+  }
+
+  @Deprecated
+  public static List<String> setBracketPlaceholders(Player p, List<String> text) {
+    return setPlaceholders((OfflinePlayer)p, text, BRACKET_PLACEHOLDER_PATTERN);
+  }
 }

src/main/java/me/clip/placeholderapi/PlaceholderAPIPlugin.java

@@ -84,7 +84,7 @@ public class PlaceholderAPIPlugin extends JavaPlugin {
 		getLogger().info("Placeholder expansion registration initializing...");
 		expansionManager.registerAllExpansions();
 		if (config.checkUpdates()) {
-			new UpdateChecker(this);
+			new UpdateChecker(this).fetch();
 		}
 		if (config.isCloudEnabled()) {
 			enableCloud();
@@ -149,8 +149,8 @@ public class PlaceholderAPIPlugin extends JavaPlugin {
                 for (PlaceholderHook hook : p.values()) {
                     if (hook instanceof PlaceholderExpansion) {
                         PlaceholderExpansion ex = (PlaceholderExpansion) hook;
-                        map.put(ex.getPlugin() == null ? ex.getIdentifier()
-                                : ex.getPlugin(), 1);
+                        map.put(ex.getRequiredPlugin() == null ? ex.getIdentifier()
+                                : ex.getRequiredPlugin(), 1);
                     }
                 }
             }
@@ -180,10 +180,10 @@ public class PlaceholderAPIPlugin extends JavaPlugin {
 	public void enableCloud() {
 		if (expansionCloud == null) {
 			expansionCloud = new ExpansionCloudManager(this);
-			expansionCloud.fetch();
+			expansionCloud.fetch(config.cloudAllowUnverifiedExpansions());
 		} else {
 			expansionCloud.clean();
-			expansionCloud.fetch();
+			expansionCloud.fetch(config.cloudAllowUnverifiedExpansions());
 		}
 	}
 

src/main/java/me/clip/placeholderapi/PlaceholderHook.java

@@ -20,15 +20,31 @@
  */
 package me.clip.placeholderapi;
 
+import org.bukkit.OfflinePlayer;
 import org.bukkit.entity.Player;
 
 public abstract class PlaceholderHook {
 
+  /**
+   * called when a placeholder value is requested from this hook
+   * @param p {@link OfflinePlayer} to request the placeholder value for, null if not needed for a player
+   * @param params String passed to the hook to determine what value to return
+   * @return value for the requested player and params
+   */
+	public String onRequest(OfflinePlayer p, String params) {
+		if (p != null && p.isOnline()) {
+			return onPlaceholderRequest((Player) p, params);
+		}
+		return onPlaceholderRequest(null, params);
+	}
+
 	/**
-	 * called when a placeholder is requested from this PlaceholderHook
-	 * @param p Player requesting the placeholder value for, null if not needed for a player
-	 * @param params String passed for the placeholder hook to determine what value to return
+	 * called when a placeholder is requested from this hook
+	 * @param p {@link Player} to request the placeholder value for, null if not needed for a player
+	 * @param params String passed to the hook to determine what value to return
 	 * @return value for the requested player and params
 	 */
-	public abstract String onPlaceholderRequest(Player p, String params);
+	public String onPlaceholderRequest(Player p, String params) {
+		return null;
+	}
 }

src/main/java/me/clip/placeholderapi/PlaceholderListener.java

@@ -80,7 +80,7 @@ public class PlaceholderListener implements Listener {
 		PlaceholderExpansion e = m.getCachedExpansion(event.getPlugin().getName().toLowerCase());
 		if (e != null && e.canRegister()) {
 			if (e.isRegistered() || m.registerExpansion(e)) {
-				m.removeCachedExpansion(e.getPlugin());
+				m.removeCachedExpansion(e.getRequiredPlugin());
 			}
 		}
 	}
@@ -122,11 +122,11 @@ public class PlaceholderListener implements Listener {
 				
 				PlaceholderExpansion ex = (PlaceholderExpansion) i;
 				
-				if (ex.getPlugin() == null) {
+				if (ex.getRequiredPlugin() == null) {
 					continue;
 				}
 				
-				if (ex.getPlugin().equalsIgnoreCase(n)) {
+				if (ex.getRequiredPlugin().equalsIgnoreCase(n)) {
 					if (PlaceholderAPI.unregisterExpansion(ex)) {
 						plugin.getLogger().info("Unregistered placeholder expansion: " + ex.getIdentifier());
 					}

src/main/java/me/clip/placeholderapi/commands/ExpansionCloudCommands.java

@@ -24,13 +24,7 @@ import me.clip.placeholderapi.PlaceholderAPI;
 import me.clip.placeholderapi.PlaceholderAPIPlugin;
 import me.clip.placeholderapi.expansion.PlaceholderExpansion;
 import me.clip.placeholderapi.expansion.cloud.CloudExpansion;
-import me.clip.placeholderapi.util.Msg;
 import me.rayzr522.jsonmessage.JSONMessage;
-import net.md_5.bungee.api.chat.ClickEvent;
-import net.md_5.bungee.api.chat.ComponentBuilder;
-import net.md_5.bungee.api.chat.HoverEvent;
-import net.md_5.bungee.api.chat.TextComponent;
-import org.bukkit.ChatColor;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
@@ -79,7 +73,7 @@ public class ExpansionCloudCommands implements CommandExecutor {
 		if (args[1].equalsIgnoreCase("refresh") || args[1].equalsIgnoreCase("update") || args[1].equalsIgnoreCase("fetch")) {
 			msg(s, "&aRefresh task started. Use &f/papi ecloud list all &ain a few!!");
 			plugin.getExpansionCloud().clean();
-			plugin.getExpansionCloud().fetch();
+			plugin.getExpansionCloud().fetch(plugin.getPlaceholderAPIConfig().cloudAllowUnverifiedExpansions());
 			return true;
 		}
 
@@ -217,7 +211,7 @@ public class ExpansionCloudCommands implements CommandExecutor {
 
             if (!(s instanceof Player) || plugin.getExpansionManager().getRegisteredExpansion(expansion.getName()) == null) {
                 msg(s, "&bPlaceholders: &f" + placeholders.size(),
-                        String.join("&a, &f"));
+                        String.join("&a, &f", placeholders));
                 return true;
             }
 

src/main/java/me/clip/placeholderapi/commands/PlaceholderAPICommands.java

@@ -155,16 +155,8 @@ public class PlaceholderAPICommands implements CommandExecutor {
 					Msg.msg(s, "&7Version: &f" + ex.getVersion());
 				}
 				
-				if (ex.getDescription() != null) {
-					Msg.msg(s, ex.getDescription());
-				}
-				
-				if (ex.getLink() != null) {
-					Msg.msg(s, "&7Link: &f" + ex.getLink());
-				}
-				
-				if (ex.getPlugin() != null) {
-					Msg.msg(s, "&7Requires plugin: &f" + ex.getPlugin());
+				if (ex.getRequiredPlugin() != null) {
+					Msg.msg(s, "&7Requires plugin: &f" + ex.getRequiredPlugin());
 				}
 
 				if (ex.getPlaceholders() != null) {

src/main/java/me/clip/placeholderapi/events/ExpansionRegisterEvent.java

@@ -0,0 +1,48 @@
+/*
+ *
+ * PlaceholderAPI
+ * Copyright (C) 2018 Ryan McCarthy
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ *
+ */
+package me.clip.placeholderapi.events;
+
+import me.clip.placeholderapi.expansion.PlaceholderExpansion;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+public class ExpansionRegisterEvent extends Event {
+
+	private static final HandlerList HANDLERS = new HandlerList();
+	private PlaceholderExpansion expansion;
+
+	public ExpansionRegisterEvent(PlaceholderExpansion expansion) {
+		this.expansion = expansion;
+	}
+
+	@Override
+	public HandlerList getHandlers() {
+		return HANDLERS;
+	}
+
+	public static HandlerList getHandlerList() {
+		return HANDLERS;
+	}
+	
+	public PlaceholderExpansion getExpansion() {
+		return expansion;
+	}
+}

src/main/java/me/clip/placeholderapi/events/ExpansionUnregisterEvent.java

@@ -27,7 +27,7 @@ import org.bukkit.event.HandlerList;
 
 public class ExpansionUnregisterEvent extends Event {
 
-	private static final HandlerList handlers = new HandlerList();
+	private static final HandlerList HANDLERS = new HandlerList();
 	private PlaceholderExpansion expansion;
 
 	public ExpansionUnregisterEvent(PlaceholderExpansion expansion) {
@@ -36,11 +36,11 @@ public class ExpansionUnregisterEvent extends Event {
 
 	@Override
 	public HandlerList getHandlers() {
-		return handlers;
+		return HANDLERS;
 	}
 
 	public static HandlerList getHandlerList() {
-		return handlers;
+		return HANDLERS;
 	}
 	
 	public PlaceholderExpansion getExpansion() {

src/main/java/me/clip/placeholderapi/events/PlaceholderHookUnloadEvent.java

@@ -27,7 +27,7 @@ import org.bukkit.event.HandlerList;
 @Deprecated
 public class PlaceholderHookUnloadEvent extends Event {
 
-	private static final HandlerList handlers = new HandlerList();
+	private static final HandlerList HANDLERS = new HandlerList();
 	private String plugin;
 	private PlaceholderHook hook;
 
@@ -38,11 +38,11 @@ public class PlaceholderHookUnloadEvent extends Event {
 
 	@Override
 	public HandlerList getHandlers() {
-		return handlers;
+		return HANDLERS;
 	}
 
 	public static HandlerList getHandlerList() {
-		return handlers;
+		return HANDLERS;
 	}
 	
 	public String getHookName() {

src/main/java/me/clip/placeholderapi/expansion/ExpansionManager.java

@@ -116,16 +116,13 @@ public final class ExpansionManager {
 		}
 
 		if (!c.canRegister()) {
-			if (c.getPlugin() != null) {
-				cache.put(c.getPlugin().toLowerCase(), c);
+			if (c.getRequiredPlugin() != null) {
+				cache.put(c.getRequiredPlugin().toLowerCase(), c);
 			}
 			return false;
 		}
 
 		if (!c.register()) {
-			if (c.getPlugin() != null) {
-				cache.put(c.getPlugin().toLowerCase(), c);
-			}
 			return false;
 		}
 

src/main/java/me/clip/placeholderapi/expansion/PlaceholderExpansion.java

@@ -33,60 +33,59 @@ public abstract class PlaceholderExpansion extends PlaceholderHook {
 	
 	/**
 	 * The name of this expansion
-	 * @return identifier used for expansion if no name present
+	 * @return {@link #getIdentifier()} by default, name of this expansion if specified
 	 */
 	public String getName() {
 		return getIdentifier();
 	}
 
 	/**
-	 * Get the identifier that this placeholder expansion uses to be passed placeholder requests
-	 * @return placeholder identifier that is associated with this class
+	 * The placeholder identifier of this expanion
+	 * @return placeholder identifier that is associated with this expansion
 	 */
 	public abstract String getIdentifier();
 	
 	/**
-	 * Get the plugin that this expansion hooks into. 
-	 * This will ensure the expansion is added to a cache if canRegister() returns false
-	 * get. 
-	 * The expansion will be removed from the cache
-	 * once a plugin loads with the name that is here and the expansion is registered
-	 * @return placeholder identifier that is associated with this class
-	 */
-	public abstract String getPlugin();
-	
-	/**
-	 * Get the author of this PlaceholderExpansion
+	 * The author of this expansion
 	 * @return name of the author for this expansion
 	 */
 	public abstract String getAuthor();
 	
 	/**
-	 * Get the version of this PlaceholderExpansion
+	 * The version of this expansion
 	 * @return current version of this expansion
 	 */
 	public abstract String getVersion();
 
-	public String getDescription() { return null; }
+  /**
+   * The name of the plugin that this expansion hooks into.
+   * by default will return the deprecated {@link #getPlugin()} method
+   * @return plugin name that this expansion requires to function
+   */
+  public String getRequiredPlugin() {
+    return getPlugin();
+  }
 
-	public String getLink() { return null; }
-
-	public List<String> getPlaceholders() {
-		return null;
-	}
+  /**
+   * The placeholders associated with this expansion
+   * @return placeholder list that this expansion provides
+   */
+  public List<String> getPlaceholders() {
+    return null;
+  }
 
 	/**
 	 * Expansions that do not use the ecloud and instead register from the dependency should set this to true
 	 * to ensure that your placeholder expansion is not unregistered when the papi reload command is used
-	 * @return if the expansion should persist through reloads
+	 * @return if this expansion should persist through placeholder reloads
 	 */
 	public boolean persist() {
 		return false;
 	}
 	
 	/**
-	 * Check if a placeholder has already been registered with this identifier
-	 * @return true if the identifier for this expansion has already been registered
+	 * Check if this placeholder identfier has already been registered
+	 * @return true if the identifier for this expansion is already registered
 	 */
 	public boolean isRegistered() {
 		Validate.notNull(getIdentifier(), "Placeholder identifier can not be null!");
@@ -94,20 +93,21 @@ public abstract class PlaceholderExpansion extends PlaceholderHook {
 	}
 	
 	/**
-	 * If any requirements are required to be checked before this hook can register, add them here
+	 * If any requirements need to be checked before this expansion should register,
+   * you can check them here
 	 * @return true if this hook meets all the requirements to register
 	 */
 	public boolean canRegister() {
-		return getPlugin() == null || Bukkit.getPluginManager().getPlugin(getPlugin()) != null;
+		return getRequiredPlugin() == null || Bukkit.getPluginManager().getPlugin(getRequiredPlugin()) != null;
 	}
 	
 	/**
-	 * Attempt to register this PlaceholderExpansion with PlaceholderAPI
-	 * @return true if this class and identifier have been successfully registered with PlaceholderAPI
+	 * Attempt to register this PlaceholderExpansion
+	 * @return true if this expansion is now registered with PlaceholderAPI
 	 */
 	public boolean register() {
 		Validate.notNull(getIdentifier(), "Placeholder identifier can not be null!");
-		return PlaceholderAPI.registerPlaceholderHook(getIdentifier(), this);
+		return PlaceholderAPI.registerExpansion(this);
 	}
 	
 	/**
@@ -153,4 +153,25 @@ public abstract class PlaceholderExpansion extends PlaceholderHook {
 	public boolean configurationContains(String path) {
 		return getPlaceholderAPI().getConfig().contains("expansions." + getIdentifier() + "." + path); 
 	}
+
+
+  /**
+   * @deprecated  As of versions greater than 2.8.7, use {@link #getRequiredPlugin()}
+   */
+  @Deprecated
+  public String getPlugin() {
+    return null;
+  }
+
+  /**
+   * @deprecated  As of versions greater than 2.8.7, use the expansion cloud to show a description
+   */
+  @Deprecated
+  public String getDescription() { return null; }
+
+  /**
+   * @deprecated  As of versions greater than 2.8.7, use the expansion cloud to display a link
+   */
+  @Deprecated
+  public String getLink() { return null; }
 }

src/main/java/me/clip/placeholderapi/expansion/cloud/CloudExpansion.java

@@ -22,8 +22,6 @@ package me.clip.placeholderapi.expansion.cloud;
 
 import me.clip.placeholderapi.util.TimeUtil;
 
-import java.util.ArrayList;
-import java.util.HashSet;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;

src/main/java/me/clip/placeholderapi/expansion/cloud/ExpansionCloudManager.java

@@ -42,289 +42,291 @@ import java.util.stream.IntStream;
 
 public class ExpansionCloudManager {
 
-	private PlaceholderAPIPlugin plugin;
-	private final String API = "http://api.extendedclip.com/v2/";
-	private final File dir;
-	private final TreeMap<Integer, CloudExpansion> remote = new TreeMap<>();
-	private final List<String> downloading = new ArrayList<>();
-	private Gson gson;
+    private PlaceholderAPIPlugin plugin;
+    private final String API = "http://api.extendedclip.com/v2/";
+    private final File dir;
+    private final TreeMap<Integer, CloudExpansion> remote = new TreeMap<>();
+    private final List<String> downloading = new ArrayList<>();
+    private Gson gson;
 
-	public ExpansionCloudManager(PlaceholderAPIPlugin instance) {
-		plugin = instance;
-		gson = new Gson();
-		dir = new File(instance.getDataFolder() + File.separator + "expansions");
-		if (!dir.exists()) {
-			try {
-				dir.mkdirs();
-			} catch (Exception ex) {
-            ex.printStackTrace();
+    public ExpansionCloudManager(PlaceholderAPIPlugin instance) {
+        plugin = instance;
+        gson = new Gson();
+        dir = new File(instance.getDataFolder() + File.separator + "expansions");
+        if (!dir.exists()) {
+            try {
+                dir.mkdirs();
+            } catch (Exception ex) {
+                ex.printStackTrace();
+            }
         }
-		}
-	}
+    }
 
-	public void clean() {
-		remote.clear();
-		downloading.clear();
-		gson = null;
-	}
+    public void clean() {
+        remote.clear();
+        downloading.clear();
+    }
 
-	public boolean isDownloading(String expansion) {
-	    return downloading.contains(expansion);
-	}
+    public boolean isDownloading(String expansion) {
+        return downloading.contains(expansion);
+    }
 
-	public Map<Integer, CloudExpansion> getCloudExpansions() {
-	    return remote;
-	}
+    public Map<Integer, CloudExpansion> getCloudExpansions() {
+        return remote;
+    }
 
-	public CloudExpansion getCloudExpansion(String name) {
-		return remote.values().stream().filter(ex -> ex.getName().equalsIgnoreCase(name)).findFirst().orElse(null);
-	}
+    public CloudExpansion getCloudExpansion(String name) {
+        return remote.values().stream().filter(ex -> ex.getName().equalsIgnoreCase(name)).findFirst().orElse(null);
+    }
 
-	public int getCloudAuthorCount() {
+    public int getCloudAuthorCount() {
         return remote.values().stream().collect(Collectors.groupingBy(CloudExpansion::getAuthor, Collectors.counting())).size();
-	}
+    }
 
-	public long getToUpdateCount() {
+    public long getToUpdateCount() {
         return PlaceholderAPI.getExpansions().stream().filter(ex -> getCloudExpansion(ex.getName()) != null && getCloudExpansion(ex.getName()).shouldUpdate()).count();
     }
 
-	public Map<Integer, CloudExpansion> getAllByAuthor(String author) {
-		if (remote.isEmpty()) {
-			return null;
-		}
-		TreeMap<Integer, CloudExpansion> byAuthor = new TreeMap<>();
-		boolean first = true;
-		for (CloudExpansion ex : remote.values()) {
-			if (ex.getAuthor().equalsIgnoreCase(author)) {
-				if (first) {
-					first = false;
-					byAuthor.put(0, ex);
-				} else {
-					byAuthor.put(byAuthor.lastKey()+1, ex);
-				}
-			}
-		}
+    public Map<Integer, CloudExpansion> getAllByAuthor(String author) {
+        if (remote.isEmpty()) {
+            return null;
+        }
+        TreeMap<Integer, CloudExpansion> byAuthor = new TreeMap<>();
+        boolean first = true;
+        for (CloudExpansion ex : remote.values()) {
+            if (ex.getAuthor().equalsIgnoreCase(author)) {
+                if (first) {
+                    first = false;
+                    byAuthor.put(0, ex);
+                } else {
+                    byAuthor.put(byAuthor.lastKey() + 1, ex);
+                }
+            }
+        }
 
-		if (byAuthor.isEmpty()) {
-			return null;
-		}
-		return byAuthor;
-	}
-	
-	public Map<Integer, CloudExpansion> getAllInstalled() {
-		if (remote.isEmpty()) {
-			return null;
-		}
-		TreeMap<Integer, CloudExpansion> has = new TreeMap<>();
-		boolean first = true;
-		for (CloudExpansion ex : remote.values()) {
-			if (ex.hasExpansion()) {
-				if (first) {
-					first = false;
-					has.put(1, ex);
-				} else {
-					has.put(has.lastKey()+1, ex);
-				}
-			}
-		}
-		
-		if (has.isEmpty()) {
-			return null;
-		}
-		return has;
-	}
-	
-	public int getPagesAvailable(Map<Integer, CloudExpansion> map, int amount) {
-		if (map == null) { 
-			return 0;
-		}
-		int pages = map.size() > 0 ? 1 : 0;
-		if (pages == 0) {
-			return pages;
-		}
-		if (map.size() > amount) {
-			pages = map.size()/amount;
-			if (map.size() % amount > 0) {
-				pages++;
-			}
-		}
-		return pages;
-	}
-	
-	public Map<Integer, CloudExpansion> getPage(Map<Integer, CloudExpansion> map, int page, int size) {
-		if (map == null || map.size() == 0 || page > getPagesAvailable(map, size)) {
-			return null;
-		}
-		int end = size*page;
-		int start = end-size;
-		TreeMap<Integer, CloudExpansion> ex = new TreeMap<>();
-        IntStream.range(start, end).forEach(n -> ex.put(n, map.get(n)));
-		return ex;
-	}
-
-	public void fetch() {
-		
-		plugin.getLogger().info("Fetching available expansion information...");
-
-		new BukkitRunnable() {
-			
-				@Override
-				public void run() {
-
-					StringBuilder sb;
-
-					try {
-
-						URL site = new URL(API);
-						
-						HttpURLConnection connection = (HttpURLConnection) site.openConnection();
-						
-						connection.setRequestMethod("GET");
-						
-						connection.connect();
-						
-						BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream()));
-						
-						sb = new StringBuilder();
-						
-						String line;
-
-						while ((line = br.readLine()) != null) {
-							sb.append(line);
-						}
-
-						br.close();
-						connection.disconnect();
-
-					} catch (Exception e) {
-						return;
-					}
-
-					String json = sb.toString();
-					JSONParser parser = new JSONParser();
-					Object obj = null;
-
-					try {
-                        obj = parser.parse(json);
-                    } catch (ParseException e) {
-                        e.printStackTrace();
-                    }
-
-					if (obj == null) {
-                        return;
-                    }
-
-					List<CloudExpansion> unsorted = new ArrayList<>();
-
-					if (obj instanceof JSONObject) {
-
-                        JSONObject jo = (JSONObject) obj;
-
-                        for (Object o : jo.keySet()) {
-
-							JSONObject sub = (JSONObject) jo.get(o);
-
-                        	CloudExpansion ce = gson.fromJson(sub.toJSONString(), CloudExpansion.class);
-
-                        	if (ce.getLatestVersion() == null || ce.getVersion(ce.getLatestVersion()) == null) {
-                        	    continue;
-                            }
-
-                        	ce.setName(o.toString());
-
-                            PlaceholderExpansion ex = plugin.getExpansionManager().getRegisteredExpansion(ce.getName());
-
-                            if (ex != null && ex.isRegistered()) {
-                                ce.setHasExpansion(true);
-                                if (!ex.getVersion().equals(ce.getLatestVersion())) {
-                                    ce.setShouldUpdate(true);
-                                }
-                            }
-
-                            unsorted.add(ce);
-                        }
-
-                        int count = 0;
-
-                        unsorted.sort(Comparator.comparing(CloudExpansion::getLastUpdate).reversed());
-
-                        for (CloudExpansion e : unsorted) {
-                            remote.put(count, e);
-                            count++;
-                        }
-
-                        plugin.getLogger().info(count + " placeholder expansions are available on the cloud.");
-
-                        long updates = getToUpdateCount();
-
-                        if (updates > 0) {
-                            plugin.getLogger().info(updates + " installed expansions have updates available.");
-                        }
-                    }
-				}
-		}.runTaskAsynchronously(plugin);
-	}
-	
-	private void download(URL url, String name) throws IOException {
-	    
-		InputStream is = null;
-		
-	    FileOutputStream fos = null;
-
-	    try {
-	    	
-	        URLConnection urlConn = url.openConnection();
-	        
-	        is = urlConn.getInputStream();  
-	        
-	        fos = new FileOutputStream(dir.getAbsolutePath() + File.separator + "Expansion-" + name + ".jar");
-
-	        byte[] buffer = new byte[is.available()];
-	        
-	        int l;
-
-	        while ((l = is.read(buffer)) > 0) {  
-	            fos.write(buffer, 0, l);
-	        }
-	    } finally {
-	        try {
-	            if (is != null) {
-	                is.close();
-	            }
-	        } finally {
-	            if (fos != null) {
-	                fos.close();
-	            }
-	        }
-	    }
-	}
-
-	public void downloadExpansion(final String player, final CloudExpansion ex) {
-	    downloadExpansion(player, ex, ex.getLatestVersion());
+        if (byAuthor.isEmpty()) {
+            return null;
+        }
+        return byAuthor;
     }
 
-	public void downloadExpansion(final String player, final CloudExpansion ex, final String version) {
+    public Map<Integer, CloudExpansion> getAllInstalled() {
+        if (remote.isEmpty()) {
+            return null;
+        }
+        TreeMap<Integer, CloudExpansion> has = new TreeMap<>();
+        boolean first = true;
+        for (CloudExpansion ex : remote.values()) {
+            if (ex.hasExpansion()) {
+                if (first) {
+                    first = false;
+                    has.put(1, ex);
+                } else {
+                    has.put(has.lastKey() + 1, ex);
+                }
+            }
+        }
 
-		if (downloading.contains(ex.getName())) {
-			return;
-		}
+        if (has.isEmpty()) {
+            return null;
+        }
+        return has;
+    }
 
-		final CloudExpansion.Version ver = ex.getVersions()
-				.stream()
-				.filter(v -> v.getVersion().equals(version))
-				.findFirst()
-				.orElse(null);
+    public int getPagesAvailable(Map<Integer, CloudExpansion> map, int amount) {
+        if (map == null) {
+            return 0;
+        }
+        int pages = map.size() > 0 ? 1 : 0;
+        if (pages == 0) {
+            return pages;
+        }
+        if (map.size() > amount) {
+            pages = map.size() / amount;
+            if (map.size() % amount > 0) {
+                pages++;
+            }
+        }
+        return pages;
+    }
 
+    public Map<Integer, CloudExpansion> getPage(Map<Integer, CloudExpansion> map, int page, int size) {
+        if (map == null || map.size() == 0 || page > getPagesAvailable(map, size)) {
+            return null;
+        }
+        int end = size * page;
+        int start = end - size;
+        TreeMap<Integer, CloudExpansion> ex = new TreeMap<>();
+        IntStream.range(start, end).forEach(n -> ex.put(n, map.get(n)));
+        return ex;
+    }
 
-		if (ver == null) {
-			return;
-		}
+    public void fetch(boolean allowUnverified) {
 
-		downloading.add(ex.getName());
+        plugin.getLogger().info("Fetching available expansion information...");
 
-		plugin.getLogger().info("Attempting download of expansion: " + ex.getName() + (player != null ? " by user: " + player : "") + " from url: " + ver.getUrl());
+        new BukkitRunnable() {
 
-		Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
+            @Override
+            public void run() {
+
+                StringBuilder sb;
+
+                try {
+
+                    URL site = new URL(API);
+
+                    HttpURLConnection connection = (HttpURLConnection) site.openConnection();
+
+                    connection.setRequestMethod("GET");
+
+                    connection.connect();
+
+                    BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream()));
+
+                    sb = new StringBuilder();
+
+                    String line;
+
+                    while ((line = br.readLine()) != null) {
+                        sb.append(line);
+                    }
+
+                    br.close();
+                    connection.disconnect();
+
+                } catch (Exception e) {
+                    return;
+                }
+
+                String json = sb.toString();
+                JSONParser parser = new JSONParser();
+                Object obj = null;
+
+                try {
+                    obj = parser.parse(json);
+                } catch (ParseException e) {
+                    e.printStackTrace();
+                }
+
+                if (obj == null) {
+                    return;
+                }
+
+                List<CloudExpansion> unsorted = new ArrayList<>();
+
+                if (obj instanceof JSONObject) {
+
+                    JSONObject jo = (JSONObject) obj;
+
+                    for (Object o : jo.keySet()) {
+
+                        JSONObject sub = (JSONObject) jo.get(o);
+
+                        CloudExpansion ce = gson.fromJson(sub.toJSONString(), CloudExpansion.class);
+
+                        if (!allowUnverified && !ce.isVerified()) {
+                            continue;
+                        }
+
+                        if (ce.getLatestVersion() == null || ce.getVersion(ce.getLatestVersion()) == null) {
+                            continue;
+                        }
+
+                        ce.setName(o.toString());
+
+                        PlaceholderExpansion ex = plugin.getExpansionManager().getRegisteredExpansion(ce.getName());
+
+                        if (ex != null && ex.isRegistered()) {
+                            ce.setHasExpansion(true);
+                            if (!ex.getVersion().equals(ce.getLatestVersion())) {
+                                ce.setShouldUpdate(true);
+                            }
+                        }
+
+                        unsorted.add(ce);
+                    }
+
+                    int count = 0;
+
+                    unsorted.sort(Comparator.comparing(CloudExpansion::getLastUpdate).reversed());
+
+                    for (CloudExpansion e : unsorted) {
+                        remote.put(count, e);
+                        count++;
+                    }
+
+                    plugin.getLogger().info(count + " placeholder expansions are available on the cloud.");
+
+                    long updates = getToUpdateCount();
+
+                    if (updates > 0) {
+                        plugin.getLogger().info(updates + " installed expansions have updates available.");
+                    }
+                }
+            }
+        }.runTaskAsynchronously(plugin);
+    }
+
+    private void download(URL url, String name) throws IOException {
+
+        InputStream is = null;
+
+        FileOutputStream fos = null;
+
+        try {
+
+            URLConnection urlConn = url.openConnection();
+
+            is = urlConn.getInputStream();
+
+            fos = new FileOutputStream(dir.getAbsolutePath() + File.separator + "Expansion-" + name + ".jar");
+
+            byte[] buffer = new byte[is.available()];
+
+            int l;
+
+            while ((l = is.read(buffer)) > 0) {
+                fos.write(buffer, 0, l);
+            }
+        } finally {
+            try {
+                if (is != null) {
+                    is.close();
+                }
+            } finally {
+                if (fos != null) {
+                    fos.close();
+                }
+            }
+        }
+    }
+
+    public void downloadExpansion(final String player, final CloudExpansion ex) {
+        downloadExpansion(player, ex, ex.getLatestVersion());
+    }
+
+    public void downloadExpansion(final String player, final CloudExpansion ex, final String version) {
+
+        if (downloading.contains(ex.getName())) {
+            return;
+        }
+
+        final CloudExpansion.Version ver = ex.getVersions()
+                .stream()
+                .filter(v -> v.getVersion().equals(version))
+                .findFirst()
+                .orElse(null);
+
+        if (ver == null) {
+            return;
+        }
+
+        downloading.add(ex.getName());
+
+        plugin.getLogger().info("Attempting download of expansion: " + ex.getName() + (player != null ? " by user: " + player : "") + " from url: " + ver.getUrl());
+
+        Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
 
             try {
 
@@ -367,5 +369,5 @@ public class ExpansionCloudManager {
             });
 
         });
-	}
+    }
 }

src/main/java/me/clip/placeholderapi/updatechecker/UpdateChecker.java

@@ -1,8 +1,8 @@
 package me.clip.placeholderapi.updatechecker;
 
 import me.clip.placeholderapi.PlaceholderAPIPlugin;
+import me.clip.placeholderapi.util.Msg;
 import org.bukkit.Bukkit;
-import org.bukkit.ChatColor;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
@@ -12,94 +12,73 @@ import javax.net.ssl.HttpsURLConnection;
 import java.io.BufferedReader;
 import java.io.InputStreamReader;
 import java.net.URL;
-import java.util.regex.Pattern;
 
-/**
- * thanks maxim
- */
 public class UpdateChecker implements Listener {
 
 	private PlaceholderAPIPlugin plugin;
-	
-    private final int resourceId = 6245;
-    
-    private static String latestVersion = "";
-    
-    private static boolean updateAvailable = false;
+    private final int RESOURCE_ID = 6245;
+    private String spigotVersion, pluginVersion;
+    private boolean updateAvailable;
 
     public UpdateChecker(PlaceholderAPIPlugin i) {
     	plugin = i;
-    	Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
-            if (checkForUpdate()) {
-                Bukkit.getScheduler().runTask(plugin, () -> {
-                    plugin.getLogger().info("An update for PlaceholderAPI (v" + getLatestVersion() + ") is available at:");
-                    plugin.getLogger().info("https://www.spigotmc.org/resources/placeholderapi." + resourceId + "/");
-                    register();
-                });
+        pluginVersion = i.getDescription().getVersion();
+    }
+
+    public boolean hasUpdateAvailable() { return updateAvailable; }
+
+    public String getSpigotVersion() {
+        return spigotVersion;
+    }
+
+    public void fetch() {
+        Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
+            try {
+                HttpsURLConnection con = (HttpsURLConnection) new URL("https://api.spigotmc.org/legacy/update.php?resource=" + RESOURCE_ID).openConnection();
+                con.setRequestMethod("GET");
+                spigotVersion = new BufferedReader(new InputStreamReader(con.getInputStream())).readLine();
+            } catch (Exception ex) {
+                plugin.getLogger().info("Failed to check for updates on spigot.");
+                return;
             }
+
+            if (spigotVersion == null || spigotVersion.isEmpty()) {
+                return;
+            }
+
+            updateAvailable = spigotIsNewer();
+
+            if (!updateAvailable) {
+                return;
+            }
+
+            Bukkit.getScheduler().runTask(plugin, () -> {
+                    plugin.getLogger().info("An update for PlaceholderAPI (v" + getSpigotVersion() + ") is available at:");
+                    plugin.getLogger().info("https://www.spigotmc.org/resources/placeholderapi." + RESOURCE_ID + "/");
+                    Bukkit.getPluginManager().registerEvents(this, plugin);
+            });
         });
     }
 
-    private void register() {
-    	Bukkit.getPluginManager().registerEvents(this, plugin);
+    private boolean spigotIsNewer() {
+        if (spigotVersion == null || spigotVersion.isEmpty()) return false;
+        String plV = toReadable(pluginVersion);
+        String spV = toReadable(spigotVersion);
+        return plV.compareTo(spV) < 0;
+    }
+
+    private String toReadable(String version) {
+        if (version.contains("-DEV-")) {
+            version = version.split("-DEV-")[0];
+        }
+        return version.replaceAll("\\.","");
     }
 
     @EventHandler(priority = EventPriority.MONITOR)
     public void onJoin(PlayerJoinEvent e) {
-    	if (e.getPlayer().hasPermission("placeholderapi.updatenotify")) {
-    		e.getPlayer().sendMessage(ChatColor.translateAlternateColorCodes('&', "&bAn update for &fPlaceholder&7API &e(&fPlaceholder&7API &fv" + getLatestVersion() + "&e)"));
-    		e.getPlayer().sendMessage(ChatColor.translateAlternateColorCodes('&', "&bis available at &ehttps://www.spigotmc.org/resources/placeholderapi." + resourceId + "/"));
-    	}
-    }
-
-    private String getSpigotVersion() {
-        try {
-            HttpsURLConnection con = (HttpsURLConnection) new URL("https://api.spigotmc.org/legacy/update.php?resource=" + resourceId).openConnection();
-            con.setRequestMethod("GET");
-            String version = new BufferedReader(new InputStreamReader(con.getInputStream())).readLine();
-            if (version.length() <= 7) {
-                return version;
-            }
-        } catch (Exception ex) {
-            plugin.getLogger().info("Failed to check for a update on spigot.");
+        if (e.getPlayer().hasPermission("placeholderapi.updatenotify")) {
+            Msg.msg(e.getPlayer(), "&bAn update for &fPlaceholder&7API &e(&fPlaceholder&7API &fv" + getSpigotVersion() + "&e)"
+            , "&bis available at &ehttps://www.spigotmc.org/resources/placeholderapi." + RESOURCE_ID + "/");
         }
-        return null;
     }
-
-    private boolean checkHigher(String currentVersion, String newVersion) {
-        String current = toReadable(currentVersion);
-        String newVers = toReadable(newVersion);
-        return current.compareTo(newVers) < 0;
-    }
-
-    public boolean checkForUpdate() {
-        String version = getSpigotVersion();
-        if (version != null) {
-            if (checkHigher(plugin.getDescription().getVersion(), version)) {
-                latestVersion = version;
-                updateAvailable = true;
-                return true;
-            }
-        }
-        return false;
-    }
-
-    public static boolean updateAvailable() {
-        return updateAvailable;
-    }
-
-    public static String getLatestVersion() {
-        return latestVersion;
-    }
-
-    private String toReadable(String version) {
-        String[] split = Pattern.compile(".", Pattern.LITERAL).split(version.replace("v", ""));
-        version = "";
-        for (String s : split) {
-        	version += String.format("%4s", s);
-        } 
-        return version;
-    }
-	 
-
 }

src/main/java/me/clip/placeholderapi/util/Msg.java

@@ -28,7 +28,7 @@ import java.util.Arrays;
 public class Msg {
 
 	public static void msg(CommandSender s, String... msg) {
-		Arrays.stream(msg).forEach(text  -> s.sendMessage(color(text)));
+		Arrays.stream(msg).map(Msg::color).forEach(s::sendMessage);
 	}
 
 	public static String color(String text) {