Update to 2.8.7

Changed Msg#msg to use method references

pom.xml

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

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

@@ -20,13 +20,14 @@
  */
 package me.clip.placeholderapi;
 
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+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.entity.Player;
 import org.bukkit.plugin.Plugin;
 
@@ -35,227 +36,235 @@ import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
+import static me.clip.placeholderapi.util.Msg.color;
+
 public class PlaceholderAPI {
-	
-	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 !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));
+    private PlaceholderAPI() {
     }
 
-	/**
-	 * 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(Player p, List<String> text) {
-		return setPlaceholders(p, text, BRACKET_PLACEHOLDER_PATTERN);
-	}
+    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<>();
 
-	/**
-	 * 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);
-	}
+    /**
+     * 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;
+    }
+
+    /**
+     * 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() {
+        return ImmutableSet.copyOf(placeholders.keySet());
+    }
+
+    /**
+     * Get map of registered placeholders
+     *
+     * @return copy of the internal placeholder map
+     */
+    public static Map<String, PlaceholderHook> getPlaceholders() {
+        return ImmutableMap.copyOf(placeholders);
+    }
+
+    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);
+    }
+
+    /**
+     * 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(Player 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 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);
+    }
+
+    /**
+     * 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;
+        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
+     * @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 %<(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 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);
-	}
+    public static String setPlaceholders(Player player, String text, Pattern placeholderPattern) {
+        if (text == null) return null;
+        if (placeholders.isEmpty()) return color(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 color(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;
+        return text.stream().map(line -> setRelationalPlaceholders(one, two, line)).collect(Collectors.toList());
+    }
+
+    /**
+     * 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);
+    }
 
     /**
      * unregister ALL placeholder hooks that are currently registered
@@ -272,7 +281,7 @@ public class PlaceholderAPI {
         if (placeholders.isEmpty()) return;
         getPlaceholders().forEach((key, value) -> {
             if (value instanceof PlaceholderExpansion) {
-            	PlaceholderExpansion ex = (PlaceholderExpansion) value;
+                PlaceholderExpansion ex = (PlaceholderExpansion) value;
                 if (!ex.persist()) {
                     unregisterExpansion(ex);
                 }
@@ -280,6 +289,14 @@ public class PlaceholderAPI {
         });
     }
 
+    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));
@@ -287,37 +304,36 @@ public class PlaceholderAPI {
         }
         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;
-	}
-	
-	public static String colorize(String text) {
-		return ChatColor.translateAlternateColorCodes('&', text);
-	}
-	
-	@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 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());
+    }
 }

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();
@@ -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/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/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/PlaceholderExpansion.java

@@ -107,7 +107,7 @@ public abstract class PlaceholderExpansion extends PlaceholderHook {
 	 */
 	public boolean register() {
 		Validate.notNull(getIdentifier(), "Placeholder identifier can not be null!");
-		return PlaceholderAPI.registerPlaceholderHook(getIdentifier(), this);
+		return PlaceholderAPI.registerExpansion(this);
 	}
 	
 	/**

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 boolean isDownloading(String expansion) {
-	    return downloading.contains(expansion);
-	}
-	
-	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 int getCloudAuthorCount() {
+    }
+
+    public void clean() {
+        remote.clear();
+        downloading.clear();
+    }
+
+    public boolean isDownloading(String expansion) {
+        return downloading.contains(expansion);
+    }
+
+    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 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);
-				}
-			}
-		}
-		
-		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 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 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) {
-		
-		if (downloading.contains(ex.getName())) {
-			return;
-		}
 
-		final CloudExpansion.Version ver = ex.getVersions()
-				.stream()
-				.filter(v -> v.getVersion().equals(version))
-				.findFirst()
-				.orElse(null);
+    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 (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());
+        if (has.isEmpty()) {
+            return null;
+        }
+        return has;
+    }
 
-		Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
+    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(boolean allowUnverified) {
+
+        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 (!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);
-    }
-    
-    @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.");
-        }
-        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 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) {
-        String[] split = Pattern.compile(".", Pattern.LITERAL).split(version.replace("v", ""));
-        version = "";
-        for (String s : split) {
-        	version += String.format("%4s", s);
-        } 
-        return 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")) {
+            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 + "/");
+        }
+    }
 }

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) {