Add an option to use message dispatcher without formatter

README.md

@@ -46,26 +46,26 @@ implementation("dev.shiza:honey:2.0.0")
 A showcase of how to use *honey*, can be found in [honey-test-plugin](honey-test-plugin) module.
 
 ```java
-/* for titles::audience */
-dispatcher.createTitle()
+// * sending a message as title with all honey features
+AdventureMessageDispatcher.createTitle()
     .recipient(event.getPlayer())
-    .title(it -> it.template("Hello!"))
-    .subtitle(it -> it.template("It is a pleasure to see you there {{player.getName}}")
+    .title(it -> it.template(formatter, "Hello!"))
+    .subtitle(it -> it.template(formatter, "It is a pleasure to see you there {{player.getName}}")
     .variable("player", event.getPlayer()))
     .times(2, 4, 2)
     .dispatch();
 
-/* for chat::audience */
-dispatcher.createChat()
+// * sending a message as chat message with all honey features
+AdventureMessageDispatcher.createChat()
     .recipient(Bukkit.getServer())
-    .template("{{player.getName}} has joined the server!")
+    .template(formatter, "{{player.getName}} has joined the server!")
     .variable("player", event.getPlayer())
     .dispatch();
 
-/* for actionbar::audience */
-dispatcher.createActionBar()
+// * sending a message as action bar with predefined message without any placeholder support
+AdventureMessageDispatcher.createActionBar()
     .recipient(event.getPlayer())
-    .template("Honey is great, isn't it?")
+    .template(Component.text("Honey is great, isn't it?"))
     .dispatch();
 ```
 

honey-common/src/dev/shiza/honey/adventure/message/dispatcher/AdventureMessageDispatcher.java

@@ -1,32 +1,24 @@
 package dev.shiza.honey.adventure.message.dispatcher;
 
-import dev.shiza.honey.message.Message;
 import dev.shiza.honey.message.dispatcher.MessageBaseDispatcher;
 import dev.shiza.honey.message.dispatcher.MessageDispatcher;
 import dev.shiza.honey.message.dispatcher.TitleMessageDispatcher;
