Revert "Use YAML instead of JSON (closes #11)"

This reverts commit fea65917

build.gradle

@@ -19,8 +19,6 @@ dependencies {
 		exclude(group: "net.fabricmc.fabric-api")
 	}
 
-	implementation "com.fasterxml.jackson.dataformat:jackson-dataformat-yaml:${project.jackson_version}"
-
 	compileOnly "org.projectlombok:lombok:${project.lombok_version}"
 	annotationProcessor "org.projectlombok:lombok:${project.lombok_version}"
 }

gradle.properties

@@ -13,5 +13,4 @@ org.gradle.jvmargs=-Xmx1G
 
 # Dependencies
 	cloth_config_version=4.8.3
-	lombok_version=1.18.12
-	jackson_version=2.12.0
+	lombok_version=1.18.12

src/main/java/me/lortseam/completeconfig/Config.java

@@ -1,32 +1,32 @@
 package me.lortseam.completeconfig;
 
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.module.SimpleModule;
-import com.fasterxml.jackson.dataformat.yaml.YAMLMapper;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonSyntaxException;
 import me.lortseam.completeconfig.api.ConfigCategory;
 import me.lortseam.completeconfig.data.CollectionMap;
 import me.lortseam.completeconfig.serialization.CollectionMapDeserializer;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
