Conformance test suite

.github/dependabot.yml

@@ -3,7 +3,7 @@ updates:
   - package-ecosystem: "gradle"
     directory: "/"
     schedule:
-      interval: "weekly"
+      interval: "monthly"
     open-pull-requests-limit: 10
     groups:
       test:
@@ -13,4 +13,4 @@ updates:
   - package-ecosystem: "github-actions"
     directory: "/"
     schedule:
-      interval: "weekly"
+      interval: "monthly"

sonar-project.properties

@@ -0,0 +1 @@
+sonar.java.source=17

src/main/java/com/felipestanzani/jtoon/DecodeOptions.java

@@ -10,44 +10,46 @@
  *                     IllegalArgumentException on invalid input. When false,
  *                     uses best-effort parsing and returns null on errors
  *                     (default: true)
+ * @param expandPaths  Path expansion mode for dotted keys (default: OFF)
  */
 public record DecodeOptions(
         int indent,
         Delimiter delimiter,
-        boolean strict) {
+        boolean strict,
+        PathExpansion expandPaths) {
     /**
-     * Default decoding options: 2 spaces indent, comma delimiter, strict validation
+     * Default decoding options: 2 spaces indent, comma delimiter, strict validation, path expansion off
      */
-    public static final DecodeOptions DEFAULT = new DecodeOptions(2, Delimiter.COMMA, true);
+    public static final DecodeOptions DEFAULT = new DecodeOptions(2, Delimiter.COMMA, true, PathExpansion.OFF);
 
     /**
      * Creates DecodeOptions with default values.
      */
     public DecodeOptions() {
-        this(2, Delimiter.COMMA, true);
+        this(2, Delimiter.COMMA, true, PathExpansion.OFF);
     }
 
     /**
      * Creates DecodeOptions with custom indent, using default delimiter and strict
      * mode.
      */
     public static DecodeOptions withIndent(int indent) {
-        return new DecodeOptions(indent, Delimiter.COMMA, true);
+        return new DecodeOptions(indent, Delimiter.COMMA, true, PathExpansion.OFF);
     }
 
     /**
      * Creates DecodeOptions with custom delimiter, using default indent and strict
      * mode.
      */
     public static DecodeOptions withDelimiter(Delimiter delimiter) {
-        return new DecodeOptions(2, delimiter, true);
+        return new DecodeOptions(2, delimiter, true, PathExpansion.OFF);
     }
 
     /**
      * Creates DecodeOptions with custom strict mode, using default indent and
      * delimiter.
      */
     public static DecodeOptions withStrict(boolean strict) {
-        return new DecodeOptions(2, Delimiter.COMMA, strict);
+        return new DecodeOptions(2, Delimiter.COMMA, strict, PathExpansion.OFF);
     }
 }

src/main/java/com/felipestanzani/jtoon/JToon.java

@@ -4,40 +4,9 @@
 import com.felipestanzani.jtoon.encoder.ValueEncoder;
 import com.felipestanzani.jtoon.normalizer.JsonNormalizer;
 import tools.jackson.databind.JsonNode;
-import tools.jackson.databind.ObjectMapper;
 
