Master -> 3.0

6 files changed, 1406 insertions, 0 deletions

diff --git a/Essentials2Compat/pom.xml b/Essentials2Compat/pom.xml
new file mode 100644
index 000000000..9c5bc6752
--- /dev/null
+++ b/Essentials2Compat/pom.xml
@@ -0,0 +1,21 @@
+
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <parent>
+    <groupId>net.essentials3</groupId>
+    <artifactId>BuildAll</artifactId>
+    <version>3.0-SNAPSHOT</version>
+    <relativePath>../pom.xml</relativePath>
+  </parent>
+
+  <artifactId>Essentials2Compat</artifactId>
+  <dependencies>
+    <dependency>
+      <groupId>${project.groupId}</groupId>
+      <artifactId>Essentials</artifactId>
+      <version>${project.version}</version>
+    </dependency>
+  </dependencies>
+</project>
diff --git a/Essentials2Compat/src/com/earth2me/essentials/Essentials.java b/Essentials2Compat/src/com/earth2me/essentials/Essentials.java
new file mode 100644
index 000000000..dc612e8d6
--- /dev/null
+++ b/Essentials2Compat/src/com/earth2me/essentials/Essentials.java
@@ -0,0 +1,22 @@
+package com.earth2me.essentials;
+
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.java.JavaPlugin;
+
+
+public class Essentials extends JavaPlugin
+{
+	@Override
+	public void onEnable()
+	{
+		Bukkit.getLogger().info("You can remove this compatibility plugin, when all plugins are updated to Essentials 3");
+		//TODO: Update files to new 3.0 format
+		//TODO: Move Eco Api here
+	}
+
+	@Override
+	public void onDisable()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+}
diff --git a/Essentials2Compat/src/com/earth2me/essentials/EssentialsConf.java b/Essentials2Compat/src/com/earth2me/essentials/EssentialsConf.java
new file mode 100644
index 000000000..0dc36e262
--- /dev/null
+++ b/Essentials2Compat/src/com/earth2me/essentials/EssentialsConf.java
@@ -0,0 +1,397 @@
+package com.earth2me.essentials;
+
+import static com.earth2me.essentials.I18n._;
+import com.google.common.io.Files;
+import java.io.*;
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.charset.Charset;
+import java.nio.charset.CharsetDecoder;
+import java.nio.charset.CoderResult;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.Server;
+import org.bukkit.World;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.InvalidConfigurationException;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.inventory.ItemStack;
+
+
+@Deprecated
+public class EssentialsConf extends YamlConfiguration
+{
+	private static final Logger LOGGER = Logger.getLogger("Minecraft");
+	private transient File configFile;
+	private transient String templateName = null;
+	private transient Class<?> resourceClass = EssentialsConf.class;
+	private static final Charset UTF8 = Charset.forName("UTF-8");
+
+	public EssentialsConf(final File configFile)
+	{
+		super();
+		this.configFile = configFile;
+	}
+
+	public synchronized void load()
+	{
+		configFile = configFile.getAbsoluteFile();
+		if (!configFile.getParentFile().exists())
+		{
+			if (!configFile.getParentFile().mkdirs())
+			{
+				LOGGER.log(Level.SEVERE, _("failedToCreateConfig", configFile.toString()));
+			}
+		}
+		// This will delete files where the first character is 0. In most cases they are broken.
+		if (configFile.exists() && configFile.length() != 0)
+		{
+			try
+			{
+				final InputStream input = new FileInputStream(configFile);
+				try
+				{
+					if (input.read() == 0)
+					{
+						input.close();
+						configFile.delete();
+					}
+				}
+				catch (IOException ex)
+				{
+					LOGGER.log(Level.SEVERE, null, ex);
+				}
+				finally
+				{
+					try
+					{
+						input.close();
+					}
+					catch (IOException ex)
+					{
+						LOGGER.log(Level.SEVERE, null, ex);
+					}
+				}
+			}
+			catch (FileNotFoundException ex)
+			{
+				LOGGER.log(Level.SEVERE, null, ex);
+			}
+		}
+
+		if (!configFile.exists())
+		{
+			if (templateName != null)
+			{
+				LOGGER.log(Level.INFO, _("creatingConfigFromTemplate", configFile.toString()));
+				createFromTemplate();
+			}
+			else
+			{
+				try
+				{
+					LOGGER.log(Level.INFO, _("creatingEmptyConfig", configFile.toString()));
+					if (!configFile.createNewFile())
+					{
+						LOGGER.log(Level.SEVERE, _("failedToCreateConfig", configFile.toString()));
+					}
+				}
+				catch (IOException ex)
+				{
+					LOGGER.log(Level.SEVERE, _("failedToCreateConfig", configFile.toString()), ex);
+				}
+			}
+		}
+
+
+		try
+		{
+			final FileInputStream inputStream = new FileInputStream(configFile);
+			try
+			{
+				final FileChannel channel = inputStream.getChannel();
+				final ByteBuffer buffer = ByteBuffer.allocate((int)configFile.length());
+				channel.read(buffer);
+				buffer.rewind();
+				final CharBuffer data = CharBuffer.allocate((int)configFile.length());
+				CharsetDecoder decoder = UTF8.newDecoder();
+				CoderResult result = decoder.decode(buffer, data, true);
+				if (result.isError())
+				{
+					buffer.rewind();
+					data.clear();
+					LOGGER.log(Level.INFO, "File " + configFile.getAbsolutePath().toString() + " is not utf-8 encoded, trying " + Charset.defaultCharset().displayName());
+					decoder = Charset.defaultCharset().newDecoder();
+					result = decoder.decode(buffer, data, true);
+					if (result.isError())
+					{
+						throw new InvalidConfigurationException("Invalid Characters in file " + configFile.getAbsolutePath().toString());
+					}
+					else
+					{
+						decoder.flush(data);
+					}
+				}
+				else
+				{
+					decoder.flush(data);
+				}
+				final int end = data.position();
+				data.rewind();
+				super.loadFromString(data.subSequence(0, end).toString());
+			}
+			finally
+			{
+				inputStream.close();
+			}
+		}
+		catch (IOException ex)
+		{
+			LOGGER.log(Level.SEVERE, ex.getMessage(), ex);
+		}
+		catch (InvalidConfigurationException ex)
+		{
+			File broken = new File(configFile.getAbsolutePath() + ".broken." + System.currentTimeMillis());
+			configFile.renameTo(broken);
+			LOGGER.log(Level.SEVERE, "The file " + configFile.toString() + " is broken, it has been renamed to " + broken.toString(), ex.getCause());
+		}
+	}
+
+	private void createFromTemplate()
+	{
+		InputStream istr = null;
+		OutputStream ostr = null;
+		try
+		{
+			istr = resourceClass.getResourceAsStream(templateName);
+			if (istr == null)
+			{
+				LOGGER.log(Level.SEVERE, _("couldNotFindTemplate", templateName));
+				return;
+			}
+			ostr = new FileOutputStream(configFile);
+			byte[] buffer = new byte[1024];
+			int length = 0;
+			length = istr.read(buffer);
+			while (length > 0)
+			{
+				ostr.write(buffer, 0, length);
+				length = istr.read(buffer);
+			}
+		}
+		catch (IOException ex)
+		{
+			LOGGER.log(Level.SEVERE, _("failedToWriteConfig", configFile.toString()), ex);
+		}
+		finally
+		{
+			try
+			{
+				if (istr != null)
+				{
+					istr.close();
+				}
+			}
+			catch (IOException ex)
+			{
+				Logger.getLogger(EssentialsConf.class.getName()).log(Level.SEVERE, null, ex);
+			}
+			try
+			{
+				if (ostr != null)
+				{
+					ostr.close();
+				}
+			}
+			catch (IOException ex)
+			{
+				LOGGER.log(Level.SEVERE, _("failedToCloseConfig", configFile.toString()), ex);
+			}
+		}
+	}
+
+	public void setTemplateName(final String templateName)
+	{
+		this.templateName = templateName;
+	}
+
+	public File getFile()
+	{
+		return configFile;
+	}
+
+	public void setTemplateName(final String templateName, final Class<?> resClass)
+	{
+		this.templateName = templateName;
+		this.resourceClass = resClass;
+	}
+
+	public boolean hasProperty(final String path)
+	{
+		return isSet(path);
+	}
+
+	public Location getLocation(final String path, final Server server) throws Exception
+	{
+		final String worldName = getString((path == null ? "" : path + ".") + "world");
+		if (worldName == null || worldName.isEmpty())
+		{
+			return null;
+		}
+		final World world = server.getWorld(worldName);
+		if (world == null)
+		{
+			throw new Exception(_("invalidWorld"));
+		}
+		return new Location(world,
+							getDouble((path == null ? "" : path + ".") + "x", 0),
+							getDouble((path == null ? "" : path + ".") + "y", 0),
+							getDouble((path == null ? "" : path + ".") + "z", 0),
+							(float)getDouble((path == null ? "" : path + ".") + "yaw", 0),
+							(float)getDouble((path == null ? "" : path + ".") + "pitch", 0));
+	}
+
+	public void setProperty(final String path, final Location loc)
+	{
+		set((path == null ? "" : path + ".") + "world", loc.getWorld().getName());
+		set((path == null ? "" : path + ".") + "x", loc.getX());
+		set((path == null ? "" : path + ".") + "y", loc.getY());
+		set((path == null ? "" : path + ".") + "z", loc.getZ());
+		set((path == null ? "" : path + ".") + "yaw", loc.getYaw());
+		set((path == null ? "" : path + ".") + "pitch", loc.getPitch());
+	}
+
+	@Override
+	public ItemStack getItemStack(final String path)
+	{
+		final ItemStack stack = new ItemStack(
+				Material.valueOf(getString(path + ".type", "AIR")),
+				getInt(path + ".amount", 1),
+				(short)getInt(path + ".damage", 0));
+		final ConfigurationSection enchants = getConfigurationSection(path + ".enchant");
+		if (enchants != null)
+		{
+			for (String enchant : enchants.getKeys(false))
+			{
+				final Enchantment enchantment = Enchantment.getByName(enchant.toUpperCase(Locale.ENGLISH));
+				if (enchantment == null)
+				{
+					continue;
+				}
+				final int level = getInt(path + ".enchant." + enchant, enchantment.getStartLevel());
+				stack.addUnsafeEnchantment(enchantment, level);
+			}
+		}
+		return stack;
+		/*
+		 * ,
+		 * (byte)getInt(path + ".data", 0)
+		 */
+	}
+
+	public void setProperty(final String path, final ItemStack stack)
+	{
+		final Map<String, Object> map = new HashMap<String, Object>();
+		map.put("type", stack.getType().toString());
+		map.put("amount", stack.getAmount());
+		map.put("damage", stack.getDurability());
+		Map<Enchantment, Integer> enchantments = stack.getEnchantments();
+		if (!enchantments.isEmpty())
+		{
+			Map<String, Integer> enchant = new HashMap<String, Integer>();
+			for (Map.Entry<Enchantment, Integer> entry : enchantments.entrySet())
+			{
+				enchant.put(entry.getKey().getName().toLowerCase(Locale.ENGLISH), entry.getValue());
+			}
+			map.put("enchant", enchant);
+		}
+		// getData().getData() is broken
+		//map.put("data", stack.getDurability());
+		set(path, map);
+	}
+
+	public long getLong(final String path, final long def)
+	{
+		try
+		{
+			final Number num = (Number)get(path);
+			return num == null ? def : num.longValue();
+		}
+		catch (ClassCastException ex)
+		{
+			return def;
+		}
+	}
+
+	@Override
+	public double getDouble(final String path, final double def)
+	{
+		try
+		{
+			Number num = (Number)get(path);
+			return num == null ? def : num.doubleValue();
+		}
+		catch (ClassCastException ex)
+		{
+			return def;
+		}
+	}
+
+	public void save()
+	{
+		try
+		{
+			save(configFile);
+		}
+		catch (IOException ex)
+		{
+			LOGGER.log(Level.SEVERE, ex.getMessage(), ex);
+		}
+	}
+
+	@Override
+	public synchronized void save(final File file) throws IOException
+	{
+		if (file == null)
+		{
+			throw new IllegalArgumentException("File cannot be null");
+		}
+
+		Files.createParentDirs(file);
+
+		final String data = saveToString();
+
+		final OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(file), UTF8);
+
+		try
+		{
+			writer.write(data);
+		}
+		finally
+		{
+			writer.close();
+		}
+	}
+
+	public Object getProperty(String path)
+	{
+		return get(path);
+	}
+
+	public void setProperty(String path, Object object)
+	{
+		set(path, object);
+	}
+
+	public void removeProperty(String path)
+	{
+		set(path, null);
+	}
+}
diff --git a/Essentials2Compat/src/com/earth2me/essentials/EssentialsUpgrade.java b/Essentials2Compat/src/com/earth2me/essentials/EssentialsUpgrade.java
new file mode 100644
index 000000000..97338579d
--- /dev/null
+++ b/Essentials2Compat/src/com/earth2me/essentials/EssentialsUpgrade.java
@@ -0,0 +1,729 @@
+package com.earth2me.essentials;
+
+import com.earth2me.essentials.economy.WorthHolder;
+import com.earth2me.essentials.storage.ManagedFile;
+import static com.earth2me.essentials.I18n._;
+import com.earth2me.essentials.api.IEssentials;
+import com.earth2me.essentials.settings.Spawns;
+import com.earth2me.essentials.storage.Location;
+import com.earth2me.essentials.storage.YamlStorageWriter;
+import java.io.*;
+import java.math.BigInteger;
+import java.security.DigestInputStream;
+import java.security.MessageDigest;
+import java.util.*;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.inventory.ItemStack;
+
+
+@Deprecated
+public class EssentialsUpgrade
+{
+	private final static Logger LOGGER = Logger.getLogger("Minecraft");
+	private final transient IEssentials ess;
+	private final transient EssentialsConf doneFile;
+
+	EssentialsUpgrade(final IEssentials essentials)
+	{
+		ess = essentials;
+		if (!ess.getDataFolder().exists())
+		{
+			ess.getDataFolder().mkdirs();
+		}
+		doneFile = new EssentialsConf(new File(ess.getDataFolder(), "upgrades-done.yml"));
+		doneFile.load();
+	}
+
+	private void moveWorthValuesToWorthYml()
+	{
+		if (doneFile.getBoolean("moveWorthValuesToWorthYml", false))
+		{
+			return;
+		}
+		try
+		{
+			final File configFile = new File(ess.getDataFolder(), "config.yml");
+			if (!configFile.exists())
+			{
+				return;
+			}
+			final EssentialsConf conf = new EssentialsConf(configFile);
+			conf.load();
+			final WorthHolder worth = new WorthHolder(ess);
+			boolean found = false;
+			for (Material mat : Material.values())
+			{
+				final int id = mat.getId();
+				final double value = conf.getDouble("worth-" + id, Double.NaN);
+				if (!Double.isNaN(value))
+				{
+					found = true;
+					worth.setPrice(new ItemStack(mat, 1, (short)0, (byte)0), value);
+				}
+			}
+			if (found)
+			{
+				removeLinesFromConfig(configFile, "\\s*#?\\s*worth-[0-9]+.*", "# Worth values have been moved to worth.yml");
+			}
+			doneFile.setProperty("moveWorthValuesToWorthYml", true);
+			doneFile.save();
+		}
+		catch (Throwable e)
+		{
+			LOGGER.log(Level.SEVERE, _("upgradingFilesError"), e);
+		}
+	}
+
+	private void moveMotdRulesToFile(String name)
+	{
+		if (doneFile.getBoolean("move" + name + "ToFile", false))
+		{
+			return;
+		}
+		try
+		{
+			final File file = new File(ess.getDataFolder(), name + ".txt");
+			if (file.exists())
+			{
+				return;
+			}
+			final File configFile = new File(ess.getDataFolder(), "config.yml");
+			if (!configFile.exists())
+			{
+				return;
+			}
+			final EssentialsConf conf = new EssentialsConf(configFile);
+			conf.load();
+			List<String> lines = conf.getStringList(name);
+			if (lines != null && !lines.isEmpty())
+			{
+				if (!file.createNewFile())
+				{
+					throw new IOException("Failed to create file " + file);
+				}
+				PrintWriter writer = new PrintWriter(file);
+
+				for (String line : lines)
+				{
+					writer.println(line);
+				}
+				writer.close();
+			}
+			doneFile.setProperty("move" + name + "ToFile", true);
+			doneFile.save();
+		}
+		catch (Throwable e)
+		{
+			LOGGER.log(Level.SEVERE, _("upgradingFilesError"), e);
+		}
+	}
+
+	private void removeLinesFromConfig(File file, String regex, String info) throws Exception
+	{
+		boolean needUpdate = false;
+		final BufferedReader bReader = new BufferedReader(new FileReader(file));
+		final File tempFile = File.createTempFile("essentialsupgrade", ".tmp.yml", ess.getDataFolder());
+		final BufferedWriter bWriter = new BufferedWriter(new FileWriter(tempFile));
+		do
+		{
+			final String line = bReader.readLine();
+			if (line == null)
+			{
+				break;
+			}
+			if (line.matches(regex))
+			{
+				if (!needUpdate && info != null)
+				{
+					bWriter.write(info, 0, info.length());
+					bWriter.newLine();
+				}
+				needUpdate = true;
+			}
+			else
+			{
+				if (line.endsWith("\r\n"))
+				{
+					bWriter.write(line, 0, line.length() - 2);
+				}
+				else if (line.endsWith("\r") || line.endsWith("\n"))
+				{
+					bWriter.write(line, 0, line.length() - 1);
+				}
+				else
+				{
+					bWriter.write(line, 0, line.length());
+				}
+				bWriter.newLine();
+			}
+		}
+		while (true);
+		bReader.close();
+		bWriter.close();
+		if (needUpdate)
+		{
+			if (!file.renameTo(new File(file.getParentFile(), file.getName().concat("." + System.currentTimeMillis() + ".upgradebackup"))))
+			{
+				throw new Exception(_("configFileMoveError"));
+			}
+			if (!tempFile.renameTo(file))
+			{
+				throw new Exception(_("configFileRenameError"));
+			}
+		}
+		else
+		{
+			tempFile.delete();
+		}
+	}
+
+	private void updateUsersToNewDefaultHome()
+	{
+		if (doneFile.getBoolean("updateUsersToNewDefaultHome", false))
+		{
+			return;
+		}
+		final File userdataFolder = new File(ess.getDataFolder(), "userdata");
+		if (!userdataFolder.exists() || !userdataFolder.isDirectory())
+		{
+			return;
+		}
+		final File[] userFiles = userdataFolder.listFiles();
+
+		for (File file : userFiles)
+		{
+			if (!file.isFile() || !file.getName().endsWith(".yml"))
+			{
+				continue;
+			}
+			final EssentialsConf config = new EssentialsConf(file);
+			try
+			{
+				config.load();
+				if (config.hasProperty("home") && !config.hasProperty("home.default"))
+				{
+					@SuppressWarnings("unchecked")
+					final List<Object> vals = (List<Object>)config.getProperty("home");
+					if (vals == null)
+					{
+						continue;
+					}
+					World world = ess.getServer().getWorlds().get(0);
+					if (world != null)
+					{
+						final Location loc = new Location(
+								(String)vals.get(5),
+								((Number)vals.get(0)).doubleValue(),
+								((Number)vals.get(1)).doubleValue(),
+								((Number)vals.get(2)).doubleValue(),
+								((Number)vals.get(3)).floatValue(),
+								((Number)vals.get(4)).floatValue());
+
+						final String worldName = world.getName().toLowerCase(Locale.ENGLISH);
+						if (worldName != null && !worldName.isEmpty())
+						{
+							config.removeProperty("home");
+							config.setProperty("home.default", worldName);
+							config.setProperty("home.worlds." + worldName, loc);
+							config.save();
+						}
+					}
+				}
+			}
+			catch (RuntimeException ex)
+			{
+				LOGGER.log(Level.INFO, "File: " + file.toString());
+				throw ex;
+			}
+		}
+		doneFile.setProperty("updateUsersToNewDefaultHome", true);
+		doneFile.save();
+	}
+
+	private void updateUsersPowerToolsFormat()
+	{
+		if (doneFile.getBoolean("updateUsersPowerToolsFormat", false))
+		{
+			return;
+		}
+		final File userdataFolder = new File(ess.getDataFolder(), "userdata");
+		if (!userdataFolder.exists() || !userdataFolder.isDirectory())
+		{
+			return;
+		}
+		final File[] userFiles = userdataFolder.listFiles();
+
+		for (File file : userFiles)
+		{
+			if (!file.isFile() || !file.getName().endsWith(".yml"))
+			{
+				continue;
+			}
+			final EssentialsConf config = new EssentialsConf(file);
+			try
+			{
+				config.load();
+				if (config.hasProperty("powertools"))
+				{
+					@SuppressWarnings("unchecked")
+					final Map<String, Object> powertools = config.getConfigurationSection("powertools").getValues(false);
+					if (powertools == null)
+					{
+						continue;
+					}
+					for (Map.Entry<String, Object> entry : powertools.entrySet())
+					{
+						if (entry.getValue() instanceof String)
+						{
+							List<String> temp = new ArrayList<String>();
+							temp.add((String)entry.getValue());
+							((Map<String, Object>)powertools).put(entry.getKey(), temp);
+						}
+					}
+					config.save();
+				}
+			}
+			catch (RuntimeException ex)
+			{
+				LOGGER.log(Level.INFO, "File: " + file.toString());
+				throw ex;
+			}
+		}
+		doneFile.setProperty("updateUsersPowerToolsFormat", true);
+		doneFile.save();
+	}
+
+	private void updateUsersHomesFormat()
+	{
+		if (doneFile.getBoolean("updateUsersHomesFormat", false))
+		{
+			return;
+		}
+		final File userdataFolder = new File(ess.getDataFolder(), "userdata");
+		if (!userdataFolder.exists() || !userdataFolder.isDirectory())
+		{
+			return;
+		}
+		final File[] userFiles = userdataFolder.listFiles();
+
+		for (File file : userFiles)
+		{
+			if (!file.isFile() || !file.getName().endsWith(".yml"))
+			{
+				continue;
+			}
+			final EssentialsConf config = new EssentialsConf(file);
+			try
+			{
+
+				config.load();
+				if (config.hasProperty("home") && config.hasProperty("home.default"))
+				{
+					@SuppressWarnings("unchecked")
+					final String defworld = (String)config.getProperty("home.default");
+					final Location defloc = getFakeLocation(config, "home.worlds." + defworld);
+					if (defloc != null)
+					{
+						config.setProperty("homes.home", defloc);
+					}
+
+					Set<String> worlds = config.getConfigurationSection("home.worlds").getKeys(false);
+					Location loc;
+					String worldName;
+
+					if (worlds == null)
+					{
+						continue;
+					}
+					for (String world : worlds)
+					{
+						if (defworld.equalsIgnoreCase(world))
+						{
+							continue;
+						}
+						loc = getFakeLocation(config, "home.worlds." + world);
+						if (loc == null)
+						{
+							continue;
+						}
+						worldName = loc.getWorldName().toLowerCase(Locale.ENGLISH);
+						if (worldName != null && !worldName.isEmpty())
+						{
+							config.setProperty("homes." + worldName, loc);
+						}
+					}
+					config.removeProperty("home");
+					config.save();
+				}
+
+			}
+			catch (RuntimeException ex)
+			{
+				LOGGER.log(Level.INFO, "File: " + file.toString());
+				throw ex;
+			}
+		}
+		doneFile.setProperty("updateUsersHomesFormat", true);
+		doneFile.save();
+	}
+
+	/*
+	 * private void moveUsersDataToUserdataFolder() { final File usersFile = new File(ess.getDataFolder(), "users.yml");
+	 * if (!usersFile.exists()) { return; } final EssentialsConf usersConfig = new EssentialsConf(usersFile);
+	 * usersConfig.load(); for (String username : usersConfig.getKeys(null)) { final User user = new User(new
+	 * OfflinePlayer(username, ess), ess); final String nickname = usersConfig.getString(username + ".nickname"); if
+	 * (nickname != null && !nickname.isEmpty() && !nickname.equals(username)) { user.setNickname(nickname); } final
+	 * List<String> mails = usersConfig.getStringList(username + ".mail", null); if (mails != null && !mails.isEmpty())
+	 * { user.setMails(mails); } if (!user.hasHome()) { @SuppressWarnings("unchecked") final List<Object> vals =
+	 * (List<Object>)usersConfig.getProperty(username + ".home"); if (vals != null) { World world =
+	 * ess.getServer().getWorlds().get(0); if (vals.size() > 5) { world = getFakeWorld((String)vals.get(5)); } if (world
+	 * != null) { user.setHome("home", new Location(world, ((Number)vals.get(0)).doubleValue(),
+	 * ((Number)vals.get(1)).doubleValue(), ((Number)vals.get(2)).doubleValue(), ((Number)vals.get(3)).floatValue(),
+	 * ((Number)vals.get(4)).floatValue())); } } } } usersFile.renameTo(new File(usersFile.getAbsolutePath() + ".old"));
+	 * }
+	 */
+
+	private void convertWarps()
+	{
+		final File warpsFolder = new File(ess.getDataFolder(), "warps");
+		if (!warpsFolder.exists())
+		{
+			warpsFolder.mkdirs();
+		}
+		final File[] listOfFiles = warpsFolder.listFiles();
+		if (listOfFiles.length >= 1)
+		{
+			for (int i = 0; i < listOfFiles.length; i++)
+			{
+				final String filename = listOfFiles[i].getName();
+				if (listOfFiles[i].isFile() && filename.endsWith(".dat"))
+				{
+					try
+					{
+						final BufferedReader rx = new BufferedReader(new FileReader(listOfFiles[i]));
+						double x, y, z;
+						float yaw, pitch;
+						String worldName;
+						try
+						{
+							if (!rx.ready())
+							{
+								continue;
+							}
+							x = Double.parseDouble(rx.readLine().trim());
+							if (!rx.ready())
+							{
+								continue;
+							}
+							y = Double.parseDouble(rx.readLine().trim());
+							if (!rx.ready())
+							{
+								continue;
+							}
+							z = Double.parseDouble(rx.readLine().trim());
+							if (!rx.ready())
+							{
+								continue;
+							}
+							yaw = Float.parseFloat(rx.readLine().trim());
+							if (!rx.ready())
+							{
+								continue;
+							}
+							pitch = Float.parseFloat(rx.readLine().trim());
+							worldName = rx.readLine();
+						}
+						finally
+						{
+							rx.close();
+						}
+						if (worldName != null)
+						{
+							final Location loc = new Location(worldName, x, y, z, yaw, pitch);
+							((Warps)ess.getWarps()).setWarp(filename.substring(0, filename.length() - 4), loc);
+							if (!listOfFiles[i].renameTo(new File(warpsFolder, filename + ".old")))
+							{
+								throw new Exception(_("fileRenameError", filename));
+							}
+						}
+
+					}
+					catch (Exception ex)
+					{
+						LOGGER.log(Level.SEVERE, null, ex);
+					}
+				}
+			}
+
+		}
+		/*final File warpFile = new File(ess.getDataFolder(), "warps.txt");
+		if (warpFile.exists())
+		{
+			try
+			{
+				final BufferedReader rx = new BufferedReader(new FileReader(warpFile));
+				try
+				{
+					for (String[] parts = new String[0]; rx.ready(); parts = rx.readLine().split(":"))
+					{
+						if (parts.length < 6)
+						{
+							continue;
+						}
+						final String name = parts[0];
+						final double x = Double.parseDouble(parts[1].trim());
+						final double y = Double.parseDouble(parts[2].trim());
+						final double z = Double.parseDouble(parts[3].trim());
+						final float yaw = Float.parseFloat(parts[4].trim());
+						final float pitch = Float.parseFloat(parts[5].trim());
+						if (name.isEmpty())
+						{
+							continue;
+						}
+						World w = null;
+						for (World world : ess.getServer().getWorlds())
+						{
+							if (world.getEnvironment() != World.Environment.NETHER)
+							{
+								w = world;
+								break;
+							}
+						}
+						final Location loc = new Location(name, x, y, z, yaw, pitch);
+						ess.getWarps().setWarp(name, loc);
+						if (!warpFile.renameTo(new File(ess.getDataFolder(), "warps.txt.old")))
+						{
+							throw new Exception(_("fileRenameError", "warps.txt"));
+						}
+					}
+				}
+				finally
+				{
+					rx.close();
+				}
+			}
+			catch (Exception ex)
+			{
+				LOGGER.log(Level.SEVERE, null, ex);
+			}
+		}*/
+	}
+
+	/*
+	 * private void sanitizeAllUserFilenames() { if (doneFile.getBoolean("sanitizeAllUserFilenames", false)) { return; }
+	 * final File usersFolder = new File(ess.getDataFolder(), "userdata"); if (!usersFolder.exists()) { return; } final
+	 * File[] listOfFiles = usersFolder.listFiles(); for (int i = 0; i < listOfFiles.length; i++) { final String
+	 * filename = listOfFiles[i].getName(); if (!listOfFiles[i].isFile() || !filename.endsWith(".yml")) { continue; }
+	 * final String sanitizedFilename = Util.sanitizeFileName(filename.substring(0, filename.length() - 4)) + ".yml"; if
+	 * (sanitizedFilename.equals(filename)) { continue; } final File tmpFile = new File(listOfFiles[i].getParentFile(),
+	 * sanitizedFilename + ".tmp"); final File newFile = new File(listOfFiles[i].getParentFile(), sanitizedFilename); if
+	 * (!listOfFiles[i].renameTo(tmpFile)) { LOGGER.log(Level.WARNING, _("userdataMoveError", filename,
+	 * sanitizedFilename)); continue; } if (newFile.exists()) { LOGGER.log(Level.WARNING, _("duplicatedUserdata",
+	 * filename, sanitizedFilename)); continue; } if (!tmpFile.renameTo(newFile)) { LOGGER.log(Level.WARNING,
+	 * _("userdataMoveBackError", sanitizedFilename, sanitizedFilename)); } }
+	 * doneFile.setProperty("sanitizeAllUserFilenames", true); doneFile.save(); }
+	 */
+	/*
+	 * private World getFakeWorld(final String name) { final File bukkitDirectory =
+	 * ess.getDataFolder().getParentFile().getParentFile(); final File worldDirectory = new File(bukkitDirectory, name);
+	 * if (worldDirectory.exists() && worldDirectory.isDirectory()) { return new FakeWorld(worldDirectory.getName(),
+	 * World.Environment.NORMAL); } return null;
+	}
+	 */
+	public Location getFakeLocation(EssentialsConf config, String path)
+	{
+		String worldName = config.getString((path != null ? path + "." : "") + "world");
+		if (worldName == null || worldName.isEmpty())
+		{
+			return null;
+		}
+		return new Location(worldName,
+							config.getDouble((path != null ? path + "." : "") + "x", 0),
+							config.getDouble((path != null ? path + "." : "") + "y", 0),
+							config.getDouble((path != null ? path + "." : "") + "z", 0),
+							(float)config.getDouble((path != null ? path + "." : "") + "yaw", 0),
+							(float)config.getDouble((path != null ? path + "." : "") + "pitch", 0));
+	}
+
+	private void deleteOldItemsCsv()
+	{
+		if (doneFile.getBoolean("deleteOldItemsCsv", false))
+		{
+			return;
+		}
+		final File file = new File(ess.getDataFolder(), "items.csv");
+		if (file.exists())
+		{
+			try
+			{
+				final Set<BigInteger> oldconfigs = new HashSet<BigInteger>();
+				oldconfigs.add(new BigInteger("66ec40b09ac167079f558d1099e39f10", 16)); // sep 1
+				oldconfigs.add(new BigInteger("34284de1ead43b0bee2aae85e75c041d", 16)); // crlf
+				oldconfigs.add(new BigInteger("c33bc9b8ee003861611bbc2f48eb6f4f", 16)); // jul 24
+				oldconfigs.add(new BigInteger("6ff17925430735129fc2a02f830c1daa", 16)); // crlf
+
+				MessageDigest digest = ManagedFile.getDigest();
+				final BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
+				final DigestInputStream dis = new DigestInputStream(bis, digest);
+				final byte[] buffer = new byte[1024];
+				try
+				{
+					while (dis.read(buffer) != -1)
+					{
+					}
+				}
+				finally
+				{
+					dis.close();
+				}
+
+				BigInteger hash = new BigInteger(1, digest.digest());
+				if (oldconfigs.contains(hash) && !file.delete())
+				{
+					throw new IOException("Could not delete file " + file.toString());
+				}
+				doneFile.setProperty("deleteOldItemsCsv", true);
+				doneFile.save();
+			}
+			catch (IOException ex)
+			{
+				Bukkit.getLogger().log(Level.SEVERE, ex.getMessage(), ex);
+			}
+		}
+	}
+
+	private void updateSpawnsToNewSpawnsConfig()
+	{
+		if (doneFile.getBoolean("updateSpawnsToNewSpawnsConfig", false))
+		{
+			return;
+		}
+		final File configFile = new File(ess.getDataFolder(), "spawn.yml");
+		if (configFile.exists())
+		{
+
+			final EssentialsConf config = new EssentialsConf(configFile);
+			try
+			{
+				config.load();
+				if (!config.hasProperty("spawns"))
+				{
+					final Spawns spawns = new Spawns();
+					Set<String> keys = config.getKeys(false);
+					for (String group : keys)
+					{
+						Location loc = getFakeLocation(config, group);
+						spawns.getSpawns().put(group.toLowerCase(Locale.ENGLISH), loc);
+					}
+					if (!configFile.renameTo(new File(ess.getDataFolder(), "spawn.yml.old")))
+					{
+						throw new Exception(_("fileRenameError", "spawn.yml"));
+					}
+					PrintWriter writer = new PrintWriter(configFile);
+					try
+					{
+						new YamlStorageWriter(writer).save(spawns);
+					}
+					finally
+					{
+						writer.close();
+					}
+				}
+			}
+			catch (Exception ex)
+			{
+				Bukkit.getLogger().log(Level.SEVERE, ex.getMessage(), ex);
+			}
+		}
+		doneFile.setProperty("updateSpawnsToNewSpawnsConfig", true);
+		doneFile.save();
+	}
+
+	private void updateJailsToNewJailsConfig()
+	{
+		if (doneFile.getBoolean("updateJailsToNewJailsConfig", false))
+		{
+			return;
+		}
+		final File configFile = new File(ess.getDataFolder(), "jail.yml");
+		if (configFile.exists())
+		{
+
+			final EssentialsConf config = new EssentialsConf(configFile);
+			try
+			{
+				config.load();
+				if (!config.hasProperty("jails"))
+				{
+					final com.earth2me.essentials.settings.Jails jails = new com.earth2me.essentials.settings.Jails();
+					Set<String> keys = config.getKeys(false);
+					for (String jailName : keys)
+					{
+						Location loc = getFakeLocation(config, jailName);
+						jails.getJails().put(jailName.toLowerCase(Locale.ENGLISH), loc);
+					}
+					if (!configFile.renameTo(new File(ess.getDataFolder(), "jail.yml.old")))
+					{
+						throw new Exception(_("fileRenameError", "jail.yml"));
+					}
+					PrintWriter writer = new PrintWriter(configFile);
+					try
+					{
+						new YamlStorageWriter(writer).save(jails);
+					}
+					finally
+					{
+						writer.close();
+					}
+				}
+			}
+			catch (Exception ex)
+			{
+				Bukkit.getLogger().log(Level.SEVERE, ex.getMessage(), ex);
+			}
+		}
+		doneFile.setProperty("updateJailsToNewJailsConfig", true);
+		doneFile.save();
+	}
+
+	private void warnMetrics()
+	{
+		if (doneFile.getBoolean("warnMetrics", false))
+		{
+			return;
+		}
+		ess.getSettings().setMetricsEnabled(false);
+		doneFile.setProperty("warnMetrics", true);
+		doneFile.save();
+	}
+
+	public void beforeSettings()
+	{
+		if (!ess.getDataFolder().exists())
+		{
+			ess.getDataFolder().mkdirs();
+		}
+		moveWorthValuesToWorthYml();
+		moveMotdRulesToFile("motd");
+		moveMotdRulesToFile("rules");
+	}
+
+	public void afterSettings()
+	{
+		//TODO?
+		//sanitizeAllUserFilenames();
+		updateUsersToNewDefaultHome();
+		//moveUsersDataToUserdataFolder();
+		convertWarps();
+		updateUsersPowerToolsFormat();
+		updateUsersHomesFormat();
+		deleteOldItemsCsv();
+		updateSpawnsToNewSpawnsConfig();
+		updateJailsToNewJailsConfig();
+		warnMetrics();
+	}
+}
diff --git a/Essentials2Compat/src/com/earth2me/essentials/api/Economy.java b/Essentials2Compat/src/com/earth2me/essentials/api/Economy.java
new file mode 100644
index 000000000..cf8cb640c
--- /dev/null
+++ b/Essentials2Compat/src/com/earth2me/essentials/api/Economy.java
@@ -0,0 +1,231 @@
+package com.earth2me.essentials.api;
+
+import com.earth2me.essentials.utils.Util;
+
+
+/**
+ * Instead of using this api directly, we recommend to use the register plugin:
+ * http://bit.ly/RegisterMethod
+ */
+public final class Economy
+{
+	private Economy()
+	{
+	}
+	private static IEssentials ess;
+	private static final String noCallBeforeLoad = "Essentials API is called before Essentials is loaded.";
+
+	/**
+	 * Returns the balance of a user
+	 * @param name Name of the user
+	 * @return balance
+	 * @throws UserDoesNotExistException 
+	 */
+	public static double getMoney(String name) throws UserDoesNotExistException
+	{
+		if (ess == null)
+		{
+			throw new RuntimeException(noCallBeforeLoad);
+		}
+		return ess.getEconomy().getMoney(name);
+	}
+
+	/**
+	 * Sets the balance of a user
+	 * @param name Name of the user
+	 * @param balance The balance you want to set
+	 * @throws UserDoesNotExistException If a user by that name does not exists
+	 * @throws NoLoanPermittedException If the user is not allowed to have a negative balance
+	 */
+	public static void setMoney(String name, double balance) throws UserDoesNotExistException, NoLoanPermittedException
+	{
+		if (ess == null)
+		{
+			throw new RuntimeException(noCallBeforeLoad);
+		}
+		ess.getEconomy().setMoney(name, balance);
+	}
+
+	/**
+	 * Adds money to the balance of a user
+	 * @param name Name of the user
+	 * @param amount The money you want to add
+	 * @throws UserDoesNotExistException If a user by that name does not exists
+	 * @throws NoLoanPermittedException If the user is not allowed to have a negative balance
+	 */
+	public static void add(String name, double amount) throws UserDoesNotExistException, NoLoanPermittedException
+	{
+		double result = getMoney(name) + amount;
+		setMoney(name, result);
+	}
+
+	/**
+	 * Substracts money from the balance of a user
+	 * @param name Name of the user
+	 * @param amount The money you want to substract
+	 * @throws UserDoesNotExistException If a user by that name does not exists
+	 * @throws NoLoanPermittedException If the user is not allowed to have a negative balance
+	 */
+	public static void subtract(String name, double amount) throws UserDoesNotExistException, NoLoanPermittedException
+	{
+		double result = getMoney(name) - amount;
+		setMoney(name, result);
+	}
+
+	/**
+	 * Divides the balance of a user by a value
+	 * @param name Name of the user
+	 * @param value The balance is divided by this value
+	 * @throws UserDoesNotExistException If a user by that name does not exists
+	 * @throws NoLoanPermittedException If the user is not allowed to have a negative balance
+	 */
+	public static void divide(String name, double value) throws UserDoesNotExistException, NoLoanPermittedException
+	{
+		double result = getMoney(name) / value;
+		setMoney(name, result);
+	}
+
+	/**
+	 * Multiplies the balance of a user by a value
+	 * @param name Name of the user
+	 * @param value The balance is multiplied by this value
+	 * @throws UserDoesNotExistException If a user by that name does not exists
+	 * @throws NoLoanPermittedException If the user is not allowed to have a negative balance
+	 */
+	public static void multiply(String name, double value) throws UserDoesNotExistException, NoLoanPermittedException
+	{
+		double result = getMoney(name) * value;
+		setMoney(name, result);
+	}
+
+	/**
+	 * Resets the balance of a user to the starting balance
+	 * @param name Name of the user
+	 * @throws UserDoesNotExistException If a user by that name does not exists
+	 * @throws NoLoanPermittedException If the user is not allowed to have a negative balance
+	 */
+	public static void resetBalance(String name) throws UserDoesNotExistException, NoLoanPermittedException
+	{
+		if (ess == null)
+		{
+			throw new RuntimeException(noCallBeforeLoad);
+		}
+		ess.getEconomy().resetBalance(name);
+	}
+
+	/**
+	 * @param name Name of the user
+	 * @param amount The amount of money the user should have
+	 * @return true, if the user has more or an equal amount of money
+	 * @throws UserDoesNotExistException If a user by that name does not exists
+	 */
+	public static boolean hasEnough(String name, double amount) throws UserDoesNotExistException
+	{
+		return amount <= getMoney(name);
+	}
+
+	/**
+	 * @param name Name of the user
+	 * @param amount The amount of money the user should have
+	 * @return true, if the user has more money
+	 * @throws UserDoesNotExistException If a user by that name does not exists
+	 */
+	public static boolean hasMore(String name, double amount) throws UserDoesNotExistException
+	{
+		return amount < getMoney(name);
+	}
+
+	/**
+	 * @param name Name of the user
+	 * @param amount The amount of money the user should not have
+	 * @return true, if the user has less money
+	 * @throws UserDoesNotExistException If a user by that name does not exists
+	 */
+	public static boolean hasLess(String name, double amount) throws UserDoesNotExistException
+	{
+		return amount > getMoney(name);
+	}
+
+	/**
+	 * Test if the user has a negative balance
+	 * @param name Name of the user
+	 * @return true, if the user has a negative balance
+	 * @throws UserDoesNotExistException If a user by that name does not exists
+	 */
+	public static boolean isNegative(String name) throws UserDoesNotExistException
+	{
+		return getMoney(name) < 0.0;
+	}
+
+	/**
+	 * Formats the amount of money like all other Essentials functions.
+	 * Example: $100000 or $12345.67
+	 * @param amount The amount of money
+	 * @return Formatted money
+	 */
+	public static String format(double amount)
+	{
+		if (ess == null)
+		{
+			throw new RuntimeException(noCallBeforeLoad);
+		}
+		return Util.displayCurrency(amount, ess);
+	}
+
+	/**
+	 * Test if a player exists to avoid the UserDoesNotExistException
+	 * @param name Name of the user
+	 * @return true, if the user exists
+	 */
+	public static boolean playerExists(String name)
+	{
+		if (ess == null)
+		{
+			throw new RuntimeException(noCallBeforeLoad);
+		}
+		return ess.getEconomy().playerExists(name);
+	}
+
+	/**
+	 * Test if a player is a npc
+	 * @param name Name of the player
+	 * @return true, if it's a npc
+	 * @throws UserDoesNotExistException 
+	 */
+	public static boolean isNPC(String name) throws UserDoesNotExistException
+	{
+		if (ess == null)
+		{
+			throw new RuntimeException(noCallBeforeLoad);
+		}
+		return ess.getEconomy().isNPC(name);
+	}
+
+	/**
+	 * Creates dummy files for a npc, if there is no player yet with that name.
+	 * @param name Name of the player
+	 * @return true, if a new npc was created
+	 */
+	public static boolean createNPC(String name)
+	{
+		if (ess == null)
+		{
+			throw new RuntimeException(noCallBeforeLoad);
+		}
+		return ess.getEconomy().createNPC(name);
+	}
+
+	/**
+	 * Deletes a user, if it is marked as npc. 
+	 * @param name Name of the player
+	 * @throws UserDoesNotExistException 
+	 */
+	public static void removeNPC(String name) throws UserDoesNotExistException
+	{
+		if (ess == null)
+		{
+			throw new RuntimeException(noCallBeforeLoad);
+		}
+		ess.getEconomy().removeNPC(name);
+	}
+}
diff --git a/Essentials2Compat/src/plugin.yml b/Essentials2Compat/src/plugin.yml
new file mode 100644
index 000000000..e3d9afe83
--- /dev/null
+++ b/Essentials2Compat/src/plugin.yml
@@ -0,0 +1,6 @@
+name: Essentials
+main: com.earth2me.essentials.Essentials
+version: 2.9
+website: http://tiny.cc/EssentialsWiki
+description: Compatibility plugin for older plugins
+authors: [Zenexer, ementalo, Aelux, Brettflan, KimKandor, snowleo, ceulemans, Xeology, KHobbits]