Prepare release for the next version (#13)

* Update bom usage

* Update version and group definition

* Update cyano definition

* Add generic layer for file tests

* Add new test case

* Implement new method and deprecate one

* Fix wrong import

* Add classes to handle custom data loading for our map part

# Conflicts:
#	src/main/java/net/theevilreaper/aves/map/AbstractMapProvider.java
#	src/main/java/net/theevilreaper/aves/map/MapProvider.java
#	src/main/java/net/theevilreaper/aves/util/functional/PathFilter.java

* Small improvements

* Add test for the new provider

* Remove debug

* Fix tests

* Change annotation usage to NotNull

* Update variable visibility

* Fix test execution

* Move TestMapProvider class

* Disable some assert calls

* Use junit launcher from the provided bom

* Update version usage in the readme file

* Update version to 1.8.0

---------

Co-authored-by: theEvilReaper <steffenwx@gmail.com>

Author: Joltras

README.md

@@ -34,7 +34,7 @@ Add the following dependency to your `build.gradle.kts` file:
 
 ```kotlin
 dependencies {
-    implementation("net.theevilreaper.aves:aves:1.6.1")
+    implementation("net.theevilreaper.aves:aves:<version>")
 }
 ```
 

build.gradle.kts

@@ -6,8 +6,8 @@ plugins {
     alias(libs.plugins.publishdata)
 }
 
-group = "net.theevilreaper.aves"
-version = "1.7.0"
+group = "net.theevilreaper"
+version = "1.8.0"
 description = "Aves"
 
 java {
@@ -21,11 +21,11 @@ configurations.all {
 }
 
 dependencies {
-    implementation(platform(libs.bom.base))
+    implementation(platform(libs.mycelium.bom))
     compileOnly(libs.adventure)
     compileOnly(libs.minestom)
 
-    testImplementation(platform(libs.bom.base))
+    testImplementation(platform(libs.mycelium.bom))
     testImplementation(libs.adventure)
     testImplementation(libs.minestom)
     testImplementation(libs.cyano)

settings.gradle.kts

@@ -26,17 +26,17 @@ dependencyResolutionManagement {
     }
     versionCatalogs {
         create("libs") {
-            version("bom", "1.2.0")
-            version("junit.platform", "1.12.2")
+            version("bom", "1.2.3")
             version("publishdata", "1.4.0")
 
-            library("bom.base", "net.onelitefeather.mycelium.bom", "mycelium-bom").versionRef("bom")
+            library("mycelium.bom", "net.onelitefeather", "mycelium-bom").versionRef("bom")
             library("minestom","net.minestom", "minestom-snapshots").withoutVersion()
             library("adventure", "net.kyori", "adventure-text-minimessage").withoutVersion()
-            library("cyano", "net.onelitefeather.cyano", "cyano").withoutVersion()
+            library("cyano", "net.onelitefeather", "cyano").withoutVersion()
             library("junit-jupiter", "org.junit.jupiter", "junit-jupiter").withoutVersion()
             library("junit-jupiter-engine", "org.junit.jupiter", "junit-jupiter-engine").withoutVersion()
-            library("junit.platform.launcher", "org.junit.platform", "junit-platform-launcher").versionRef("junit.platform")
+            library("junit.platform.launcher", "org.junit.platform", "junit-platform-launcher").withoutVersion()
+
             plugin("publishdata", "de.chojo.publishdata").versionRef("publishdata")
         }
     }

src/main/java/net/theevilreaper/aves/map/AbstractMapProvider.java

@@ -0,0 +1,115 @@
+package net.theevilreaper.aves.map;
+
+import net.theevilreaper.aves.file.FileHandler;
+import net.theevilreaper.aves.util.functional.PathFilter;
+import net.minestom.server.MinecraftServer;
+import net.minestom.server.coordinate.Pos;
+import net.minestom.server.entity.Player;
+import net.minestom.server.instance.Instance;
+import net.minestom.server.instance.InstanceContainer;
+import net.minestom.server.instance.anvil.AnvilLoader;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.UnmodifiableView;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+/**
+ * Abstract base implementation of {@link MapProvider} for managing map lifecycles
+ * within a server session. Handles loading map entries from disk, registering map
+ * instances, and providing access to the currently active map and instance.
+ * <p>
+ * Subclasses should implement logic for switching maps and managing map-specific data.
+ * </p>
+ *
+ * @author theEvilReaper
+ * @version 1.0.0
+ * @since 1.6.0
+ */
+public abstract class AbstractMapProvider implements MapProvider {
+
+    private static final Logger MAP_LOGGER = LoggerFactory.getLogger(AbstractMapProvider.class);
+
+    private final PathFilter<MapEntry> mapFilter;
+
+    protected FileHandler fileHandler;
+    protected List<MapEntry> mapEntries;
+
+    protected BaseMap activeMap;
+    protected InstanceContainer activeInstance;
+
+    /**
+     * Constructs a BaseMapProvider with the specified FileHandler.
+     *
+     * @param fileHandler the {@link FileHandler} used to load and save maps
+     * @param mapFilter   the filtering logic for the map entries
+     */
+    protected AbstractMapProvider(@NotNull FileHandler fileHandler, @NotNull PathFilter<MapEntry> mapFilter) {
+        this.fileHandler = fileHandler;
+        this.mapFilter = mapFilter;
+    }
+
+    /**
+     * Registers the specified map entry as an active instance in the server.
+     * Sets up chunk loading and time rate, and registers the instance with the server manager.
+     *
+     * @param instance the instance to be registered; must not be null
+     * @param mapEntry the map entry representing the world data; must not be null
+     */
+    protected void registerInstance(@NotNull InstanceContainer instance, @NotNull MapEntry mapEntry) {
+        instance.setChunkLoader(new AnvilLoader(mapEntry.getDirectoryRoot()));
+        instance.enableAutoChunkLoad(true);
+        instance.setTimeRate(0);
+        MinecraftServer.getInstanceManager().registerInstance(instance);
+    }
+
+    /**
+     * Loads all available map entries from the specified directory.
+     * Only directories passing the configured map filter are included.
+     * Handles IO exceptions gracefully by logging and reporting to the server exception manager.
+     *
+     * @param path the root directory containing map folders; must not be null
+     * @return a list of map entries found in the directory, possibly empty but never null
+     */
+    protected @NotNull List<MapEntry> loadMapEntries(@NotNull Path path) {
+        List<MapEntry> givenMaps = new ArrayList<>();
+        try (Stream<Path> stream = Files.list(path)) {
+            givenMaps.addAll(this.mapFilter.filter(stream.filter(Files::isDirectory)));
+        } catch (IOException exception) {
+            MinecraftServer.getExceptionManager().handleException(exception);
+            MAP_LOGGER.error("Unable to load maps from path {}", path, exception);
+        }
+        return givenMaps;
+    }
+
+    @Override
+    public void teleportToSpawn(@NotNull Player player, boolean instanceSet) {
+        Pos pos = this.activeMap.getSpawnOrDefault(FALLBACK_POS);
+        if (!instanceSet) {
+            player.teleport(pos);
+            return;
+        }
+        player.setInstance(this.activeInstance, pos);
+    }
+
+    @Override
+    public @UnmodifiableView @NotNull List<MapEntry> getEntries() {
+        if (this.mapEntries == null) return Collections.emptyList();
+        return Collections.unmodifiableList(this.mapEntries);
+    }
+
+    @Override
+    public @NotNull Supplier<@Nullable Instance> getActiveInstance() {
+        return () -> this.activeInstance;
+    }
+}
+

src/main/java/net/theevilreaper/aves/map/BaseMap.java

@@ -175,7 +175,7 @@ public boolean hasSpawn() {
      * @param defaultSpawn the default spawn location
      * @return the spawn location or the default spawn location
      */
-    public @Nullable Pos getSpawnOrDefault(@NotNull Pos defaultSpawn) {
+    public @NotNull Pos getSpawnOrDefault(@NotNull Pos defaultSpawn) {
         return spawn != null ? spawn : defaultSpawn;
     }
 }

src/main/java/net/theevilreaper/aves/map/BaseMapEntry.java

@@ -2,7 +2,10 @@
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
+import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 
@@ -16,6 +19,8 @@
  */
 public final class BaseMapEntry implements MapEntry {
 
+    private static final Logger LOGGER = LoggerFactory.getLogger(BaseMapEntry.class);
+
     private final String mapFileNaming;
     private final Path directory;
     private Path mapFilePath;
@@ -39,6 +44,18 @@ public final class BaseMapEntry implements MapEntry {
         }
     }
 
+    @Override
+    public void createFile() {
+        if (this.mapFilePath != null && Files.exists(mapFilePath)) return;
+
+        try {
+            this.mapFilePath = directory.resolve(mapFileNaming);
+            Files.createFile(this.mapFilePath);
+        } catch (IOException exception) {
+            LOGGER.warn("Could not create map file for path {}", mapFilePath, exception);
+        }
+    }
+
     /**
      * Refreshes the map entry. It will check if the map file exists.
      */

src/main/java/net/theevilreaper/aves/map/MapEntry.java

@@ -44,10 +44,16 @@ public sealed interface MapEntry permits BaseMapEntry {
         return new BaseMapEntry(directoryRoot, mapFileNaming);
     }
 
+    /**
+     * Creates a new MapEntry from the given path.
+     */
+    void createFile();
+
     /**
      * If the method is called the entry checks if the data file exists.
      * This can be used to update the path references in special cases.
      */
+    @Deprecated(forRemoval = true, since = "Please use createFile instead")
     void refresh();
 
     /**

src/main/java/net/theevilreaper/aves/map/MapProvider.java

@@ -0,0 +1,58 @@
+package net.theevilreaper.aves.map;
+
+import net.minestom.server.coordinate.Pos;
+import net.minestom.server.entity.Player;
+import net.minestom.server.instance.Instance;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.UnmodifiableView;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.function.Supplier;
+
+/**
+ * The {@link MapProvider} interface is responsible for managing the available maps.
+ * It will load all maps data from the given path and store them.
+ * It would not load the map itself over a {@link net.minestom.server.instance.anvil.AnvilLoader} instance.
+ * This behavior is handled by another class.
+ *
+ * @author theEvilReaper
+ * @version 1.0.0
+ * @since 1.6.0
+ */
+public interface MapProvider {
+
+    Pos FALLBACK_POS = new Pos(0, 100, 0);
+
+    /**
+     * Saves the given data from a {@link BaseMap} to the given path.
+     *
+     * @param path    the path where the map data should be saved
+     * @param baseMap the map data which should be saved
+     */
+    void saveMap(@NotNull Path path, @NotNull BaseMap baseMap);
+
+    /**
+     * Teleports a {@link Player} to the current active spawn position of the {@link Instance}.
+     *
+     * @param player      the player which should be teleported
+     * @param instanceSet if the instance should be set to the current active instance
+     */
+    void teleportToSpawn(@NotNull Player player, boolean instanceSet);
+
+    /**
+     * Returns a {@link List} which contains all available maps as {@link MapEntry} objects.
+     *
+     * @return the given list of maps
+     */
+    @UnmodifiableView
+    @NotNull List<MapEntry> getEntries();
+
+    /**
+     * Returns the current active {@link Instance} which is used for the game.
+     *
+     * @return the current active instance
+     */
+    @NotNull Supplier<@Nullable Instance> getActiveInstance();
+}

src/main/java/net/theevilreaper/aves/util/functional/PathFilter.java

@@ -0,0 +1,28 @@
+package net.theevilreaper.aves.util.functional;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.stream.Stream;
+
+/**
+ * The {@link PathFilter<T>} is a functional interface that can be used to bind a filter logic to a method reference.
+ * It can be used for filtering a {@link Stream} of {@link Path} objects and returning a list of {@link T} objects.
+ *
+ * @param <T> the type of the objects to be filtered
+ * @author theEvilReaper
+ * @version 1.0.0
+ * @since 1.0.0
+ */
+@FunctionalInterface
+public interface PathFilter<T> {
+
+    /**
+     * Filters the given stream of map paths and returns a list of {@link T} objects.
+     *
+     * @param stream the stream of map paths to filter
+     * @return a list of filtered {@link T} objects
+     */
+    @NotNull List<T> filter(@NotNull Stream<Path> stream);
+}

src/test/java/net/theevilreaper/aves/FileTestBase.java

@@ -0,0 +1,34 @@
+package net.theevilreaper.aves;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.io.IOException;
+import java.nio.file.DirectoryStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+/**
+ * The {@link FileTestBase} is a base class for all tests that need a temporary directory.
+ * It will create a temporary directory for each test and delete it after the test is finished.
+ *
+ * @author theEvilReaper
+ * @version 1.0.0
+ * @since 1.6.1
+ */
+public abstract class FileTestBase {
+
+    @TempDir
+    protected Path tempDir;
+
+    @AfterEach
+    void tearDown() {
+        try (DirectoryStream<Path> stream = Files.newDirectoryStream(tempDir)) {
+            for (Path file : stream) {
+                Files.delete(file);
+            }
+        } catch (IOException exception) {
+            exception.printStackTrace();
+        }
+    }
+}