-/**
- * Main API for encoding and decoding JToon format.
- *
- * <p>
- * JToon is a structured text format that represents JSON-like data in a more
- * human-readable way, with support for tabular arrays and inline formatting.
- * </p>
- *
- * <h2>Usage Examples:</h2>
- *
- * <pre>{@code
- * // Encode a Java object with default options
- * String toon = JToon.encode(myObject);
- *
- * // Encode with custom options
- * EncodeOptions options = new EncodeOptions(4, Delimiter.PIPE, true);
- * String toon = JToon.encode(myObject, options);
- *
- * // Encode a plain JSON string directly
- * String toon = JToon.encodeJson("{\"id\":123,\"name\":\"Ada\"}");
- *
- * // Decode TOON back to Java objects
- * Object result = JToon.decode(toon);
- *
- * // Decode TOON directly to JSON string
- * String json = JToon.decodeToJson(toon);
- * }</pre>
- */
 public final class JToon {
 
-    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
-
     private JToon() {
         throw new UnsupportedOperationException("Utility class cannot be instantiated");
     }
@@ -179,11 +148,6 @@ public static String decodeToJson(String toon) {
      *                                  invalid
      */
     public static String decodeToJson(String toon, DecodeOptions options) {
-        try {
-            Object decoded = ValueDecoder.decode(toon, options);
-            return OBJECT_MAPPER.writeValueAsString(decoded);
-        } catch (Exception e) {
-            throw new IllegalArgumentException("Failed to convert decoded value to JSON: " + e.getMessage(), e);
-        }
+        return ValueDecoder.decodeToJson(toon, options);
     }
 }

src/main/java/com/felipestanzani/jtoon/PathExpansion.java

@@ -0,0 +1,18 @@
+package com.felipestanzani.jtoon;
+
+/**
+ * Path expansion mode for decoding dotted keys.
+ */
+public enum PathExpansion {
+    /**
+     * Safe mode: expands dotted keys like "a.b.c" into nested objects.
+     * Only expands keys that are valid identifier segments.
+     */
+    SAFE,
+
+    /**
+     * Off mode: treats dotted keys as literal keys.
+     */
+    OFF
+}
+

src/main/java/com/felipestanzani/jtoon/decoder/PrimitiveDecoder.java

@@ -9,14 +9,15 @@
  * Converts TOON scalar representations to appropriate Java types:
  * </p>
  * <ul>
- *   <li>{@code "null"} → {@code null}</li>
- *   <li>{@code "true"} / {@code "false"} → {@code Boolean}</li>
- *   <li>Numeric strings → {@code Long} or {@code Double}</li>
- *   <li>Quoted strings → {@code String} (with unescaping)</li>
- *   <li>Bare strings → {@code String}</li>
+ * <li>{@code "null"} → {@code null}</li>
+ * <li>{@code "true"} / {@code "false"} → {@code Boolean}</li>
+ * <li>Numeric strings → {@code Long} or {@code Double}</li>
+ * <li>Quoted strings → {@code String} (with unescaping)</li>
+ * <li>Bare strings → {@code String}</li>
  * </ul>
  *
  * <h2>Examples:</h2>
+ * 
  * <pre>{@code
  * parse("null")      → null
  * parse("true")      → true
@@ -46,27 +47,52 @@ static Object parse(String value) {
         }
 
         // Check for null literal
-        if ("null".equals(value)) {
-            return null;
-        }
-
-        // Check for boolean literals
-        if ("true".equals(value)) {
-            return true;
-        }
-        if ("false".equals(value)) {
-            return false;
+        switch (value) {
+            case "null" -> {
+                return null;
+            }
+            case "true" -> {
+                return true;
+            }
+            case "false" -> {
+                return false;
+            }
+            default -> {
+                // Do nothing, continue to next check
+            }
         }
 
         // Check for quoted strings
-        if (value.startsWith("\"") && value.endsWith("\"")) {
+        if (value.startsWith("\"")) {
+            // Validate string before unescaping
+            StringEscaper.validateString(value);
             return StringEscaper.unescape(value);
         }
 
+        // Check for leading zeros (treat as string, except for "0", "-0", "0.0", etc.)
+        String trimmed = value.trim();
+        if (trimmed.length() > 1 && trimmed.matches("^-?0+[\\d].*")
+                && !trimmed.matches("^-?0+(\\.0+)?([eE][+-]?\\d+)?$")) {
+            return value;
+        }
+
         // Try parsing as number
         try {
+            // Check if it contains exponent notation or decimal point
             if (value.contains(".") || value.contains("e") || value.contains("E")) {
-                return Double.parseDouble(value);
+                double parsed = Double.parseDouble(value);
+                // Handle negative zero - Java doesn't distinguish, but spec says it should be 0
+                if (parsed == 0.0) {
+                    return 0L;
+                }
+                // Check if the result is a whole number - if so, return as Long
+                if (parsed == Math.floor(parsed)
+                        && !Double.isInfinite(parsed)
+                        && parsed >= Long.MIN_VALUE
+                        && parsed <= Long.MAX_VALUE)
+                    return (long) parsed;
+
+                return parsed;
             } else {
                 return Long.parseLong(value);
             }