Add support for Stringified NBT objects

build.gradle

@@ -56,6 +56,7 @@ dependencies {
  implementation 'com.github.seancfoley:ipaddress:5.3.3'
 
  // Tests - JUnit 5
+ testImplementation("org.junit.jupiter:junit-jupiter-params:5.7.0")
  testImplementation("org.junit.jupiter:junit-jupiter-api:5.7.0")
  testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.7.0")
 

src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTag.java

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2020-2021 DumbDogDiner <dumbdogdiner.com>. All rights reserved.
+ * Licensed under the MIT license, see LICENSE for more information...
+ */
+package com.dumbdogdiner.stickyapi.common.nbt;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonPrimitive;
+import org.jetbrains.annotations.NotNull;
+
+
+/**
+ * A convenience class for converting booleans from {@link JsonPrimitive}s, and for easily creating
+ */
+public class NbtBooleanTag extends NbtPrimitiveTag<Boolean> {
+ private final boolean bool;
+
+ public NbtBooleanTag(boolean bool) {
+ this.bool = bool;
+ }
+
+ /**
+ * Converts a {@link JsonPrimitive} of a boolean to a new {@link NbtBooleanTag}
+ * It is recommended to make sure the primitive is a boolean first
+ *
+ * @param primitive The incoming {@link JsonPrimitive} to be converted, must be a boolean type!
+ * @return A new tag with tbe boolean value of the primitive
+ * @throws ClassCastException if the primitive is not a boolean
+ * @see JsonPrimitive#isBoolean()
+ */
+ public static @NotNull NbtBooleanTag fromPrimitive(@NotNull JsonPrimitive primitive) throws ClassCastException {
+ return new NbtBooleanTag(primitive.getAsBoolean());
+ }
+
+ // As much as I hate the object form... we have to because generics
+ @Override
+ public @NotNull Boolean asPrimitive() {
+ return bool;
+ }
+
+ @Override
+ public @NotNull JsonElement toJson() {
+ return new JsonPrimitive(bool);
+ }
+
+ @Override
+ public @NotNull String toNbtString() {
+ return bool ? NbtNumberTag.TRUE.toNbtString() : NbtNumberTag.FALSE.toNbtString();
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (other instanceof NbtBooleanTag) {
+ return ((NbtBooleanTag) other).asPrimitive() == bool;
+ } else if (other instanceof NbtNumberTag) {
+ return (!((NbtNumberTag) other).asPrimitive().equals(0)) == bool;
+ } else {
+ return false;
+ }
+ }
+
+ @Override
+ public int hashCode() {
+ return Boolean.hashCode(bool);
+ }
+}

src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtCompoundTag.java

@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) 2020-2021 DumbDogDiner <dumbdogdiner.com>. All rights reserved.
+ * Licensed under the MIT license, see LICENSE for more information...
+ */
+package com.dumbdogdiner.stickyapi.common.nbt;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.StringJoiner;
+
+/**
+ * A wrapper tag that allows working with Compound NBT tags as maps!
+ */
+public class NbtCompoundTag extends HashMap<String, NbtTag> implements NbtTag {
+
+ /**
+ * Creates a new {@link NbtCompoundTag} from an existing {@link Map}
+ * {@inheritDoc}
+ */
+ public NbtCompoundTag(Map<String, NbtTag> map) {
+ super(map);
+ }
+
+ /**
+ * Create a new, blank {@link NbtCompoundTag}
+ *
+ * {@inheritDoc}
+ */
+ public NbtCompoundTag() {
+ super();
+ }
+
+ /**
+ * Create a new {@link NbtCompoundTag} with an existing key and tag (useful for 1-element compound tags!)
+ * @param key The key to set
+ * @param tag The tag to assign
+ */
+ public NbtCompoundTag(String key, NbtTag tag){
+ super();
+ put(key, tag);
+ }
+
+ /**
+ * Constructs a new {@link NbtCompoundTag} from a given {@link JsonObject}
+ */
+ public static NbtCompoundTag fromJsonObject(JsonObject object){
+ NbtCompoundTag tag = new NbtCompoundTag();
+ for(String elementName : object.keySet()){
+ tag.put(elementName, NbtJsonAdapter.fromJson(object.get(elementName)));
+ }
+ return tag;
+ }
+
+ @Override
+ public @NotNull JsonElement toJson() {
+ JsonObject object = new JsonObject();
+ forEach((name, nbtTag) -> {
+ if(nbtTag instanceof NbtPrimitiveTag){
+ Object primitive = ((NbtPrimitiveTag<?>) nbtTag).asPrimitive();
+ if(primitive instanceof NbtNumberTag){
+ object.addProperty(name, ((NbtNumberTag) primitive).asPrimitive());
+ } else if(primitive instanceof NbtBooleanTag){
+ object.addProperty(name, ((NbtBooleanTag) primitive).asPrimitive());
+ } else if(primitive instanceof NbtStringTag){
+ object.addProperty(name, ((NbtStringTag) primitive).asPrimitive());
+ }
+ } else {
+ object.add(name, nbtTag.toJson());
+ }
+ });
+ return object;
+ }
+
+ @Override
+ public @NotNull String toNbtString() {
+ StringJoiner stringNbt = new StringJoiner(",", "{", "}");
+ forEach((name, nbtTag) -> {
+ StringJoiner element = new StringJoiner(":");
+ element.add(name);
+ element.add(nbtTag.toNbtString());
+ stringNbt.add(element.toString());
+ });
+ return stringNbt.toString();
+ }
+
+ /**
+ * Convenience method to add a number directly to the compound tag with a given key
+ * @return The original number
+ */
+ public @NotNull Number put(@NotNull String key, @NotNull Number n) {
+ put(key, new NbtNumberTag(n));
+ return n;
+ }
+
+ /**
+ * Convenience method to add a boolean directly to the compound tag with a given key
+ * @return The original boolean
+ */
+ public boolean put(@NotNull String key, boolean b) {
+ put(key, new NbtBooleanTag(b));
+ return b;
+ }
+
+ /**
+ * Convenience method to add a String directly to the compound tag with a given key
+ * @return The original String
+ */
+ public String put(@NotNull String key, @NotNull String s){
+ put(key, new NbtStringTag(s));
+ return s;
+ }
+
+}

