TestingPluginManager.java

package pluginbase.testingbukkit.plugin;

import com.google.common.collect.ImmutableSet;
import org.bukkit.Server;
import org.bukkit.event.Event;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.permissions.Permissible;
import org.bukkit.permissions.Permission;
import org.bukkit.permissions.PermissionDefault;
import org.bukkit.plugin.*;
import org.bukkit.plugin.java.JavaPlugin;
import org.powermock.api.mockito.PowerMockito;
import pluginbase.testingbukkit.FileLocations;

import java.io.File;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.util.*;

public class TestingPluginManager implements PluginManager {

    List<Plugin> plugins = new ArrayList<Plugin>();
    Set<Plugin> enabledPlugins = new HashSet<Plugin>();
    private final Map<String, Permission> permissions = new HashMap<String, Permission>();
    private final Map<Boolean, Set<Permission>> defaultPerms = new LinkedHashMap<Boolean, Set<Permission>>();
    private final Map<String, Map<Permissible, Boolean>> permSubs = new HashMap<String, Map<Permissible, Boolean>>();
    private final Map<Boolean, Map<Permissible, Boolean>> defSubs = new HashMap<Boolean, Map<Permissible, Boolean>>();

    Server server;
    PluginLoader pluginLoader;

    public TestingPluginManager(Server server) {
        this.server = server;

        this.pluginLoader = PowerMockito.mock(PluginLoader.class);

        defaultPerms.put(true, new HashSet<Permission>());
        defaultPerms.put(false, new HashSet<Permission>());
    }

    @Override
    public void registerInterface(Class<? extends PluginLoader> aClass) throws IllegalArgumentException {
        //To change body of implemented methods use File | Settings | File Templates.
    }

    @Override
    public Plugin getPlugin(String s) {
        for (Plugin plugin : plugins) {
            if (plugin.getName().equals(s)) {
                return plugin;
            }
        }
        return null;
    }

    @Override
    public Plugin[] getPlugins() {
        return plugins.toArray(new Plugin[plugins.size()]);
    }

    @Override
    public boolean isPluginEnabled(String s) {
        for (Plugin plugin : enabledPlugins) {
            if (plugin.getName().equals(s)) {
                return true;
            }
        }
        return false;
    }

    @Override
    public boolean isPluginEnabled(Plugin plugin) {
        return enabledPlugins.contains(plugin);
    }

    @Override
    public Plugin loadPlugin(File file) throws InvalidPluginException, InvalidDescriptionException, UnknownDependencyException {
        return null;
    }

