From c0352181e1c85a5bf3790f2587a063b66e6914ba Mon Sep 17 00:00:00 2001 From: BradBot_1 Date: Fri, 30 Jun 2023 03:00:59 +0100 Subject: [PATCH] FEAT: toml parser + toml compiler --- src/main/java/fun/bb1/toml/Toml.java | 68 ++++++++ src/main/java/fun/bb1/toml/TomlJBuilder.java | 165 +++++++++++++++++++ 2 files changed, 233 insertions(+) create mode 100644 src/main/java/fun/bb1/toml/Toml.java create mode 100644 src/main/java/fun/bb1/toml/TomlJBuilder.java diff --git a/src/main/java/fun/bb1/toml/Toml.java b/src/main/java/fun/bb1/toml/Toml.java new file mode 100644 index 0000000..32cd6d9 --- /dev/null +++ b/src/main/java/fun/bb1/toml/Toml.java @@ -0,0 +1,68 @@ +package fun.bb1.toml; + +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.time.OffsetDateTime; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.tomlj.TomlArray; +import org.tomlj.TomlParseError; +import org.tomlj.TomlParseResult; +import org.tomlj.TomlTable; + +public final class Toml { + + private Toml() { } + + public static final @NotNull Object parseString(@NotNull final String tomlString) { + TomlParseResult result = org.tomlj.Toml.parse(tomlString); + if (result.hasErrors()) { + System.err.println("While parsing a toml document [" + result.errors().size() + "] error(s) where found!"); + for (final @NotNull TomlParseError error : result.errors()) { + if (error.getMessage() == null || error.getMessage().equals("")) continue; + System.err.println(error.getMessage()); + } + } + return recurse(result); + } + + private static final @NotNull ITomlElement recurse(@NotNull final Object toml) { + if (toml instanceof TomlArray tomlArray) { + final @NotNull fun.bb1.toml.TomlArray newTomlArray = new fun.bb1.toml.TomlArray(); + for (@NotNull final Object tomlElement : tomlArray.toList()) { + newTomlArray.add(recurse(tomlElement)); + } + return newTomlArray; + } + if (toml instanceof TomlTable tomlTable) { + final @NotNull TomlObject tomlObject = new TomlObject(); + for (@NotNull final String key : tomlTable.keySet()) { + tomlObject.add(key, recurse(tomlTable.get(key))); + } + return tomlObject; + } + if (toml instanceof Number primitive) return new TomlPrimitive(primitive); + if (toml instanceof CharSequence primitive) return new TomlPrimitive(primitive.toString()); + if (toml instanceof Boolean primitive) return new TomlPrimitive(primitive); + if (toml instanceof Character primitive) return new TomlPrimitive(primitive); + if (toml instanceof LocalDate primitive) return new TomlPrimitive(primitive); + if (toml instanceof LocalTime primitive) return new TomlPrimitive(primitive); + if (toml instanceof LocalDateTime primitive) return new TomlPrimitive(primitive); + if (toml instanceof OffsetDateTime primitive) return new TomlPrimitive(primitive); + throw new IllegalArgumentException("The provided toml argument is invalid! " + toml.getClass()); // should never reach here + } + + public static final @NotNull String toToml(@NotNull final ITomlElement tomlElement) { + @NotNull final Object toml = recurse(tomlElement); + if (toml instanceof TomlTable tomlObject) return tomlObject.toToml(); + if (toml instanceof TomlArray tomlArray) return tomlArray.toToml(); + return toml.toString(); + } + + private static final @Nullable Object recurse(@NotNull final ITomlElement toml) { + return new TomlJBuilder().recurse(toml); + } + +} diff --git a/src/main/java/fun/bb1/toml/TomlJBuilder.java b/src/main/java/fun/bb1/toml/TomlJBuilder.java new file mode 100644 index 0000000..9558627 --- /dev/null +++ b/src/main/java/fun/bb1/toml/TomlJBuilder.java @@ -0,0 +1,165 @@ +package fun.bb1.toml; + +import java.lang.reflect.Constructor; +import java.lang.reflect.Field; +import java.lang.reflect.InaccessibleObjectException; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.Map; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.tomlj.TomlArray; +import org.tomlj.TomlInvalidTypeException; +import org.tomlj.TomlPosition; +import org.tomlj.TomlTable; +import org.tomlj.TomlVersion; + +import fun.bb1.exceptions.handler.ExceptionHandler; + +final class TomlJBuilder { + + private static final @NotNull Class TOML_TABLE = ExceptionHandler.handle(()->Class.forName("org.tomlj.MutableTomlTable")); + private static final @NotNull Constructor TOML_TABLE_CONSTRUCTOR = ExceptionHandler.handle(()->TOML_TABLE.getConstructor(TomlVersion.class, TomlPosition.class)); + private static final @NotNull Field TOML_TABLE_PROPERTIES = ExceptionHandler.handle(()->TOML_TABLE.getField("properties")); + + private static final @NotNull Class TOML_TABLE_ELEMENT = ExceptionHandler.handle(()->Class.forName("org.tomlj.MutableTomlTable$Element")); + private static final @NotNull Constructor TOML_TABLE_ELEMENT_CONSTRUCTOR = ExceptionHandler.handle(()->TOML_TABLE_ELEMENT.getConstructor(Object.class, TomlPosition.class)); + + private static final @NotNull Class TOML_ARRAY = ExceptionHandler.handle(()->Class.forName("org.tomlj.MutableTomlArray")); + private static final @NotNull Method TOML_ARRAY_CREATE = ExceptionHandler.handle(()->TOML_ARRAY.getMethod("create", TomlVersion.class, boolean.class)); + private static final @NotNull Method TOML_ARRAY_APPEND = ExceptionHandler.handle(()->TOML_ARRAY.getMethod("append", Object.class, TomlPosition.class)); + + private int row = 1; + private int column = 1; + + TomlJBuilder() { + try { + TOML_TABLE_CONSTRUCTOR.setAccessible(true); + TOML_TABLE_PROPERTIES.setAccessible(true); + TOML_TABLE_ELEMENT_CONSTRUCTOR.setAccessible(true); + TOML_ARRAY_CREATE.setAccessible(true); + TOML_ARRAY_APPEND.setAccessible(true); + } catch (InaccessibleObjectException | SecurityException e) { + System.err.println("Failed to open up the required fields for toml, please report this as a bug!"); + e.printStackTrace(); + } + } + + public final @Nullable Object recurse(@NotNull final ITomlElement toml) { + if (toml instanceof TomlPrimitive primitive) return primitive.getInner(); + if (toml instanceof fun.bb1.toml.TomlArray tomlArray) { + @Nullable final TomlArray array = buildArray(); + if (array == null) return null; + for (int i = 0; i < tomlArray.getSize(); i++) { + int row = this.row; + this.row++; + @NotNull final ITomlElement preConversionObject = tomlArray.get(i); + if (preConversionObject.isTomlArray() || preConversionObject.isTomlObject()) { + this.column++; + } + @Nullable final Object convertedObject = recurse(preConversionObject); + if (preConversionObject.isTomlArray() || preConversionObject.isTomlObject()) { + this.column--; + } + if (convertedObject == null) { + this.row--; + continue; + } + if (!appendToArray(array, convertedObject, row)) { + this.row--; + } + } + return array; + } + @NotNull final TomlObject tomlObject = toml.getAsTomlObject(); + @Nullable final TomlTable table = buildTable(); + if (table == null) return null; + for (@NotNull final String key : tomlObject) { + @NotNull final ITomlElement preConversionObject = tomlObject.get(key); + int row = this.row; + this.row++; + if (preConversionObject.isTomlArray() || preConversionObject.isTomlObject()) { + this.column++; + } + @Nullable final Object convertedObject = recurse(preConversionObject); + if (preConversionObject.isTomlArray() || preConversionObject.isTomlObject()) { + this.column--; + } + if (convertedObject == null) { + this.row--; + continue; + } + if (!putOnTable(table, key, convertedObject, row)) { + this.row--; + } + } + return tomlObject; + } + + private final @NotNull TomlPosition getPosition() { + return TomlPosition.positionAt(this.row, this.column); + } + + private final @Nullable TomlArray buildArray() { + return (TomlArray) new ExceptionHandler<>(()->TOML_ARRAY_CREATE.invoke(null, TomlVersion.LATEST)).catcher((e) -> { + System.err.println("Failed to load TomlArray instance via reflection, please report this as a bug!"); + e.printStackTrace(); + return null; + }).get(); + } + + private final boolean appendToArray(@NotNull final TomlArray tomlArray, @NotNull Object convertedObject, int row) { + try { + if (convertedObject instanceof Double || convertedObject instanceof Float) { + convertedObject = ((Number)convertedObject).floatValue(); + } else if (convertedObject instanceof Number num) { + convertedObject = num.intValue(); + } + TOML_ARRAY_APPEND.invoke(tomlArray, convertedObject, TomlPosition.positionAt(row, this.column)); + return true; + } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { + System.err.println("Failed to append to a TomlArray instance via reflection, please report this as a bug!"); + e.printStackTrace(); + } catch (TomlInvalidTypeException t) { + System.err.println("Failed to append to a TomlArray instance via reflection, this may be an issue with your Toml!"); + t.printStackTrace(); + } + return false; + } + + private final @Nullable TomlTable buildTable() { + return (TomlTable) new ExceptionHandler<>(()->TOML_TABLE_CONSTRUCTOR.newInstance(TomlVersion.LATEST, getPosition())).catcher((e) -> { + System.err.println("Failed to load TomlTable instance via reflection, please report this as a bug!"); + e.printStackTrace(); + return null; + }).get(); + } + + public final boolean putOnTable(@NotNull final TomlTable table, @NotNull final String key, @NotNull final Object convertedObject, int row) { + final @Nullable Map properties = getPropertiesOfTable(table); + if (properties == null) return false; + @Nullable final Object builtElement = buildTableElement(convertedObject); + if (builtElement == null) return false; + properties.put(key, builtElement); + return true; + } + + @SuppressWarnings("unchecked") + private final @Nullable Map getPropertiesOfTable(@NotNull final TomlTable tomlTable) { + return (Map) new ExceptionHandler<>(()->TOML_TABLE_PROPERTIES.get(tomlTable)).catcher((e) -> { + System.err.println("Failed to get TomlTable's properties via reflection, please report this as a bug!"); + e.printStackTrace(); + return null; + }).get(); + } + + private final @Nullable Object buildTableElement(@NotNull final Object toContain) { + return (TomlTable) new ExceptionHandler<>(()->TOML_TABLE_ELEMENT_CONSTRUCTOR.newInstance(toContain, getPosition())).catcher((e) -> { + System.err.println("Failed to load TomlTable$Element instance via reflection, please report this as a bug!"); + e.printStackTrace(); + return null; + }).get(); + } + +}