-import dev.shiza.honey.message.formatter.MessageFormatter;
 import net.kyori.adventure.audience.Audience;
 import net.kyori.adventure.text.Component;
 
 public final class AdventureMessageDispatcher {
 
-  private final MessageFormatter<Component> messageFormatter;
+  private AdventureMessageDispatcher() {}
 
-  public AdventureMessageDispatcher(final MessageFormatter<Component> messageFormatter) {
-    this.messageFormatter = messageFormatter;
+  public static MessageDispatcher<Audience, Component> createChat() {
+    return new MessageBaseDispatcher<>(Audience.empty(), Audience::sendMessage);
   }
 
-  public MessageDispatcher<Audience, Component> createChat() {
-    return new MessageBaseDispatcher<>(
-        messageFormatter, Message.blank(), Audience.empty(), Audience::sendMessage);
+  public static MessageDispatcher<Audience, Component> createActionBar() {
+    return new MessageBaseDispatcher<>(Audience.empty(), Audience::sendActionBar);
   }
 
-  public MessageDispatcher<Audience, Component> createActionBar() {
-    return new MessageBaseDispatcher<>(
-        messageFormatter, Message.blank(), Audience.empty(), Audience::sendActionBar);
-  }
-
-  public TitleMessageDispatcher<Audience, Component> createTitle() {
-    return new AdventureTitleMessageDispatcher(messageFormatter);
+  public static TitleMessageDispatcher<Audience, Component> createTitle() {
+    return new AdventureTitleMessageDispatcher();
   }
 }

honey-common/src/dev/shiza/honey/adventure/message/dispatcher/AdventureTitleMessageDispatcher.java

@@ -2,11 +2,9 @@
 
 import com.google.common.collect.ImmutableList;
 import com.spotify.futures.CompletableFutures;
-import dev.shiza.honey.message.Message;
 import dev.shiza.honey.message.dispatcher.MessageBaseDispatcher;
 import dev.shiza.honey.message.dispatcher.MessageDispatcher;
 import dev.shiza.honey.message.dispatcher.TitleMessageDispatcher;
-import dev.shiza.honey.message.formatter.MessageFormatter;
 import java.time.Duration;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
@@ -20,41 +18,31 @@
 public final class AdventureTitleMessageDispatcher
     implements TitleMessageDispatcher<Audience, Component> {
 
-  private final MessageFormatter<Component> messageFormatter;
   private final MessageDispatcher<Audience, Component> times;
   private final MessageDispatcher<Audience, Component> title;
   private final MessageDispatcher<Audience, Component> subtitle;
   private final Audience recipient;
 
   public AdventureTitleMessageDispatcher(
-      final MessageFormatter<Component> messageFormatter,
       final MessageDispatcher<Audience, Component> times,
       final MessageDispatcher<Audience, Component> title,
       final MessageDispatcher<Audience, Component> subtitle,
       final Audience recipient) {
-    this.messageFormatter = messageFormatter;
     this.times = times;
     this.title = title;
     this.subtitle = subtitle;
     this.recipient = recipient;
   }
 
-  public AdventureTitleMessageDispatcher(final MessageFormatter<Component> messageFormatter) {
+  public AdventureTitleMessageDispatcher() {
     this(
-        messageFormatter,
         new MessageBaseDispatcher<>(
-            messageFormatter,
-            Message.blank(),
             Audience.empty(),
             (audience, component) -> audience.sendTitlePart(TitlePart.TIMES, Title.DEFAULT_TIMES)),
         new MessageBaseDispatcher<>(
-            messageFormatter,
-            Message.blank(),
             Audience.empty(),
             (audience, component) -> audience.sendTitlePart(TitlePart.TITLE, component)),
         new MessageBaseDispatcher<>(
-            messageFormatter,
-            Message.blank(),
             Audience.empty(),
             (audience, component) -> audience.sendTitlePart(TitlePart.SUBTITLE, component)),
         Audience.empty());
@@ -68,31 +56,26 @@ public TitleMessageDispatcher<Audience, Component> times(
             Duration.ofSeconds(fadeIn), Duration.ofSeconds(stay), Duration.ofSeconds(fadeOut));
     final MessageDispatcher<Audience, Component> timesDispatcher =
         new MessageBaseDispatcher<>(
-            messageFormatter,
-            Message.blank(),
-            recipient,
-            (audience, component) -> audience.sendTitlePart(TitlePart.TIMES, titleTime));
+            recipient, (audience, component) -> audience.sendTitlePart(TitlePart.TIMES, titleTime));
     return new AdventureTitleMessageDispatcher(
-        messageFormatter, timesDispatcher, title, subtitle, recipient);
+        timesDispatcher.template(Component.empty()), title, subtitle, recipient);
   }
 
   @Override
   public TitleMessageDispatcher<Audience, Component> title(
       final UnaryOperator<MessageDispatcher<Audience, Component>> consumer) {
-    return new AdventureTitleMessageDispatcher(
-        messageFormatter, times, consumer.apply(title), subtitle, recipient);
+    return new AdventureTitleMessageDispatcher(times, consumer.apply(title), subtitle, recipient);
   }
 
   @Override
   public TitleMessageDispatcher<Audience, Component> subtitle(
       final UnaryOperator<MessageDispatcher<Audience, Component>> consumer) {
-    return new AdventureTitleMessageDispatcher(
-        messageFormatter, times, title, consumer.apply(subtitle), recipient);
+    return new AdventureTitleMessageDispatcher(times, title, consumer.apply(subtitle), recipient);
   }
 
   @Override
   public TitleMessageDispatcher<Audience, Component> recipient(final Audience recipient) {
-    return new AdventureTitleMessageDispatcher(messageFormatter, times, title, subtitle, recipient);
+    return new AdventureTitleMessageDispatcher(times, title, subtitle, recipient);
   }
 
   @Override

honey-common/src/dev/shiza/honey/message/dispatcher/MessageBaseDispatcher.java

@@ -1,6 +1,9 @@
 package dev.shiza.honey.message.dispatcher;
 
 import dev.shiza.honey.message.Message;
+import dev.shiza.honey.message.dispatcher.MessageRenderer.DelegatingMessageRenderer;
+import dev.shiza.honey.message.dispatcher.MessageRenderer.FormattingMessageRenderer;
+import dev.shiza.honey.message.dispatcher.MessageRenderer.EmptyMessageRenderer;
 import dev.shiza.honey.message.formatter.MessageFormatter;
 import java.util.concurrent.CompletableFuture;
 import java.util.function.BiConsumer;
@@ -10,71 +13,69 @@
 public final class MessageBaseDispatcher<VIEWER, RESULT>
     implements MessageDispatcher<VIEWER, RESULT> {
 
-  private final MessageFormatter<RESULT> messageFormatter;
-  private final Message message;
+  private final MessageRenderer<RESULT> renderer;
   private final VIEWER recipient;
   private final BiConsumer<VIEWER, RESULT> deliver;
 
-  public MessageBaseDispatcher(
-      final MessageFormatter<RESULT> messageFormatter,
-      final Message message,
+  private MessageBaseDispatcher(
+      final MessageRenderer<RESULT> renderer,
       final VIEWER recipient,
       final BiConsumer<VIEWER, RESULT> deliver) {
-    this.messageFormatter = messageFormatter;
-    this.message = message;
+    this.renderer = renderer;
     this.recipient = recipient;
     this.deliver = deliver;
   }
 
+  public MessageBaseDispatcher(final VIEWER recipient, final BiConsumer<VIEWER, RESULT> deliver) {
+    this(new EmptyMessageRenderer<>(), recipient, deliver);
+  }
+
   @Override
   public MessageDispatcher<VIEWER, RESULT> recipient(final VIEWER recipient) {
-    return new MessageBaseDispatcher<>(messageFormatter, message, recipient, deliver);
+    return new MessageBaseDispatcher<>(renderer, recipient, deliver);
   }
 
   @Override
-  public MessageDispatcher<VIEWER, RESULT> template(final String template) {
-    return new MessageBaseDispatcher<>(messageFormatter, Message.of(template), recipient, deliver);
+  public MessageDispatcher<VIEWER, RESULT> template(
+      final MessageFormatter<RESULT> formatter, final String template) {
+    return new MessageBaseDispatcher<>(
+        new FormattingMessageRenderer<>(formatter, Message.of(template)), recipient, deliver);
   }
 
   @Override
-  public MessageDispatcher<VIEWER, RESULT> variable(final String key, final Object value) {
+  public MessageDispatcher<VIEWER, RESULT> template(final RESULT message) {
     return new MessageBaseDispatcher<>(
-        messageFormatter, message.placeholders(it -> it.withValue(key, value)), recipient, deliver);
+        new DelegatingMessageRenderer<>(message), recipient, deliver);
+  }
+
+  @Override
+  public MessageDispatcher<VIEWER, RESULT> variable(final String key, final Object value) {
+    final MessageRenderer<RESULT> newRenderer = renderer.variable(key, value);
+    return new MessageBaseDispatcher<>(newRenderer, recipient, deliver);
   }
 
   @Override
   public MessageDispatcher<VIEWER, RESULT> promisedVariable(final String key, final Object value) {
-    return new MessageBaseDispatcher<>(
-        messageFormatter,
-        message.placeholders(it -> it.withPromisedValue(key, value)),
-        recipient,
-        deliver);
+    final MessageRenderer<RESULT> newRenderer = renderer.promisedVariable(key, value);
+    return new MessageBaseDispatcher<>(newRenderer, recipient, deliver);
   }
 
   @Override
   public MessageDispatcher<VIEWER, RESULT> promisedVariable(
       final String key, final CompletableFuture<Object> value) {
-    return new MessageBaseDispatcher<>(
-        messageFormatter,
-        message.placeholders(it -> it.withPromisedValue(key, value)),
-        recipient,
-        deliver);
+    final MessageRenderer<RESULT> newRenderer = renderer.promisedVariable(key, value);
+    return new MessageBaseDispatcher<>(newRenderer, recipient, deliver);
   }
 
   @Override
   public void dispatch() {
-    if (!message.context().getPromisedValues().isEmpty()) {
-      throw new MessageDispatchingException(
-          "Cannot dispatch a message with promised values synchronously");
-    }
-
-    deliver.accept(recipient, messageFormatter.format(message));
+    deliver.accept(recipient, renderer.render());
   }
 
   @Override
   public CompletableFuture<Void> dispatchAsync() {
-    return messageFormatter
-        .formatAsync(message)
+    return renderer
+        .renderAsync()
         .thenAccept(result -> deliver.accept(recipient, result))
         .exceptionally(
             cause -> {

honey-common/src/dev/shiza/honey/message/dispatcher/MessageDispatcher.java

@@ -1,18 +1,23 @@
 package dev.shiza.honey.message.dispatcher;
 
+import dev.shiza.honey.message.formatter.MessageFormatter;
 import java.util.concurrent.CompletableFuture;
 
 public interface MessageDispatcher<VIEWER, RESULT> {
 
   MessageDispatcher<VIEWER, RESULT> recipient(final VIEWER recipient);
 
-  MessageDispatcher<VIEWER, RESULT> template(final String template);
+  MessageDispatcher<VIEWER, RESULT> template(
+      final MessageFormatter<RESULT> formatter, final String template);
+
+  MessageDispatcher<VIEWER, RESULT> template(final RESULT message);
 
   MessageDispatcher<VIEWER, RESULT> variable(final String key, final Object value);
 
   MessageDispatcher<VIEWER, RESULT> promisedVariable(final String key, final Object value);
 
-  MessageDispatcher<VIEWER, RESULT> promisedVariable(final String key, final CompletableFuture<Object> value);
+  MessageDispatcher<VIEWER, RESULT> promisedVariable(
+      final String key, final CompletableFuture<Object> value);
 
   void dispatch();