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.7</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,320 +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.expansion.PlaceholderExpansion;
 import me.clip.placeholderapi.expansion.Relational;
 import org.apache.commons.lang.Validate;
 import org.bukkit.Bukkit;
+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;
-
-import static me.clip.placeholderapi.util.Msg.color;
-
 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() {
+  }
+
+  /**
+   * 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;
+  }
 
-    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<>();
+  /**
+   * 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 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;
+  /**
+   * 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(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());
+  }
 
-    /**
-     * 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;
+  /**
+   * 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;
     }
-
-    /**
-     * 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;
+    if (placeholders.isEmpty()) {
+      return color(text);
     }
-
-    /**
-     * 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 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;
-        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 %<(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 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));
-                }
-            }
+    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 color(text);
+      }
     }
+    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 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));
-                }
-            }
+  /**
+   * 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;
         }
-        return color(text);
-    }
-
-    /**
-     * unregister ALL placeholder hooks that are currently registered
-     */
-    protected static void unregisterAll() {
-        unregisterAllProvidedExpansions();
-        placeholders.clear();
-    }
-
-    /**
-     * 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 registerExpansion(PlaceholderExpansion ex) {
-        if (registerPlaceholderHook(ex.getIdentifier(), ex)) {
-            Bukkit.getPluginManager().callEvent(new ExpansionRegisterEvent(ex));
-            return true;
+        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 false;
+      }
     }
+    return color(text);
+  }
 
-    public static boolean unregisterExpansion(PlaceholderExpansion ex) {
-        if (unregisterPlaceholderHook(ex.getIdentifier())) {
-            Bukkit.getPluginManager().callEvent(new ExpansionUnregisterEvent(ex));
-            return true;
+  /**
+   * unregister ALL placeholder hooks that are currently registered
+   */
+  protected static void unregisterAll() {
+    unregisterAllProvidedExpansions();
+    placeholders.clear();
+  }
+
+  /**
+   * 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);
         }
-        return false;
-    }
+      }
+    });
+  }
 
-    public static Pattern getPlaceholderPattern() {
-        return PLACEHOLDER_PATTERN;
+  public static boolean registerExpansion(PlaceholderExpansion ex) {
+    if (registerPlaceholderHook(ex.getIdentifier(), ex)) {
+      Bukkit.getPluginManager().callEvent(new ExpansionRegisterEvent(ex));
+      return true;
     }
+    return false;
+  }
 
-    public static Pattern getBracketPlaceholderPattern() {
-        return BRACKET_PLACEHOLDER_PATTERN;
+  public static boolean unregisterExpansion(PlaceholderExpansion ex) {
+    if (unregisterPlaceholderHook(ex.getIdentifier())) {
+      Bukkit.getPluginManager().callEvent(new ExpansionUnregisterEvent(ex));
+      return true;
     }
+    return false;
+  }
 
-    public static Pattern getRelationalPlaceholderPattern() {
-        return RELATIONAL_PLACEHOLDER_PATTERN;
-    }
+  public static Pattern getPlaceholderPattern() {
+    return PLACEHOLDER_PATTERN;
+  }
 
-    @Deprecated
-    public static Set<String> getRegisteredPlaceholderPlugins() {
-        return getRegisteredIdentifiers();
-    }
+  public static Pattern getBracketPlaceholderPattern() {
+    return BRACKET_PLACEHOLDER_PATTERN;
+  }
 
-    @Deprecated
-    public static Set<String> getExternalPlaceholderPlugins() {
-        return null;
-    }
+  public static Pattern getRelationalPlaceholderPattern() {
+    return RELATIONAL_PLACEHOLDER_PATTERN;
+  }
 
-    @Deprecated
-    public static boolean registerPlaceholderHook(Plugin plugin, PlaceholderHook placeholderHook) {
-        return plugin != null && registerPlaceholderHook(plugin.getName(), placeholderHook);
-    }
+  @Deprecated
+  public static Set<String> getRegisteredPlaceholderPlugins() {
+    return getRegisteredIdentifiers();
+  }
 
-    @Deprecated
-    public static boolean unregisterPlaceholderHook(Plugin plugin) {
-        return plugin != null && unregisterPlaceholderHook(plugin.getName());
-    }
+  @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

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

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/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/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,16 +93,17 @@ 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!");
@@ -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; }
 }