complete editor module

Author: HSGamer

editor/src/main/java/io/github/projectunified/minigamecore/editor/Editor.java

@@ -5,21 +5,46 @@
 import java.util.Map;
 import java.util.Optional;
 
-public interface Editor<A, T> extends EditorAction<A> {
-    Map<String, EditorAction<A>> actions();
+/**
+ * The Editor
+ *
+ * @param <T> the type of the exported object
+ */
+public interface Editor<T> extends EditorAction {
+    /**
+     * The map of all available actions of the editor
+     *
+     * @return the action map
+     */
+    Map<String, EditorAction> actions();
 
+    /**
+     * Reset the editor
+     */
     void reset();
 
+    /**
+     * Get an object representing the status of the editor
+     *
+     * @return the status
+     */
     Object status();
 
-    Optional<T> export(A actor);
+    /**
+     * Export the object from the editor
+     *
+     * @param actor the actor
+     * @return the object if it's exported successfully, otherwise empty
+     */
+    Optional<T> export(EditorActor actor);
 
+    /**
+     * Migrate from the object
+     *
+     * @param data the object
+     */
     void migrate(T data);
 
-    default boolean sendActionUsage(A actor) {
-        return false;
-    }
-
     @Override
     default String description() {
         return getClass().getSimpleName();
@@ -31,16 +56,16 @@ default String usage() {
     }
 
     @Override
-    default Collection<String> complete(A actor, String[] args) {
+    default Collection<String> complete(EditorActor actor, String[] args) {
         if (args.length == 0) {
             return Collections.emptyList();
         }
-        Map<String, EditorAction<A>> actions = actions();
+        Map<String, EditorAction> actions = actions();
         if (args.length == 1) {
             return actions.keySet();
         }
         String actionName = args[0];
-        EditorAction<A> action = actions.get(actionName);
+        EditorAction action = actions.get(actionName);
         if (action == null) {
             return Collections.emptyList();
         }
@@ -49,12 +74,13 @@ default Collection<String> complete(A actor, String[] args) {
         return action.complete(actor, subArgs);
     }
 
-    default boolean execute(A actor, String[] args) {
+    @Override
+    default boolean execute(EditorActor actor, String[] args) {
         if (args.length == 0) {
-            return sendActionUsage(actor);
+            return actor.sendUsage(this);
         }
         String command = args[0];
-        EditorAction<A> action = actions().get(command);
+        EditorAction action = actions().get(command);
         if (action == null) {
             return false;
         }

editor/src/main/java/io/github/projectunified/minigamecore/editor/EditorAction.java

@@ -3,19 +3,51 @@
 import java.util.Collection;
 import java.util.Collections;
 
-public interface EditorAction<A> {
-    boolean execute(A actor, String[] args);
+/**
+ * An action of the editor
+ */
+public interface EditorAction {
+    /**
+     * Execute the action
+     *
+     * @param actor the actor
+     * @param args  the arguments
+     * @return true if the action is executed successfully
+     */
+    boolean execute(EditorActor actor, String[] args);
 
+    /**
+     * Get the description of the action
+     *
+     * @return the description
+     */
     String description();
 
-    default Collection<String> complete(A actor, String[] args) {
+    /**
+     * Get the completion suggestions, given the arguments
+     *
+     * @param actor the action
+     * @param args  the argument
+     * @return the suggestions
+     */
+    default Collection<String> complete(EditorActor actor, String[] args) {
         return Collections.emptyList();
     }
 
+    /**
+     * Get the usage of the action
+     *
+     * @return the usage
+     */
     default String usage() {
         return "";
     }
 
+    /**
+     * Check if the action requires arguments
+     *
+     * @return true if it does
+     */
     default boolean requiresArgs() {
         return !usage().isEmpty();
     }

editor/src/main/java/io/github/projectunified/minigamecore/editor/EditorActor.java

@@ -0,0 +1,30 @@
+package io.github.projectunified.minigamecore.editor;
+
+/**
+ * The actor that interacts the editor
+ */
+public interface EditorActor {
+    /**
+     * Send the message
+     *
+     * @param message the message
+     * @param success true if it's a success message
+     */
+    void sendMessage(String message, boolean success);
+
+    /**
+     * Send the usage of the action
+     *
+     * @param action the action
+     * @return true if the usage is sent successfully
+     */
+    boolean sendUsage(EditorAction action);
+
+    /**
+     * Send the usage of the editor
+     *
+     * @param editor the editor
+     * @return true if the usage is sent successfully
+     */
+    boolean sendUsage(Editor<?> editor);
+}

editor/src/main/java/io/github/projectunified/minigamecore/editor/EditorStatusDisplay.java

@@ -3,25 +3,103 @@
 import java.lang.reflect.Array;
 import java.util.*;
 
-public abstract class EditorStatusDisplay<B, T> {
+/**
+ * The helper class to handle editor status
+ *
+ * @param <B> the builder
+ * @param <S> the section
+ * @param <T> the object that is built from the builder
+ */
+public abstract class EditorStatusDisplay<B, S, T> {
+    /**
+     * Create a new builder
+     *
+     * @return the builder
+     */
     protected abstract B newBuilder();
 
-    protected abstract void appendPadding(B builder, int level);
-
-    protected abstract void appendKey(B builder, String key, boolean fromCollection);
-
-    protected abstract void appendSize(B builder, int size);
-
-    protected abstract void appendValue(B builder, Object value, int level, Editor<?, ?> editor);
-
+    /**
+     * Create a new section
+     *
+     * @param builder the builder
+     * @return the section
+     */
+    protected abstract S newSection(B builder);
+
+    /**
+     * Add padding to the section
+     *
+     * @param section the section
+     * @param level   the padding level
+     */
+    protected abstract void appendPadding(S section, int level);
+
+    /**
+     * Add key to the section
+     *
+     * @param section        the section
+     * @param key            the key
+     * @param fromCollection whether the key is from a collection
+     */
+    protected abstract void appendKey(S section, String key, boolean fromCollection);
+
+    /**
+     * Add size to the section
+     *
+     * @param section the section
+     * @param size    the size
+     */
+    protected abstract void appendSize(S section, int size);
+
+    /**
+     * Add value to the section
+     *
+     * @param section the section
+     * @param value   the value
+     * @param editor  the current editor
+     */
+    protected abstract void appendValue(S section, Object value, Editor<?> editor);
+
+    /**
+     * Add section to the builder
+     *
+     * @param section the section
+     * @param builder the builder
+     * @return the new builder
+     */
+    protected abstract B addToBuilder(S section, B builder);
+
+    /**
+     * Build the final object from the builder
+     *
+     * @param builder the builder
+     * @return the object
+     */
     protected abstract T build(B builder);
 
-    protected Object preprocessValue(Object value, Editor<?, ?> editor) {
+    /**
+     * Preprocess the editor value
+     *
+     * @param value  the value
+     * @param editor the editor
+     * @return the preprocessed object
+     */
+    protected Object preprocessValue(Object value, Editor<?> editor) {
+        while (value instanceof Editor<?>) {
+            Editor<?> subEditor = (Editor<?>) value;
+            value = subEditor.status();
+        }
         return value;
     }
 
-    public List<T> display(Editor<?, ?> editor) {
-        List<T> list = new ArrayList<>();
+    /**
+     * Display the editor by converting the editor status to an object
+     *
+     * @param editor the editor
+     * @return the status object
+     */
+    public T display(Editor<?> editor) {
+        B builder = newBuilder();
         Deque<Entry> deque = new ArrayDeque<>();
         deque.addFirst(new Entry(0, "ROOT", editor, false));
         while (!deque.isEmpty()) {
@@ -34,32 +112,28 @@ public List<T> display(Editor<?, ?> editor) {
                 continue;
             }
 
-            while (value instanceof Editor<?, ?>) {
-                Editor<?, ?> subEditor = (Editor<?, ?>) value;
-                value = subEditor.status();
-            }
+            S section = newSection(builder);
 
-            B builder = newBuilder();
-            appendPadding(builder, level);
-            appendKey(builder, entry.key(), entry.fromCollection());
+            appendPadding(section, level);
+            appendKey(section, entry.key(), entry.fromCollection());
             if (value instanceof Collection<?>) {
                 Collection<?> collection = (Collection<?>) value;
-                appendSize(builder, collection.size());
+                appendSize(section, collection.size());
                 List<Object> copyList = new ArrayList<>(collection);
                 for (int i = copyList.size() - 1; i >= 0; i--) {
                     Object o = copyList.get(i);
                     deque.addFirst(new Entry(level + 1, Integer.toString(i), o, true));
                 }
             } else if (value.getClass().isArray()) {
                 int length = Array.getLength(value);
-                appendSize(builder, length);
+                appendSize(section, length);
                 for (int i = length - 1; i >= 0; i--) {
                     Object o = Array.get(value, i);
                     deque.addFirst(new Entry(level + 1, Integer.toString(i), o, true));
                 }
             } else if (value instanceof Map<?, ?>) {
                 Map<?, ?> subMap = (Map<?, ?>) value;
-                appendSize(builder, subMap.size());
+                appendSize(section, subMap.size());
                 List<Map.Entry<?, ?>> copyList = new ArrayList<>(subMap.entrySet());
                 for (int i = subMap.size() - 1; i >= 0; i--) {
                     Map.Entry<?, ?> o = copyList.get(i);
@@ -69,11 +143,11 @@ public List<T> display(Editor<?, ?> editor) {
                 Map.Entry<?, ?> subEntry = (Map.Entry<?, ?>) value;
                 deque.addFirst(new Entry(level + 1, Objects.toString(subEntry.getKey()), subEntry.getValue(), false));
             } else {
-                appendValue(builder, value, level, editor);
+                appendValue(section, value, editor);
             }
-            list.add(build(builder));
+            builder = addToBuilder(section, builder);
         }
-        return list;
+        return build(builder);
     }
 
     private static final class Entry {
@@ -120,14 +194,5 @@ public boolean equals(Object obj) {
         public int hashCode() {
             return Objects.hash(level, key, value, fromCollection);
         }
-
-        @Override
-        public String toString() {
-            return "Entry[" +
-                    "level=" + level + ", " +
-                    "key=" + key + ", " +
-                    "value=" + value + ", " +
-                    "fromCollection=" + fromCollection + ']';
-        }
     }
 }