Merge pull request #1242 from mworzala/feat/hetergeneous_list_improvements

Improved support for hetergeneous lists

Author: zml2008

nbt/src/main/java/net/kyori/adventure/nbt/ListBinaryTagImpl.java

@@ -280,10 +280,19 @@ static BinaryTag unbox(final CompoundBinaryTag compound) {
   }
 
   static CompoundBinaryTag box(final BinaryTag tag) {
-    if (tag instanceof CompoundBinaryTag) {
-      return (CompoundBinaryTag) tag;
-    } else {
+    if (needsBox(tag)) {
       return new CompoundBinaryTagImpl(Collections.singletonMap(WRAPPER_KEY, tag));
+    } else {
+      return (CompoundBinaryTag) tag;
     }
   }
+
+  private static boolean needsBox(final BinaryTag tag) {
+    if (!(tag instanceof CompoundBinaryTag)) {
+      return true;
+    }
+
+    final CompoundBinaryTag compound = (CompoundBinaryTag) tag;
+    return compound.size() == 1 && compound.get(WRAPPER_KEY) != null;
+  }
 }

nbt/src/main/java/net/kyori/adventure/nbt/TagStringIO.java

@@ -71,11 +71,15 @@ public final class TagStringIO {
 
   private final boolean acceptLegacy;
   private final boolean emitLegacy;
+  private final boolean acceptHeterogeneousLists;
+  private final boolean emitHeterogeneousLists;
   private final String indent;
 
   private TagStringIO(final @NotNull Builder builder) {
     this.acceptLegacy = builder.acceptLegacy;
     this.emitLegacy = builder.emitLegacy;
+    this.acceptHeterogeneousLists = builder.acceptHeterogeneousLists;
+    this.emitHeterogeneousLists = builder.emitHeterogeneousLists;
     this.indent = builder.indent;
   }
 
@@ -96,6 +100,7 @@ private TagStringIO(final @NotNull Builder builder) {
       final CharBuffer buffer = new CharBuffer(input);
       final TagStringReader parser = new TagStringReader(buffer);
       parser.legacy(this.acceptLegacy);
+      parser.heterogeneousLists(this.acceptHeterogeneousLists);
       final CompoundBinaryTag tag = parser.compound();
       if (buffer.skipWhitespace().hasMore()) {
         throw new IOException("Document had trailing content after first CompoundTag");
@@ -206,6 +211,7 @@ private TagStringIO(final @NotNull Builder builder) {
     final StringBuilder sb = new StringBuilder();
     try (final TagStringWriter emit = new TagStringWriter(sb, this.indent)) {
       emit.legacy(this.emitLegacy);
+      emit.heterogeneousLists(this.emitHeterogeneousLists);
       emit.writeTag(input);
     }
     return sb.toString();
@@ -240,6 +246,7 @@ public void toWriter(final @NotNull BinaryTag input, final @NotNull Writer dest)
     Objects.requireNonNull(dest, "dest");
     try (final TagStringWriter emit = new TagStringWriter(dest, this.indent)) {
       emit.legacy(this.emitLegacy);
+      emit.heterogeneousLists(this.emitHeterogeneousLists);
       emit.writeTag(input);
     }
   }
@@ -252,6 +259,8 @@ public void toWriter(final @NotNull BinaryTag input, final @NotNull Writer dest)
   public static class Builder {
     private boolean acceptLegacy = true;
     private boolean emitLegacy = false;
+    private boolean acceptHeterogeneousLists = false;
+    private boolean emitHeterogeneousLists = false;
     private String indent = "";
 
     Builder() {
@@ -326,6 +335,36 @@ public static class Builder {
       return this;
     }
 
+    /**
+     * Configure whether or not the resulting IO configuration will accept heterogeneous lists.
+     *
+     * <p>Heterogeneous lists are lists that contain multiple types of tags, such as a list containing
+     * both strings and integers.</p>
+     *
+     * @param heterogeneous whether to accept heterogeneous lists
+     * @return this builder
+     * @since 4.22.0
+     */
+    public @NotNull Builder acceptHeterogeneousLists(final boolean heterogeneous) {
+      this.acceptHeterogeneousLists = heterogeneous;
+      return this;
+    }
+
+    /**
+     * Configure whether or not the resulting IO configuration will emit heterogeneous lists.
+     *
+     * <p>Heterogeneous lists are lists that contain multiple types of tags, such as a list containing
+     * both strings and integers.</p>
+     *
+     * @param heterogeneous whether to emit heterogeneous lists
+     * @return this builder
+     * @since 4.22.0
+     */
+    public @NotNull Builder emitHeterogeneousLists(final boolean heterogeneous) {
+      this.emitHeterogeneousLists = heterogeneous;
+      return this;
+    }
+
     /**
      * Create a new IO configuration from this builder.
      *

nbt/src/main/java/net/kyori/adventure/nbt/TagStringReader.java

@@ -40,7 +40,7 @@ final class TagStringReader {
 
   private final CharBuffer buffer;
   private boolean acceptLegacy;
-  private boolean acceptHeterogenousLists;
+  private boolean acceptHeterogeneousLists;
   private int depth;
 
   TagStringReader(final CharBuffer buffer) {
@@ -64,7 +64,8 @@ public CompoundBinaryTag compound() throws StringTagParseException {
   }
 
   public ListBinaryTag list() throws StringTagParseException {
-    final ListBinaryTag.Builder<BinaryTag> builder = ListBinaryTag.builder();
+    final ListBinaryTag.Builder<BinaryTag> builder = this.acceptHeterogeneousLists
+      ? ListBinaryTag.heterogeneousListBinaryTag() : ListBinaryTag.builder();
     this.buffer.expect(Tokens.ARRAY_BEGIN);
     final boolean prefixedIndex = this.acceptLegacy && this.buffer.peek() == '0' && this.buffer.peek(1) == ':';
     if (!prefixedIndex && this.buffer.takeIf(Tokens.ARRAY_END)) {
@@ -432,4 +433,8 @@ private static String unescape(final String withEscapes) {
   public void legacy(final boolean acceptLegacy) {
     this.acceptLegacy = acceptLegacy;
   }
+
+  public void heterogeneousLists(final boolean acceptHeterogeneousLists) {
+    this.acceptHeterogeneousLists = acceptHeterogeneousLists;
+  }
 }

nbt/src/main/java/net/kyori/adventure/nbt/TagStringWriter.java

@@ -41,6 +41,7 @@ final class TagStringWriter implements AutoCloseable {
    */
   private boolean needsSeparator;
   private boolean legacy;
+  private boolean heterogeneousLists;
 
   TagStringWriter(final Appendable out, final String indent) {
     this.out = out;
@@ -52,6 +53,11 @@ public TagStringWriter legacy(final boolean legacy) {
     return this;
   }
 
+  public TagStringWriter heterogeneousLists(final boolean emitHeterogeneousLists) {
+    this.heterogeneousLists = emitHeterogeneousLists;
+    return this;
+  }
+
   // NBT-specific
 
   public TagStringWriter writeTag(final BinaryTag tag) throws IOException {
@@ -96,7 +102,8 @@ private TagStringWriter writeCompound(final CompoundBinaryTag tag) throws IOExce
     return this;
   }
 
-  private TagStringWriter writeList(final ListBinaryTag tag) throws IOException {
+  private TagStringWriter writeList(final ListBinaryTag rawTag) throws IOException {
+    final ListBinaryTag tag = this.heterogeneousLists ? rawTag.unwrapHeterogeneity() : rawTag.wrapHeterogeneity();
     this.beginList();
     int idx = 0;
     final boolean lineBreaks = this.prettyPrinting() && this.breakListElement(tag.elementType());

nbt/src/test/java/net/kyori/adventure/nbt/ListBinaryTagTest.java

@@ -126,6 +126,24 @@ void testBoxHeterogeneous() {
     assertEquals(expected, input.wrapHeterogeneity());
   }
 
+  @Test
+  void testBoxHeterogeneousDoubleWrap() {
+    // For backwards compatibility, wrapping a tag which is already {"": value} should wrap it again.
+    final ListBinaryTag input = ListBinaryTag.listBinaryTag(
+      BinaryTagTypes.LIST_WILDCARD,
+      Arrays.asList(
+        CompoundBinaryTag.from(Collections.singletonMap("", longBinaryTag(5))),
+              StringBinaryTag.stringBinaryTag("five")
+      )
+    );
+    final ListBinaryTag expected = ListBinaryTag.builder()
+      .add(CompoundBinaryTag.from(Collections.singletonMap("", CompoundBinaryTag.from(Collections.singletonMap("", longBinaryTag(5))))))
+      .add(CompoundBinaryTag.from(Collections.singletonMap("", stringBinaryTag("five"))))
+      .build();
+
+    assertEquals(expected, input.wrapHeterogeneity());
+  }
+
   @Test
   void testBoxingReversible() {
     final ListBinaryTag input = ListBinaryTag.listBinaryTag(

nbt/src/test/java/net/kyori/adventure/nbt/StringIOTest.java

@@ -252,6 +252,29 @@ void testLegacyListTag() throws IOException {
     assertEquals(builder.build(), tag);
   }
 
+  @Test
+  void testHeterogeneousListTag() throws IOException {
+    final String input = "[\"Tag #1\",2]";
+    final BinaryTag tag = this.stringToTag(input, false, true);
+    assertEquals("[{:\"Tag #1\"},{:2}]", this.tagToString(tag));
+    final StringWriter output = new StringWriter();
+    try (final TagStringWriter writer = new TagStringWriter(output, "").heterogeneousLists(true)) {
+      writer.writeTag(tag);
+    }
+    assertEquals(input, output.toString());
+
+    final ListTagBuilder<BinaryTag> builder = new ListTagBuilder<>(true);
+    builder.add(StringBinaryTag.stringBinaryTag("Tag #1"));
+    builder.add(IntBinaryTag.intBinaryTag(2));
+    assertEquals(builder.build(), tag);
+  }
+
+  @Test
+  void testFailHeterogeneousListTag() {
+    final String input = "[\"Tag #1\",2]";
+    assertThrows(IllegalArgumentException.class, () -> this.stringToTag(input, false, false));
+  }
+
   @Test
   void testReadsLegacyCompoundKey() throws IOException {
     final String input = "{test*compound: \"hello world\"}";
@@ -351,9 +374,14 @@ private BinaryTag stringToTag(final String input) throws StringTagParseException
   }
 
   private BinaryTag stringToTag(final String input, final boolean acceptLegacy) throws StringTagParseException {
+    return this.stringToTag(input, acceptLegacy, false);
+  }
+
+  private BinaryTag stringToTag(final String input, final boolean acceptLegacy, final boolean acceptHeterogeneousLists) throws StringTagParseException {
     final CharBuffer buffer = new CharBuffer(input);
     final TagStringReader parser = new TagStringReader(buffer);
     parser.legacy(acceptLegacy);
+    parser.heterogeneousLists(acceptHeterogeneousLists);
     final BinaryTag ret = parser.tag();
     if (buffer.skipWhitespace().hasMore()) {
       throw buffer.makeError("Trailing content after parse!");