Complete stringifier, swap out functions in JSONObject for new Stringifier methods

Author: stevenlagoy

src/main/java/core/FileOperations.java

@@ -24,7 +24,7 @@ public static enum FileExtension {
         private final String extension;
 
         FileExtension(String extension) {
-            this.extension = extension;
+            this.extension = extension != null ? extension : "";
         }
 
         public String getExtension() {

src/main/java/core/JSONObject.java

@@ -11,16 +11,6 @@
  */
 public class JSONObject implements Iterable<Object> {
 
-    /**
-     * The maximum number of array entries which may be put on a single line in the string representation. Objects are
-     * expanded and count as at least three lines.
-     */
-    public static final int SINGLE_LINE_ENTRIES_MAX = 5;
-    /** The maximum length of a line in string representation. Lines exceeding this length will be split. */
-    public static final int LINE_LENGTH_MAX = 55;
-    /** String used for indentation in formatted string output. */
-    public static final String INDENT = "    ";
-
     /*
      * Valid JSON types include:
      * String:
@@ -180,7 +170,14 @@ public Boolean getAsBoolean() {
     }
 
     public JSONObject getAsObject() {
-        return value instanceof JSONObject ? (JSONObject) value : null;
+
+        if (value instanceof JSONObject) return (JSONObject) value;
+
+        if (value instanceof List<?> && type.equals(JSONObject.class)) {
+            return this;
+        }
+
+        return null;
     }
 
     public List<?> getAsList() {
@@ -307,112 +304,7 @@ public Iterator<Object> iterator() {
      */
     @Override
     public String toString() {
-        return toString(0);
-    }
-
-    /**
-     * Turn this JSONObject into a String representation. Works recursively increasing the indentation with each
-     * recursion.
-     *
-     * @param indent
-     *            The number of indentation steps to add to each line in the resulting String
-     *
-     * @return The String representation of this JSONObject, indented the given number of steps
-     *
-     * @see JSONObject#toString()
-     * @see JSONObject#INDENT
-     */
-    private String toString(int indent) {
-        StringBuilder sb = new StringBuilder();
-        String indentation = INDENT.repeat(indent);
-
-        if (!key.equals(""))
-            sb.append(String.format("\"%s\" : ", this.key));
-
-        if (value == null)
-            sb.append("null");
-        else if (value instanceof String)
-            sb.append(String.format("\"%s\"", value));
-        else if (value instanceof Number || value instanceof Boolean)
-            sb.append(value);
-        else if (value instanceof List<?>) {
-            List<?> list = getAsList();
-            if (list.isEmpty()) {
-                if (type != null && JSONObject.class.isAssignableFrom(type))
-                    sb.append("{}");
-                else
-                    sb.append("[]");
-            }
-            else if (list.get(0) instanceof JSONObject) {
-                sb.append("{\n");
-                for (int i = 0; i < list.size(); i++) {
-                    sb.append(indentation).append(INDENT);
-                    JSONObject item = (JSONObject) list.get(i);
-                    if (item == null) {
-                        System.out.println("null");
-                    }
-                    if (item != null) {
-                        sb.append(item.toString(indent + 1));
-                    }
-                    else {
-                        sb.append("null");
-                    }
-                    if (i < list.size() - 1)
-                        sb.append(",");
-                    sb.append("\n");
-                }
-                sb.append(indentation).append("}");
-            }
-            else {
-                StringBuilder listStrB = new StringBuilder();
-                listStrB.append("[");
-                for (int i = 0; i < list.size(); i++) {
-                    if (i > 0)
-                        listStrB.append(", ");
-                    listStrB.append(formatValue(list.get(i)));
-                }
-                listStrB.append("]");
-                String result = listStrB.toString();
-
-                if (result.length() > LINE_LENGTH_MAX || countInnerListEntries(list) > SINGLE_LINE_ENTRIES_MAX) {
-                    // List must be single entry per line
-                    String[] lines = StringOperations.splitByStringNotInArray(result.substring(1, result.length() - 1),
-                            ",");
-                    result = "";
-                    for (int i = 0; i < lines.length; i++) {
-                        String[] linelines = lines[i].split("\n");
-                        int extraIndent = 0;
-                        for (int j = 0; j < linelines.length; j++) {
-                            String lineline = linelines[j];
-                            if (lineline.equals("}"))
-                                extraIndent--;
-                            result += indentation + INDENT + INDENT.repeat(extraIndent) + lineline.trim();
-                            if (lineline.equals("{")) {
-                                extraIndent++;
-                                result += "\n"; // skip comma
-                                continue;
-                            }
-                            if (j < linelines.length - 2)
-                                result += ",\n";
-                            else if (j == linelines.length - 2)
-                                result += "\n";
-                            else if (i < lines.length - 1)
-                                result += ",\n";
-                        }
-                    }
-                    // result = String.join(",\n", lines);
-
-                    sb.append("[\n").append(result).append("\n").append(indentation).append("]");
-                }
-                else {
-                    result = indentation + INDENT + result;
-
-                    sb.append(result.trim());
-                }
-            }
-        }
-
-        return sb.toString();
+        return String.join("\n", JSONStringifier.expandJson(JSONStringifier.stringifyJson(this)));
     }
 
     /**
@@ -474,7 +366,13 @@ public int hashCode() {
      *
      * @see JSONObject#toString()
      */
-    public boolean equals(JSONObject other) {
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null || getClass() != obj.getClass())
+            return false;
+        JSONObject other = (JSONObject) obj;
         return this.toString().equals(other.toString());
     }
 

src/main/java/core/JSONProcessor.java

@@ -37,6 +37,7 @@ public class JSONProcessor {
      */
 
     public static JSONObject processJson(Path path) {
+        if (path == null) return null;
         List<String> contents = FileOperations.readFile(path);
         String key = path.getFileName().toString().split("\\.")[0];
         return processJson(key, contents);

src/main/java/core/JSONStringifier.java

@@ -1,15 +1,11 @@
 package core;
 
 import java.nio.file.Path;
+import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 
 public class JSONStringifier {
-
-    public static void main(String[] args) {
-        JSONObject json = JSONProcessor.processJson(Path.of("src\\tests\\java\\data\\test1\\test1.json"));
-        System.out.println(JSONStringifier.stringifyJson(json));
-    }
 
     /*
      * JSON BNF Grammar
@@ -40,37 +36,61 @@ public static void main(String[] args) {
      */
 
     public static String stringifyJson(JSONObject json) {
-        return stringifyValue(json.getValue());
+        String result = stringifyObject(json.getAsObject());
+        return result.substring(1, result.length() - 1);
     }
 
-    public static String stringifyValue(Object value) {
-        if (value instanceof List) {
-            List<?> list = (List<?>) value;
-            if (!list.isEmpty()) {
-                
-            }
-            return stringifyArray((List<?>) value);
+    public static String stringifyValue(Object value, Class<?> type) {
+        if (type.equals(JSONObject.class)) {
+            @SuppressWarnings("unchecked") // The type of this object is known from the type parameter
+            ArrayList<JSONObject> objects = (ArrayList<JSONObject>) value;
+            StringBuilder result = new StringBuilder();
+            for (JSONObject object : objects)
+                result.append(stringifyObject(object));
+            return result.toString();
+        }
+        if (type.equals(ArrayList.class)) {
+            return stringifyArray((ArrayList<?>) value);
         }
+        return stringifyValue(value);
+    }
+    public static String stringifyValue(Object value) {
         if (value instanceof String) return "\"" + stringifyEscape((String) value) + "\"";
         if (value instanceof Number || value instanceof Boolean) return value.toString();
         if (value == null) return "null";
         else throw new IllegalArgumentException("Unsupported JSON value: " + value);
     }
-    public static String stringifyValue(Object value, Class<?> type) {
-        return null;
-    }
 
     public static String stringifyObject(JSONObject object) {
         if (object == null) return "{}";
 
         StringBuilder sb = new StringBuilder();
         sb.append("{");
-        Iterator<?> it = object.iterator();
-        while (it.hasNext()) {
-            sb.append(stringifyValue(object.getKey())).append(" : ");
-            sb.append(stringifyValue(it.next()));
-            if (it.hasNext()) sb.append(", ");
+        
+        sb.append(stringifyValue(object.getKey()));
+        sb.append(" : ");
+
+        Object value = object.getValue();
+        Class<?> type = object.getType();
+
+        if (value == null)
+            sb.append("null");
+        else if (type != null && type.equals(JSONObject.class)) {
+            @SuppressWarnings("unchecked")
+            List<JSONObject> objects = (ArrayList<JSONObject>) value;
+            sb.append("{");
+            for (int i = 0; i < objects.size(); i++) {
+                String nested = stringifyObject(objects.get(i));
+                sb.append(nested.substring(1, nested.length() - 1));
+                if (i < objects.size() - 1) sb.append(", ");
+            }
+            sb.append("}");
         }
+        else if (type != null)
+            sb.append(stringifyValue(value, type));
+        else
+            sb.append(stringifyValue(value));
+
         sb.append("}");
 
         return sb.toString();
@@ -102,4 +122,59 @@ public static String stringifyEscape(String escape) {
             .replace("\t", "\\t");
     }
 
+    public static List<String> expandJson(String json) {
+        List<String> result = new ArrayList<>();
+        int indentation = 0;
+        String tab = "    ";
+
+        StringBuilder currentLine = new StringBuilder();
+
+        for (int i = 0; i < json.length(); i++) {
+            char c = json.charAt(i);
+
+            if (StringOperations.isInString(json, i) && c != '"') {
+                currentLine.append(c);
+                continue;
+            }
+            switch (c) {
+                case '"' :
+                    currentLine.append(c);
+                    break;
+                case '{' :
+                case '[' :
+                    currentLine.append(c);
+                    result.add(tab.repeat(indentation) + currentLine);
+                    currentLine = new StringBuilder();
+                    indentation++;
+                    break;
+                case '}' :
+                case ']' :
+                    if (currentLine.length() > 0) {
+                        result.add(tab.repeat(indentation) + currentLine);
+                        currentLine = new StringBuilder();
+                    }
+                    indentation--;
+                    result.add(tab.repeat(indentation) + c);
+                    break;
+                case ',' :
+                    currentLine.append(c);
+                    result.add(tab.repeat(indentation) + currentLine);
+                    currentLine = new StringBuilder();
+                    break;
+                case ':' :
+                    currentLine.append(" ").append(c).append(" ");
+                    break;
+                default :
+                    if (!Character.isWhitespace(c)) {
+                        currentLine.append(c);
+                    }
+            }
+        }
+
+        if (currentLine.length() > 0) {
+            result.add(tab.repeat(indentation) + currentLine);
+        }
+        return result;
+    }
+
 }

src/tests/java/StringifierTests.java

@@ -0,0 +1,44 @@
+import static org.junit.Assert.*;
+import org.junit.Test;
+import core.JSONObject;
+import core.JSONStringifier;
+import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.List;
+
+public class StringifierTests {
+
+    @Test
+    public void stringifyJson() {
+        ArrayList<JSONObject> inner = new ArrayList<>();
+        inner.add(new JSONObject("key1", "value1"));
+        inner.add(new JSONObject("key2", 42));
+        JSONObject nested = new JSONObject("nested", inner);
+        String result = JSONStringifier.stringifyJson(nested);
+        assertEquals("\"nested\" : {\"key1\" : \"value1\", \"key2\" : 42}", result);
+    }
+
+    @Test
+    public void stringifyValue() {
+        // Test primitive values
+        assertEquals("\"hello\"", JSONStringifier.stringifyValue("hello"));
+        assertEquals("42", JSONStringifier.stringifyValue(42));
+        assertEquals("true", JSONStringifier.stringifyValue(true));
+        assertEquals("null", JSONStringifier.stringifyValue(null));
+        
+        // Test with type information
+        List<Integer> numbers = new ArrayList<>();
+        numbers.add(1);
+        numbers.add(2);
+        numbers.add(3);
+        assertEquals("[1, 2, 3]", JSONStringifier.stringifyValue(numbers, ArrayList.class));
+        
+        // Test nested objects with type
+        List<JSONObject> objects = new ArrayList<>();
+        objects.add(new JSONObject("key1", "value1"));
+        objects.add(new JSONObject("key2", "value2"));
+        String result = JSONStringifier.stringifyValue(objects, JSONObject.class);
+        assertEquals("{\"key1\" : \"value1\"}{\"key2\" : \"value2\"}", result);
+    }
+
+}