    public Plugin loadPlugin(PluginDescriptionFile pdf) {
        try {
            Class<Plugin> clazz = (Class<Plugin>) Class.forName(pdf.getMain());
            Constructor<Plugin> constructor = clazz.getDeclaredConstructor(PluginLoader.class, Server.class, PluginDescriptionFile.class, File.class, File.class);
            constructor.setAccessible(true);
            File pluginDir = new File(FileLocations.PLUGIN_DIRECTORY, pdf.getName());
            Plugin plugin = constructor.newInstance(pluginLoader, server, pdf, pluginDir, new File(FileLocations.PLUGIN_DIRECTORY, "pluginTestFile"));
            //getField("server").set(plugin, server);
            //getField("description").set(plugin, pdf);
            //getField("dataFolder").set(plugin, pluginDir);
            plugin.onLoad();
            plugins.add(plugin);
            return plugin;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    private Field getField(String name) throws Exception {
        Field field = JavaPlugin.class.getDeclaredField(name);
        field.setAccessible(true);
        return field;
    }

    @Override
    public Plugin[] loadPlugins(File file) {
        return new Plugin[0];
    }

    @Override
    public void disablePlugins() {
        for (Plugin plugin : new HashSet<Plugin>(enabledPlugins)) {
            disablePlugin(plugin);
        }
    }

    @Override
    public void clearPlugins() {
        disablePlugins();
        plugins.clear();
    }

    @Override
    public void callEvent(Event event) throws IllegalStateException {
        //To change body of implemented methods use File | Settings | File Templates.
    }

    @Override
    public void registerEvents(Listener listener, Plugin plugin) {
        //To change body of implemented methods use File | Settings | File Templates.
    }

    @Override
    public void registerEvent(Class<? extends Event> aClass, Listener listener, EventPriority eventPriority, EventExecutor eventExecutor, Plugin plugin) {
        //To change body of implemented methods use File | Settings | File Templates.
    }

    @Override
    public void registerEvent(Class<? extends Event> aClass, Listener listener, EventPriority eventPriority, EventExecutor eventExecutor, Plugin plugin, boolean b) {
        //To change body of implemented methods use File | Settings | File Templates.
    }

    @Override
    public void enablePlugin(Plugin plugin) {
        plugin.onEnable();
    }

    @Override
    public void disablePlugin(Plugin plugin) {
        if (enabledPlugins.contains(plugin)) {
            plugin.onDisable();
            enabledPlugins.remove(plugin);
        }
    }

    public Permission getPermission(String name) {
        return permissions.get(name.toLowerCase());
    }

    public void addPermission(Permission perm) {
        String name = perm.getName().toLowerCase();

        if (permissions.containsKey(name)) {
            throw new IllegalArgumentException("The permission " + name + " is already defined!");
        }

        permissions.put(name, perm);
        calculatePermissionDefault(perm);
    }

    public Set<Permission> getDefaultPermissions(boolean op) {
        return ImmutableSet.copyOf(defaultPerms.get(op));
    }

    public void removePermission(Permission perm) {
        removePermission(perm.getName());
    }

    public void removePermission(String name) {
        permissions.remove(name.toLowerCase());
    }

    public void recalculatePermissionDefaults(Permission perm) {
        if (permissions.containsValue(perm)) {
            defaultPerms.get(true).remove(perm);
            defaultPerms.get(false).remove(perm);

            calculatePermissionDefault(perm);
        }
    }

    private void calculatePermissionDefault(Permission perm) {
        if ((perm.getDefault() == PermissionDefault.OP) || (perm.getDefault() == PermissionDefault.TRUE)) {
            defaultPerms.get(true).add(perm);
            dirtyPermissibles(true);
        }
        if ((perm.getDefault() == PermissionDefault.NOT_OP) || (perm.getDefault() == PermissionDefault.TRUE)) {
            defaultPerms.get(false).add(perm);
            dirtyPermissibles(false);
        }
    }

    private void dirtyPermissibles(boolean op) {
        Set<Permissible> permissibles = getDefaultPermSubscriptions(op);

        for (Permissible p : permissibles) {
            p.recalculatePermissions();
        }
    }

    public void subscribeToPermission(String permission, Permissible permissible) {
        String name = permission.toLowerCase();
        Map<Permissible, Boolean> map = permSubs.get(name);

        if (map == null) {
            map = new WeakHashMap<Permissible, Boolean>();
            permSubs.put(name, map);
        }

        map.put(permissible, true);
    }

    public void unsubscribeFromPermission(String permission, Permissible permissible) {
        String name = permission.toLowerCase();
        Map<Permissible, Boolean> map = permSubs.get(name);

        if (map != null) {
            map.remove(permissible);

            if (map.isEmpty()) {
                permSubs.remove(name);
            }
        }
    }

    public Set<Permissible> getPermissionSubscriptions(String permission) {
        String name = permission.toLowerCase();
        Map<Permissible, Boolean> map = permSubs.get(name);

        if (map == null) {
            return ImmutableSet.of();
        } else {
            return ImmutableSet.copyOf(map.keySet());
        }
    }

    public void subscribeToDefaultPerms(boolean op, Permissible permissible) {
        Map<Permissible, Boolean> map = defSubs.get(op);

        if (map == null) {
            map = new WeakHashMap<Permissible, Boolean>();
            defSubs.put(op, map);
        }

        map.put(permissible, true);
    }

    public void unsubscribeFromDefaultPerms(boolean op, Permissible permissible) {
        Map<Permissible, Boolean> map = defSubs.get(op);

        if (map != null) {
            map.remove(permissible);

            if (map.isEmpty()) {
                defSubs.remove(op);
            }
        }
    }

    public Set<Permissible> getDefaultPermSubscriptions(boolean op) {
        Map<Permissible, Boolean> map = defSubs.get(op);

        if (map == null) {
            return ImmutableSet.of();
        } else {
            return ImmutableSet.copyOf(map.keySet());
        }
    }

    public Set<Permission> getPermissions() {
        return new HashSet<Permission>(permissions.values());
    }

    @Override
    public boolean useTimings() {
        return false;
    }
}