src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtJsonAdapter.java

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2020-2021 DumbDogDiner <dumbdogdiner.com>. All rights reserved.
+ * Licensed under the MIT license, see LICENSE for more information...
+ */
+package com.dumbdogdiner.stickyapi.common.nbt;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonPrimitive;
+import lombok.experimental.UtilityClass;
+import org.jetbrains.annotations.NotNull;
+
+import java.text.MessageFormat;
+
+/**
+ * Utility class for easy creation of the appropriate {@link NbtTag} from an existing {@link JsonElement}
+ */
+@UtilityClass
+public final class NbtJsonAdapter {
+ /**
+ * Creates the appropriate tag from a given {@link JsonElement}, but never creates a {@link NbtJsonTag}
+ * @param element The incoming {@link JsonElement} to convert
+ * @return the new {@link NbtTag}
+ */
+ public static NbtTag fromJson(@NotNull JsonElement element) {
+ if(element.isJsonArray()){
+ return NbtListTag.fromJsonArray(element.getAsJsonArray());
+ } else if(element.isJsonObject()){
+ return NbtCompoundTag.fromJsonObject(element.getAsJsonObject());
+ } else if (element.isJsonPrimitive()) {
+ // TODO: Rewrite to look cleaner?
+ // https://github.com/DumbDogDiner/StickyAPI/pull/92/files#r575639999
+ JsonPrimitive primitive = element.getAsJsonPrimitive();
+ if(primitive.isBoolean()){
+ return NbtBooleanTag.fromPrimitive(primitive);
+ } else if(primitive.isNumber()){
+ return NbtNumberTag.fromPrimitive(primitive);
+ } else if(primitive.isString()){
+ return NbtStringTag.fromPrimitive(primitive);
+ } else {
+ throw new UnsupportedOperationException("Illegal type of NBT primitive");
+ }
+ } else if(element.isJsonNull()) {
+ return null;
+ } else {
+ throw new UnsupportedOperationException(MessageFormat.format("This type of JSONElement is unsupported ({0})", element.getClass().getName()));
+ }
+
+ }
+}