-import java.io.IOException;
 import java.util.List;
 
 public class Config extends CollectionMap {
 
     private static final Logger LOGGER = LogManager.getLogger();
 
-    Config(String modID, List<ConfigCategory> topLevelCategories, JsonNode yaml) {
+    Config(String modID, List<ConfigCategory> topLevelCategories, JsonElement json) {
         super("config." + modID);
         for (ConfigCategory category : topLevelCategories) {
             if (!fill(modTranslationKey, category)) {
                 continue;
             }
             try {
-                new YAMLMapper().registerModule(new SimpleModule()
-                        .addDeserializer(CollectionMapDeserializer.TYPE, new CollectionMapDeserializer(this, category.getConfigCategoryID()))
-                ).readValue(yaml.traverse(), CollectionMapDeserializer.TYPE);
-            } catch (IOException e) {
+                new GsonBuilder()
+                        .registerTypeAdapter(CollectionMapDeserializer.TYPE, new CollectionMapDeserializer(this, category.getConfigCategoryID()))
+                        .create()
+                        .fromJson(json, CollectionMapDeserializer.TYPE);
+            } catch (JsonSyntaxException e) {
                 LOGGER.warn("[CompleteConfig] An error occurred while trying to load the config for category " + category.getClass());
             }
         }

src/main/java/me/lortseam/completeconfig/ConfigHandler.java

@@ -1,10 +1,6 @@
 package me.lortseam.completeconfig;
 
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.module.SimpleModule;
-import com.fasterxml.jackson.databind.node.NullNode;
-import com.fasterxml.jackson.dataformat.yaml.YAMLMapper;
+import com.google.gson.*;
 import me.lortseam.completeconfig.api.ConfigCategory;
 import me.lortseam.completeconfig.api.ConfigOwner;
 import me.lortseam.completeconfig.gui.GuiBuilder;
@@ -18,6 +14,7 @@ import org.apache.commons.lang3.ArrayUtils;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
+import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.IOException;
 import java.io.Writer;
@@ -28,10 +25,11 @@ import java.util.*;
 
 public final class ConfigHandler {
 
-    private static final ObjectMapper MAPPER = new YAMLMapper().registerModule(new SimpleModule()
-            .addSerializer(CollectionSerializer.TYPE, new CollectionSerializer())
-            .addSerializer(EntrySerializer.TYPE, new EntrySerializer())
-    );
+    private static final Gson GSON = new GsonBuilder()
+            .registerTypeAdapter(CollectionSerializer.TYPE, new CollectionSerializer())
+            .registerTypeAdapter(EntrySerializer.TYPE, new EntrySerializer())
+            .setPrettyPrinting()
+            .create();
     private static final Logger LOGGER = LogManager.getLogger();
     private static final Map<Class<? extends ConfigOwner>, ConfigHandler> HANDLERS = new HashMap<>();
 
@@ -52,7 +50,7 @@ public final class ConfigHandler {
             return null;
         }
         String[] subPath = ArrayUtils.add(branch, 0, modID);
-        subPath[subPath.length - 1] = subPath[subPath.length - 1] + ".yaml";
+        subPath[subPath.length - 1] = subPath[subPath.length - 1] + ".json";
         Path jsonPath = Paths.get(FabricLoader.getInstance().getConfigDir().toString(), subPath);
         if (HANDLERS.values().stream().anyMatch(handler -> handler.jsonPath.equals(jsonPath))) {
             throw new IllegalArgumentException("A config of the mod " + modID + " with the specified branch " + Arrays.toString(branch) + " already exists!");
@@ -82,15 +80,17 @@ public final class ConfigHandler {
         this.guiBuilder = guiBuilder;
     }
 
-    private JsonNode load() {
+    private JsonElement load() {
         if(Files.exists(jsonPath)) {
             try {
-                return MAPPER.readTree(new FileReader(jsonPath.toString()));
-            } catch (IOException e) {
+                return GSON.fromJson(new FileReader(jsonPath.toString()), JsonElement.class);
+            } catch (FileNotFoundException e) {
+                throw new RuntimeException(e);
+            } catch (JsonSyntaxException e) {
                 LOGGER.warn("[CompleteConfig] An error occurred while trying to load the config " + jsonPath.toString());
             }
         }
-        return NullNode.instance;
+        return JsonNull.INSTANCE;
     }
 
     /**
@@ -124,7 +124,7 @@ public final class ConfigHandler {
             }
         }
         try(Writer writer = Files.newBufferedWriter(jsonPath)) {
-            MAPPER.writeValue(writer, config);
+            GSON.toJson(config, writer);
         } catch (IOException e) {
             throw new RuntimeException(e);
         }

src/main/java/me/lortseam/completeconfig/serialization/CollectionDeserializer.java

@@ -1,39 +1,31 @@
 package me.lortseam.completeconfig.serialization;
 
-import com.fasterxml.jackson.core.JsonParser;
-import com.fasterxml.jackson.databind.DeserializationContext;
-import com.fasterxml.jackson.databind.JsonDeserializer;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.JsonNodeFactory;
-import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.google.gson.*;
+import com.google.gson.reflect.TypeToken;
 import me.lortseam.completeconfig.data.Collection;
 import me.lortseam.completeconfig.data.CollectionMap;
 import me.lortseam.completeconfig.data.EntryMap;
 
-import java.io.IOException;
-import java.util.Iterator;
+import java.lang.reflect.Type;
+import java.util.Map;
 
-public class CollectionDeserializer extends JsonDeserializer<Collection> {
+public class CollectionDeserializer implements JsonDeserializer<Collection> {
 
-    public static final Class<Collection> TYPE = Collection.class;
+    public static final Type TYPE = new TypeToken<Collection>() {}.getType();
 
     @Override
-    public Collection deserialize(JsonParser parser, DeserializationContext context) throws IOException {
-        ObjectNode collections = new ObjectNode(JsonNodeFactory.instance);
-        ObjectNode entries = new ObjectNode(JsonNodeFactory.instance);
-        ObjectNode collection = parser.readValueAsTree();
-        Iterator<String> iterator = collection.fieldNames();
-        while (iterator.hasNext()) {
-            String key = iterator.next();
-            JsonNode value = collection.findValue(key);
-            if (value.isObject()) {
-                collections.set(key, value);
+    public Collection deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
+        JsonObject collections = new JsonObject();
+        JsonObject entries = new JsonObject();
+        for (Map.Entry<String, JsonElement> entry : json.getAsJsonObject().entrySet()) {
+            if (entry.getValue().isJsonObject()) {
+                collections.add(entry.getKey(), entry.getValue());
             } else {
-                entries.set(key, value);
+                entries.add(entry.getKey(), entry.getValue());
             }
         }
-        context.readValue(collections.traverse(), CollectionMap.class);
-        context.readValue(entries.traverse(), EntryMap.class);
+        context.deserialize(collections, new TypeToken<CollectionMap>() {}.getType());
+        context.deserialize(entries, new TypeToken<EntryMap>() {}.getType());
         return null;
     }
 

src/main/java/me/lortseam/completeconfig/serialization/CollectionMapDeserializer.java

@@ -1,23 +1,18 @@
 package me.lortseam.completeconfig.serialization;
 
-import com.fasterxml.jackson.core.JsonParser;
-import com.fasterxml.jackson.databind.DeserializationContext;
-import com.fasterxml.jackson.databind.JsonDeserializer;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.module.SimpleModule;
-import com.fasterxml.jackson.databind.type.TypeFactory;
-import com.fasterxml.jackson.dataformat.yaml.YAMLMapper;
+import com.google.gson.*;
+import com.google.gson.reflect.TypeToken;
 import me.lortseam.completeconfig.data.Collection;
 import me.lortseam.completeconfig.data.CollectionMap;
 
-import java.io.IOException;
+import java.lang.reflect.Type;
 import java.util.LinkedHashMap;
 import java.util.Map;
 
-public class CollectionMapDeserializer extends JsonDeserializer<CollectionMap> {
+public class CollectionMapDeserializer implements JsonDeserializer<CollectionMap> {
 
-    private static final YAMLMapper MAPPER = new YAMLMapper();
-    public static final Class<CollectionMap> TYPE = CollectionMap.class;
+    private static final Gson GSON = new Gson();
+    public static final Type TYPE = new TypeToken<CollectionMap>() {}.getType();
 
     private final Map<String, Collection> configMap;
     private final String collectionID;
@@ -32,28 +27,27 @@ public class CollectionMapDeserializer extends JsonDeserializer<CollectionMap> {
     }
 
     @Override
-    public CollectionMap deserialize(JsonParser parser, DeserializationContext context) throws IOException {
-        LinkedHashMap<String, JsonNode> map = MAPPER.readValue(parser, TypeFactory.defaultInstance().constructMapType(LinkedHashMap.class, String.class, JsonNode.class));
+    public CollectionMap deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
+        LinkedHashMap<String, JsonElement> map = GSON.fromJson(json, new TypeToken<LinkedHashMap<String, JsonElement>>() {}.getType());
         if (collectionID == null) {
-            for (Map.Entry<String, JsonNode> entry : map.entrySet()) {
-                deserializeCollection(entry.getKey(), entry.getValue());
-            }
+            map.forEach(this::deserializeCollection);
         } else {
             deserializeCollection(collectionID, map.get(collectionID));
         }
         return null;
     }
 
-    private void deserializeCollection(String collectionID, JsonNode node) throws IOException {
+    private void deserializeCollection(String collectionID, JsonElement element) {
         Collection collection = configMap.get(collectionID);
         if (collection == null) {
             return;
         }
-        new YAMLMapper().registerModule(new SimpleModule()
-                .addDeserializer(CollectionDeserializer.TYPE, new CollectionDeserializer())
-                .addDeserializer(CollectionMapDeserializer.TYPE, new CollectionMapDeserializer(collection.getCollections()))
-                .addDeserializer(EntryMapDeserializer.TYPE, new EntryMapDeserializer(collection.getEntries()))
-        ).readValue(node.traverse(), Collection.class);
+        new GsonBuilder()
+                .registerTypeAdapter(CollectionDeserializer.TYPE, new CollectionDeserializer())
+                .registerTypeAdapter(CollectionMapDeserializer.TYPE, new CollectionMapDeserializer(collection.getCollections()))
+                .registerTypeAdapter(EntryMapDeserializer.TYPE, new EntryMapDeserializer(collection.getEntries()))
+                .create()
+                .fromJson(element, Collection.class);
     }
 
 }

src/main/java/me/lortseam/completeconfig/serialization/CollectionSerializer.java

@@ -1,30 +1,21 @@
 package me.lortseam.completeconfig.serialization;
 
-import com.fasterxml.jackson.core.JsonGenerator;
-import com.fasterxml.jackson.databind.JsonSerializer;
-import com.fasterxml.jackson.databind.SerializerProvider;
+import com.google.gson.*;
+import com.google.gson.reflect.TypeToken;
 import me.lortseam.completeconfig.data.Collection;
-import me.lortseam.completeconfig.data.Entry;
 
-import java.io.IOException;
-import java.util.Map;
+import java.lang.reflect.Type;
 
-public class CollectionSerializer extends JsonSerializer<Collection> {
+public class CollectionSerializer implements JsonSerializer<Collection> {
 
-    public static final Class<Collection> TYPE = Collection.class;
+    public static final Type TYPE = new TypeToken<Collection>() {}.getType();
 
     @Override
-    public void serialize(Collection value, JsonGenerator generator, SerializerProvider serializers) throws IOException {
-        generator.writeStartObject();
-        for (Map.Entry<String, Collection> entry : value.getCollections().entrySet()) {
-            generator.writeFieldName(entry.getKey());
-            serializers.defaultSerializeValue(entry.getValue(), generator);
-        }
-        for (Map.Entry<String, Entry> entry : value.getEntries().entrySet()) {
-            generator.writeFieldName(entry.getKey());
-            serializers.defaultSerializeValue(entry.getValue(), generator);
-        }
-        generator.writeEndObject();
+    public JsonElement serialize(Collection src, Type typeOfSrc, JsonSerializationContext context) {
+        JsonObject jsonObject = new JsonObject();
+        src.getCollections().forEach((key, collection) -> jsonObject.add(key, context.serialize(collection)));
+        src.getEntries().forEach((key, entry) -> jsonObject.add(key, context.serialize(entry)));
+        return jsonObject;
     }
 
 }

src/main/java/me/lortseam/completeconfig/serialization/EntryDeserializer.java

@@ -1,19 +1,20 @@
 package me.lortseam.completeconfig.serialization;
 
-import com.fasterxml.jackson.core.JsonParseException;
-import com.fasterxml.jackson.core.JsonParser;
-import com.fasterxml.jackson.databind.DeserializationContext;
-import com.fasterxml.jackson.databind.JsonDeserializer;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonParseException;
+import com.google.gson.reflect.TypeToken;
 import me.lortseam.completeconfig.data.Entry;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
-import java.io.IOException;
+import java.lang.reflect.Type;
 
-public class EntryDeserializer<T> extends JsonDeserializer<Entry<T>> {
+public class EntryDeserializer<T> implements JsonDeserializer<Entry<T>> {
 
     private static final Logger LOGGER = LogManager.getLogger();
-    public static final Class<Entry> TYPE = Entry.class;
+    public static final Type TYPE = new TypeToken<Entry<?>>() {}.getType();
 
     private final Entry<T> configEntry;
 
@@ -22,11 +23,11 @@ public class EntryDeserializer<T> extends JsonDeserializer<Entry<T>> {
     }
 
     @Override
-    public Entry<T> deserialize(JsonParser parser, DeserializationContext context) {
+    public Entry<T> deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
         try {
-            T value = context.readValue(parser, configEntry.getType());
+            T value = context.deserialize(json, configEntry.getType());
             configEntry.setValue(value);
-        } catch (IOException e) {
+        } catch (JsonParseException e) {
             LOGGER.warn("[CompleteConfig] An error occurred while trying to load the config entry's value of field " + configEntry.getField() + ": " + e.getMessage());
         }
         return configEntry;

src/main/java/me/lortseam/completeconfig/serialization/EntryMapDeserializer.java

@@ -1,40 +1,35 @@
 package me.lortseam.completeconfig.serialization;
 
-import com.fasterxml.jackson.core.JsonParser;
-import com.fasterxml.jackson.databind.DeserializationContext;
-import com.fasterxml.jackson.databind.JsonDeserializer;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.module.SimpleModule;
-import com.fasterxml.jackson.databind.type.TypeFactory;
-import com.fasterxml.jackson.dataformat.yaml.YAMLMapper;
+import com.google.gson.*;
+import com.google.gson.reflect.TypeToken;
 import lombok.RequiredArgsConstructor;
-import me.lortseam.completeconfig.data.Entry;
 import me.lortseam.completeconfig.data.EntryMap;
+import me.lortseam.completeconfig.data.Entry;
 
-import java.io.IOException;
+import java.lang.reflect.Type;
 import java.util.LinkedHashMap;
-import java.util.Map;
 
 @RequiredArgsConstructor
-public class EntryMapDeserializer extends JsonDeserializer<EntryMap> {
+public class EntryMapDeserializer implements JsonDeserializer<EntryMap> {
 
-    private static final YAMLMapper MAPPER = new YAMLMapper();
-    public static final Class<EntryMap> TYPE = EntryMap.class;
+    private static final Gson GSON = new Gson();
+    public static final Type TYPE = new TypeToken<EntryMap>() {}.getType();
 
     private final EntryMap configMap;
 
     @Override
-    public EntryMap deserialize(JsonParser parser, DeserializationContext context) throws IOException {
-        LinkedHashMap<String, JsonNode> map = MAPPER.readValue(parser, TypeFactory.defaultInstance().constructMapType(LinkedHashMap.class, String.class, JsonNode.class));
-        for (Map.Entry<String, JsonNode> mapEntry : map.entrySet()) {
-            Entry<?> entry = configMap.get(mapEntry.getKey());
+    public EntryMap deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
+        LinkedHashMap<String, JsonElement> map = GSON.fromJson(json, new TypeToken<LinkedHashMap<String, JsonElement>>() {}.getType());
+        map.forEach((entryID, element) -> {
+            Entry<?> entry = configMap.get(entryID);
             if (entry == null) {
-                break;
+                return;
             }
-            new YAMLMapper().registerModule(new SimpleModule()
-                    .addDeserializer(EntryDeserializer.TYPE, new EntryDeserializer<>(entry))
-            ).readValue(mapEntry.getValue().traverse(), Entry.class);
-        }
+            new GsonBuilder()
+                    .registerTypeAdapter(EntryDeserializer.TYPE, new EntryDeserializer<>(entry))
+                    .create()
+                    .fromJson(element, new TypeToken<Entry<?>>() {}.getType());
+        });
         return null;
     }
 

src/main/java/me/lortseam/completeconfig/serialization/EntrySerializer.java

@@ -1,19 +1,19 @@
 package me.lortseam.completeconfig.serialization;
 
-import com.fasterxml.jackson.core.JsonGenerator;
-import com.fasterxml.jackson.databind.JsonSerializer;
-import com.fasterxml.jackson.databind.SerializerProvider;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonSerializationContext;
+import com.google.gson.JsonSerializer;
 import me.lortseam.completeconfig.data.Entry;
 
-import java.io.IOException;
+import java.lang.reflect.Type;
 
-public class EntrySerializer extends JsonSerializer<Entry> {
+public class EntrySerializer implements JsonSerializer<Entry> {
 
-    public static final Class<Entry> TYPE = Entry.class;
+    public static final Type TYPE = Entry.class;
 
     @Override
-    public void serialize(Entry entry, JsonGenerator generator, SerializerProvider serializers) throws IOException {
-        serializers.defaultSerializeValue(entry.getValue(), generator);
+    public JsonElement serialize(Entry entry, Type typeOfSrc, JsonSerializationContext context) {
+        return context.serialize(entry.getValue());
     }
 
 }