updated to java 25,

improved the pipeline builder, added option to chain map, filter, and or handlers for better flow,
removed unsafe allocator, we won't use it in the future,
removed metadata api, we won't use it in the future

Author: Pesekjak

.github/workflows/test-foundry-core.yml

@@ -0,0 +1,35 @@
+name: Foundry Core Tests
+on:
+  push:
+    branches:
+      - master
+      - 'dev/**'
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  test:
+    if: "! contains(toJSON(github.event.commits.*.message), '[ci skip]')"
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v5
+      - name: Set up JDK 25
+        uses: actions/setup-java@v5
+        with:
+          java-version: '25'
+          distribution: 'temurin'
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+      - name: Grant execute permission for gradlew
+        run: chmod +x gradlew
+      - name: Run Tests
+        run: ./gradlew :foundry-core:test --stacktrace
+      - name: Publish Test Report
+        uses: actions/upload-artifact@v4
+        if: always() # run even if tests fail
+        with:
+          name: test-results
+          path: build/reports/tests/test/
+          retention-days: 5

build-logic/build.gradle.kts

@@ -6,10 +6,9 @@ repositories {
     mavenCentral()
 }
 
-tasks {
-    compileKotlin {
-        kotlinOptions {
-            jvmTarget = "21"
-        }
+kotlin {
+    jvmToolchain {
+        // NOTE: Kotlin does not yet support 25 JDK target, it will fall back to 24 but is safe to ignore
+        languageVersion.set(JavaLanguageVersion.of(25))
     }
-}
+}

build-logic/src/main/kotlin/java-library-convention.gradle.kts

@@ -28,15 +28,16 @@ dependencies {
     testImplementation(libs.findLibrary("junit-api").get())
     testRuntimeOnly(libs.findLibrary("junit-engine").get())
     testImplementation(libs.findLibrary("junit-params").get())
+    testRuntimeOnly(libs.findLibrary("junit-platform-launcher").get())
 }
 
 //
 // Java configuration
 //
 
 java {
-    sourceCompatibility = JavaVersion.VERSION_21
-    targetCompatibility = JavaVersion.VERSION_21
+    sourceCompatibility = JavaVersion.VERSION_25
+    targetCompatibility = JavaVersion.VERSION_25
     withSourcesJar()
 }
 
@@ -46,10 +47,10 @@ java {
 
 tasks {
     withType<JavaCompile> {
-        options.release.set(21)
+        options.release.set(25)
         options.encoding = Charsets.UTF_8.name()
     }
     test {
         useJUnitPlatform()
     }
-}
+}

foundry-core/build.gradle.kts

@@ -26,4 +26,4 @@ publishing {
             from(components["java"])
         }
     }
-}
+}

foundry-core/src/main/java/org/machinemc/foundry/CommonHandlers.java

@@ -0,0 +1,106 @@
+package org.machinemc.foundry;
+
+import org.jspecify.annotations.NonNull;
+import org.jspecify.annotations.Nullable;
+
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+
+/**
+ * Contains utility methods to construct common data handler implementations.
+ */
+public final class CommonHandlers {
+
+    /**
+     * Returns a {@link DataHandler} that performs an identity transformation.
+     * That is, it returns the same instance as it receives.
+     *
+     * @param <T> data type
+     * @return identity data handler
+     */
+    public static <T> DataHandler<T, T> identity() {
+        return o -> o;
+    }
+
+    /**
+     * Returns a {@link DataHandler} that wraps all items data
+     * into an optional.
+     * <p>
+     * This handler allows application of operations such as {@link #filter(Predicate)}
+     * further down the pipeline.
+     *
+     * @return data handler
+     * @param <T> type
+     */
+    public static <T> DataHandler<T, Optional<T>> protect() {
+        return Optional::ofNullable;
+    }
+
+    /**
+     * Returns a {@link DataHandler} that wraps around a function,
+     * applying it to only present items.
+     *
+     * @param mapper mapper function
+     * @return data handler
+     * @param <I> input type
+     * @param <O> output type
+     */
+    public static <I, O> DataHandler<Optional<I>, Optional<O>> map(Function<@NonNull I, @NonNull O> mapper) {
+        return input -> input.map(mapper);
+    }
+
+    /**
+     * Returns a {@link DataHandler} that applies the wrapped data handler only on present
+     * items.
+     *
+     * @param handler handler to apply
+     * @return data handler that wraps around given handler
+     * @param <I> input type
+     * @param <O> output type
+     */
+    public static <I, O> DataHandler<Optional<I>, Optional<O>> map(DataHandler<I, O> handler) {
+        return input -> input.isPresent()
+                ? Optional.ofNullable(handler.transform(input.get()))
+                : Optional.empty();
+    }
+
+    /**
+     * Returns a {@link DataHandler} that filters incoming items.
+     *
+     * @param filter filter predicate
+     * @return data handler
+     * @param <T> type
+     */
+    public static <T> DataHandler<Optional<T>, Optional<T>> filter(Predicate<@NonNull T> filter) {
+        return input -> input.filter(filter);
+    }
+
+    /**
+     * Returns a {@link DataHandler} that returns the same item if it is present,
+     * else provides a new value using given supplier.
+     *
+     * @param supplier supplier for missing items
+     * @return data handler
+     * @param <T> type
+     */
+    public static <T> DataHandler<Optional<T>, Optional<T>> or(Supplier<@NonNull T> supplier) {
+        return input -> input.or(() -> Optional.of(supplier.get()));
+    }
+
+    /**
+     * Returns a {@link DataHandler} that unwraps the items from optional.
+     *
+     * @return data handler
+     * @param <T> type
+     */
+    public static <T> DataHandler<Optional<T>, @Nullable T> elseNull() {
+        return input -> input.orElse(null);
+    }
+
+    private CommonHandlers() {
+        throw new UnsupportedOperationException();
+    }
+
+}

foundry-core/src/main/java/org/machinemc/foundry/DataHandler.java

@@ -14,17 +14,6 @@
 @FunctionalInterface
 public interface DataHandler<I, O> {
 
-    /**
-     * Returns a {@link DataHandler} that performs an identity transformation.
-     * That is, it returns the same instance as it receives.
-     *
-     * @param <T> data type
-     * @return identity data handler
-     */
-    static <T> DataHandler<T, T> identity() {
-        return o -> o;
-    }
-
     /**
      * Processes the given instance of type {@link I} and transforms it into an instance of type {@link O}.
      *