Merge pull request #5 from ZorTik/development

Development

Author: ZorTik

.idea/jarRepositories.xml

@@ -18,12 +18,17 @@ repositories {
         name = 'sonatype'
         url = "https://oss.sonatype.org/content/repositories/snapshots/"
     }
+    maven {
+        name = 'jitpack'
+        url = 'https://jitpack.io'
+    }
 }
 
 dependencies {
     implementation group: 'org.jetbrains', name: 'annotations', version: '20.1.0'
     compileOnly 'org.spigotmc:spigot-api:1.8.8-R0.1-SNAPSHOT'
     compileOnly 'org.projectlombok:lombok:1.18.24'
+    compileOnly 'com.github.ZorTik:ContainrGUI:0.4.1'
     annotationProcessor 'org.projectlombok:lombok:1.18.24'
 }
 

build.gradle

@@ -0,0 +1,26 @@
+package me.zort.configurationlib;
+
+import me.zort.configurationlib.configuration.bukkit.BukkitFileConfigurationNode;
+import me.zort.configurationlib.configuration.virtual.VirtualSectionNode;
+import org.bukkit.plugin.Plugin;
+
+import java.io.File;
+
+public final class ConfigurationLib {
+
+    private ConfigurationLib() {
+    }
+
+    public static BukkitFileConfigurationNode bukkit(File file) {
+        return ConfigurationLibBukkit.of(ConfigurationLibBukkit.prepareDataFile(file));
+    }
+
+    public static BukkitFileConfigurationNode bukkit(Plugin plugin, String name) {
+        return ConfigurationLibBukkit.of(ConfigurationLibBukkit.prepareDataFile(plugin, name));
+    }
+
+    public static VirtualSectionNode virtual() {
+        return new VirtualSectionNode();
+    }
+
+}

src/main/java/me/zort/configurationlib/ConfigurationLib.java

