Merge branch 'refs/heads/feat-gui' into dev

# Conflicts:
#	common/base/src/main/java/it/angrybear/yagl/utils/ObjectUtils.java
#	item/bukkit/src/test/java/it/angrybear/yagl/listeners/PersistentListenerTest.java

Author: fulminazzo

README.md

@@ -2,7 +2,8 @@
 
 Its core functions relate to the [Bukkit project](https://dev.bukkit.org/), but one can use the **base** modules across any preferred platform.
 
-Since every module provides a **serializer** one, to load and save the objects, it is possible to store or create **GUIs** and **custom Items** in unrelated platforms;
+Since every module provides a **serializer** one to load and save the objects,
+it is possible to store or create **GUIs** and **custom Items** in unrelated platforms;
 then, send the actual data to a [Bukkit](https://dev.bukkit.org/) backend and display it.
 
 For example, a `/hub` plugin that works with [BungeeCord](https://www.spigotmc.org/wiki/bungeecord/) or [Velocity](https://papermc.io/software/velocity).

build.gradle

@@ -112,7 +112,7 @@ allprojects {
         }
 
         if (!projectName.contains("-"))
-            subprojects.findAll { !it.name.equals(TEST_MODULE) } .each {api project(it.path)}
+            subprojects.findAll { (it.name != TEST_MODULE) } .each {api project(it.path)}
 
         testCompileOnly libs.lombok
         testAnnotationProcessor libs.lombok

common/base/src/main/java/it/angrybear/yagl/utils/ObjectUtils.java

@@ -3,20 +3,102 @@
 import it.fulminazzo.fulmicollection.objects.Refl;
 import it.fulminazzo.fulmicollection.structures.Tuple;
 import it.fulminazzo.fulmicollection.utils.ReflectionUtils;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.lang.reflect.Field;
-import java.util.Collection;
-import java.util.LinkedHashMap;
-import java.util.Map;
+import java.lang.reflect.*;
+import java.util.*;
 import java.util.stream.Collectors;
 
 /**
  * The type Object utils.
  */
-public class ObjectUtils {
+@SuppressWarnings("unchecked")
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public final class ObjectUtils {
     private static final String EMPTY_IDENTIFIER = "";
 
+    /**
+     * Copies the given object to a new one.
+     *
+     * @param <T> the type of the object to copy from
+     * @param t   the object to copy from
+     * @return the copy
+     */
+    public static <T> T copy(final @NotNull T t) {
+        Class<? extends T> clazz = (Class<? extends T>) t.getClass();
+        try {
+            ReflectionUtils.getConstructor(clazz);
+        } catch (Exception e) {
+            // Get the most abstract class
+            Class<?> c = clazz;
+            Class<?>[] interfaces;
+            while ((interfaces = c.getInterfaces()).length != 0) {
+                Class<?> tmp = interfaces[0];
+                if (!tmp.equals(Iterable.class) && !tmp.getSimpleName().startsWith("Abstract"))
+                    c = tmp;
+                else break;
+            }
+            clazz = ReflectionUtils.getClass(c.getCanonicalName() + "Impl");
+        }
+        return copy(t, clazz);
+    }
+
+    /**
+     * Copies the given object to a new one using the provided class.
+     * If an interface is provided, it tries to convert it to a non-abstract implementation by appending <i>Impl</i>.
+     * If no such class is found, an {@link IllegalArgumentException} is thrown.
+     *
+     * @param <T>   the type of the object to copy from
+     * @param <O>   the type of the returned object
+     * @param t     the object to copy from
+     * @param clazz the class to copy to
+     * @return the copy
+     */
+    public static <T, O extends T> O copy(final @NotNull T t, @NotNull Class<O> clazz) {
+        if (clazz.isInterface() || Modifier.isAbstract(clazz.getModifiers()))
+            try {
+                clazz = ReflectionUtils.getClass(clazz.getCanonicalName() + "Impl");
+            } catch (IllegalArgumentException e) {
+                throw new IllegalArgumentException(String.format("Could not copy object to abstract class '%s': no '%sImpl' class found",
+                        clazz.getCanonicalName(), clazz.getCanonicalName()));
+            }
+
+        Refl<O> object = new Refl<>(clazz, new Object[0]);
+        for (final Field field : object.getNonStaticFields())
+            try {
+                Object obj1 = ReflectionUtils.get(field, t);
+                if (obj1 instanceof Collection) {
+                    Class<?> tmpClass = obj1.getClass();
+                    // In the case of creation with Arrays.asList()
+                    if (tmpClass.getCanonicalName().equals(Arrays.class.getCanonicalName() + ".ArrayList"))
+                        tmpClass = ArrayList.class;
+                    Class<Collection<Object>> finalClass = (Class<Collection<Object>>) tmpClass;
+                    obj1 = ((Collection<?>) obj1).stream()
+                            .collect(Collectors.toCollection(() -> new Refl<>(finalClass, new Object[0]).getObject()));
+                } else if (obj1 instanceof Map) {
+                    Map<Object, Object> map = new HashMap<>();
+                    ((Map<Object, Object>) obj1).putAll(map);
+                    obj1 = map;
+                } else if (obj1 != null)
+                    if (obj1.getClass().isArray()) {
+                        Object[] tmp = (Object[]) obj1;
+                        Object[] arr = (Object[]) Array.newInstance(obj1.getClass().getComponentType(), tmp.length);
+                        System.arraycopy(tmp, 0, arr, 0, arr.length);
+                        obj1 = arr;
+                    } else
+                        try {
+                            Method copy = obj1.getClass().getDeclaredMethod("copy");
+                            obj1 = ReflectionUtils.setAccessible(copy).invoke(obj1);
+                        } catch (InvocationTargetException | NoSuchMethodException | IllegalAccessException ignored) {}
+                object.setFieldObject(field, obj1);
+            } catch (IllegalArgumentException ignored) {}
+
+        return object.getObject();
+    }
+
     /**
      * Prints the given object in a JSON format.
      * If the object (or an object contained in it) is "empty",

common/base/src/test/java/it/angrybear/yagl/utils/ObjectUtilsTest.java

@@ -0,0 +1,77 @@
+package it.angrybear.yagl.utils;
+
+import org.jetbrains.annotations.NotNull;
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class ObjectUtilsTest {
+
+    @Test
+    void testCopyOfNoInterface() {
+        Object current = new CopyNoInterface("hello");
+        Object o = ObjectUtils.copy(current);
+        assertInstanceOf(CopyNoInterfaceImpl.class, o);
+        assertNotEquals(current, o);
+    }
+
+    @Test
+    void testCopyOfIterable() {
+        Object current = new CopyIterable("hello");
+        Object o = ObjectUtils.copy(current);
+        assertInstanceOf(CopyIterableImpl.class, o);
+        assertNotEquals(current, o);
+    }
+
+    @Test
+    void testCopyOfData() {
+        GeneralCopy c1 = new GeneralCopy();
+        GeneralCopy c2 = ObjectUtils.copy(c1);
+        assertNotEquals(c1.list.getClass(), c2.list.getClass());
+        assertIterableEquals(c1.list, c2.list);
+        assertNotEquals(c1.array, c2.array);
+        assertArrayEquals(c1.array, c2.array);
+        assertNotEquals(c1.copiable, c2.copiable);
+    }
+
+    private static class GeneralCopy {
+        List<String> list = Arrays.asList("hello", "world");
+        String[] array = new String[]{"hello", "world"};
+        GeneralCopiable copiable = new GeneralCopiable();
+    }
+
+    private static class GeneralCopiable {
+
+        public GeneralCopiable copy() {
+            return new GeneralCopiable();
+        }
+    }
+
+    private static class CopyIterableImpl { }
+
+    private static class CopyIterable implements Iterable<String> {
+
+        public CopyIterable(String s) {
+
+        }
+
+        @NotNull
+        @Override
+        public Iterator<String> iterator() {
+            return null;
+        }
+    }
+
+    private static class CopyNoInterfaceImpl { }
+
+    private static class CopyNoInterface {
+
+        public CopyNoInterface(String s) {
+
+        }
+    }
+}

common/serializer/src/main/java/it/angrybear/yagl/parsers/TypedParser.java

@@ -6,10 +6,9 @@
 import it.fulminazzo.yamlparser.configuration.IConfiguration;
 import it.fulminazzo.yamlparser.parsers.CallableYAMLParser;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 
 /**
- * This parser allows to parse an object using the {@link CallableYAMLParser} methods.
+ * This parser allows parsing an object using the {@link CallableYAMLParser} methods.
  * However, it forces the saved object to store a <i>type</i> field, that contains the name of the class of the original object.
  * Upon loading, this class is retrieved (and will throw errors for invalid values) to recreate the object.
  *
@@ -34,7 +33,7 @@ public TypedParser(final @NotNull Class<C> clazz) {
 
     @SuppressWarnings("unchecked")
     @Override
-    protected @NotNull TriConsumer<@NotNull IConfiguration, @NotNull String, @Nullable C> getDumper() {
+    protected TriConsumer<IConfiguration, String, C> getDumper() {
         return (c, s, g) -> {
             super.getDumper().accept(c, s, g);
             if (g == null) return;

common/serializer/src/main/java/it/angrybear/yagl/parsers/YAGLParser.java

@@ -12,7 +12,7 @@ public final class YAGLParser {
 
     /**
      * Adds all the parsers from the {@link it.angrybear.yagl.parsers} package to {@link FileConfiguration}.
-     * @deprecated This will NOT add module specific parsers. It is recommended to look for the <b>&lt;module&gt;YAGLParser</b> class instead.
+     * @deprecated This will NOT add module-specific parsers. It is recommended to look for the <b>&lt;module&gt;YAGLParser</b> class instead.
      */
     @Deprecated
     public static void addAllParsers() {

common/serializer/src/main/java/it/angrybear/yagl/utils/ParserUtils.java

@@ -50,7 +50,9 @@ public final class ParserUtils {
     public static <C> @NotNull String classToType(final @NotNull Class<C> coreClass, final @NotNull Class<? extends C> toConvert) {
         final String mainClassName = coreClass.getSimpleName();
         String name = toConvert.getSimpleName();
+        if (name.startsWith(mainClassName)) name = name.substring(mainClassName.length());
         if (name.endsWith(mainClassName)) name = name.substring(0, name.length() - mainClassName.length());
+        if (name.equals("Impl")) name = "default";
         name = FileUtils.formatStringToYaml(name);
         return name.replace("-", "_").toUpperCase();
     }

gradle/libs.versions.toml

@@ -1,8 +1,8 @@
 [versions]
 delombok = "8.4"
 
-fulmicollection = "1.5.1"
-yamlparser = "1.6.1"
+fulmicollection = "1.5.2"
+yamlparser = "1.6.2"
 
 spigot = "1.14-R0.1-SNAPSHOT"
 spigot_obsolete = "1.8.8-R0.1-SNAPSHOT"
@@ -14,7 +14,7 @@ annotations = "24.1.0"
 
 junit = "5.9.1"
 mockito = "4.11.0"
-jbukkit = "2.0"
+jbukkit = "2.1"
 
 [libraries]
 fulmicollection = { module = "it.fulminazzo:FulmiCollection", version.ref = "fulmicollection" }

gui/base/build.gradle

@@ -0,0 +1,3 @@
+dependencies {
+    api project(':item:item-base')
+}