update version

# Conflicts:
#	build.gradle
#	gradle.properties

.gitattributes

@@ -4,4 +4,4 @@ gradlew.bat                                 text eol=crlf
 gradle/wrapper/gradle-wrapper.properties    text eol=lf
 
 # Other
-.gitattributes  text eol=lf
+.gitattributes  text eol=lf

.gitignore

@@ -9,4 +9,3 @@ out/
 # GRADLE #
 .gradle/
 build/
-publish.gradle

.gitlab-ci.yml

@@ -0,0 +1,11 @@
+image: gradle:7.2.0-jdk8
+variables:
+  GRADLE_OPTS: "-Dorg.gradle.daemon=false"
+before_script:
+  - export GRADLE_USER_HOME=`pwd`/.gradle
+
+build:
+  stage: build
+  only:
+    - master
+  script: gradle --console=plain publish

README.MD

@@ -0,0 +1,698 @@
+# GHAST TOOLS
+
+![version: 1.13](https://img.shields.io/badge/version-1.13-0a0.svg?style=flat)
+![bukkit-api: 1.12](https://img.shields.io/badge/bukkit--api-1.12-d50.svg?style=flat)
+
+Набор вспомогательных инструментов для Bukkit API.  
+_Основан на версии Bukkit API 1.12._
+
+## Содержание
+
+1. [Перед использованием](#перед-использованием)
+2. [GhastTools](#ghasttools)
+3. [AssetsManager](#assetsmanager)
+4. [BuildHelper](#buildhelper)
+5. [CommandManager](#commandmanager)
+6. [EffectsHelper](#effectshelper)
+7. [EventContext](#eventcontext)
+8. [JdbcTemplate](#jdbctemplate)
+9. [ScheduleManager](#schedulemanager)
+10. [ScheduleTask](#scheduletask)
+11. [Messages](#messages)
+12. [XLog](#xlog)
+13. [Подключение](#подключение)
+    1. [Gradle](#gradle)
+    2. [Maven](#maven)
+
+---
+
+## Перед использованием
+
+Перед началом использования, необходимо в вашем Bukkit-плагине прописать подобный код:
+
+```java
+void onLoad() {
+    GhastTools.setPlugin(this);
+}
+```
+
+Это необходимо сделать, т.к. весь инструментарий основан на статических (static) методах.
+
+Все методы данного набора инструментов объеденены в классы, выполняющие роль группировщиков. 
+
+## GhastTools
+
+Методы общего назначения или без определённой группировки.
+
+### loadConfig
+
+Загрузка файла настроек плагина - `config.yml`.
+
+```java
+YamlConfiguration config = GhastTools.loadConfig();
+```
+
+По-умолчанию "гаст" пытается файл найти в папке плагина - `getDataFolder()`.
+Если файла там нет, то выгружает встроенный (имеющийся в `.jar` файле плагина) в эту папку и загружает его.
+
+```java
+YamlConfiguration config = GhastTools.loadConfig(false);
+```
+
+Если передать параметр `false`, то при отсутствии файла `config.yml` в папке плагина,
+будет загруден исключительно встроенный файл настроек.
+
+### copyLocation
+
+Копирования объекта `Location`
+
+```java
+Location location = ...;
+Location copyLoc = GhastTools.copyLocation(location); 
+```
+
+## AssetsManager
+
+Методы по работе с файлами плагина (_"ассетами"_).
+
+У каждой группы методов один и тот же набор входных параметров:
+
+- `resourceName` - наименование и путь к файлу в папке плагина
+- `defaultResourceName` - наименование и путь к файлу в плагине.  
+  _Опционально. По-умолчанию равнен `resourceName`_
+- `saveDefault` - необходимость скопировать содержимое файла из `defaultResourceName` в файл `resourceName`.  
+  _Опционально. По-умолчанию равен `true`_
+  
+Правила поиска файлов так же одинаков для каждой группы:
+
+- В начале файл ищется в папке плагина
+- Если файл отсутствует в папке плагина, то...
+    - если `defaultResourceName` не равен `null`...
+        - если `saveDefault` равен `true`, то файл из плагина будет выгружен в папку плагина и от туда загружен в память.
+        - если `saveDefault` равен `false`, то данные будут взяты из файлв в плагине.
+    - если `defaultResourceName` равен `null`, то будет брошено исключение `AssetsException` с описанием ошибки вида "Файл X не найден".
+
+### getAsInputStream
+
+```java
+InputStream inputStream = AssetsManager.getAsInputStream("translate.ru.yml", "translate.yml", false);
+```
+
+### getAsReader
+
+```java
+Reader reader = AssetsManager.getAsReader("translate.ru.yml", "translate.yml", false);
+```
+
+### getAsString
+
+```java
+String string = AssetsManager.getAsString("readme.txt", "readme.txt", StandardCharsets.UTF_8, false);
+```
+
+У этой группы есть дополнительный _опциональный_ параметр - `charset` - в котором указывается кодиривка получаемой строки.  
+_По-умолчанию равен `StandardCharsets.UTF_8`_
+
+## BuildHelper
+
+Набор методов облегчающих размецение объектов на карте.
+
+### placeSkull
+
+Установка черепа.
+
+```java
+Location location = ...;
+Skull skull = BuildHelper.placeSkull(location, BlockFace.NORTH);
+skull.update(true); // иначе изменения на карте не применятся и череп будет висеть в воздухе
+```
+
+### placePlayerHead
+
+Установка головы игрока.
+
+```java
+Location location = ...;
+Skull playerHead = BuildHelper.placePlayerHead(location, BlockFace.NORTH);
+playerHead.update(true); // иначе изменения на карте не применятся и голова будет висеть в воздухе
+```
+
+Если третьим параметром передать URL текстуры, то голова будет текстурирована.
+
+```java
+Location location = ...;
+BuildHelper.placePlayerHead(location, BlockFace.NORTH, "http://...");
+```
+
+### setPlayerHeadSkin
+
+Установка текстуры для головы игрока.
+
+```java
+Location location = ...;
+Skull playerHead = BuildHelper.placePlayerHead(location, BlockFace.NORTH);
+playerHead.update(true); // иначе изменения на карте не применятся и голова будет висеть в воздухе
+setPlayerHeadSkin(playerHead);
+```
+
+Порядок выполнения методов в приведённом выше примере **важен**. Если `playerHead.update(true)` вызвать после
+установки текстуры, она собъётся на стандартную.
+
+### placeSignWall
+
+```java
+Location location = ...;
+Sign signWall = BuildHelper.placeSignWall(location, BlockFace.NORTH)
+```
+
+## CommandManager
+
+Регистрация команд.
+
+Имеется два варианта использования: упрощённый
+
+```java
+CommandManager.register("start", (sender, args) -> sender.sendMessage("hello!"));
+```
+
+и подробный:
+
+```java
+CommandManager.create("start")
+        .useOnlyPlayer()
+        .executer((sender, args) -> sender.sendMessage("hello!"))
+        .register();
+```
+
+### register
+
+Упрощенная регистрация команды. Указывается лишь название команды и исполнитель.
+
+```java
+CommandManager.register("start", (sender, args) -> sender.sendMessage("hello!"));
+```
+
+### create
+
+Конструктор для подробного варианта регистрации команды.
+
+```java
+CommandManager.Builder builder = CommandManager.create("start");
+```
+
+### executer
+
+Указание исполнителя для команды
+
+```java
+CommandManager.Builder builder = CommandManager.create("start")
+        .executer((sender, args) -> sender.sendMessage("hello!"));
+```
+
+### onError
+
+Обработчик исключений
+
+```java
+CommandManager.Builder builder = CommandManager.create("start")
+        .onError((sender, commandName, args, exception) -> {
+            sender.sendMessage(ChatColor.RED + "Произошла ошибка при выполнении команды '" + commandName + "'.");
+            exception.printStackTrace();
+        });
+```
+
+### useOnlyPlayer
+
+Указание, что данную команду могут использовать только Игроки.
+Опционально можно указать сообщение, которое будет выводиться в консоль.  
+_Отменяет действие указателя `useOnlyConsole`_
+
+```java
+CommandManager.Builder builder = CommandManager.create("start")
+        .useOnlyPlayer("Команду могут использовать только игроки");
+```
+
+### useOnlyConsole
+
+Указание, что данную команду можно использовать только в консоле.
+Опционально можно указать сообщение, которое будет выводиться Игроку.  
+_Отменяет действие указателя `useOnlyPlayer`_
+
+```java
+CommandManager.Builder builder = CommandManager.create("start")
+        .useOnlyConsole(ChatColor.RED + "Команду можно использовать только в консоли");
+```
+
+### register
+
+Регистрация описанной в Конструкторе команды.
+
+```java
+CommandManager.create("start")
+        .useOnlyPlayer()
+        .executer((sender, args) -> sender.sendMessage("hello!"))
+        .register();
+```
+
+## EffectsHelper
+
+Набор методов для работы с эффектами.
+
+### playSound
+
+Воспроизвести звук.
+
+```java
+Location location = ...;
+EffectsHelper.playSound(location, Sound.AMBIENT_CAVE, 1.0f);
+```
+
+### particle
+
+Создание частиц.
+
+```java
+Location location = ...;
+EffectsHelper.particle(location, Particle.REDSTONE, 1.0d, 1.0d, 1.0d, 1.0d, 5);
+```
+
+## EventContext
+
+Регистрация группы обработчиков событий, объединённых общим условием выполнения.
+
+```java
+EventContext.create()
+        .filter(() -> Bukkit.getOnlinePlayers().size() > 10)
+        .onEvent(PlayerJoinEvent.class, event -> { event.getPlayer().kickPlayer("Max players"); });
+```
+
+### create
+
+Создание контекста событий.
+
+```java
+EventContext eventContext = EventContext.create();
+```
+
+### filter
+
+Условие, при котором будут срабатывать обработчики событий в данном контексте.
+
+```java
+EventContext.create()
+        .filter(() -> Bukkit.getOnlinePlayers().size() > 10)
+```
+
+### onEvent
+
+Указание события и его обработчика.  
+_Обработчик события регистрируется сразу же._
+
+```java
+EventContext.create()
+        .filter(() -> Bukkit.getOnlinePlayers().size() > 10)
+        .onEvent(PlayerJoinEvent.class, event -> event.getPlayer().kickPlayer("Max players"));
+```
+
+### cancelEvent
+
+Отменить событие.  
+_Обработчик события регистрируется сразу же._
+
+```java
+EventContext.create()
+        .cancelEvent(BlockPlaceEvent.class);
+```
+
+эквивалентен коду:
+
+```java
+EventContext.create()
+        .onEvent(BlockPlaceEvent.class, event -> event.setCancelled(true))
+```
+
+## JdbcTemplate
+
+Инструмент для упрощения работы с SQL базами данных, работающими через JDBC.
+
+Для начала потребуется создать объект `DataSource`
+
+```java
+// На примере MySQL
+MysqlDataSource dataSource = new MysqlDataSource();
+dataSource.setServerName("localhost");
+dataSource.setPort(3306);
+dataSource.setCharacterEncoding(StandardCharsets.UTF_8.name());
+dataSource.setDatabaseName("MyDataBase");
+dataSource.setUser("root");
+dataSource.setPassword("secret");
+```
+
+После чего создать `JdbcTemplate`
+
+```java
+JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
+```
+
+### execute
+
+Выполнение SQL запроса без последующей обработки результатов выполнения.
+
+```java
+jdbcTemplate.execute("CREATE TABLE my_table (id int, name varchar(16));");
+```
+
+### query
+
+Выполнение SQL запроса и обработка его результатов.  
+Может возвращать любой тип объектов. 
+
+```java
+String name = jdbcTemplate.query("SELECT name FROM my_table LIMIT 0,1", resultSet -> {
+        if (resultSet.next()) {
+            return resultSet.getString("name");
+        } else {
+            return null;
+        }
+});
+```
+
+```java
+List<String> names = jdbcTemplate.query("SELECT name FROM my_table", resultSet -> {
+        if (resultSet.next()) {
+            List<String> list = new ArrayList<>();
+            do {
+                list.add(resultSet.getString("name"));
+            } while (resultSet.next());
+            return list;
+        } else {
+            return Collections.emptyList();
+        }
+});
+```
+
+### queryOne
+
+Выполнение SQL запроса с расчетом, что результат будет единичным либо не будет вовсе.  
+Возвращает `Optional`.
+
+```java
+Optional<String> optName = jdbcTemplate.queryOne("SELECT name FROM my_table WHERE name LIKE 'dmitriymx'", rs -> rs.getString("name"));
+```
+
+### queryList
+
+Выполнение SQL запроса и обработка результата как списка данных.  
+Возвращает `List`.
+
+```java
+List<String> names = jdbcTemplate.queryList("SELECT name FROM my_table", (resultSet, rowNum) -> resultSet.getString("name"));
+```
+
+### queryForMap
+
+Выполнение SQL запроса с расчетом, что результат будет единичным либо не будет вовсе.  
+Возвращает `Map<String, Object>`, где ключ — это наименование колонок таблицы, а значения — это значения в ячейках таблицы.
+
+```java
+Map<String, Object> map = jdbcTemplate.queryForMap("SELECT * FROM my_table LIMIT 0,1;");
+```
+
+### queryForMapList
+
+Выполнение SQL запроса и обработка результата как списка данных.  
+Возвращает `List<Map<String, Object>>`, где ключ — это наименование колонок таблицы, а значения — это значения в ячейках таблицы.
+
+```java
+List<Map<String, Object>> mapList = jdbcTemplate.queryForMapList("SELECT * FROM my_table");
+```
+
+### update
+
+Выполнение SQL запроса где будет происходить обновление данных в таблице.
+Под "обновлением" подразумеваются любые изменения в таблице: `UPDATE`, `DELETE`, `INSERT`.  
+Возвращает число строк, которые были _по факту обновлены_ в таблице.
+
+```java
+int rows = jdbcTemplate.update("DELETE FROM my_table WHERE name LIKE 'dmitriymx';");
+```
+
+## ScheduleManager
+
+Набор методов для создания параллельных задач, выполняющихся один раз или по рассписанию.
+
+### createTask
+
+Создание конструктора задачи.
+
+```java
+ScheduleManager.Builder builder = ScheduleManager.createTask();
+```
+
+### useBukkitScheduler
+
+Если задача будет взаимодействоватьс **Bukkit API** или необходима привязка задачи к _тикам_,
+то необходимо использовать данный указатель.
+
+В ином случае, указатель не нужен.
+
+```java
+ScheduleManager.Builder builder = ScheduleManager.createTask()
+        .useBukkitScheduler();
+```
+
+### after
+
+Указание, что задачу нужно выполнить не сразу, а с некоторой задержкой перед запуском.
+
+```java
+ScheduleManager.Builder builder = ScheduleManager.createTask()
+        .after(5, TimeUnit.MINUTES);
+```
+
+### every
+
+Указание, что задачу нужно повторять через указанное время.
+
+```java
+ScheduleManager.Builder builder = ScheduleManager.createTask()
+        .every(5, TimeUnit.MINUTES);
+```
+
+### create
+
+Создание описанной задачи.
+
+```java
+ScheduleTask scheduleTask = ScheduleManager.createTask()
+        .every(1, TimeUnit.SECONDS)
+        .create(() -> Bukkit.getServer().getLogger().info("TimeMS: " + System.currentTimeMillis()));
+```
+
+_Задача будет только создана. Для её выполнения нужно вызвать `scheduleTask.start()`._
+
+### execute
+
+Создание и выполнение описанной задачи.
+
+```java
+ScheduleTask scheduleTask = ScheduleManager.createTask()
+        .every(1, TimeUnit.SECONDS)
+        .execute(() -> Bukkit.getServer().getLogger().info("TimeMS: " + System.currentTimeMillis()));
+```
+
+## ScheduleTask
+
+Вспомогательный объект, созданный через `ScheduleManager`. Позволяет управлять созданной задачей.
+
+### start
+
+Запускает задачу, если она еще не запущена.
+
+```java
+ScheduleTask scheduleTask = ...;
+scheduleTask.start();
+```
+
+### isCanceled
+
+Возвращает состояние задачи. Если `true`, значит задача была или _отменена/остоновлена_ или была завершена.
+
+```java
+ScheduleTask scheduleTask = ...;
+boolean status = scheduleTask.isCanceled();
+```
+
+### cancel
+
+Отменяет/Остонавливает выполнение задачи.
+
+```java
+ScheduleTask scheduleTask = ...;
+scheduleTask.cancel();
+```
+
+## Messages
+
+Инструмент для работы с параметизированными сообщениями или просто сообщениями, которые храняться в отдельном файле.
+
+Параметизированные сообщения имеют следующий вид: `Привет, {player}!`.
+
+### load
+
+Загрузка сообщений в инструмент.
+
+Есть три варианта: через `Properties`
+
+```java
+Properties properties = ...;
+Messages.load(properties);
+```
+
+через `Map<String, String>`
+
+```java
+Map<String, String> map = ...;
+Messages.load(map);
+```
+
+через `Reader`
+
+```java
+Reader reader = ...;
+Messages.load(reader);
+```
+
+Следует учесть, про при работе через `Reader`, **Messages** ожидает там обнаружить список строк в формате `key=value`.
+
+### get
+
+Получение обычноего или параметизированного сообщения.
+
+Для примера, пусть у нас будут такие сообщения:
+
+```properties
+simple=Простое сообщение
+welcome=Приветствуем, {player}!
+```
+
+Для получения простого сообщения, просто указываем его ключ:
+
+```java
+String message = Messages.get("simple");
+// Простое сообщение
+```
+
+Для получения параметизированного сообщения, нужно помимо ключа передать параметры.
+Есть два способа: через `Map<String, Object>`
+
+```java
+Map<String, Object> = map = new HashMap<>(1);
+map.put("player", "David");
+
+String message = Messages.get("welcome", map);
+// Приветствуем, David!
+```
+
+через попарное перечисление параметров
+
+```java
+String message = Messages.get("welcome", "player", "David");
+// Приветствуем, David!
+```
+
+Если по указанному ключу сообщение отсутствует, то **Messages** вернёт значение самого ключа
+
+```java
+String message = Messages.get("not_exists_key");
+// not_exists_key
+
+message = Messages.get("not_exists_key", "player", "David");
+// not_exists_key
+```
+
+Если параметр, который указан в шаблоне не был указан/определён, то параметр останется как есть
+
+```java
+String message = Messages.get("welcome");
+// Приветствуем, {player}!
+
+message = Messages.get("welcome", "unknown_param_key", 123);
+// Приветствуем, {player}!
+```
+
+### format
+
+**Messages** можно использовать и просто для форматирования параметизированных шаблонов:
+
+```java
+Map<String, Object> = map = new HashMap<>(1);
+map.put("player", "David");
+
+String message = Messages.format("Приветствуем, {player}!", map);
+// Приветствуем, David!
+```
+
+```java
+String message = Messages.foramt("Приветствуем, {player}!", "player", "David");
+// Приветствуем, David!
+```
+
+## XLog
+
+Замена стандартному `getLogger()`, который использует `java.utils.Logger` и не всегда удобен для логирования.
+
+Имеет 4 уровня логирования: `debug`, `info`, `warning`, `error`.
+
+Сообщения могут быть шаблонизированными. Синтаксис шаблонов — `java.text.MessageFormat`.
+
+Примеры:
+
+```java
+XLog.info("Hello");
+XLog.info("Player {0} join game", event.getPlayer().getName());
+
+XLog.error("ERROR!", exception);
+XLog.error("ERROR: {0}", exception.getMessage());
+// Для экранирования "{" нужно перед ней поставить "'".
+// А для использования "'" нужно их дублировать.
+XLog.error("ERROR ''{0}'' in Event '{{1}'}: {2}", exception.getClass(), event.getClass(), exception.getMessage());
+XLog.error("ERROR: {0}", exception.getMessage(), exception);
+```
+
+---
+
+## Подключение
+
+### Gradle
+
+```groovy
+repositories {
+    maven { url 'https://dmx-mc-project.gitlab.io/maven-repository/' }
+}
+```
+
+```groovy
+implementation group: 'ghast', name: 'ghast-tools', version: '1.13'
+```
+
+### Maven
+
+```xml
+<repositories>
+    <repository>
+        <id>dmx-mc-project</id>
+        <url>https://dmx-mc-project.gitlab.io/maven-repository/</url>
+    </repository>
+</repositories>
+```
+
+```xml
+<dependencies>
+    <dependency>
+        <groupId>ghast</groupId>
+        <artifactId>ghast-tools</artifactId>
+        <version>1.13</version>
+    </dependency>
+</dependencies>
+```

build.gradle

@@ -1,45 +1,88 @@
+//file:noinspection GroovyAssignabilityCheck
 plugins {
     id 'java'
+    id 'maven-publish'
+    id 'jacoco'
 }
 
-def publishScript = file(rootProject.getProjectDir().getPath() + '/publish.gradle')
-if (publishScript.exists()) {
-    apply from: publishScript.path
-}
+project.group = 'ghast'
+jar.archiveBaseName.set(project.name)
+project.version = '1.13'
+def gitlab_projectid = 23328133
 
-project.group = projectGroup
-project.version = projectVersion
+compileJava {
+    sourceCompatibility = targetCompatibility = JavaVersion.VERSION_1_8
+    options.encoding = 'UTF-8'
+}
 
 repositories {
-    mavenLocal()
     mavenCentral()
     maven { url 'https://hub.spigotmc.org/nexus/content/groups/public' }
 }
 
-ext {
-    libs = [
-            bukkit: [lib: 'org.bukkit:bukkit:1.12.2-R0.1-SNAPSHOT', exclude: [
-                    'com.google.code.gson:gson',
-                    'com.googlecode.json-simple:json-simple',
-                    'commons-lang:commons-lang',
-                    'org.yaml:snakeyaml'
-            ]],
-            lombok: 'org.projectlombok:lombok:1.18.12'
-    ]
+def lombokVersion = '1.18.22'
+def junitVersion = '5.8.1'
+def bukkitVersion = '1.12.2-R0.1-SNAPSHOT'
+
+dependencies {
+    annotationProcessor("org.projectlombok:lombok:$lombokVersion")
+    compileOnly("org.projectlombok:lombok:$lombokVersion")
+
+    compileOnly("org.bukkit:bukkit:$bukkitVersion") {
+        exclude(module: 'gson')
+        exclude(module: 'json-simple')
+        exclude(module: 'commons-lang')
+        exclude(module: 'snakeyaml')
+    }
+    implementation('org.apache.commons:commons-text:1.9')
+    implementation('org.jooq:joor-java-8:0.9.14')
+
+    testImplementation("org.junit.jupiter:junit-jupiter-api:$junitVersion")
+    testImplementation("org.junit.jupiter:junit-jupiter-engine:$junitVersion")
+    testImplementation('org.mockito:mockito-core:4.0.0')
+    testImplementation('org.jooq:joor-java-8:0.9.14')
+    testImplementation("org.bukkit:bukkit:$bukkitVersion") {
+        exclude(module: 'gson')
+        exclude(module: 'json-simple')
+        exclude(module: 'commons-lang')
+        exclude(module: 'snakeyaml')
+    }
+    testImplementation('com.h2database:h2:1.4.200')
 }
 
-def compileOnly2(library) {
-    dependencies.compileOnly library.lib, {
-        library.exclude.each { String excludeLibStr ->
-            String[] excludeLib = excludeLibStr.split(':')
-            exclude group: excludeLib[0], module: excludeLib[1]
+test {
+    useJUnitPlatform()
+}
+
+jacoco {
+    toolVersion = '0.8.5'
+}
+
+jacocoTestReport {
+    dependsOn test
+}
+
+publishing {
+    publications {
+        mavenBinary(MavenPublication) {
+            groupId = project.group
+            artifactId = project.name
+            version = project.version
+
+            from components.java
+        }
+    }
+
+    repositories {
+        maven {
+            url "https://gitlab.com/api/v4/projects/${gitlab_projectid}/packages/maven"
+            credentials(HttpHeaderCredentials) {
+                name = 'Job-Token'
+                value = System.getenv('CI_JOB_TOKEN')
+            }
+            authentication {
+                header(HttpHeaderAuthentication)
+            }
         }
     }
 }
-
-dependencies {
-    compileOnly libs.lombok
-    annotationProcessor libs.lombok
-
-    compileOnly2 libs.bukkit
-}

gradle.properties

@@ -1,3 +0,0 @@
-projectGroup=ghast
-projectName=ghast-tools
-projectVersion=1.1

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.7-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.2-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

settings.gradle

@@ -1,2 +1 @@
-rootProject.name = projectName
-
+rootProject.name = 'ghast-tools'

src/main/java/ghast/AssetsException.java

@@ -1,13 +0,0 @@
-package ghast;
-
-public class AssetsException extends RuntimeException {
-
-	public AssetsException(String message) {
-		super(message);
-	}
-
-	public AssetsException(String message, Throwable cause) {
-		super(message, cause);
-	}
-}
-

src/main/java/ghast/AssetsManager.java

@@ -1,113 +0,0 @@
-package ghast;
-
-import lombok.experimental.UtilityClass;
-import org.bukkit.plugin.Plugin;
-
-import java.io.File;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.net.URL;
-import java.nio.file.Files;
-import java.nio.file.Path;
-
-import static java.text.MessageFormat.format;
-
-@UtilityClass
-@SuppressWarnings("unused")
-public class AssetsManager {
-
-	private static final String ERROR_NOT_FOUND = "Asset \"{0}\" not found";
-
-	public void saveTo(String resourceName, Path targetPath) {
-		URL resourceUrl = getResourceUrl(resourceName);
-
-		Path saveToPath;
-		if (Files.isDirectory(targetPath)) {
-			saveToPath = targetPath.resolve(resourceName);
-		} else {
-			saveToPath = targetPath;
-		}
-
-		doSaveTo(resourceUrl, saveToPath);
-	}
-
-	public void saveTo(String resourceName, File targetPath) {
-		saveTo(resourceName, targetPath.toPath());
-	}
-
-	public InputStream loadResource(String resourceName, String defaultResourceName, boolean saveDefault) {
-		Plugin plugin = GhastTools.getPlugin();
-		InputStream inputStream;
-
-		Path pathToResource = plugin.getDataFolder().toPath().resolve(resourceName);
-		if (Files.exists(pathToResource)) {
-			inputStream = openResource(pathToResource);
-		} else if (defaultResourceName != null) {
-			URL resourceUrl = getResourceUrl(defaultResourceName);
-
-			if (saveDefault) {
-				doSaveTo(resourceUrl, pathToResource);
-				inputStream = openResource(pathToResource);
-			} else {
-				inputStream = openResource(resourceUrl);
-			}
-		} else {
-			throw new AssetsException(format(ERROR_NOT_FOUND, resourceName));
-		}
-
-		return inputStream;
-	}
-
-	public InputStream loadResource(String resourceName, String defaultResourceName) {
-		return loadResource(resourceName, defaultResourceName, true);
-	}
-
-	public InputStream loadResource(String resourceName, boolean saveDefault) {
-		return loadResource(resourceName, resourceName, saveDefault);
-	}
-
-	public InputStream loadResource(String resourceName) {
-		return loadResource(resourceName, resourceName, true);
-	}
-
-	private URL getResourceUrl(String resourceName) {
-		URL resourceUrl = AssetsManager.class.getClassLoader().getResource(resourceName);
-		if (resourceUrl == null) {
-			throw new AssetsException(format(ERROR_NOT_FOUND, resourceName));
-		}
-
-		return resourceUrl;
-	}
-
-	private void doSaveTo(URL resourceUrl, Path saveToPath) {
-		try (InputStream inputStream = resourceUrl.openStream();
-			 OutputStream outputStream = Files.newOutputStream(saveToPath)) {
-
-			byte[] buffer = new byte[8192];
-			int count;
-			while ((count = inputStream.read(buffer)) != -1) {
-				outputStream.write(buffer, 0, count);
-			}
-		} catch (IOException e) {
-			throw new AssetsException(format("Error save asset \"{0}\" to \"{1}\": {2}",
-					resourceUrl, saveToPath, e.getMessage()), e);
-		}
-	}
-
-	private InputStream openResource(Path pathToResource) {
-		try {
-			return Files.newInputStream(pathToResource);
-		} catch (IOException e) {
-			throw new AssetsException(format("Error open asset \"{0}\": {1}", pathToResource, e.getMessage()), e);
-		}
-	}
-
-	private InputStream openResource(URL resourceUrl) {
-		try {
-			return resourceUrl.openStream();
-		} catch (IOException e) {
-			throw new AssetsException(format("Error open asset \"{0}\": {1}", resourceUrl, e.getMessage()), e);
-		}
-	}
-}

src/main/java/ghast/BuildHelper.java

@@ -3,34 +3,140 @@ package ghast;
 import lombok.experimental.UtilityClass;
 import org.bukkit.Location;
 import org.bukkit.Material;
+import org.bukkit.SkullType;
 import org.bukkit.block.Block;
 import org.bukkit.block.BlockFace;
 import org.bukkit.block.Sign;
 import org.bukkit.block.Skull;
+import org.joor.Reflect;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Base64;
+import java.util.UUID;
+
+import static org.joor.Reflect.on;
+import static org.joor.Reflect.onClass;
 
 @UtilityClass
 @SuppressWarnings("unused")
 public class BuildHelper {
 
-	public Skull placeSkull(Location location, BlockFace face) {
-		Block block = location.getWorld().getBlockAt(location);
-		block.setType(Material.SKULL);
-		Skull skull = (Skull) block.getState();
-		skull.setRotation(face);
-		org.bukkit.material.Skull skullMaterial = (org.bukkit.material.Skull) skull.getData();
-		skullMaterial.setFacingDirection(BlockFace.SELF);
+    private final Class<?> CLASS_BLOCKPOSITION = getClassForName("net.minecraft.server.v1_12_R1.BlockPosition");
+    private final Class<?> CLASS_GAMEPROFILE = getClassForName("com.mojang.authlib.GameProfile");
 
-		return skull;
-	}
+    /**
+     * Установка черепа.
+     * <p>
+     * После установки, необходимо выполнить <code>skull.update(true);</code>
+     *
+     * @param location место установки.
+     * @param face куда будет повёрнут череп.
+     * @return Блок типа {@link Skull}
+     */
+    public Skull placeSkull(Location location, BlockFace face) {
+        Location fixedLocation = GhastTools.copyLocation(location);
+        fixedLocation.setZ(fixedLocation.getZ() - 1);
 
-	public Sign placeSignWall(Location location, BlockFace face) {
-		Block block = location.getWorld().getBlockAt(location);
-		block.setType(Material.WALL_SIGN);
+        Block block = location.getWorld().getBlockAt(location);
+        block.setType(Material.SKULL);
 
-		Sign sign = (Sign) block.getState();
-		org.bukkit.material.Sign signMaterial = (org.bukkit.material.Sign) sign.getData();
-		signMaterial.setFacingDirection(face);
+        Skull skull = (Skull) block.getState();
+        skull.setRotation(face);
 
-		return sign;
-	}
+        org.bukkit.material.Skull skullMaterial = (org.bukkit.material.Skull) skull.getData();
+        skullMaterial.setFacingDirection(BlockFace.SELF);
+
+        return skull;
+    }
+
+    /**
+     * Установка головы игрока.
+     * <p>
+     * После установки, необходимо выполнить <code>skull.update(true);</code>
+     *
+     * @param location место установки.
+     * @param face куда будет повёрнута голова.
+     * @return Блок типа {@link Skull}
+     */
+    public static Skull placePlayerHead(Location location, BlockFace face) {
+        Location fixedLocation = GhastTools.copyLocation(location);
+        fixedLocation.setZ(fixedLocation.getZ() - 1);
+
+        Block block = fixedLocation.getWorld().getBlockAt(fixedLocation);
+        block.setType(Material.SKULL);
+
+        Skull skull = (Skull) block.getState();
+        skull.setSkullType(SkullType.PLAYER);
+        skull.setRotation(face);
+
+        org.bukkit.material.Skull skullMaterial = (org.bukkit.material.Skull) skull.getData();
+        skullMaterial.setFacingDirection(BlockFace.SELF);
+        return skull;
+    }
+
+    /**
+     * Установка текстурированной головы игрока.
+     *
+     * @param location место установки.
+     * @param face куда будет повёрнута голова.
+     * @param skinUrl URL на текстуру
+     * @return Блок типа {@link Skull}
+     */
+    public static Skull placePlayerHead(Location location, BlockFace face, String skinUrl) {
+        Skull playerHead = placePlayerHead(location, face);
+        playerHead.update(true);
+        setPlayerHeadSkin(playerHead, skinUrl);
+
+        return playerHead;
+    }
+
+    /**
+     * Установка текстуры для головы игрока.
+     *
+     * @param skull блок головы игрока
+     * @param skinUrl URL на текстуру
+     */
+    public static void setPlayerHeadSkin(Skull skull, String skinUrl) {
+        //TODO заменить рефлексию на "фантомные" классы
+        Reflect reflectBlockPosition = onClass(CLASS_BLOCKPOSITION)
+                .create(skull.getX(), skull.getY(), skull.getZ());
+
+        on(skull.getWorld())
+                .call("getHandle")
+                .call("getTileEntity", reflectBlockPosition.get())
+                .call("setGameProfile", getReflectPlayerProfile(skinUrl).get());
+    }
+
+    public Sign placeSignWall(Location location, BlockFace face) {
+        Block block = location.getWorld().getBlockAt(location);
+        block.setType(Material.WALL_SIGN);
+
+        Sign sign = (Sign) block.getState();
+        org.bukkit.material.Sign signMaterial = (org.bukkit.material.Sign) sign.getData();
+        signMaterial.setFacingDirection(face);
+
+        return sign;
+    }
+
+    private Reflect getReflectPlayerProfile(String url) {
+        Reflect reflectProperty = onClass("com.mojang.authlib.properties.Property")
+                .create("textures", Base64.getEncoder()
+                        .encodeToString(("{textures:{SKIN:{url:\"" + url + "\"}}}").getBytes(StandardCharsets.UTF_8)));
+
+        Reflect reflectGameProfile = onClass(CLASS_GAMEPROFILE)
+                .create(UUID.randomUUID(), null);
+
+        reflectGameProfile.call("getProperties")
+                .call("put", "textures", reflectProperty.get());
+
+        return reflectGameProfile;
+    }
+
+    private Class<?> getClassForName(String className) {
+        try {
+            return Class.forName(className);
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
 }

src/main/java/ghast/EffectsHelper.java

@@ -0,0 +1,27 @@
+package ghast;
+
+import lombok.experimental.UtilityClass;
+import org.bukkit.Location;
+import org.bukkit.Particle;
+import org.bukkit.Sound;
+import org.bukkit.SoundCategory;
+import org.bukkit.util.Vector;
+
+@UtilityClass
+@SuppressWarnings("unused")
+public class EffectsHelper {
+
+    public void playSound(Location location, Sound sound, float pitch) {
+        location.getWorld().playSound(location, sound, SoundCategory.MASTER, 1.0f, pitch);
+    }
+
+    public void particle(Location location, Particle particle, double dx, double dy, double dz, double speed, int amount) {
+        location.getWorld().spawnParticle(particle, location, amount, dx, dy, dz, speed);
+    }
+
+    //TODO нужно проверить
+    public void particle(Location location, Particle particle, Vector vector, double speed, int amount) {
+        particle(location, particle, vector.getX(), vector.getY(), vector.getZ(), speed, amount);
+    }
+}
+

src/main/java/ghast/EventContext.java

@@ -0,0 +1,71 @@
+package ghast;
+
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+import org.bukkit.Bukkit;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.BooleanSupplier;
+import java.util.function.Consumer;
+
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+@SuppressWarnings("unused")
+public class EventContext implements Listener {
+
+    private static final BooleanSupplier EMPTY_FILTER = () -> true;
+    private static final Consumer<Cancellable> CANCEL_EVENT = event -> event.setCancelled(true);
+
+    private final Map<Class<? extends Event>, Consumer<?>> eventMap = new HashMap<>();
+    private BooleanSupplier filter = EMPTY_FILTER;
+
+    public EventContext filter(BooleanSupplier filter) {
+        this.filter = (filter != null ? filter : EMPTY_FILTER);
+        return this;
+    }
+
+    public <T extends Event> EventContext onEvent(Class<T> eventType, EventPriority eventPriority, Consumer<T> consumer) {
+        if (consumer == null) {
+            eventMap.remove(eventType);
+        } else {
+            eventMap.put(eventType, consumer);
+            bukkitRegisterEvent(eventType, eventPriority);
+        }
+        return this;
+    }
+
+    public <T extends Event> EventContext onEvent(Class<T> eventType, Consumer<T> consumer) {
+        return onEvent(eventType, EventPriority.NORMAL, consumer);
+    }
+
+    public <T extends Event & Cancellable> EventContext cancelEvent(Class<T> eventType, EventPriority eventPriority) {
+        eventMap.put(eventType, CANCEL_EVENT);
+        bukkitRegisterEvent(eventType, eventPriority);
+        return this;
+    }
+
+    public <T extends Event & Cancellable> EventContext cancelEvent(Class<T> eventType) {
+        return cancelEvent(eventType, EventPriority.NORMAL);
+    }
+
+    private void bukkitRegisterEvent(Class<? extends Event> eventType, EventPriority eventPriority) {
+        Bukkit.getPluginManager().registerEvent(eventType, this, eventPriority,
+                this::eventExecute, GhastTools.getPlugin());
+    }
+
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    private void eventExecute(Listener listener, Event event) {
+        Consumer consumer = eventMap.get(event.getClass());
+        if (consumer != null && filter.getAsBoolean()) {
+            consumer.accept(event);
+        }
+    }
+
+    public static EventContext create() {
+        return new EventContext();
+    }
+}

src/main/java/ghast/EventManager.java

@@ -1,66 +0,0 @@
-package ghast;
-
-import lombok.AccessLevel;
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
-import lombok.Setter;
-import lombok.experimental.UtilityClass;
-import org.bukkit.Bukkit;
-import org.bukkit.event.Event;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.Listener;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.function.BooleanSupplier;
-import java.util.function.Consumer;
-
-@UtilityClass
-@SuppressWarnings("unused")
-public class EventManager {
-
-	public Builder createContext() {
-		return new Builder();
-	}
-
-	@RequiredArgsConstructor(access = AccessLevel.PRIVATE)
-	public static class Builder {
-
-		private static final BooleanSupplier EMPTY_FILTER = () -> true;
-
-		private final EventContext eventContext = new EventContext();
-
-		public Builder filter(BooleanSupplier filter) {
-			eventContext.setFilter(filter != null ? filter : EMPTY_FILTER);
-			return this;
-		}
-
-		public <T extends Event> Builder onEvent(Class<T> eventType, EventPriority eventPriority, Consumer<T> consumer) {
-			eventContext.getEventMap().put(eventType, consumer);
-			Bukkit.getPluginManager().registerEvent(eventType, eventContext, eventPriority,
-					eventContext::eventExecute, GhastTools.getPlugin());
-			return this;
-		}
-
-		public <T extends Event> Builder onEvent(Class<T> eventType, Consumer<T> consumer) {
-			return onEvent(eventType, EventPriority.NORMAL, consumer);
-		}
-	}
-
-	@RequiredArgsConstructor(access = AccessLevel.PRIVATE)
-	@Getter(AccessLevel.PRIVATE)
-	@Setter(AccessLevel.PRIVATE)
-	private static class EventContext implements Listener {
-
-		private final Map<Class<? extends Event>, Consumer<?>> eventMap = new HashMap<>();
-		private BooleanSupplier filter;
-
-		@SuppressWarnings({ "unchecked", "rawtypes" })
-		private void eventExecute(Listener listener, Event event) {
-			Consumer consumer = eventMap.get(event.getClass());
-			if (consumer != null && filter.getAsBoolean()) {
-				consumer.accept(event);
-			}
-		}
-	}
-}

src/main/java/ghast/GhastTools.java

@@ -1,57 +1,55 @@
 package ghast;
 
+import ghast.assets.AssetsManager;
 import lombok.experimental.UtilityClass;
+import org.bukkit.Location;
 import org.bukkit.configuration.file.YamlConfiguration;
 import org.bukkit.plugin.Plugin;
 
 import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
+import java.io.Reader;
 import java.lang.ref.WeakReference;
 
 @UtilityClass
 @SuppressWarnings("unused")
 public class GhastTools {
 
-	private static WeakReference<Plugin> refPlugin;
+    private static WeakReference<Plugin> refPlugin;
 
-	@SuppressWarnings("java:S2696")
-	public void setPlugin(Plugin plugin) {
-		if (plugin == null) {
-			refPlugin = null;
-		} else {
-			refPlugin = new WeakReference<>(plugin);
-		}
-	}
+    public void setPlugin(Plugin plugin) {
+        refPlugin = plugin == null ? null : new WeakReference<>(plugin);
+    }
 
-	@SuppressWarnings("java:S112")
-	public YamlConfiguration loadConfig(boolean saveDefault) {
-		if (saveDefault) {
-			getPlugin().saveDefaultConfig();
-		}
+    public Plugin getPlugin() {
+        if (refPlugin == null) {
+            throw new RuntimeException("Plugin not set.");
+        }
 
-		try (InputStream inputStream = AssetsManager.loadResource("config.yml", saveDefault)) {
-			return YamlConfiguration.loadConfiguration(new InputStreamReader(inputStream));
-		} catch (IOException e) {
-			throw new RuntimeException("Error load config: " + e.getMessage(), e);
-		}
-	}
+        Plugin plugin = refPlugin.get();
+        if (plugin == null) {
+            throw new RuntimeException("Plugin not set.");
+        }
 
-	public YamlConfiguration loadConfig() {
-		return loadConfig(true);
-	}
+        return plugin;
+    }
 
-	@SuppressWarnings("java:S112")
-	Plugin getPlugin() {
-		if (refPlugin == null) {
-			throw new RuntimeException("Plugin not set.");
-		}
+    public YamlConfiguration loadConfig(boolean saveDefault) {
+        if (saveDefault) {
+            getPlugin().saveDefaultConfig();
+        }
 
-		Plugin plugin = refPlugin.get();
-		if (plugin == null) {
-			throw new RuntimeException("Plugin not set.");
-		}
+        try (Reader reader = AssetsManager.getAsReader("config.yml", saveDefault)) {
+            return YamlConfiguration.loadConfiguration(reader);
+        } catch (IOException e) {
+            throw new RuntimeException("Error load config: " + e.getMessage(), e);
+        }
+    }
 
-		return plugin;
-	}
+    public YamlConfiguration loadConfig() {
+        return loadConfig(true);
+    }
+
+    public Location copyLocation(Location location) {
+        return new Location(location.getWorld(), location.getX(), location.getY(), location.getZ());
+    }
 }

src/main/java/ghast/HashMaps.java

@@ -0,0 +1,171 @@
+package ghast;
+
+import lombok.*;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Создание Map как в Java 9+.
+ */
+@SuppressWarnings("DuplicatedCode")
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public final class HashMaps {
+
+    public static <K, V> Map<K, V> of() {
+        return new HashMap<>(0);
+    }
+
+    public static <K, V> Map<K, V> of(K k1, V v1) {
+        return new HashMap<K, V>(1) {{
+            put(k1, v1);
+        }};
+    }
+
+    public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2) {
+        return new HashMap<K, V>(2) {{
+            put(k1, v1);
+            put(k2, v2);
+        }};
+    }
+
+    public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3) {
+        return new HashMap<K, V>(3) {{
+            put(k1, v1);
+            put(k2, v2);
+            put(k3, v3);
+        }};
+    }
+
+    public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4) {
+        return new HashMap<K, V>(4) {{
+            put(k1, v1);
+            put(k2, v2);
+            put(k3, v3);
+            put(k4, v4);
+        }};
+    }
+
+    public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5) {
+        return new HashMap<K, V>(5) {{
+            put(k1, v1);
+            put(k2, v2);
+            put(k3, v3);
+            put(k4, v4);
+            put(k5, v5);
+        }};
+    }
+
+    public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5,
+                                      K k6, V v6) {
+        return new HashMap<K, V>(6) {{
+            put(k1, v1);
+            put(k2, v2);
+            put(k3, v3);
+            put(k4, v4);
+            put(k5, v5);
+            put(k6, v6);
+        }};
+    }
+
+    public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5,
+                                      K k6, V v6, K k7, V v7) {
+        return new HashMap<K, V>(7) {{
+            put(k1, v1);
+            put(k2, v2);
+            put(k3, v3);
+            put(k4, v4);
+            put(k5, v5);
+            put(k6, v6);
+            put(k7, v7);
+        }};
+    }
+
+    public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5,
+                                      K k6, V v6, K k7, V v7, K k8, V v8) {
+        return new HashMap<K, V>(8) {{
+            put(k1, v1);
+            put(k2, v2);
+            put(k3, v3);
+            put(k4, v4);
+            put(k5, v5);
+            put(k6, v6);
+            put(k7, v7);
+            put(k8, v8);
+        }};
+    }
+
+    public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5,
+                                      K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9) {
+        return new HashMap<K, V>(9) {{
+            put(k1, v1);
+            put(k2, v2);
+            put(k3, v3);
+            put(k4, v4);
+            put(k5, v5);
+            put(k6, v6);
+            put(k7, v7);
+            put(k8, v8);
+            put(k9, v9);
+        }};
+    }
+
+    public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5,
+                                      K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10) {
+        return new HashMap<K, V>(10) {{
+            put(k1, v1);
+            put(k2, v2);
+            put(k3, v3);
+            put(k4, v4);
+            put(k5, v5);
+            put(k6, v6);
+            put(k7, v7);
+            put(k8, v8);
+            put(k9, v9);
+            put(k10, v10);
+        }};
+    }
+
+    @SafeVarargs
+    public static <K, V> Map<K, V> ofEntries(Map.Entry<? extends K, ? extends V>... entries) {
+        if (entries == null || entries.length == 0) {
+            return of();
+        }
+
+        Map<K, V> map = new HashMap<>(entries.length);
+        for (Map.Entry<? extends K, ? extends V> entry : entries) {
+            map.put(entry.getKey(), entry.getValue());
+        }
+
+        return map;
+    }
+
+    public static <K, V> Map.Entry<K, V> entry(K k, V v) {
+        return new SimpleEntry<>(k, v);
+    }
+
+    @AllArgsConstructor
+    @EqualsAndHashCode
+    private static class SimpleEntry<K, V> implements Map.Entry<K, V> {
+
+        private final K key;
+        private V value;
+
+        @Override
+        public K getKey() {
+            return key;
+        }
+
+        @Override
+        public V getValue() {
+            return value;
+        }
+
+        @Override
+        public V setValue(V value) {
+            V prev = this.value;
+            this.value = value;
+            return prev;
+        }
+    }
+}

src/main/java/ghast/I18n.java

@@ -0,0 +1,94 @@
+package ghast;
+
+import com.google.common.collect.HashBasedTable;
+import com.google.common.collect.Table;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+import lombok.experimental.UtilityClass;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.text.StringSubstitutor;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.Reader;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @deprecated use {@link Messages}
+ */
+@UtilityClass
+@SuppressWarnings("unused")
+@Deprecated
+public class I18n {
+
+    private final String DEFAULT_LANG = "en";
+    private final Table<String/*Lang*/, String/*Key*/, String/*Template|Message*/> messagesMap = HashBasedTable.create();
+
+    //region Load messages
+    public void loadMessages(String lang, Reader reader) {
+        Map<String, String> map = messagesMap.row(lang.toLowerCase());
+
+        try {
+            BufferedReader bufferedReader = new BufferedReader(reader);
+            String line;
+            while ((line = bufferedReader.readLine()) != null) {
+                String[] split = line.split("=", 2);
+                map.put(split[0].trim().toLowerCase(), split[1].trim());
+            }
+        } catch (IOException e) {
+            throw new RuntimeException("Error load messages: " + e.getMessage(), e);
+        }
+    }
+
+    public void loadMessages(String lang, Map<String, String> messages) {
+        Map<String, String> map = messagesMap.row(lang.toLowerCase());
+        messages.forEach((k, v) -> map.put(k.toLowerCase(), v));
+    }
+
+    public void loadMessages(Reader reader) {
+        loadMessages(DEFAULT_LANG, reader);
+    }
+
+    public void loadMessages(Map<String, String> messages) {
+        loadMessages(DEFAULT_LANG, messages);
+    }
+    //endregion
+
+    //region Get message
+    public String get(String lang, String key) {
+        return messagesMap.row(lang.toLowerCase()).getOrDefault(key.toLowerCase(), StringUtils.EMPTY);
+    }
+
+    public String get(String lang, String key, Map<String, Object> params) {
+        return StringSubstitutor.replace(get(lang, key.toLowerCase()), params, "{", "}");
+    }
+
+    public String get(String key) {
+        return get(DEFAULT_LANG, key);
+    }
+
+    public String get(String key, Map<String, Object> params) {
+        return get(DEFAULT_LANG, key, params);
+    }
+    //endregion
+
+    public ParamBuilder paramBuilder() {
+        return new ParamBuilder();
+    }
+
+    @NoArgsConstructor(access = AccessLevel.PRIVATE)
+    public static class ParamBuilder {
+
+        private final Map<String, Object> params = new HashMap<>();
+
+        public ParamBuilder add(String key, Object value) {
+            params.put(key, value);
+            return this;
+        }
+
+        public Map<String, Object> build() {
+            return params;
+        }
+    }
+}

src/main/java/ghast/Messages.java

@@ -0,0 +1,163 @@
+package ghast;
+
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+import org.apache.commons.text.StringSubstitutor;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.Reader;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Properties;
+import java.util.stream.Collectors;
+
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public final class Messages {
+
+	private static final Map<String/*Key*/, String/*Template|Message*/> MESSAGES_MAP = new HashMap<>();
+
+	//region Load messages
+	/**
+	 * Загрузка сообщений из {@link Properties}
+	 *
+	 * @param properties список сообщений и шаблонов
+	 */
+	public static void load(Properties properties) {
+		load(properties.entrySet().stream().collect(Collectors.toMap(
+				entry -> (String) entry.getKey(),
+				entry -> (String) entry.getValue()
+		)));
+	}
+
+	/**
+	 * Загрузка сообщений из {@link Reader}.
+	 * <p>
+	 * Формат строк: {@code key=value}
+	 * </p>
+	 *
+	 * @param reader {@link Reader} со списоком сообщений и шаблонов
+	 */
+	public static void load(Reader reader) {
+		try(BufferedReader bufferedReader = new BufferedReader(reader)) {
+			Map<String, String> map = bufferedReader.lines()
+					.map(line -> line.split("=", 2))
+					.collect(Collectors.toMap(
+							pair -> pair[0].trim().toLowerCase(),
+							pair -> pair[1].trim()
+					));
+			load(map);
+		} catch (IOException e) {
+			//TODO заменить на специализированный Exception
+			throw new RuntimeException("Error load messages: " + e.getMessage(), e);
+		}
+	}
+
+	/**
+	 * Загрузка сообщений из {@link Map}<{@link String}, {@link String}>.
+	 *
+	 * @param messages список сообщений и шаблонов
+	 */
+	public static void load(Map<String, String> messages) {
+		MESSAGES_MAP.clear();
+		MESSAGES_MAP.putAll(messages);
+	}
+	//endregion
+
+	//region Get messages
+	/**
+	 * Получить обычное сообщение по ключу/коду.
+	 *
+	 * @param key ключ/код
+	 * @return Сообщение, если таковое задано. Иначе - ключ
+	 */
+	public static String get(String key) {
+		String keyLc = key.toLowerCase();
+		return MESSAGES_MAP.getOrDefault(keyLc, keyLc);
+	}
+
+	/**
+	 * Получить параметизированное сообщение по ключу/коду.
+	 *
+	 * @param key    ключ/код
+	 * @param params список параметров
+	 * @return Сообщение, если таковое задано. Иначе - ключ
+	 */
+	public static String get(String key, Map<String, Object> params) {
+		String keyLc = key.toLowerCase();
+
+		if (MESSAGES_MAP.containsKey(keyLc)) {
+			return format(MESSAGES_MAP.get(keyLc), params);
+		} else {
+			return keyLc;
+		}
+	}
+
+	/**
+	 * Получить параметизированное сообщение по ключу/коду.
+	 *
+	 * @param key    ключ/код
+	 * @param params чередующийся по парный список параметров: {@link String (str)param_name}, {@link Object (obj)param_value} и т.д.
+	 * @return Сообщение, если таковое задано. Иначе - ключ
+	 */
+	@SuppressWarnings("unchecked")
+	public static String get(String key, Object... params) {
+		if (params.length == 1 && params[0] instanceof Map) {
+			return get(key, (Map<String, Object>) params[0]);
+		}
+
+		String keyLc = key.toLowerCase();
+
+		if (MESSAGES_MAP.containsKey(keyLc)) {
+			return format(MESSAGES_MAP.get(keyLc), params);
+		} else {
+			return keyLc;
+		}
+	}
+	//endregion
+
+	//region Format message
+	/**
+	 * Получить сообщение по формату.
+	 *
+	 * @param format параметизированное сообщение
+	 * @param params параметры
+	 * @return сообщение
+	 */
+	public static String format(String format, Map<String, Object> params) {
+		return StringSubstitutor.replace(format, params, "{", "}");
+	}
+
+	/**
+	 * Получить сообщение по формату.
+	 *
+	 * @param format параметизированное сообщение
+	 * @param params параметры
+	 * @return сообщение
+	 */
+	@SuppressWarnings("unchecked")
+	public static String format(String format, Object... params) {
+		if (params.length == 1 && params[0] instanceof Map) {
+			return format(format, (Map<String, Object>) params[0]);
+		}
+
+		return format(format, arrayParamsToMap(params));
+	}
+	//endregion
+
+	private static Map<String, Object> arrayParamsToMap(Object... params) {
+		int len;
+		if ((params.length % 2) == 1) {
+			len = params.length - 1;
+		} else {
+			len = params.length;
+		}
+
+		Map<String, Object> map = new HashMap<>(len / 2);
+		for (int i = 0; i < len; i = i + 2) {
+			map.put((String) params[i], params[i + 1]);
+		}
+
+		return map;
+	}
+}

src/main/java/ghast/ScheduleManager.java

@@ -1,92 +0,0 @@
-package ghast;
-
-import com.google.common.util.concurrent.ThreadFactoryBuilder;
-import lombok.AccessLevel;
-import lombok.NoArgsConstructor;
-import lombok.experimental.UtilityClass;
-import org.bukkit.Bukkit;
-import org.bukkit.scheduler.BukkitScheduler;
-
-import java.util.concurrent.*;
-
-@UtilityClass
-@SuppressWarnings("unused")
-public class ScheduleManager {
-
-	private static final ThreadFactory THREAD_FACTORY = new ThreadFactoryBuilder()
-			.setNameFormat("ScheduleManager-Thread-%d")
-			.setDaemon(true)
-			.build();
-
-	public Builder createTask() {
-		return new Builder();
-	}
-
-	@NoArgsConstructor(access = AccessLevel.PRIVATE)
-	public static class Builder {
-
-		private static final long MS_PER_ONE_TICK = 1000L/*one second by ms*/ / 20L/*tick per second*/;
-		private boolean useBukkitScheduler = false;
-		private Long afterMs;
-		private Long everyMs;
-
-		public Builder useBukkitScheduler() {
-			this.useBukkitScheduler = true;
-			return this;
-		}
-
-		public Builder after(long value, TimeUnit unit) {
-			this.afterMs = unit.toMillis(value);
-			return this;
-		}
-
-		public Builder every(long value, TimeUnit unit) {
-			this.everyMs = unit.toMillis(value);
-			return this;
-		}
-
-		public void execute(Runnable runnable) {
-			if (useBukkitScheduler) {
-				createBukkitSchedule(runnable);
-			} else {
-				createSchedule(runnable);
-			}
-		}
-
-		private void createBukkitSchedule(Runnable runnable) {
-			BukkitScheduler bukkitScheduler = Bukkit.getScheduler();
-
-			if (this.afterMs == null && this.everyMs == null) {
-				bukkitScheduler.runTask(GhastTools.getPlugin(), runnable);
-			} else if (this.everyMs != null) {
-				long everyTicks = this.everyMs / MS_PER_ONE_TICK;
-				long afterTicks = this.afterMs != null ? this.afterMs / MS_PER_ONE_TICK : 0;
-				bukkitScheduler.runTaskTimer(GhastTools.getPlugin(), runnable, afterTicks, everyTicks);
-			} else {
-				long ticks = this.afterMs / MS_PER_ONE_TICK;
-				bukkitScheduler.runTaskLater(GhastTools.getPlugin(), runnable, ticks);
-			}
-		}
-
-		private void createSchedule(Runnable runnable) {
-			ExecutorService executorService;
-
-			if (this.afterMs == null && this.everyMs == null) {
-				executorService = Executors.newSingleThreadExecutor(THREAD_FACTORY);
-				executorService.execute(runnable);
-			} else if (this.everyMs != null) {
-				ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1, THREAD_FACTORY);
-				scheduledExecutorService.scheduleAtFixedRate(runnable,
-						this.afterMs != null ? this.afterMs : 0,
-						everyMs, TimeUnit.MILLISECONDS);
-				executorService = scheduledExecutorService;
-			} else {
-				ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1, THREAD_FACTORY);
-				scheduledExecutorService.schedule(runnable, afterMs, TimeUnit.MILLISECONDS);
-				executorService = scheduledExecutorService;
-			}
-
-			executorService.shutdown();
-		}
-	}
-}

src/main/java/ghast/XLog.java

@@ -0,0 +1,81 @@
+package ghast;
+
+import lombok.experimental.UtilityClass;
+
+import java.util.logging.Level;
+
+import static java.text.MessageFormat.format;
+
+/**
+ * @deprecated use {@link ghast.logger.BukkitLogger}
+ */
+@UtilityClass
+@SuppressWarnings("unused")
+@Deprecated
+public class XLog {
+
+    //region Debug
+    public void debug(String pattern, Object... objects) {
+        if (objects.length > 1 && objects[objects.length - 1] instanceof Throwable) {
+            Throwable throwable = (Throwable) objects[objects.length - 1];
+            Object[] values = new Object[objects.length - 1];
+            System.arraycopy(objects, 0, values, 0, values.length);
+
+            debug(format(pattern, values), throwable);
+        } else {
+            debug(format(pattern, objects));
+        }
+    }
+
+    public void debug(String message, Throwable throwable) {
+        GhastTools.getPlugin().getLogger().log(Level.FINE, message, throwable);
+    }
+
+    public void debug(String message) {
+        GhastTools.getPlugin().getLogger().fine(message);
+    }
+    //endregion
+
+    //region Info
+    public void info(String pattern, Object... objects) {
+        info(format(pattern, objects));
+    }
+
+    public void info(String message) {
+        GhastTools.getPlugin().getLogger().info(message);
+    }
+    //endregion
+
+    //region Warning
+    public void warn(String pattern, Object... objects) {
+        warn(format(pattern, objects));
+    }
+
+    public void warn(String message) {
+        GhastTools.getPlugin().getLogger().warning(message);
+    }
+    //endregion
+
+    //region Error
+    public void error(String pattern, Object... objects) {
+        if (objects.length > 1 && objects[objects.length - 1] instanceof Throwable) {
+            Throwable throwable = (Throwable) objects[objects.length - 1];
+            Object[] values = new Object[objects.length - 1];
+            System.arraycopy(objects, 0, values, 0, values.length);
+
+            error(format(pattern, values), throwable);
+        } else {
+            error(format(pattern, objects));
+        }
+    }
+
+    public void error(String message) {
+        GhastTools.getPlugin().getLogger().severe(message);
+    }
+
+    public void error(String message, Throwable throwable) {
+        GhastTools.getPlugin().getLogger().log(Level.SEVERE, message, throwable);
+    }
+    //endregion
+
+}

src/main/java/ghast/assets/AssetsException.java

@@ -0,0 +1,13 @@
+package ghast.assets;
+
+public class AssetsException extends RuntimeException {
+
+    public AssetsException(String message) {
+        super(message);
+    }
+
+    public AssetsException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}
+

src/main/java/ghast/assets/AssetsManager.java

@@ -0,0 +1,163 @@
+package ghast.assets;
+
+import ghast.GhastTools;
+import lombok.experimental.UtilityClass;
+import org.bukkit.plugin.Plugin;
+
+import java.io.*;
+import java.net.URL;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Scanner;
+
+import static java.text.MessageFormat.format;
+
+@UtilityClass
+@SuppressWarnings("unused")
+public class AssetsManager {
+
+    private static final String ERROR_NOT_FOUND = "Asset \"{0}\" not found";
+    private static final String ERROR_OPEN = "Error open asset \"{0}\": {1}";
+
+    //region getAsInputStream methods
+    public InputStream getAsInputStream(String resourceName, String defaultResourceName, boolean saveDefault) {
+        Plugin plugin = GhastTools.getPlugin();
+        InputStream inputStream;
+
+        Path pathToResource = plugin.getDataFolder().toPath().resolve(resourceName);
+        if (Files.exists(pathToResource)) {
+            inputStream = openResource(pathToResource);
+        } else if (defaultResourceName != null) {
+            URL resourceUrl = getResourceUrl(defaultResourceName);
+
+            if (saveDefault) {
+                doSaveTo(resourceUrl, pathToResource);
+                inputStream = openResource(pathToResource);
+            } else {
+                inputStream = openResource(resourceUrl);
+            }
+        } else {
+            throw new AssetsException(format(ERROR_NOT_FOUND, resourceName));
+        }
+
+        return inputStream;
+    }
+
+    public InputStream getAsInputStream(String resourceName, String defaultResourceName) {
+        return getAsInputStream(resourceName, defaultResourceName, true);
+    }
+
+    public InputStream getAsInputStream(String resourceName, boolean saveDefault) {
+        return getAsInputStream(resourceName, resourceName, saveDefault);
+    }
+
+    public InputStream getAsInputStream(String resourceName) {
+        return getAsInputStream(resourceName, resourceName, true);
+    }
+    //endregion
+
+    //region getAsReader methods
+    public Reader getAsReader(String resourceName, String defaultResourceName, boolean saveDefault) {
+        return new InputStreamReader(getAsInputStream(resourceName, defaultResourceName, saveDefault));
+    }
+
+    public Reader getAsReader(String resourceName, String defaultResourceName) {
+        return new InputStreamReader(getAsInputStream(resourceName, defaultResourceName, true));
+    }
+
+    public Reader getAsReader(String resourceName, boolean saveDefault) {
+        return new InputStreamReader(getAsInputStream(resourceName, resourceName, saveDefault));
+    }
+
+    public Reader getAsReader(String resourceName) {
+        return new InputStreamReader(getAsInputStream(resourceName, resourceName, true));
+    }
+    //endregion
+
+    //region getAsString methods
+    public String getAsString(String resourceName, String defaultResourceName, Charset charset, boolean saveDefault) {
+        try (InputStream inputStream = getAsInputStream(resourceName, defaultResourceName, saveDefault);
+             Scanner scanner = new Scanner(inputStream, charset.name()).useDelimiter("\\A")) {
+
+            return scanner.next();
+        } catch (IOException e) {
+            throw new AssetsException(format(ERROR_OPEN, resourceName, e.getMessage()), e);
+        }
+    }
+
+    public String getAsString(String resourceName, String defaultResourceName, Charset charset) {
+        return getAsString(resourceName, defaultResourceName, charset, true);
+    }
+
+    public String getAsString(String resourceName, String defaultResourceName, boolean saveDefault) {
+        return getAsString(resourceName, defaultResourceName, StandardCharsets.UTF_8, saveDefault);
+    }
+
+    public String getAsString(String resourceName, String defaultResourceName) {
+        return getAsString(resourceName, defaultResourceName, StandardCharsets.UTF_8, true);
+    }
+
+    public String getAsString(String resourceName, Charset charset, boolean saveDefault) {
+        return getAsString(resourceName, resourceName, charset, saveDefault);
+    }
+
+    public String getAsString(String resourceName, Charset charset) {
+        return getAsString(resourceName, resourceName, charset, true);
+    }
+
+    public String getAsString(String resourceName, boolean saveDefault) {
+        return getAsString(resourceName, resourceName, StandardCharsets.UTF_8, saveDefault);
+    }
+
+    public String getAsString(String resourceName) {
+        return getAsString(resourceName, resourceName, StandardCharsets.UTF_8, true);
+    }
+    //endregion
+
+    private URL getResourceUrl(String resourceName) {
+        URL resourceUrl = AssetsManager.class.getClassLoader().getResource(resourceName);
+        if (resourceUrl == null) {
+            throw new AssetsException(format(ERROR_NOT_FOUND, resourceName));
+        }
+
+        return resourceUrl;
+    }
+
+    private void doSaveTo(URL resourceUrl, Path saveToPath) {
+        try {
+            Files.createDirectories(saveToPath.getParent());
+
+            try (InputStream inputStream = resourceUrl.openStream();
+                 OutputStream outputStream = Files.newOutputStream(saveToPath)) {
+
+                byte[] buffer = new byte[8192];
+                int count;
+                while ((count = inputStream.read(buffer)) != -1) {
+                    outputStream.write(buffer, 0, count);
+                }
+                outputStream.flush();
+            }
+        } catch (IOException e) {
+            throw new AssetsException(format("Error save asset \"{0}\" to \"{1}\": {2}",
+                    resourceUrl, saveToPath, e.getMessage()), e);
+        }
+    }
+
+    private InputStream openResource(Path pathToResource) {
+        try {
+            return Files.newInputStream(pathToResource);
+        } catch (IOException e) {
+            throw new AssetsException(format(ERROR_OPEN, pathToResource, e.getMessage()), e);
+        }
+    }
+
+    private InputStream openResource(URL resourceUrl) {
+        try {
+            return resourceUrl.openStream();
+        } catch (IOException e) {
+            throw new AssetsException(format(ERROR_OPEN, resourceUrl, e.getMessage()), e);
+        }
+    }
+}

src/main/java/ghast/command/CommandExecuter.java

@@ -0,0 +1,8 @@
+package ghast.command;
+
+import org.bukkit.command.CommandSender;
+
+public interface CommandExecuter {
+
+    void execute(CommandSender sender, String[] args);
+}

src/main/java/ghast/command/CommandManager.java

@@ -0,0 +1,69 @@
+package ghast.command;
+
+import lombok.AccessLevel;
+import lombok.RequiredArgsConstructor;
+import lombok.experimental.UtilityClass;
+import org.bukkit.Bukkit;
+
+import static org.joor.Reflect.on;
+
+@UtilityClass
+@SuppressWarnings("unused")
+public class CommandManager {
+
+    public Builder create(String name) {
+        return new Builder(name);
+    }
+
+    public void register(String name, CommandExecuter executer) {
+        create(name).executer(executer).register();
+    }
+
+    @RequiredArgsConstructor(access = AccessLevel.PRIVATE)
+    public static class Builder {
+
+        private final String name;
+        private CommandExecuter executer;
+        private ErrorConsumer errorConsumer;
+        private Boolean onlyPlayer;
+        private String deniedMessage;
+
+        public Builder executer(CommandExecuter executer) {
+            this.executer = executer;
+            return this;
+        }
+
+        public Builder onError(ErrorConsumer errorConsumer) {
+            this.errorConsumer = errorConsumer;
+            return this;
+        }
+
+        public Builder useOnlyPlayer(String deniedMessage) {
+            this.onlyPlayer = true;
+            this.deniedMessage = deniedMessage;
+            return this;
+        }
+
+        public Builder useOnlyPlayer() {
+            return useOnlyPlayer(null);
+        }
+
+        public Builder useOnlyConsole(String deniedMessage) {
+            this.onlyPlayer = false;
+            this.deniedMessage = deniedMessage;
+            return this;
+        }
+
+        public Builder useOnlyConsole() {
+            return useOnlyConsole(null);
+        }
+
+        public void register() {
+            //TODO для Paper такие "извращения" не требуются. Нужно продумать.
+            on(Bukkit.getServer())
+                    .call("getCommandMap")
+                    .call("register", name, new CommandWrapper(name, this.onlyPlayer, this.deniedMessage,
+                            this.executer, this.errorConsumer));
+        }
+    }
+}

src/main/java/ghast/command/CommandWrapper.java

@@ -0,0 +1,70 @@
+package ghast.command;
+
+import ghast.XLog;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.defaults.BukkitCommand;
+import org.bukkit.entity.Player;
+
+class CommandWrapper extends BukkitCommand {
+
+    private static final String DEFAULT_DENIED_MESSAGE_PLAYERS = ChatColor.RED + "This command use only players";
+    private static final String DEFAULT_DENIED_MESSAGE_CONSOLE = ChatColor.RED + "This command use only in console";
+
+    private static final ErrorConsumer DEFAULT_ERROR_CONSUMER =
+            (sender, commandName, args, exception) -> {
+                sender.sendMessage(String.format("%sError execute command '%s'!", ChatColor.RED, commandName));
+                XLog.error("Error execute command ''{0}'' with args ''{1}''",
+                        commandName, String.join(" ", args), exception);
+            };
+
+    private final CommandExecuter executer;
+    private final ErrorConsumer errorConsumer;
+    private final Boolean onlyPlayer;
+    private String deniedMessage;
+
+    protected CommandWrapper(String name, Boolean onlyPlayer, String deniedMessage,
+            CommandExecuter executer, ErrorConsumer errorConsumer) {
+        super(name);
+        this.onlyPlayer = onlyPlayer;
+        this.executer = executer;
+
+        if (onlyPlayer != null) {
+            if (deniedMessage == null) {
+                this.deniedMessage = Boolean.TRUE.equals(onlyPlayer) ? DEFAULT_DENIED_MESSAGE_PLAYERS
+                        : DEFAULT_DENIED_MESSAGE_CONSOLE;
+            } else {
+                this.deniedMessage = deniedMessage;
+            }
+        }
+
+        if(errorConsumer == null) {
+            this.errorConsumer = DEFAULT_ERROR_CONSUMER;
+        } else {
+            this.errorConsumer = errorConsumer;
+        }
+    }
+
+    @Override
+    public boolean execute(CommandSender commandSender, String commandName, String[] args) {
+        if (Boolean.TRUE.equals(onlyPlayer)) {
+            if (!(commandSender instanceof Player)) {
+                commandSender.sendMessage(deniedMessage);
+                return true;
+            }
+        } else if (Boolean.FALSE.equals(onlyPlayer)) { // use console only
+            if (commandSender instanceof Player) {
+                commandSender.sendMessage(deniedMessage);
+                return true;
+            }
+        }
+
+        try {
+            executer.execute(commandSender, args);
+            return true;
+        } catch (Exception e) {
+            errorConsumer.accept(commandSender, commandName, args, e);
+            return false;
+        }
+    }
+}

src/main/java/ghast/command/ErrorConsumer.java

@@ -0,0 +1,8 @@
+package ghast.command;
+
+import org.bukkit.command.CommandSender;
+
+public interface ErrorConsumer {
+
+    void accept(CommandSender sender, String commandName, String[] args, Exception exception);
+}

src/main/java/ghast/database/CannotGetJdbcConnectionException.java

@@ -0,0 +1,10 @@
+package ghast.database;
+
+import java.sql.SQLException;
+
+public class CannotGetJdbcConnectionException extends DataAccessException {
+
+    public CannotGetJdbcConnectionException(String msg, SQLException ex) {
+        super(msg, ex);
+    }
+}

src/main/java/ghast/database/DataAccessException.java

@@ -0,0 +1,18 @@
+package ghast.database;
+
+import lombok.Getter;
+
+@Getter
+public class DataAccessException extends RuntimeException {
+
+    private String sql;
+
+    public DataAccessException(String msg, Throwable cause) {
+        super(msg, cause);
+    }
+
+    public DataAccessException(String msg, String sql, Throwable cause) {
+        this(msg, cause);
+        this.sql = sql;
+    }
+}

src/main/java/ghast/database/JdbcOperations.java

@@ -0,0 +1,22 @@
+package ghast.database;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+public interface JdbcOperations {
+
+    void execute(String sql) throws DataAccessException;
+
+    <T> T query(String sql, ResultSetExtractor<T> rse) throws DataAccessException;
+
+    <T> Optional<T> queryOne(String sql, ResultSetExtractor<T> rse) throws DataAccessException;
+
+    <T> List<T> queryList(String sql, RowMapper<T> rowMapper) throws DataAccessException;
+
+    Map<String, Object> queryForMap(String sql) throws DataAccessException;
+
+    List<Map<String, Object>> queryForMapList(String sql) throws DataAccessException;
+
+    int update(String sql) throws DataAccessException;
+}

src/main/java/ghast/database/JdbcTemplate.java

@@ -0,0 +1,244 @@
+package ghast.database;
+
+import ghast.XLog;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import javax.sql.DataSource;
+import java.sql.Date;
+import java.sql.*;
+import java.util.*;
+
+@NoArgsConstructor
+@Getter
+@Setter
+public class JdbcTemplate implements JdbcOperations {
+
+    private static final String DBG_SQL_INFO = "Execute SQL: {0}";
+    private DataSource dataSource;
+
+    public JdbcTemplate(DataSource dataSource) {
+        setDataSource(dataSource);
+    }
+
+    @Override
+    public void execute(String sql) throws DataAccessException {
+        XLog.debug(DBG_SQL_INFO, sql);
+
+        Connection connection = openConnection();
+        Statement statement = null;
+        try {
+            statement = connection.createStatement();
+            statement.execute(sql);
+        } catch (SQLException e) {
+            throw new DataAccessException("Error execute SQL", sql, e);
+        } finally {
+            closeStatement(statement);
+            closeConnection(connection);
+        }
+    }
+
+    @Override
+    public <T> T query(String sql, ResultSetExtractor<T> rse) throws DataAccessException {
+        XLog.debug(DBG_SQL_INFO, sql);
+
+        Connection connection = openConnection();
+        Statement statement = null;
+        ResultSet resultSet = null;
+        try {
+            statement = connection.createStatement();
+            resultSet = statement.executeQuery(sql);
+            return rse.extractData(resultSet);
+        } catch (SQLException e) {
+            throw new DataAccessException("Error execute SQL", sql, e);
+        } finally {
+            closeResultSet(resultSet);
+            closeStatement(statement);
+            closeConnection(connection);
+        }
+    }
+
+    @Override
+    public <T> Optional<T> queryOne(String sql, ResultSetExtractor<T> rse) throws DataAccessException {
+        return query(sql, rs -> {
+            if (rs.next()) {
+                return Optional.ofNullable(rse.extractData(rs));
+            } else {
+                return Optional.empty();
+            }
+        });
+    }
+
+    @Override
+    public <T> List<T> queryList(String sql, final RowMapper<T> rowMapper) throws DataAccessException {
+        return query(sql, rs -> {
+            List<T> resultList;
+            int rowNum = 0;
+            if (rs.next()) {
+                resultList = new ArrayList<>();
+
+                do {
+                    resultList.add(rowMapper.mapRow(rs, rowNum++));
+                } while (rs.next());
+            } else {
+                resultList = Collections.emptyList();
+            }
+
+            return resultList;
+        });
+    }
+
+    @Override
+    public Map<String, Object> queryForMap(String sql) throws DataAccessException {
+        return query(sql, rs -> {
+            if (rs.next()) {
+                ResultSetMetaData metaData = rs.getMetaData();
+                int columnCount = metaData.getColumnCount();
+
+                return rowToMap(columnCount, metaData, rs);
+            } else {
+                return Collections.emptyMap();
+            }
+        });
+    }
+
+    @Override
+    public List<Map<String, Object>> queryForMapList(String sql) throws DataAccessException {
+        return query(sql, rs -> {
+            List<Map<String, Object>> resultList;
+
+            if (rs.next()) {
+                resultList = new ArrayList<>();
+
+                ResultSetMetaData metaData = rs.getMetaData();
+                int columnCount = metaData.getColumnCount();
+
+                do {
+                    resultList.add(rowToMap(columnCount, metaData, rs));
+                } while (rs.next());
+            } else {
+                resultList = Collections.emptyList();
+            }
+
+            return resultList;
+        });
+    }
+
+    @Override
+    public int update(String sql) throws DataAccessException {
+        XLog.debug(DBG_SQL_INFO, sql);
+
+        Connection connection = openConnection();
+        Statement statement = null;
+        try {
+            statement = connection.createStatement();
+            int rows = statement.executeUpdate(sql);
+            XLog.debug("Affected {0} rows", rows);
+            return rows;
+        } catch (SQLException e) {
+            XLog.error("Error execute SQL: {0}", e.getMessage(), e);
+            return 0;
+        } finally {
+            closeStatement(statement);
+            closeConnection(connection);
+        }
+    }
+
+    private Connection openConnection() {
+        try {
+            return getDataSource().getConnection();
+        } catch (SQLException ex) {
+            throw new CannotGetJdbcConnectionException("Could not get JDBC Connection", ex);
+        }
+    }
+
+    private String lookupColumnName(ResultSetMetaData resultSetMetaData, int columnIndex) throws SQLException {
+        String name = resultSetMetaData.getColumnLabel(columnIndex);
+        if (name == null || name.isEmpty()) {
+            name = resultSetMetaData.getColumnName(columnIndex);
+        }
+        return name;
+    }
+
+    private Map<String, Object> rowToMap(int columnCount, ResultSetMetaData metaData, ResultSet rs) throws SQLException {
+        Map<String, Object> rowMap = new LinkedHashMap<>(columnCount);
+
+        for (int i = 1; i <= columnCount; i++) {
+            String key = lookupColumnName(metaData, i);
+            Object value = getResultSetRawValue(rs, i);
+            rowMap.put(key, value);
+        }
+
+        return rowMap;
+    }
+
+    private Object getResultSetRawValue(ResultSet resultSet, int index) throws SQLException {
+        Object obj = resultSet.getObject(index);
+        if (obj == null) {
+            return null;
+        }
+
+        String className = obj.getClass().getName();
+
+        if (obj instanceof Blob) {
+            Blob blob = (Blob) obj;
+            obj = blob.getBytes(1, (int) blob.length());
+        } else if (obj instanceof Clob) {
+            Clob clob = (Clob) obj;
+            obj = clob.getSubString(1, (int) clob.length());
+        } else if ("oracle.sql.TIMESTAMP".equals(className) || "oracle.sql.TIMESTAMPTZ".equals(className)) {
+            obj = resultSet.getTimestamp(index);
+        } else if (className.startsWith("oracle.sql.DATE")) {
+            String metaDataClassName = resultSet.getMetaData().getColumnClassName(index);
+            if ("java.sql.Timestamp".equals(metaDataClassName) || "oracle.sql.TIMESTAMP".equals(metaDataClassName)) {
+                obj = resultSet.getTimestamp(index);
+            } else {
+                obj = resultSet.getDate(index);
+            }
+        } else if (obj instanceof Date
+                && "java.sql.Timestamp".equals(resultSet.getMetaData().getColumnClassName(index))) {
+            obj = resultSet.getTimestamp(index);
+        }
+
+        return obj;
+    }
+
+    private void closeResultSet(ResultSet resultSet) {
+        if (resultSet != null) {
+            try {
+                resultSet.close();
+            } catch (SQLException e) {
+                XLog.debug("Could not close JDBC ResultSet", e);
+            } catch (Exception e) {
+                XLog.debug("Unexpected exception on closing JDBC ResultSet", e);
+            }
+        }
+    }
+
+    private void closeStatement(Statement statement) {
+        if (statement != null) {
+            try {
+                statement.close();
+            } catch (SQLException e) {
+                XLog.debug("Could not close JDBC Statement", e);
+            } catch (Exception e) {
+                XLog.debug("Unexpected exception on closing JDBC Statement", e);
+            }
+        }
+    }
+
+    private void closeConnection(Connection con) {
+        if (con == null) {
+            return;
+        }
+
+        try {
+            con.close();
+        } catch (SQLException e) {
+            XLog.debug("Could not close JDBC Connection", e);
+        } catch (Exception e) {
+            XLog.debug("Unexpected exception on closing JDBC Connection", e);
+        }
+    }
+}

src/main/java/ghast/database/ResultSetExtractor.java

@@ -0,0 +1,9 @@
+package ghast.database;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+public interface ResultSetExtractor<T> {
+
+    T extractData(ResultSet rs) throws SQLException, DataAccessException;
+}

src/main/java/ghast/database/RowMapper.java

@@ -0,0 +1,9 @@
+package ghast.database;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+public interface RowMapper<T> {
+
+    T mapRow(ResultSet rs, int rowNum) throws SQLException;
+}

src/main/java/ghast/logger/BukkitLogger.java

@@ -0,0 +1,42 @@
+package ghast.logger;
+
+import lombok.RequiredArgsConstructor;
+
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+@RequiredArgsConstructor
+public class BukkitLogger extends LoggerAdapter {
+
+    private final Logger originallLogger;
+
+    @Override
+    public void debug(String message) {
+        originallLogger.log(Level.CONFIG, message);
+    }
+
+    @Override
+    public void debug(String message, Throwable throwable) {
+        originallLogger.log(Level.CONFIG, message, throwable);
+    }
+
+    @Override
+    public void info(String message) {
+        originallLogger.log(Level.INFO, message);
+    }
+
+    @Override
+    public void warn(String message) {
+        originallLogger.log(Level.WARNING, message);
+    }
+
+    @Override
+    public void error(String message) {
+        originallLogger.log(Level.SEVERE, message);
+    }
+
+    @Override
+    public void error(String message, Throwable throwable) {
+        originallLogger.log(Level.SEVERE, message, throwable);
+    }
+}

src/main/java/ghast/logger/FormattingPair.java

@@ -0,0 +1,17 @@
+package ghast.logger;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor
+@Getter
+public class FormattingPair {
+
+    private final String message;
+    private final Throwable throwable;
+
+    public FormattingPair(String message) {
+        this.message = message;
+        this.throwable = null;
+    }
+}

src/main/java/ghast/logger/LoggerAdapter.java

@@ -0,0 +1,37 @@
+package ghast.logger;
+
+public abstract class LoggerAdapter {
+
+    public abstract void debug(String message);
+    public abstract void debug(String message, Throwable throwable);
+    public abstract void info(String message);
+    public abstract void warn(String message);
+    public abstract void error(String message);
+    public abstract void error(String message, Throwable throwable);
+
+    public void debug(String pattern, Object... objects) {
+        FormattingPair formattingPair = LoggerFormatter.arrayFormat(pattern, objects);
+        if (formattingPair.getThrowable() != null) {
+            debug(formattingPair.getMessage(), formattingPair.getThrowable());
+        } else {
+            debug(formattingPair.getMessage());
+        }
+    }
+
+    public void info(String pattern, Object... objects) {
+        info(StringFormatter.arrayFormat(pattern, objects));
+    }
+
+    public void warn(String pattern, Object... objects) {
+        warn(StringFormatter.arrayFormat(pattern, objects));
+    }
+
+    public void error(String pattern, Object... objects) {
+        FormattingPair formattingPair = LoggerFormatter.arrayFormat(pattern, objects);
+        if (formattingPair.getThrowable() != null) {
+            error(formattingPair.getMessage(), formattingPair.getThrowable());
+        } else {
+            error(formattingPair.getMessage());
+        }
+    }
+}

src/main/java/ghast/logger/LoggerFormatter.java

@@ -0,0 +1,55 @@
+package ghast.logger;
+
+/**
+ * Copy-Paste from org.slf4j.helpers.MessageFormatter
+ */
+public final class LoggerFormatter {
+
+    public static FormattingPair arrayFormat(String messagePattern, Object[] argArray) {
+        Object[] args;
+        Throwable throwableCandidate = getThrowableCandidate(argArray);
+        if (throwableCandidate != null) {
+            args = trimmedCopy(argArray);
+        } else {
+            args = argArray;
+        }
+
+        return arrayFormat(messagePattern, args, throwableCandidate);
+    }
+
+    public static FormattingPair arrayFormat(String messagePattern, Object[] argArray, Throwable throwable) {
+        if (messagePattern == null) {
+            return new FormattingPair(null, throwable);
+        }
+
+        if (argArray == null) {
+            return new FormattingPair(messagePattern);
+        }
+
+        return new FormattingPair(StringFormatter.arrayFormat(messagePattern, argArray), throwable);
+    }
+
+    private static Throwable getThrowableCandidate(Object[] argArray) {
+        if (argArray == null || argArray.length == 0) {
+            return null;
+        }
+
+        Object lastEntry = argArray[argArray.length - 1];
+        if (lastEntry instanceof Throwable) {
+            return (Throwable) lastEntry;
+        }
+
+        return null;
+    }
+
+    private static Object[] trimmedCopy(final Object[] argArray) {
+        int trimmedLen = argArray.length - 1;
+        Object[] trimmed = new Object[trimmedLen];
+
+        if (trimmedLen > 0) {
+            System.arraycopy(argArray, 0, trimmed, 0, trimmedLen);
+        }
+
+        return trimmed;
+    }
+}

src/main/java/ghast/logger/StringFormatter.java

@@ -0,0 +1,240 @@
+package ghast.logger;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Copy-Paste from org.slf4j.helpers.MessageFormatter
+ */
+public final class StringFormatter {
+    private static final String EMPTY = "";
+    private static final char DELIM_START = '{';
+    private static final String DELIM_STR = "{}";
+    private static final char ESCAPE_CHAR = '\\';
+
+    public static String arrayFormat(String messagePattern, Object[] argArray) {
+        if (messagePattern == null || messagePattern.equals(EMPTY)) {
+            return EMPTY;
+        } else if (argArray == null) {
+            return messagePattern;
+        }
+
+        StringBuilder sb = new StringBuilder(messagePattern.length() + 50);
+
+        int k = 0;
+        for (int i = 0; i < argArray.length; i++) {
+            int idx = messagePattern.indexOf(DELIM_STR, k);
+
+            if (idx == -1) {
+                // no more variables
+                if (k == 0) { // this is a simple string
+                    return messagePattern;
+                } else { // add the tail string which contains no variables and return
+                         // the result.
+                    sb.append(messagePattern, k, messagePattern.length());
+                    return sb.toString();
+                }
+            } else {
+                if (isEscapedDelimeter(messagePattern, idx)) {
+                    if (!isDoubleEscaped(messagePattern, idx)) {
+                        i--; // DELIM_START was escaped, thus should not be incremented
+                        sb.append(messagePattern, k, idx - 1);
+                        sb.append(DELIM_START);
+                        k = idx + 1;
+                    } else {
+                        // The escape character preceding the delimiter start is
+                        // itself escaped: "abc x:\\{}"
+                        // we have to consume one backward slash
+                        sb.append(messagePattern, k, idx - 1);
+                        deeplyAppendParameter(sb, argArray[i], new HashMap<>());
+                        k = idx + 2;
+                    }
+                } else {
+                    sb.append(messagePattern, k, idx);
+                    deeplyAppendParameter(sb, argArray[i], new HashMap<>());
+                    k = idx + 2;
+                }
+            }
+        }
+        // append the characters following the last {} pair.
+        sb.append(messagePattern, k, messagePattern.length());
+        return sb.toString();
+    }
+
+    private static boolean isEscapedDelimeter(String messagePattern, int delimeterStartIndex) {
+        if (delimeterStartIndex == 0) {
+            return false;
+        }
+        char potentialEscape = messagePattern.charAt(delimeterStartIndex - 1);
+        return potentialEscape == ESCAPE_CHAR;
+    }
+
+    private static boolean isDoubleEscaped(String messagePattern, int delimeterStartIndex) {
+        return delimeterStartIndex >= 2 && messagePattern.charAt(delimeterStartIndex - 2) == ESCAPE_CHAR;
+    }
+
+    // special treatment of array values was suggested by 'lizongbo'
+    private static void deeplyAppendParameter(StringBuilder sbuf, Object o, Map<Object[], Object> seenMap) {
+        if (o == null) {
+            sbuf.append("null");
+            return;
+        }
+        if (!o.getClass().isArray()) {
+            safeObjectAppend(sbuf, o);
+        } else {
+            // check for primitive array types because they
+            // unfortunately cannot be cast to Object[]
+            if (o instanceof boolean[]) {
+                booleanArrayAppend(sbuf, (boolean[]) o);
+            } else if (o instanceof byte[]) {
+                byteArrayAppend(sbuf, (byte[]) o);
+            } else if (o instanceof char[]) {
+                charArrayAppend(sbuf, (char[]) o);
+            } else if (o instanceof short[]) {
+                shortArrayAppend(sbuf, (short[]) o);
+            } else if (o instanceof int[]) {
+                intArrayAppend(sbuf, (int[]) o);
+            } else if (o instanceof long[]) {
+                longArrayAppend(sbuf, (long[]) o);
+            } else if (o instanceof float[]) {
+                floatArrayAppend(sbuf, (float[]) o);
+            } else if (o instanceof double[]) {
+                doubleArrayAppend(sbuf, (double[]) o);
+            } else {
+                objectArrayAppend(sbuf, (Object[]) o, seenMap);
+            }
+        }
+    }
+
+    private static void safeObjectAppend(StringBuilder sbuf, Object o) {
+        try {
+            String oAsString = o.toString();
+            sbuf.append(oAsString);
+        } catch (Throwable t) {
+            throw new RuntimeException("Failed toString() invocation on an object of type [" + o.getClass().getName() + "]", t);
+        }
+    }
+
+    @SuppressWarnings("DuplicatedCode")
+    private static void booleanArrayAppend(StringBuilder sbuf, boolean[] a) {
+        sbuf.append('[');
+        int len = a.length;
+        for (int i = 0; i < len; i++) {
+            sbuf.append(a[i]);
+            if (i != len - 1) {
+                sbuf.append(", ");
+            }
+        }
+        sbuf.append(']');
+    }
+
+    @SuppressWarnings("DuplicatedCode")
+    private static void byteArrayAppend(StringBuilder sbuf, byte[] a) {
+        sbuf.append('[');
+        int len = a.length;
+        for (int i = 0; i < len; i++) {
+            sbuf.append(a[i]);
+            if (i != len - 1) {
+                sbuf.append(", ");
+            }
+        }
+        sbuf.append(']');
+    }
+
+    @SuppressWarnings("DuplicatedCode")
+    private static void charArrayAppend(StringBuilder sbuf, char[] a) {
+        sbuf.append('[');
+        int len = a.length;
+        for (int i = 0; i < len; i++) {
+            sbuf.append(a[i]);
+            if (i != len - 1) {
+                sbuf.append(", ");
+            }
+        }
+        sbuf.append(']');
+    }
+
+    @SuppressWarnings("DuplicatedCode")
+    private static void shortArrayAppend(StringBuilder sbuf, short[] a) {
+        sbuf.append('[');
+        int len = a.length;
+        for (int i = 0; i < len; i++) {
+            sbuf.append(a[i]);
+            if (i != len - 1) {
+                sbuf.append(", ");
+            }
+        }
+        sbuf.append(']');
+    }
+
+    @SuppressWarnings("DuplicatedCode")
+    private static void intArrayAppend(StringBuilder sbuf, int[] a) {
+        sbuf.append('[');
+        int len = a.length;
+        for (int i = 0; i < len; i++) {
+            sbuf.append(a[i]);
+            if (i != len - 1) {
+                sbuf.append(", ");
+            }
+        }
+        sbuf.append(']');
+    }
+
+    @SuppressWarnings("DuplicatedCode")
+    private static void longArrayAppend(StringBuilder sbuf, long[] a) {
+        sbuf.append('[');
+        int len = a.length;
+        for (int i = 0; i < len; i++) {
+            sbuf.append(a[i]);
+            if (i != len - 1) {
+                sbuf.append(", ");
+            }
+        }
+        sbuf.append(']');
+    }
+
+    @SuppressWarnings("DuplicatedCode")
+    private static void floatArrayAppend(StringBuilder sbuf, float[] a) {
+        sbuf.append('[');
+        int len = a.length;
+        for (int i = 0; i < len; i++) {
+            sbuf.append(a[i]);
+            if (i != len - 1) {
+                sbuf.append(", ");
+            }
+        }
+        sbuf.append(']');
+    }
+
+    @SuppressWarnings("DuplicatedCode")
+    private static void doubleArrayAppend(StringBuilder sbuf, double[] a) {
+        sbuf.append('[');
+        int len = a.length;
+        for (int i = 0; i < len; i++) {
+            sbuf.append(a[i]);
+            if (i != len - 1) {
+                sbuf.append(", ");
+            }
+        }
+        sbuf.append(']');
+    }
+
+    private static void objectArrayAppend(StringBuilder sbuf, Object[] a, Map<Object[], Object> seenMap) {
+        sbuf.append('[');
+        if (!seenMap.containsKey(a)) {
+            seenMap.put(a, null);
+            int len = a.length;
+            for (int i = 0; i < len; i++) {
+                deeplyAppendParameter(sbuf, a[i], seenMap);
+                if (i != len - 1) {
+                    sbuf.append(", ");
+                }
+            }
+            // allow repeats in siblings
+            seenMap.remove(a);
+        } else {
+            sbuf.append("...");
+        }
+        sbuf.append(']');
+    }
+}

src/main/java/ghast/scheduler/BukkitScheduleTask.java

@@ -0,0 +1,33 @@
+package ghast.scheduler;
+
+import lombok.RequiredArgsConstructor;
+import org.bukkit.scheduler.BukkitTask;
+
+import java.util.function.Supplier;
+
+@RequiredArgsConstructor
+public class BukkitScheduleTask implements ScheduleTask {
+
+    private final Supplier<BukkitTask> generator;
+    private BukkitTask bukkitTask;
+
+    @Override
+    public void start() {
+        if (isCanceled()) {
+            bukkitTask = generator.get();
+        }
+    }
+
+    @Override
+    public boolean isCanceled() {
+        return bukkitTask == null || bukkitTask.isCancelled();
+    }
+
+    @Override
+    public void cancel() {
+        if (bukkitTask != null) {
+            bukkitTask.cancel();
+            bukkitTask = null;
+        }
+    }
+}

src/main/java/ghast/scheduler/JavaScheduleTask.java

@@ -0,0 +1,33 @@
+package ghast.scheduler;
+
+import lombok.RequiredArgsConstructor;
+
+import java.util.concurrent.Future;
+import java.util.function.Supplier;
+
+@RequiredArgsConstructor
+public class JavaScheduleTask implements ScheduleTask {
+
+    private final Supplier<Future<?>> generator;
+    private Future<?> future;
+
+    @Override
+    public void start() {
+        if (future == null || future.isDone()) {
+            future = generator.get();
+        }
+    }
+
+    @Override
+    public boolean isCanceled() {
+        return future == null || future.isCancelled();
+    }
+
+    @Override
+    public void cancel() {
+        if (future != null) {
+            future.cancel(true);
+            future = null;
+        }
+    }
+}

src/main/java/ghast/scheduler/ScheduleManager.java

@@ -0,0 +1,113 @@
+package ghast.scheduler;
+
+import com.google.common.util.concurrent.ThreadFactoryBuilder;
+import ghast.GhastTools;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+import lombok.experimental.UtilityClass;
+import org.bukkit.Bukkit;
+import org.bukkit.scheduler.BukkitScheduler;
+
+import java.util.concurrent.*;
+
+@UtilityClass
+@SuppressWarnings("unused")
+public class ScheduleManager {
+
+    private static final ThreadFactory THREAD_FACTORY = new ThreadFactoryBuilder()
+            .setNameFormat("ScheduleManager-Thread-%d")
+            .setDaemon(true)
+            .build();
+
+    public Builder createTask() {
+        return new Builder();
+    }
+
+    @NoArgsConstructor(access = AccessLevel.PRIVATE)
+    public static class Builder {
+
+        private static final long MS_PER_ONE_TICK = 1000L/*one second by ms*/ / 20L/*tick per second*/;
+        private boolean useBukkitScheduler = false;
+        private Long afterMs;
+        private Long everyMs;
+
+        public Builder useBukkitScheduler() {
+            this.useBukkitScheduler = true;
+            return this;
+        }
+
+        public Builder after(long value, TimeUnit unit) {
+            this.afterMs = unit.toMillis(value);
+            return this;
+        }
+
+        public Builder every(long value, TimeUnit unit) {
+            this.everyMs = unit.toMillis(value);
+            return this;
+        }
+
+        public ScheduleTask create(Runnable runnable) {
+            if (useBukkitScheduler) {
+                return createBukkitSchedule(runnable);
+            } else {
+                return createSchedule(runnable);
+            }
+        }
+
+        public ScheduleTask execute(Runnable runnable) {
+            ScheduleTask scheduleTask = create(runnable);
+            scheduleTask.start();
+            return scheduleTask;
+        }
+
+        private ScheduleTask createBukkitSchedule(Runnable runnable) {
+            BukkitScheduler bukkitScheduler = Bukkit.getScheduler();
+            BukkitScheduleTask resultTask;
+
+            if (this.afterMs == null && this.everyMs == null) {
+                resultTask = new BukkitScheduleTask(() -> bukkitScheduler.runTask(GhastTools.getPlugin(), runnable));
+            } else if (this.everyMs != null) {
+                long everyTicks = this.everyMs / MS_PER_ONE_TICK;
+                long afterTicks = this.afterMs != null ? this.afterMs / MS_PER_ONE_TICK : 0;
+                resultTask = new BukkitScheduleTask(() ->
+                        bukkitScheduler.runTaskTimer(GhastTools.getPlugin(), runnable, afterTicks, everyTicks));
+            } else {
+                long ticks = this.afterMs / MS_PER_ONE_TICK;
+                resultTask = new BukkitScheduleTask(() ->
+                        bukkitScheduler.runTaskLater(GhastTools.getPlugin(), runnable, ticks));
+            }
+
+            return resultTask;
+        }
+
+        private ScheduleTask createSchedule(Runnable runnable) {
+            ExecutorService executorService;
+            JavaScheduleTask resultTask;
+
+            if (this.afterMs == null && this.everyMs == null) {
+                executorService = Executors.newSingleThreadExecutor(THREAD_FACTORY);
+                resultTask = new JavaScheduleTask(() -> executorService.submit(runnable));
+            } else if (this.everyMs != null) {
+                ScheduledExecutorService scheduledExecutorService
+                        = Executors.newScheduledThreadPool(1, THREAD_FACTORY);
+
+                resultTask = new JavaScheduleTask(() ->
+                        scheduledExecutorService.scheduleAtFixedRate(runnable,
+                                this.afterMs != null ? this.afterMs : 0,
+                                everyMs, TimeUnit.MILLISECONDS));
+
+                executorService = scheduledExecutorService;
+            } else {
+                ScheduledExecutorService scheduledExecutorService
+                        = Executors.newScheduledThreadPool(1, THREAD_FACTORY);
+
+                resultTask = new JavaScheduleTask(() ->
+                        scheduledExecutorService.schedule(runnable, afterMs, TimeUnit.MILLISECONDS));
+                executorService = scheduledExecutorService;
+            }
+
+            executorService.shutdown();
+            return resultTask;
+        }
+    }
+}

src/main/java/ghast/scheduler/ScheduleTask.java

@@ -0,0 +1,10 @@
+package ghast.scheduler;
+
+public interface ScheduleTask {
+
+    void start();
+
+    boolean isCanceled();
+
+    void cancel();
+}

src/test/java/ghast/HashMapsTest.java

@@ -0,0 +1,182 @@
+package ghast;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class HashMapsTest {
+
+    @Test
+    void of0() {
+        Map<Object, Object> map = HashMaps.of();
+        assertNotNull(map);
+        assertTrue(map instanceof HashMap);
+        assertTrue(map.isEmpty());
+    }
+
+    @Test
+    void of1() {
+        Map<Object, Object> map = HashMaps.of("key1", "val1");
+        assertNotNull(map);
+        assertTrue(map instanceof HashMap);
+        assertEquals(1, map.size());
+    }
+
+    @Test
+    void of2() {
+        Map<Object, Object> map = HashMaps.of(
+                "key1", "val1",
+                "key2", "val2"
+        );
+        assertNotNull(map);
+        assertTrue(map instanceof HashMap);
+        assertEquals(2, map.size());
+    }
+
+    @Test
+    void of3() {
+        Map<Object, Object> map = HashMaps.of(
+                "key1", "val1",
+                "key2", "val2",
+                "key3", "val3"
+        );
+        assertNotNull(map);
+        assertTrue(map instanceof HashMap);
+        assertEquals(3, map.size());
+    }
+
+    @Test
+    void of4() {
+        Map<Object, Object> map = HashMaps.of(
+                "key1", "val1",
+                "key2", "val2",
+                "key3", "val3",
+                "key4", "val4"
+        );
+        assertNotNull(map);
+        assertTrue(map instanceof HashMap);
+        assertEquals(4, map.size());
+    }
+
+    @Test
+    void of5() {
+        Map<Object, Object> map = HashMaps.of(
+                "key1", "val1",
+                "key2", "val2",
+                "key3", "val3",
+                "key4", "val4",
+                "key5", "val5"
+        );
+        assertNotNull(map);
+        assertTrue(map instanceof HashMap);
+        assertEquals(5, map.size());
+    }
+
+    @Test
+    void of6() {
+        Map<Object, Object> map = HashMaps.of(
+                "key1", "val1",
+                "key2", "val2",
+                "key3", "val3",
+                "key4", "val4",
+                "key5", "val5",
+                "key6", "val6"
+        );
+        assertNotNull(map);
+        assertTrue(map instanceof HashMap);
+        assertEquals(6, map.size());
+    }
+
+    @Test
+    void of7() {
+        Map<Object, Object> map = HashMaps.of(
+                "key1", "val1",
+                "key2", "val2",
+                "key3", "val3",
+                "key4", "val4",
+                "key5", "val5",
+                "key6", "val6",
+                "key7", "val7"
+        );
+        assertNotNull(map);
+        assertTrue(map instanceof HashMap);
+        assertEquals(7, map.size());
+    }
+
+    @Test
+    void of8() {
+        Map<Object, Object> map = HashMaps.of(
+                "key1", "val1",
+                "key2", "val2",
+                "key3", "val3",
+                "key4", "val4",
+                "key5", "val5",
+                "key6", "val6",
+                "key7", "val7",
+                "key8", "val8"
+        );
+        assertNotNull(map);
+        assertTrue(map instanceof HashMap);
+        assertEquals(8, map.size());
+    }
+
+    @Test
+    void of9() {
+        Map<Object, Object> map = HashMaps.of(
+                "key1", "val1",
+                "key2", "val2",
+                "key3", "val3",
+                "key4", "val4",
+                "key5", "val5",
+                "key6", "val6",
+                "key7", "val7",
+                "key8", "val8",
+                "key9", "val9"
+        );
+        assertNotNull(map);
+        assertTrue(map instanceof HashMap);
+        assertEquals(9, map.size());
+    }
+
+    @Test
+    void of10() {
+        Map<Object, Object> map = HashMaps.of(
+                "key1", "val1",
+                "key2", "val2",
+                "key3", "val3",
+                "key4", "val4",
+                "key5", "val5",
+                "key6", "val6",
+                "key7", "val7",
+                "key8", "val8",
+                "key9", "val9",
+                "key10", "val10"
+        );
+        assertNotNull(map);
+        assertTrue(map instanceof HashMap);
+        assertEquals(10, map.size());
+    }
+
+    @Test
+    void ofEntries() {
+        Map<Object, Object> map = HashMaps.ofEntries(
+                HashMaps.entry("key1", "val1"),
+                HashMaps.entry("key2", "val2"),
+                HashMaps.entry("key3", "val3"),
+                HashMaps.entry("key4", "val4"),
+                HashMaps.entry("key5", "val5"),
+                HashMaps.entry("key6", "val6"),
+                HashMaps.entry("key7", "val7"),
+                HashMaps.entry("key8", "val8"),
+                HashMaps.entry("key9", "val9"),
+                HashMaps.entry("key10", "val10"),
+                HashMaps.entry("key11", "val11")
+        );
+        assertNotNull(map);
+        assertTrue(map instanceof HashMap);
+        assertEquals(11, map.size());
+    }
+}

src/test/java/ghast/MessagesLoadTest.java

@@ -0,0 +1,59 @@
+package ghast;
+
+import org.joor.Reflect;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.io.StringReader;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Properties;
+import java.util.stream.Collectors;
+
+import static org.joor.Reflect.onClass;
+import static org.junit.jupiter.api.Assertions.assertIterableEquals;
+
+class MessagesLoadTest {
+
+    Map<String, String> map;
+
+    @BeforeEach
+    void before() {
+        map = new HashMap<String, String>() {{
+            put("key1", "value1");
+            put("key2", "value2");
+        }};
+    }
+
+    @Test
+    void loadMap() {
+        Messages.load(map);
+
+        Reflect reflectMessagesMap = onClass(Messages.class).field("MESSAGES_MAP");
+        assertIterableEquals(map.entrySet(), reflectMessagesMap.as(Map.class).entrySet());
+    }
+
+    @Test
+    void loadReader() {
+        String lines = map.entrySet().stream()
+                .map(entry -> entry.getKey() + "=" + entry.getValue())
+                .collect(Collectors.joining("\n"));
+        StringReader reader = new StringReader(lines);
+
+        Messages.load(reader);
+
+        Reflect reflectMessagesMap = onClass(Messages.class).field("MESSAGES_MAP");
+        assertIterableEquals(map.entrySet(), reflectMessagesMap.as(Map.class).entrySet());
+    }
+
+    @Test
+    void loadProperties() {
+        Properties properties = new Properties();
+        properties.putAll(map);
+
+        Messages.load(properties);
+
+        Reflect reflectMessagesMap = onClass(Messages.class).field("MESSAGES_MAP");
+        assertIterableEquals(map.entrySet(), reflectMessagesMap.as(Map.class).entrySet());
+    }
+}

src/test/java/ghast/MessagesTest.java

@@ -0,0 +1,91 @@
+package ghast;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class MessagesTest {
+
+    @BeforeEach
+    void before() {
+        Map<String, String> map1 = new HashMap<String, String>() {{
+            put("simple-message", "some message");
+            put("parametrized-message", "Arg1: {key1}");
+        }};
+        Messages.load(map1);
+    }
+
+    @Test
+    void getSimpleMessage() {
+        String string = Messages.get("simple-message");
+        assertEquals("some message", string);
+    }
+
+    @Test
+    void getSimpleMessageNotFound() {
+        String string = Messages.get("non-exists-key");
+        assertEquals("non-exists-key", string);
+    }
+
+    @Test
+    void formatMap() {
+        Map<String, Object> map1 = new HashMap<String, Object>() {{
+            put("key1", "some message");
+        }};
+        String string = Messages.format("Arg1: {key1}", map1);
+        assertEquals("Arg1: some message", string);
+
+        Map<String, String> map2 = new HashMap<String, String>() {{
+            put("key1", "some message");
+        }};
+        string = Messages.format("Arg1: {key1}", map2);
+        assertEquals("Arg1: some message", string);
+    }
+
+    @Test
+    void formatArray() {
+        String string = Messages.format("Arg1: {key1}", "key1", "some message");
+        assertEquals("Arg1: some message", string);
+    }
+
+    @Test
+    void getParametrizedMessageMap() {
+        Map<String, Object> map2 = new HashMap<String, Object>() {{
+            put("key1", "some message");
+        }};
+        String string = Messages.get("parametrized-message", map2);
+        assertEquals("Arg1: some message", string);
+
+        Map<String, String> map3 = new HashMap<String, String>() {{
+            put("key1", "some message");
+        }};
+        string = Messages.get("parametrized-message", map3);
+        assertEquals("Arg1: some message", string);
+    }
+
+    @Test
+    void getParametrizedMessageMapNotFound() {
+        Map<String, Object> map2 = new HashMap<String, Object>() {{
+            put("key1", "some message");
+        }};
+
+        String string = Messages.get("non-exists-key", map2);
+        assertEquals("non-exists-key", string);
+    }
+
+    @Test
+    void getParametrizedMessageArray() {
+        String string = Messages.get("parametrized-message", "key1", "some message");
+        assertEquals("Arg1: some message", string);
+    }
+
+    @Test
+    void getParametrizedMessageArrayNotFound() {
+        String string = Messages.get("non-exists-key", "key1", "some message");
+        assertEquals("non-exists-key", string);
+    }
+}

src/test/java/ghast/database/JdbcTemplateTest.java

@@ -0,0 +1,289 @@
+package ghast.database;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Lists;
+import ghast.GhastTools;
+import org.apache.commons.lang3.builder.EqualsBuilder;
+import org.apache.commons.lang3.builder.HashCodeBuilder;
+import org.bukkit.plugin.Plugin;
+import org.h2.jdbcx.JdbcDataSource;
+import org.junit.jupiter.api.*;
+
+import javax.sql.DataSource;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.text.MessageFormat;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.StringJoiner;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+class JdbcTemplateTest {
+
+    static final String JDBC_USER = "sa";
+    static final String JDBC_PASSWORD = "";
+    static final String JDBC_DB_NAME = "in_mem_db";
+    static final String JDBC_URL = "jdbc:h2:mem:" + JDBC_DB_NAME + ";DB_CLOSE_DELAY=-1";
+
+    static final String TABLE_NAME = "TEST_TABLE";
+    static final String COLUMN_ID = "ID";
+    static final String COLUMN_NAME = "C_NAME";
+    static final String COLUMN_VALUE = "C_VALUE";
+
+    static final Object[][] DATA = new Object[][]{
+            { "Player 1", 100 }, { "Player 2", 250 },
+            { "Player 3", 0 }, { "Player 4", 780 }
+    };
+
+    static DataSource dataSource;
+    JdbcTemplate jdbcTemplate;
+
+    @BeforeAll
+    static void beforeAll() {
+        Logger logger = Logger.getLogger(JdbcTemplateTest.class.getName());
+
+        Plugin mockPlugin = mock(Plugin.class);
+        when(mockPlugin.getLogger()).thenReturn(logger);
+
+        GhastTools.setPlugin(mockPlugin);
+
+        JdbcDataSource jdbcDataSource = new JdbcDataSource();
+        jdbcDataSource.setUser(JDBC_USER);
+        jdbcDataSource.setPassword(JDBC_PASSWORD);
+        jdbcDataSource.setURL(JDBC_URL);
+
+        dataSource = jdbcDataSource;
+    }
+
+    @BeforeEach
+    void before() {
+        jdbcTemplate = new JdbcTemplate(dataSource);
+        createTable();
+
+        String sql_head = MessageFormat.format("INSERT INTO {0} ({1}, {2}) VALUES ",
+                TABLE_NAME, COLUMN_NAME, COLUMN_VALUE);
+        StringJoiner sql_sj = new StringJoiner(", ");
+        for (Object[] datum : DATA) {
+            sql_sj.add(MessageFormat.format("( ''{0}'', {1} )", datum[0], datum[1]));
+        }
+
+        jdbcTemplate.execute(sql_head + sql_sj.toString());
+    }
+
+    @AfterEach
+    void after() {
+        dropTable();
+    }
+
+    @Test
+    void testQuery_Simple_Single() {
+        String sql = MessageFormat.format("SELECT {2} FROM {0} WHERE {1} LIKE ''{3}''",
+                TABLE_NAME, COLUMN_NAME, COLUMN_VALUE, DATA[0][0]);
+
+        Integer value = jdbcTemplate.query(sql, rs -> {
+            if (rs.next()) {
+                return rs.getInt(1);
+            } else {
+                return null;
+            }
+        });
+
+        assertEquals(DATA[0][1], value);
+    }
+
+    @Test
+    void testQuery_Simple_Optional() {
+        String sql = MessageFormat.format("SELECT {2} FROM {0} WHERE {1} LIKE ''{3}''",
+                TABLE_NAME, COLUMN_NAME, COLUMN_VALUE, DATA[0][0]);
+
+        Optional<Integer> optValue = jdbcTemplate.queryOne(sql, rs -> rs.getInt(1));
+
+        assertTrue(optValue.isPresent());
+        assertEquals(DATA[0][1], optValue.get());
+    }
+
+    @Test
+    void testQuery_Simple_List() {
+        String sql = MessageFormat.format("SELECT {2} FROM {0} WHERE {1} LIKE ''{3}'' OR {1} LIKE ''{4}''",
+                TABLE_NAME, COLUMN_NAME, COLUMN_VALUE, DATA[0][0], DATA[1][0]);
+
+        List<Integer> listValues = jdbcTemplate.queryList(sql, (rs, rowNum) -> rs.getInt(1));
+
+        assertIterableEquals(Lists.newArrayList(DATA[0][1], DATA[1][1]), listValues);
+    }
+
+    @Test
+    void testQuery_Object_Single() {
+        String sql = MessageFormat.format("SELECT {1}, {2} FROM {0} WHERE {1} LIKE ''{3}''",
+                TABLE_NAME, COLUMN_NAME, COLUMN_VALUE, DATA[0][0]);
+
+        Player actualPlayer = jdbcTemplate.query(sql, rs -> {
+            if (rs.next()) {
+                Player player0 = new Player();
+                player0.name = rs.getString(COLUMN_NAME);
+                player0.value = rs.getInt(COLUMN_VALUE);
+
+                return player0;
+            } else {
+                return null;
+            }
+        });
+
+        Player expectedPlayer = new Player();
+        expectedPlayer.name = (String) DATA[0][0];
+        expectedPlayer.value = (int) DATA[0][1];
+
+        assertEquals(expectedPlayer, actualPlayer);
+    }
+
+    @Test
+    void testQuery_Object_List() {
+        String sql = MessageFormat.format("SELECT {1}, {2} FROM {0}",
+                TABLE_NAME, COLUMN_NAME, COLUMN_VALUE);
+
+        List<Player> actualPlayers = jdbcTemplate.queryList(sql, (rs, num) -> {
+            Player player0 = new Player();
+            player0.name = rs.getString(COLUMN_NAME);
+            player0.value = rs.getInt(COLUMN_VALUE);
+
+            return player0;
+        });
+
+
+        List<Player> expectedPlayers = Stream.of(DATA)
+                .map(datum -> {
+                    Player player1 = new Player();
+                    player1.name = (String) datum[0];
+                    player1.value = (int) datum[1];
+
+                    return player1;
+                })
+                .collect(Collectors.toList());
+
+
+        assertIterableEquals(expectedPlayers, actualPlayers);
+    }
+
+    @Test
+    void testQueryForMap() {
+        String sql = MessageFormat.format("SELECT {1}, {2} FROM {0} WHERE {1} LIKE ''{3}''",
+                TABLE_NAME, COLUMN_NAME, COLUMN_VALUE, DATA[0][0]);
+
+        Map<String, Object> actualMap = jdbcTemplate.queryForMap(sql);
+
+        Map<String, Object> expectedMap = ImmutableMap.of(
+                COLUMN_NAME, DATA[0][0],
+                COLUMN_VALUE, DATA[0][1]);
+
+        assertIterableEquals(expectedMap.entrySet(), actualMap.entrySet());
+    }
+
+    @Test
+    void testQueryForMapList() {
+        String sql = MessageFormat.format("SELECT {1}, {2} FROM {0}",
+                TABLE_NAME, COLUMN_NAME, COLUMN_VALUE);
+
+        List<Map<String, Object>> actualMapList = jdbcTemplate.queryForMapList(sql);
+
+        List<Map<String, Object>> expectedMapList = Stream.of(DATA)
+                .map(datum -> ImmutableMap.of(COLUMN_NAME, datum[0], COLUMN_VALUE, datum[1]))
+                .collect(Collectors.toList());
+
+        assertIterableEquals(expectedMapList, actualMapList);
+
+    }
+
+    @Test
+    void testUpdate() {
+        String newName = "Player X";
+        String sql = MessageFormat.format("UPDATE {0} SET {1} = ''{3}'' WHERE {1} LIKE ''{2}''",
+                TABLE_NAME, COLUMN_NAME, DATA[0][0], newName);
+
+        int rows = jdbcTemplate.update(sql);
+
+        assertEquals(1, rows);
+
+        sql = MessageFormat.format("SELECT {2} FROM {0} WHERE {1} LIKE ''{3}''",
+                TABLE_NAME, COLUMN_NAME, COLUMN_VALUE, newName);
+
+        Integer value = jdbcTemplate.query(sql, rs -> {
+            if (rs.next()) {
+                return rs.getInt(1);
+            } else {
+                return null;
+            }
+        });
+
+        assertEquals(DATA[0][1], value);
+    }
+
+    private void createTable() {
+        jdbcTemplate.execute("CREATE TABLE " + TABLE_NAME + " (" +
+                COLUMN_ID + " bigint auto_increment," +
+                COLUMN_NAME + " varchar(16)," +
+                COLUMN_VALUE + " integer)");
+    }
+
+    private void dropTable() {
+        jdbcTemplate.execute("DROP TABLE IF EXISTS " + TABLE_NAME);
+    }
+
+    class Player {
+        String name;
+        int value;
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (!(o instanceof Player)) return false;
+            Player player = (Player) o;
+            return new EqualsBuilder().append(value, player.value).append(name, player.name).isEquals();
+        }
+
+        @Override
+        public int hashCode() {
+            return new HashCodeBuilder(17, 37).append(name).append(value).toHashCode();
+        }
+    }
+
+    @Nested
+    class JdbcTemplateTest_ExecuteTestCase {
+
+        @BeforeEach
+        void before() {
+            jdbcTemplate = new JdbcTemplate(dataSource);
+            dropTable();
+        }
+
+        @AfterEach
+        void after() {
+            dropTable();
+        }
+
+        @Test
+        void test() throws ClassNotFoundException, IllegalAccessException, InstantiationException, SQLException {
+            createTable();
+
+            //region Check result
+            Class.forName("org.h2.Driver").newInstance();
+            Connection connection = DriverManager.getConnection(JDBC_URL, JDBC_USER, JDBC_PASSWORD);
+            ResultSet resultSet = connection.getMetaData().getTables(JDBC_DB_NAME.toUpperCase(), "PUBLIC",
+                    TABLE_NAME.toUpperCase(), new String[]{"TABLE"});
+
+            assertTrue(resultSet.next());
+
+            resultSet.close();
+            connection.close();
+            //endregion
+        }
+    }
+}

src/test/java/ghast/logger/BukkitLoggerTest.java

@@ -0,0 +1,54 @@
+package ghast.logger;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+class BukkitLoggerTest {
+
+    Logger logger;
+    BukkitLogger bukkitLogger;
+
+    @BeforeEach
+    void before() {
+        logger = mock(Logger.class);
+        bukkitLogger = new BukkitLogger(logger);
+    }
+
+    @Test
+    void debug() {
+        bukkitLogger.debug("Some String");
+        verify(logger).log(Level.CONFIG, "Some String");
+
+        Exception exception = new Exception("oops!");
+        bukkitLogger.debug("Some String", exception);
+        verify(logger).log(Level.CONFIG, "Some String", exception);
+    }
+
+    @Test
+    void info() {
+        bukkitLogger.info("some message");
+        verify(logger).log(Level.INFO, "some message");
+    }
+
+    @Test
+    void warn() {
+        bukkitLogger.warn("some message");
+        verify(logger).log(Level.WARNING, "some message");
+    }
+
+    @Test
+    void error() {
+        bukkitLogger.error("some message");
+        verify(logger).log(Level.SEVERE, "some message");
+
+        Exception exception = new Exception("oops!");
+        bukkitLogger.error("Some String", exception);
+        verify(logger).log(Level.SEVERE, "Some String", exception);
+    }
+}

src/test/java/ghast/logger/LoggerAdapterTest.java

@@ -0,0 +1,50 @@
+package ghast.logger;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+class LoggerAdapterTest {
+
+    LoggerAdapter loggerAdapter;
+
+    @BeforeEach
+    void before() {
+        loggerAdapter = mock(LoggerAdapter.class, CALLS_REAL_METHODS);
+    }
+
+    @Test
+    void debug() {
+        loggerAdapter.debug("some pattern {}", "item-1");
+        verify(loggerAdapter).debug("some pattern item-1");
+
+        Exception exception = new Exception("oops!");
+        loggerAdapter.debug("some pattern {}", "item-1", exception);
+        verify(loggerAdapter).debug("some pattern item-1", exception);
+    }
+
+    @Test
+    void info() {
+        loggerAdapter.info("some pattern {}", "item-1");
+        verify(loggerAdapter).info("some pattern item-1");
+    }
+
+    @Test
+    void warn() {
+        loggerAdapter.warn("some pattern {}", "item-1");
+        verify(loggerAdapter).warn("some pattern item-1");
+    }
+
+    @Test
+    void error() {
+        loggerAdapter.error("some pattern {}", "item-1");
+        verify(loggerAdapter).error("some pattern item-1");
+
+        Exception exception = new Exception("oops!");
+        loggerAdapter.error("some pattern {}", "item-1", exception);
+        verify(loggerAdapter).error("some pattern item-1", exception);
+    }
+}

src/test/java/ghast/logger/LoggerFormatterTest.java

@@ -0,0 +1,84 @@
+package ghast.logger;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class LoggerFormatterTest {
+
+    @Test
+    void arrayFormatNullPattern() {
+        Exception exception = new Exception("oops!");
+        FormattingPair formattingPair = LoggerFormatter.arrayFormat(null, null, exception);
+
+        assertNotNull(formattingPair);
+        assertNull(formattingPair.getMessage());
+        assertNotNull(formattingPair.getThrowable());
+        assertEquals(exception, formattingPair.getThrowable());
+
+        formattingPair = LoggerFormatter.arrayFormat(null, null, null);
+        assertNotNull(formattingPair);
+        assertNull(formattingPair.getMessage());
+        assertNull(formattingPair.getThrowable());
+    }
+
+    @Test
+    void arrayFormatNullArgs() {
+        FormattingPair formattingPair = LoggerFormatter.arrayFormat("some pattern", null, null);
+
+        assertNotNull(formattingPair);
+        assertNotNull(formattingPair.getMessage());
+        assertEquals("some pattern", formattingPair.getMessage());
+        assertNull(formattingPair.getThrowable());
+
+        formattingPair = LoggerFormatter.arrayFormat("some pattern {}", null, null);
+        assertNotNull(formattingPair);
+        assertNotNull(formattingPair.getMessage());
+        assertEquals("some pattern {}", formattingPair.getMessage());
+        assertNull(formattingPair.getThrowable());
+    }
+
+    @Test
+    void arrayFormat() {
+        Exception exception = new Exception("oops!");
+        FormattingPair formattingPair = LoggerFormatter.arrayFormat("some pattern {}", new Object[]{"item-1"}, exception);
+
+        assertNotNull(formattingPair);
+        assertNotNull(formattingPair.getMessage());
+        assertEquals("some pattern item-1", formattingPair.getMessage());
+        assertNotNull(formattingPair.getThrowable());
+        assertEquals(exception, formattingPair.getThrowable());
+    }
+
+    @Test
+    void arrayFormatWithoutThrowable() {
+        FormattingPair formattingPair = LoggerFormatter.arrayFormat("Arg1: {}", new Object[]{ "item-1" });
+
+        assertNotNull(formattingPair);
+        assertNotNull(formattingPair.getMessage());
+        assertEquals("Arg1: item-1", formattingPair.getMessage());
+        assertNull(formattingPair.getThrowable());
+    }
+
+    @Test
+    void arrayFormatWithoutThrowableNullArgs() {
+        FormattingPair formattingPair = LoggerFormatter.arrayFormat("Arg1: {}", null);
+
+        assertNotNull(formattingPair);
+        assertNotNull(formattingPair.getMessage());
+        assertEquals("Arg1: {}", formattingPair.getMessage());
+        assertNull(formattingPair.getThrowable());
+    }
+
+    @Test
+    void arrayFormatThrowableInArgs() {
+        Exception exception = new Exception("oops!");
+        FormattingPair formattingPair = LoggerFormatter.arrayFormat("Arg1: {}", new Object[]{ "item-1", exception });
+
+        assertNotNull(formattingPair);
+        assertNotNull(formattingPair.getMessage());
+        assertEquals("Arg1: item-1", formattingPair.getMessage());
+        assertNotNull(formattingPair.getThrowable());
+        assertEquals(exception, formattingPair.getThrowable());
+    }
+}

src/test/java/ghast/logger/StringFormatterTest.java

@@ -0,0 +1,95 @@
+package ghast.logger;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class StringFormatterTest {
+
+    @Test
+    void emptyPattern() {
+        String actual = StringFormatter.arrayFormat(null, null);
+        assertEquals("", actual);
+
+        actual = StringFormatter.arrayFormat("", null);
+        assertEquals("", actual);
+    }
+
+    @Test
+    void nullArgArray() {
+        String pattern = "some pattern";
+        String actual = StringFormatter.arrayFormat(pattern, null);
+        assertEquals(pattern, actual);
+
+        pattern = "some pattern {}";
+        actual = StringFormatter.arrayFormat(pattern, null);
+        assertEquals(pattern, actual);
+    }
+
+    @Test
+    void dummyPattern() {
+        String actual = StringFormatter.arrayFormat("dummy pattern", new Object[]{"argument"});
+        assertEquals("dummy pattern", actual);
+    }
+
+    @Test
+    void escapePattern() {
+        String actual = StringFormatter.arrayFormat("Arg1: \\{}", new Object[]{"item1"});
+        assertEquals("Arg1: {}", actual);
+
+        actual = StringFormatter.arrayFormat("Arg1: {}, \\{}", new Object[]{"item1"});
+        assertEquals("Arg1: item1, \\{}", actual);
+    }
+
+    @Test
+    void simpleArg() {
+        String actual;
+
+        actual = StringFormatter.arrayFormat("Arg1: {}", new Object[]{"item1"});
+        assertEquals("Arg1: item1", actual);
+
+        actual = StringFormatter.arrayFormat("Arg1: {}", new Object[]{11});
+        assertEquals("Arg1: 11", actual);
+
+        actual = StringFormatter.arrayFormat("Arg1: {}", new Object[]{11.5f});
+        assertEquals("Arg1: 11.5", actual);
+    }
+
+    @Test
+    void nullArg() {
+        String actual = StringFormatter.arrayFormat("Arg1: {}", new Object[]{null});
+        assertEquals("Arg1: null", actual);
+    }
+
+    @Test
+    void arrayArg() {
+        String actual;
+
+        actual = StringFormatter.arrayFormat("Arg1: {}", new Object[]{new boolean[]{false, true}});
+        assertEquals("Arg1: [false, true]", actual);
+
+        actual = StringFormatter.arrayFormat("Arg1: {}", new Object[]{new byte[]{0b00, 0b01}});
+        assertEquals("Arg1: [0, 1]", actual);
+
+        actual = StringFormatter.arrayFormat("Arg1: {}", new Object[]{new char[]{'c', 'h'}});
+        assertEquals("Arg1: [c, h]", actual);
+
+        actual = StringFormatter.arrayFormat("Arg1: {}", new Object[]{new short[]{11, 12}});
+        assertEquals("Arg1: [11, 12]", actual);
+
+        actual = StringFormatter.arrayFormat("Arg1: {}", new Object[]{new int[]{11, 12}});
+        assertEquals("Arg1: [11, 12]", actual);
+
+        actual = StringFormatter.arrayFormat("Arg1: {}", new Object[]{new long[]{11L, 12L}});
+        assertEquals("Arg1: [11, 12]", actual);
+
+        actual = StringFormatter.arrayFormat("Arg1: {}", new Object[]{new float[]{11.2f, 12.3f}});
+        assertEquals("Arg1: [11.2, 12.3]", actual);
+
+        actual = StringFormatter.arrayFormat("Arg1: {}", new Object[]{new double[]{11.2d, 12.3d}});
+        assertEquals("Arg1: [11.2, 12.3]", actual);
+
+        actual = StringFormatter.arrayFormat("Arg1: {}", new Object[]{new String[]{"str-arr-1", "str-arr-2"}});
+        assertEquals("Arg1: [str-arr-1, str-arr-2]", actual);
+    }
+}