@@ -2,6 +2,7 @@
 
 import me.zort.configurationlib.util.Placeholders;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 /**
  * Node deserializer class.
@@ -11,6 +12,11 @@
  */
 public interface NodeDeserializer<T, L> extends NodeAdapter<T, L> {
 
+    @Nullable
+    default T preBuildInstance(Class<T> deserializeInto, NodeContext<Node<L>, L> context, Placeholders placeholders) {
+        return null;
+    }
+
     /**
      * Deserializes the given context to deserializeInto object.
      * Return value of this function should return deserializeInto

src/main/java/me/zort/configurationlib/NodeDeserializer.java

@@ -10,6 +10,7 @@
 import me.zort.configurationlib.annotation.ThisNodeId;
 import me.zort.configurationlib.util.NodeTypeToken;
 import me.zort.configurationlib.util.Placeholders;
+import me.zort.configurationlib.util.ReflectionHelper;
 import me.zort.configurationlib.util.Validator;
 import org.apache.commons.lang.ArrayUtils;
 import org.jetbrains.annotations.ApiStatus;
@@ -35,7 +36,8 @@
 public abstract class SectionNode<L> implements Node<L> {
 
     private final Map<Class<?>, NodeAdapter<?, L>> adapters = new ConcurrentHashMap<>();
-    @Nullable
+
+    @Getter(onMethod_ = {@Nullable})
     private final SectionNode<L> parent;
     private LogAdapter logAdapter;
     @Setter
@@ -55,11 +57,10 @@ public SectionNode(@Nullable SectionNode<L> parent, LogAdapter logAdapter) {
     }
 
     @ApiStatus.Internal
-    public abstract Node<L> createNode(String key, Object value, NodeTypeToken<?> type);
+    public abstract Node<L> createNode(String key, @Nullable Object value, NodeTypeToken<?> type);
     // Key is always definitive.
     public abstract void deleteNode(String key);
     public abstract void set(String key, Node<L> node);
-    public abstract Node<L> get(String path);
     public abstract Collection<Node<L>> getNodes();
 
     public void clear() {
@@ -100,6 +101,15 @@ public void unregisterAdapter(Class<?> type) {
         adapters.remove(type);
     }
 
+    /**
+     * Creates and sets new section to the source.
+     *
+     * @param key The key/path of the section.
+     */
+    public void createSection(String key) {
+        set(key, createNode(key, null, NodeTypes.SECTION));
+    }
+
     /**
      * Updates this node's values from the provided mapped
      * object.
@@ -129,7 +139,7 @@ public void set(Object from) {
         content.forEach(this::set);
     }
 
-    public void set(String key, Object value) {
+    public void set(String key, @Nullable Object value) {
         if(isContextDebug() && isHighestLevel()) {
             doLog("Highest level inspection:");
             doLog("Before update:");
@@ -187,17 +197,40 @@ public <T> T map(Class<T> typeClass) {
         return map(typeClass, new Placeholders());
     }
 
+    @SuppressWarnings("rawtypes, unchecked")
     public <T> T map(Class<T> typeClass, Placeholders placeholders) {
         try {
             if(Primitives.isWrapperType(Primitives.wrap(typeClass))) {
                 // We cannot map sections to primitive types since
                 // sections are not leaf nodes.
                 return null;
             }
-            Constructor<T> declaredConstructor = typeClass.getDeclaredConstructor();
-            declaredConstructor.setAccessible(true);
-            return map(declaredConstructor.newInstance(), placeholders);
-        } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
+            try {
+                Constructor<T> declaredConstructor = typeClass.getDeclaredConstructor();
+                declaredConstructor.setAccessible(true);
+                return map(declaredConstructor.newInstance(), placeholders);
+            } catch(NoSuchMethodException e1) {
+                T instance = null;
+
+                try {
+                    // Use custom pre-build strategy first to assure correct
+                    // object creation.
+                    NodeDeserializer deserializer = obtainAdapter(typeClass, NodeDeserializer.class);
+                    Object tempPreBuiltInstance;
+                    if (deserializer != null && (tempPreBuiltInstance = deserializer.preBuildInstance(typeClass, getContext(), placeholders)) != null) {
+                        instance = (T) tempPreBuiltInstance;
+                    }
+                } catch(Exception e2) {
+                    debug(e2.getMessage());
+                    if (isContextDebug()) e2.printStackTrace();
+                }
+
+                if (instance == null)
+                    throw new RuntimeException("Cannot create instance of " + typeClass.getName() + "!");
+
+                return map(instance, placeholders);
+            }
+        } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
             throw new RuntimeException(e);
         }
     }
@@ -222,18 +255,20 @@ public <T> T map(T obj, Placeholders placeholders) {
     public <T> T map(T obj, Placeholders placeholders, boolean useCustomAdapters) {
         Class<?> typeClass = obj.getClass();
         if(Primitives.isWrapperType(Primitives.wrap(typeClass))) {
+            debug(String.format("Cannot map section to primitive type for %s", typeClass.getName()));
             return null;
         }
 
         NodeDeserializer nodeDeserializer = useCustomAdapters ? obtainAdapter(obj, NodeDeserializer.class) : null;
-        if(nodeDeserializer !=  null) {
+        if(nodeDeserializer != null) {
             NodeContext<Node<L>, L> context = getContext();
             Object deserialized = nodeDeserializer.deserialize(obj, context, placeholders);
             if(!obj.getClass().isAssignableFrom(deserialized.getClass())) {
                 throw new RuntimeException(String.format("Deserialized object is not assignable to the provided type! (%s -> %s)",
                         obj.getClass().getName(),
                         deserialized.getClass().getName()));
             }
+            debug(String.format("Deserialized object %s using adapter %s", deserialized, nodeDeserializer.getClass().getName()));
             return (T) deserialized;
         }
 
@@ -243,13 +278,16 @@ public <T> T map(T obj, Placeholders placeholders, boolean useCustomAdapters) {
         for(Field field : typeClass.getDeclaredFields()) {
             if(Modifier.isTransient(field.getModifiers())) {
                 // Transient fields are skipped.
+                debug(String.format("Skipping transient field %s", field.getName()));
                 continue;
             }
             field.setAccessible(true);
             Object value = Defaults.defaultValue(field.getType());
             if(String.class.equals(field.getType()) && field.isAnnotationPresent(ThisNodeId.class)) {
                 value = getName();
+                debug(String.format("Field %s is mapped to this node id %s", field.getName(), value));
             } else if(nodeCandidates.containsKey(field.getName())) {
+                debug("Found node for field " + field.getName());
                 Object builtValue = buildValue(field, nodeCandidates.get(field.getName()), placeholders);
                 if(builtValue != null) {
                     value = builtValue;
@@ -286,25 +324,58 @@ public <T> T map(T obj, Placeholders placeholders, boolean useCustomAdapters) {
     public Object buildValue(Field field, Node<L> node, Placeholders placeholders) {
         Object value = null;
 
+        debug("Building value for field " + field.getName());
+
         if(node instanceof SimpleNode && isPrimitive(field.getType())) {
             value = ((SimpleNode<L>) node).get();
+            debug(String.format("Field %s is mapped to simple node %s", field.getName(), value));
         } else if(node instanceof SectionNode) {
             Class<?> contentType;
             if(List.class.isAssignableFrom(field.getType())
             && !isPrimitive(contentType = (Class<?>) ((ParameterizedType) field.getGenericType()).getActualTypeArguments()[0])) {
                 List list = new ArrayList();
                 ((SectionNode<Object>) node).getNodes(NodeTypes.SECTION)
                         .forEach(sn -> {
-                            list.add(sn.map(contentType));
+                            if (SectionNode.class.isAssignableFrom(contentType)) {
+                                list.add(sn);
+                            } else {
+                                list.add(sn.map(contentType));
+                            }
                         });
+                debug(String.format("Field %s is mapped to list of sections %s", field.getName(), list));
                 return list;
+            } else if (SectionNode.class.isAssignableFrom(field.getType())) {
+                value = node;
+                debug(String.format("Field %s is mapped to section node %s", field.getName(), value));
             } else {
                 value = ((SectionNode<L>) node).map(field.getType());
+                debug(String.format("Field %s is mapped to section node %s", field.getName(), value));
             }
         }
         return value;
     }
 
+    @Nullable
+    public Node<L> get(String path) {
+        Map<String, Node<L>> children = new HashMap<>();
+
+        for (Node<L> node : getNodes()) {
+            children.put(node.getName(), node);
+        }
+
+        Node<L> current = this;
+        for(String key : path.split("\\.")) {
+            if(!(current instanceof SectionNode)) {
+                // Path points nowhere.
+                return null;
+            }
+            current = current == this
+                    ? children.get(key)
+                    : ((SectionNode<L>) current).get(key);
+        }
+        return current;
+    }
+
     public SimpleNode<L> getSimple(String path) {
         return (SimpleNode<L>) get(path);
     }
@@ -322,6 +393,10 @@ public <T extends Node<?>> List<T> getNodes(NodeTypeToken<T> type) {
                 .collect(Collectors.toList());
     }
 
+    public boolean has(String path) {
+        return get(path) != null;
+    }
+
     public NodeContext<Node<L>, L> getContext() {
         NodeContext<Node<L>, L> context = new NodeContext<>(this);
         getNodes().forEach(node -> context.set(node.getName(), node));
@@ -361,15 +436,20 @@ private boolean isPrimitive(Class<?> clazz) {
         return Primitives.isWrapperType(Primitives.wrap(clazz)) || String.class.equals(clazz);
     }
 
-    @SuppressWarnings("rawtypes, unchecked")
+    @SuppressWarnings("rawtypes")
     private <T extends NodeAdapter> T obtainAdapter(Object toBeSerialized, Class<T> adapterTypeClass) {
+        return obtainAdapter(toBeSerialized.getClass(), adapterTypeClass);
+    }
+
+    @SuppressWarnings("rawtypes, unchecked")
+    private <T extends NodeAdapter> T obtainAdapter(Class<?> toBeSerialized, Class<T> adapterTypeClass) {
         Validator.requireAnyType(adapterTypeClass, NodeSerializer.class, NodeDeserializer.class);
 
-        // I allow users tto define their own serializers.
+        // I allow users to define their own serializers.
         // @see NodeSerializer
         for (Class<?> aClass : adapters.keySet()) {
             NodeAdapter<?, L> nodeAdapter = adapters.get(aClass);
-            if(adapterTypeClass.isAssignableFrom(nodeAdapter.getClass()) && aClass.isAssignableFrom(toBeSerialized.getClass())) {
+            if(adapterTypeClass.isAssignableFrom(nodeAdapter.getClass()) && aClass.isAssignableFrom(toBeSerialized)) {
                 return (T) nodeAdapter;
             }
         }
@@ -394,7 +474,7 @@ public boolean isHighestLevel() {
         return parent == null;
     }
 
-    private void debug(String message) {
+    public void debug(String message) {
         if (isContextDebug()) {
             getContextLogAdapter().log(Level.INFO, message);
         }
@@ -414,7 +494,7 @@ private LogAdapter getContextLogAdapter() {
     private boolean makeContextCheck(Predicate<SectionNode<L>> test) {
         if(test.test(this))
             return true;
-        return parent != null && test.test(parent);
+        return parent != null && parent.makeContextCheck(test);
     }
 
     public static class DefaultNodeSerializer<L> implements NodeSerializer<Object, L> {
@@ -437,10 +517,6 @@ public void serialize(NodeContext context, Object from) {
                     } else {
                         name = field.getName();
                     }
-                /*getNodes().stream()
-                        .filter(n -> n.getName().equals(name))
-                        .findFirst()
-                        .ifPresent(node -> node.set(value));*/
                     context.set(name, value);
                 } catch (IllegalAccessException e) {
                     e.printStackTrace();

src/main/java/me/zort/configurationlib/SectionNode.java

@@ -13,6 +13,8 @@ default Object orElse(Object other) {
     }
 
     default String getAsString() throws ConfigurationException {
+        if (get() == null) return null;
+
         if(!isString()) throw new ConfigurationException(this, "Node " + getName() + " is not string!");
         return (String) get();
     }