src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtJsonTag.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2020-2021 DumbDogDiner <dumbdogdiner.com>. All rights reserved.
+ * Licensed under the MIT license, see LICENSE for more information...
+ */
+package com.dumbdogdiner.stickyapi.common.nbt;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonElement;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * A special type of {@link NbtTag} that converts an arbitrary {@link JsonElement} into an appropriately escaped string as NBT
+ */
+public class NbtJsonTag implements NbtTag{
+ private final @NotNull JsonElement element;
+ private static final Gson G = new GsonBuilder()
+ // Make sure things aren't weirdly escaped, may need to turn this back on
+ .disableHtmlEscaping()
+ .create();
+
+ public NbtJsonTag(@NotNull JsonElement element) {
+ this.element = element;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public @NotNull JsonElement toJson() {
+ return element;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public @NotNull String toNbtString() {
+ return '\'' + G.toJson(element)
+ // Because minecraft json is a hack on a hack.....
+ // And sometimes the NBT is just json that gets quoted
+
+ .replaceAll("(?<!\\\\)[']", "\\\\'") // Escape single quotes
+ // FIXME: do we need to escape double quotes too?? In theory we don't as long as we are using a single quote style!
+ .replace("\n", "\\n") // Replace new lines with escaped versions
+ .replaceAll("\\+n", "\\\\n") // Fix formatting of any escaped new lines already in there
+ +'\'';
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ return ((other instanceof NbtJsonTag || other instanceof NbtStringTag)
+ && toNbtString().equals(((NbtTag) other).toNbtString()));
+ }
+
+ @Override
+ public int hashCode() {
+ return element.hashCode();
+ }
+}

src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtListTag.java

@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2020-2021 DumbDogDiner <dumbdogdiner.com>. All rights reserved.
+ * Licensed under the MIT license, see LICENSE for more information...
+ */
+package com.dumbdogdiner.stickyapi.common.nbt;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.StringJoiner;
+
+/**
+ * A wrapper class that allows the construction of or conversion (from JSON) of NBT List Tags
+ */
+
+public class NbtListTag extends ArrayList<NbtTag> implements NbtTag {
+ /**
+ * Generates a new, empty {@link NbtListTag}
+ * {@inheritDoc}
+ */
+ public NbtListTag() {
+ super();
+ }
+
+ /**
+ * Generate a new {@link NbtListTag} with elements from an existing array or individual objects
+ */
+ public NbtListTag(NbtTag ... tags){
+ super(Arrays.asList(tags));
+ }
+
+ /**
+ * Converts a JSON array into an NBT List tag of the native types
+ * @param arr The Json Array to convert
+ * @return the new {@link NbtListTag}
+ */
+ public static NbtListTag fromJsonArray(JsonArray arr){
+ NbtListTag listTag = new NbtListTag();
+ for(JsonElement jse : arr){
+ listTag.add(NbtJsonAdapter.fromJson(jse));
+ }
+ return listTag;
+ }
+
+ /**
+ * Creates an NBT tag that is a list of stringified JSON elements from source array
+ * @param arr Source JSON array to convert
+ * @return The newly converted NBT list tag
+ */
+ public static NbtListTag fromJsonArrayQuoted(JsonArray arr){
+ NbtListTag listTag = new NbtListTag();
+ for(JsonElement jse : arr){
+ listTag.add(new NbtJsonTag(jse));
+ }
+ return listTag;
+ }
+
+ @Override
+ public @NotNull JsonElement toJson() {
+ JsonArray array = new JsonArray();
+ for(NbtTag tag : this){
+ array.add(tag.toJson());
+ }
+ return array;
+ }
+
+ @Override
+ public @NotNull String toNbtString() {
+ StringJoiner joiner = new StringJoiner(",", "[", "]");
+ forEach(nbtTag -> joiner.add(nbtTag.toNbtString()));
+ return joiner.toString();
+ }
+
+ /**
+ * Creates a {@link NbtStringTag} of escaped NBT as a string
+ */
+ public NbtStringTag toNbtStringTag() {
+ return new NbtStringTag(toNbtString(), true);
+ }
+}