Add support for implicit conversion

honey-common/src/dev/shiza/honey/Honey.java

@@ -1,5 +1,6 @@
 package dev.shiza.honey;
 
+import dev.shiza.honey.conversion.ImplicitConversion;
 import dev.shiza.honey.message.Message;
 import dev.shiza.honey.message.MessageCompiler;
 import dev.shiza.honey.placeholder.evaluator.PlaceholderContext;
@@ -15,13 +16,15 @@ public interface Honey<T> {
 
   static <T> Honey<T> create(
       final MessageCompiler<T> messageCompiler,
+      final ImplicitConversion implicitConversion,
       final PlaceholderContext placeholderContext,
       final PlaceholderResolver placeholderResolver,
       final PlaceholderSanitizer placeholderSanitizer,
       final PlaceholderEvaluator placeholderEvaluator,
       final ProcessorRegistry processorRegistry) {
     return new HoneyImpl<>(
         messageCompiler,
+        implicitConversion,
         placeholderContext,
         placeholderResolver,
         placeholderSanitizer,

honey-common/src/dev/shiza/honey/HoneyImpl.java

@@ -4,6 +4,7 @@
 import static java.util.Collections.emptyList;
 import static java.util.concurrent.CompletableFuture.completedFuture;
 
+import dev.shiza.honey.conversion.ImplicitConversion;
 import dev.shiza.honey.message.Message;
 import dev.shiza.honey.message.MessageCompiler;
 import dev.shiza.honey.placeholder.evaluator.EvaluatedPlaceholder;
@@ -16,6 +17,7 @@
 import dev.shiza.honey.placeholder.visitor.PlaceholderVisitorImpl;
 import dev.shiza.honey.placeholder.visitor.PromisingPlaceholderVisitor;
 import dev.shiza.honey.processor.ProcessorRegistry;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -25,6 +27,7 @@
 public class HoneyImpl<T> implements Honey<T> {
 
   private final MessageCompiler<T> messageCompiler;
+  private final ImplicitConversion implicitConversion;
   private final PlaceholderContext placeholderContext;
   private final PlaceholderResolver placeholderResolver;
   private final PlaceholderSanitizer placeholderSanitizer;
@@ -33,12 +36,14 @@ public class HoneyImpl<T> implements Honey<T> {
 
   protected HoneyImpl(
       final MessageCompiler<T> messageCompiler,
+      final ImplicitConversion implicitConversion,
       final PlaceholderContext placeholderContext,
       final PlaceholderResolver placeholderResolver,
       final PlaceholderSanitizer placeholderSanitizer,
       final PlaceholderEvaluator placeholderEvaluator,
       final ProcessorRegistry processorRegistry) {
     this.messageCompiler = messageCompiler;
+    this.implicitConversion = implicitConversion;
     this.placeholderContext = placeholderContext;
     this.placeholderResolver = placeholderResolver;
     this.placeholderSanitizer = placeholderSanitizer;
@@ -99,7 +104,25 @@ private T compile(final Message message, final List<SanitizedPlaceholder> placeh
     final String processedContent = processorRegistry.preprocess(message.content());
     final String sanitizedContent =
         placeholderSanitizer.getSanitizedContent(processedContent, placeholders);
-    return messageCompiler.compile(sanitizedContent, placeholders);
+    return messageCompiler.compile(sanitizedContent, convertPlaceholders(placeholders));
+  }
+
+  private List<SanitizedPlaceholder> convertPlaceholders(
+      final List<SanitizedPlaceholder> placeholders) {
+    if (implicitConversion == null) {
+      return placeholders;
+    }
+
+    final List<SanitizedPlaceholder> convertedPlaceholders = new ArrayList<>();
+    for (final SanitizedPlaceholder placeholder : placeholders) {
+      convertedPlaceholders.add(
+          new SanitizedPlaceholder(
+              placeholder.key(),
+              placeholder.expression(),
+              implicitConversion.convert(placeholder.evaluatedValue())));
+    }
+
+    return convertedPlaceholders;
   }
 
   private CompletableFuture<List<EvaluatedPlaceholder>> unwrapPromisedValues(

honey-common/src/dev/shiza/honey/adventure/AdventureHoney.java

@@ -3,13 +3,15 @@
 import static net.kyori.adventure.text.minimessage.MiniMessage.miniMessage;
 
 import dev.shiza.honey.Honey;
+import dev.shiza.honey.conversion.ImplicitConversion;
 import dev.shiza.honey.message.MessageCompiler;
 import dev.shiza.honey.placeholder.evaluator.PlaceholderContext;
 import dev.shiza.honey.placeholder.evaluator.PlaceholderEvaluator;
 import dev.shiza.honey.placeholder.resolver.PlaceholderResolver;
 import dev.shiza.honey.placeholder.sanitizer.PlaceholderSanitizer;
 import dev.shiza.honey.processor.ProcessorRegistry;
 import dev.shiza.honey.reflection.ReflectivePlaceholderEvaluatorFactory;
+import java.util.Collections;
 import java.util.Map;
 import java.util.function.Consumer;
 import net.kyori.adventure.text.Component;
@@ -29,22 +31,25 @@ static AdventureHoney createReflective(
       final MiniMessage miniMessage, final PlaceholderContext placeholderContext) {
     return create(
         AdventureMessageCompilerFactory.create(miniMessage),
+        ImplicitConversion.create(Collections.emptySet()),
         placeholderContext,
         PlaceholderResolver.create(),
         PlaceholderSanitizer.create(),
         ReflectivePlaceholderEvaluatorFactory.create(),
         ProcessorRegistry.create());
   }
 
-  private static AdventureHoney create(
+  static AdventureHoney create(
       final MessageCompiler<Component> messageCompiler,
+      final ImplicitConversion implicitConversion,
       final PlaceholderContext placeholderContext,
       final PlaceholderResolver placeholderResolver,
       final PlaceholderSanitizer placeholderSanitizer,
       final PlaceholderEvaluator placeholderEvaluator,
       final ProcessorRegistry processorRegistry) {
     return new AdventureHoneyImpl(
         messageCompiler,
+        implicitConversion,
         placeholderContext,
         placeholderResolver,
         placeholderSanitizer,

honey-common/src/dev/shiza/honey/adventure/AdventureHoneyImpl.java

@@ -1,6 +1,7 @@
 package dev.shiza.honey.adventure;
 
 import dev.shiza.honey.HoneyImpl;
+import dev.shiza.honey.conversion.ImplicitConversion;
 import dev.shiza.honey.message.MessageCompiler;
 import dev.shiza.honey.placeholder.evaluator.PlaceholderContext;
 import dev.shiza.honey.placeholder.evaluator.PlaceholderEvaluator;
@@ -15,13 +16,15 @@ class AdventureHoneyImpl extends HoneyImpl<Component> implements AdventureHoney
 
   AdventureHoneyImpl(
       final MessageCompiler<Component> messageCompiler,
+      final ImplicitConversion implicitConversion,
       final PlaceholderContext placeholderContext,
       final PlaceholderResolver placeholderResolver,
       final PlaceholderSanitizer placeholderSanitizer,
       final PlaceholderEvaluator placeholderEvaluator,
       final ProcessorRegistry processorRegistry) {
     super(
         messageCompiler,
+        implicitConversion,
         placeholderContext,
         placeholderResolver,
         placeholderSanitizer,

honey-common/src/dev/shiza/honey/conversion/ImplicitConversion.java

@@ -0,0 +1,43 @@
+package dev.shiza.honey.conversion;
+
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+public final class ImplicitConversion {
+
+  private final Map<Class<?>, Function<Object, Object>> conversions;
+
+  ImplicitConversion(final Set<ImplicitConversionUnit> units) {
+    this.conversions =
+        units.stream()
+            .collect(
+                Collectors.toMap(ImplicitConversionUnit::from, ImplicitConversionUnit::conversion));
+  }
+
+  public static ImplicitConversion create(final Set<ImplicitConversionUnit> units) {
+    return new ImplicitConversion(units);
+  }
+
+  public <T> T convert(final Object value) {
+    Object currentValue = value;
+
+    boolean conversionFound;
+    do {
+      conversionFound = false;
+      for (final Map.Entry<Class<?>, Function<Object, Object>> entry : conversions.entrySet()) {
+        if (entry.getKey().isAssignableFrom(currentValue.getClass())) {
+          final Object convertedValue = entry.getValue().apply(currentValue);
+          if (convertedValue != null) {
+            currentValue = convertedValue;
+            conversionFound = true;
+            break;
+          }
+        }
+      }
+    } while (conversionFound);
+
+    return (T) currentValue;
+  }
+}

honey-common/src/dev/shiza/honey/conversion/ImplicitConversionException.java

@@ -0,0 +1,8 @@
+package dev.shiza.honey.conversion;
+
+public final class ImplicitConversionException extends IllegalStateException {
+
+  public ImplicitConversionException(final String message) {
+    super(message);
+  }
+}

honey-common/src/dev/shiza/honey/conversion/ImplicitConversionUnit.java

@@ -0,0 +1,21 @@
+package dev.shiza.honey.conversion;
+
+import java.util.function.Function;
+
+public record ImplicitConversionUnit(
+    Class<?> from, Class<?> into, Function<Object, Object> conversion) {
+
+  public static <T, R> ImplicitConversionUnit unchecked(
+      final Class<T> from, final Class<R> into, final Function<T, R> conversion) {
+    if (from == null || into == null || conversion == null) {
+      throw new ImplicitConversionException(
+          "Cannot create an implicit conversion unit with null values.");
+    }
+
+    if (from.equals(into)) {
+      throw new ImplicitConversionException("Cannot create an recursive conversion unit.");
+    }
+
+    return new ImplicitConversionUnit(from, into, (Function<Object, Object>) conversion);
+  }
+}

honey-common/src/dev/shiza/honey/conversion/package-info.java

@@ -0,0 +1,4 @@
+@Experimental
+package dev.shiza.honey.conversion;
+
+import org.jetbrains.annotations.ApiStatus.Experimental;