JDT code tidy-up

Author: simbo1905

.tmp/keep

@@ -5,7 +5,7 @@
 
 import java.util.ArrayList;
 import java.util.Collections;
-import java.util.HashSet;
+
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -49,12 +49,12 @@ static String enrichedError(String baseMessage, Frame frame, JsonValue contextVa
   }
 
   /// Compiles a JTD schema and throws exceptions for invalid schemas
+  ///
   /// @param schema The JTD schema as a JsonValue
-  /// @return Compiled JtdSchema
   /// @throws IllegalArgumentException if the schema is invalid
-  public JtdSchema compile(JsonValue schema) {
+  public void compile(JsonValue schema) {
     definitions.clear();
-    return compileSchema(schema);
+    compileSchema(schema);
   }
 
   /// Validates a JSON instance against a JTD schema
@@ -324,19 +324,13 @@ JtdSchema compileSchema(JsonValue schema, boolean isRoot) {
       }
     }
 
-    return compileObjectSchema(obj, isRoot);
+    return compileObjectSchema(obj);
   }
-  
-  /// Compiles an object schema according to RFC 8927 with strict semantics
-  JtdSchema compileObjectSchema(JsonObject obj) {
-    return compileObjectSchema(obj, true); // Default to root schema
-  }
-  
+
   /// Compiles an object schema according to RFC 8927 with strict semantics
   /// @param obj The JSON object to compile
-  /// @param isRoot Whether this is a root-level schema (can contain definitions)
   /// @return Compiled JtdSchema
-  JtdSchema compileObjectSchema(JsonObject obj, boolean isRoot) {
+  JtdSchema compileObjectSchema(JsonObject obj) {
     // Check for mutually-exclusive schema forms
     List<String> forms = new ArrayList<>();
     Map<String, JsonValue> members = obj.members();
@@ -357,7 +351,7 @@ JtdSchema compileObjectSchema(JsonObject obj, boolean isRoot) {
 
     // RFC 8927: Check for form-specific properties that shouldn't be mixed
     if (forms.size() == 1) {
-      String form = forms.get(0);
+      String form = forms.getFirst();
       switch (form) {
         case "elements", "values", "enum", "ref", "type" -> {
           // These forms should not have properties-specific attributes
@@ -445,11 +439,11 @@ JtdSchema compileObjectSchema(JsonObject obj, boolean isRoot) {
         case "ref" -> compileRefSchema(obj);
         case "type" -> compileTypeSchema(obj);
         case "enum" -> compileEnumSchema(obj);
-        case "elements" -> compileElementsSchema(obj, isRoot);
-        case "properties" -> compilePropertiesSchema(obj, isRoot);
-        case "optionalProperties" -> compilePropertiesSchema(obj, isRoot); // handled together
-        case "values" -> compileValuesSchema(obj, isRoot);
-        case "discriminator" -> compileDiscriminatorSchema(obj, isRoot);
+        case "elements" -> compileElementsSchema(obj);
+        case "properties" -> compilePropertiesSchema(obj);
+        case "optionalProperties" -> compilePropertiesSchema(obj); // handled together
+        case "values" -> compileValuesSchema(obj);
+        case "discriminator" -> compileDiscriminatorSchema(obj);
         default -> throw new IllegalArgumentException("Unknown schema form: " + form);
       };
     }
@@ -542,21 +536,13 @@ JtdSchema compileEnumSchema(JsonObject obj) {
   }
 
   JtdSchema compileElementsSchema(JsonObject obj) {
-    return compileElementsSchema(obj, true); // Default to root
-  }
-  
-  JtdSchema compileElementsSchema(JsonObject obj, boolean isRoot) {
     Map<String, JsonValue> members = obj.members();
     JsonValue elementsValue = members.get("elements");
     JtdSchema elementsSchema = compileSchema(elementsValue, false); // Elements are nested schemas
     return new JtdSchema.ElementsSchema(elementsSchema);
   }
-  
+
   JtdSchema compilePropertiesSchema(JsonObject obj) {
-    return compilePropertiesSchema(obj, true); // Default to root
-  }
-  
-  JtdSchema compilePropertiesSchema(JsonObject obj, boolean isRoot) {
     Map<String, JtdSchema> properties = Map.of();
     Map<String, JtdSchema> optionalProperties = Map.of();
 
@@ -568,7 +554,7 @@ JtdSchema compilePropertiesSchema(JsonObject obj, boolean isRoot) {
       if (!(propsValue instanceof JsonObject propsObj)) {
         throw new IllegalArgumentException("properties must be an object");
       }
-      properties = parsePropertySchemas(propsObj, false); // Property schemas are nested
+      properties = parsePropertySchemas(propsObj); // Property schemas are nested
     }
 
     // Parse optional properties
@@ -577,7 +563,7 @@ JtdSchema compilePropertiesSchema(JsonObject obj, boolean isRoot) {
       if (!(optPropsValue instanceof JsonObject optPropsObj)) {
         throw new IllegalArgumentException("optionalProperties must be an object");
       }
-      optionalProperties = parsePropertySchemas(optPropsObj, false); // Property schemas are nested
+      optionalProperties = parsePropertySchemas(optPropsObj); // Property schemas are nested
     }
 
     // RFC 8927: Check for key overlap between properties and optionalProperties
@@ -603,21 +589,13 @@ JtdSchema compilePropertiesSchema(JsonObject obj, boolean isRoot) {
   }
 
   JtdSchema compileValuesSchema(JsonObject obj) {
-    return compileValuesSchema(obj, true); // Default to root
-  }
-  
-  JtdSchema compileValuesSchema(JsonObject obj, boolean isRoot) {
     Map<String, JsonValue> members = obj.members();
     JsonValue valuesValue = members.get("values");
     JtdSchema valuesSchema = compileSchema(valuesValue, false); // Values are nested schemas
     return new JtdSchema.ValuesSchema(valuesSchema);
   }
-  
+
   JtdSchema compileDiscriminatorSchema(JsonObject obj) {
-    return compileDiscriminatorSchema(obj, true); // Default to root
-  }
-  
-  JtdSchema compileDiscriminatorSchema(JsonObject obj, boolean isRoot) {
     Map<String, JsonValue> members = obj.members();
     JsonValue discriminatorValue = members.get("discriminator");
     if (!(discriminatorValue instanceof JsonString discStr)) {
@@ -704,15 +682,10 @@ void validateDiscriminatorMapping(String mappingKey, JtdSchema variantSchema, St
 
   /// Extracts and stores top-level definitions for ref resolution
   private Map<String, JtdSchema> parsePropertySchemas(JsonObject propsObj) {
-    return parsePropertySchemas(propsObj, true); // Default to root
-  }
-  
-  /// Extracts and stores top-level definitions for ref resolution
-  private Map<String, JtdSchema> parsePropertySchemas(JsonObject propsObj, boolean isRoot) {
     Map<String, JtdSchema> schemas = new java.util.HashMap<>();
     for (String key : propsObj.members().keySet()) {
       JsonValue schemaValue = propsObj.members().get(key);
-      schemas.put(key, compileSchema(schemaValue, isRoot));
+      schemas.put(key, compileSchema(schemaValue, false));
     }
     return schemas;
   }

json-java21-jtd/src/main/java/json/java21/jtd/Jtd.java

@@ -165,18 +165,6 @@ boolean validateTimestampWithFrame(Frame frame, java.util.List<String> errors, b
       return false;
     }
 
-    private boolean hasFractionalComponent(Number value) {
-      return switch (value) {
-        case null -> false;
-        case Double d -> d != Math.floor(d);
-        case Float f -> f != Math.floor(f);
-        case java.math.BigDecimal bd -> bd.remainder(java.math.BigDecimal.ONE).signum() != 0;
-        default ->
-          // Long, Integer, Short, Byte are always integers
-            false;
-      };
-    }
-    
     boolean validateIntegerWithFrame(Frame frame, String type, java.util.List<String> errors, boolean verboseErrors) {
       JsonValue instance = frame.instance();
       if (instance instanceof JsonNumber num) {

json-java21-jtd/src/main/java/json/java21/jtd/JtdSchema.java

@@ -4,7 +4,6 @@
 import net.jqwik.api.*;
 import org.junit.jupiter.api.Assertions;
 
-import java.math.BigDecimal;
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -14,7 +13,6 @@
 /// Generates comprehensive schema/document permutations to validate RFC 8927 compliance
 class JtdPropertyTest extends JtdTestBase {
 
-  private static final int MAX_DEPTH = 3;
   private static final List<String> PROPERTY_NAMES = List.of("alpha", "beta", "gamma", "delta", "epsilon");
   private static final List<List<String>> PROPERTY_PAIRS = List.of(List.of("alpha", "beta"), List.of("alpha", "gamma"), List.of("beta", "delta"), List.of("gamma", "epsilon"));
   private static final List<String> DISCRIMINATOR_VALUES = List.of("type1", "type2", "type3");
@@ -313,50 +311,6 @@ private static Arbitrary<JtdTestSchema> valuesSchemaArbitrary(int depth) {
     return jtdSchemaArbitrary(depth - 1).map(ValuesSchema::new);
   }
 
-  /// Creates simple PropertiesSchema instances for discriminator mappings without recursion
-  /// This prevents stack overflow while ensuring RFC 8927 compliance
-  private static Arbitrary<JtdTestSchema> simplePropertiesSchemaArbitrary() {
-    // Create primitive schemas that don't recurse
-    final var primitiveSchemas = Arbitraries.of(new EmptySchema(), new TypeSchema("boolean"), new TypeSchema("string"), new TypeSchema("int32"), new EnumSchema(List.of("red", "green", "blue")));
-
-    // ======================== CHANGE: USE NON-DISCRIMINATOR PROPERTY NAMES ========================
-    // RFC 8927 §2.2.8: Discriminator mapping schemas cannot define the discriminator key
-    // Use property names that won't conflict with discriminator keys
-    final var safePropertyNames = List.of("beta", "gamma", "delta", "epsilon"); // Exclude "alpha" 
-    final var safePropertyPairs = List.of(
-        List.of("beta", "gamma"),
-        List.of("gamma", "delta"), 
-        List.of("delta", "epsilon")
-    );
-    // ==================== END CHANGE: USE NON-DISCRIMINATOR PROPERTY NAMES ====================
-
-    return Arbitraries.oneOf(
-        // Empty properties schema
-        Arbitraries.of(new PropertiesSchema(Map.of(), Map.of(), false)),
-
-        // Single required property with primitive schema
-        Combinators.combine(Arbitraries.of(safePropertyNames), primitiveSchemas).as((name, schema) -> {
-          Assertions.assertNotNull(name);
-          Assertions.assertNotNull(schema);
-          return new PropertiesSchema(Map.of(name, schema), Map.of(), false);
-        }),
-
-        // Single optional property with primitive schema
-        Combinators.combine(Arbitraries.of(safePropertyNames), primitiveSchemas).as((name, schema) -> {
-          Assertions.assertNotNull(name);
-          Assertions.assertNotNull(schema);
-          return new PropertiesSchema(Map.of(), Map.of(name, schema), false);
-        }),
-
-        // Required + optional property with primitive schemas
-        Combinators.combine(Arbitraries.of(safePropertyPairs), primitiveSchemas, primitiveSchemas).as((names, requiredSchema, optionalSchema) -> {
-          Assertions.assertNotNull(names);
-          Assertions.assertNotNull(requiredSchema);
-          Assertions.assertNotNull(optionalSchema);
-          return new PropertiesSchema(Map.of(names.getFirst(), requiredSchema), Map.of(names.get(1), optionalSchema), false);
-        }));
-  }
-
   private static Arbitrary<JtdTestSchema> discriminatorSchemaArbitrary() {
 
     return Combinators.combine(Arbitraries.of(PROPERTY_NAMES), Arbitraries.of(DISCRIMINATOR_VALUES), Arbitraries.of(DISCRIMINATOR_VALUES)).as((discriminatorKey, value1, value2) -> {
@@ -398,7 +352,7 @@ private static Arbitrary<JtdTestSchema> propertiesSchemaForDiscriminatorMapping(
         .flatMap(name1 -> effectivePropertyNames.stream()
             .filter(name2 -> !name1.equals(name2))
             .map(name2 -> List.of(name1, name2)))
-        .filter(pair -> !pair.get(0).equals(discriminatorKey) && !pair.get(1).equals(discriminatorKey))
+        .filter(pair -> !pair.getFirst().equals(discriminatorKey) && !pair.get(1).equals(discriminatorKey))
         .toList();
 
     return Arbitraries.oneOf(
@@ -431,12 +385,12 @@ private static Arbitrary<JtdTestSchema> nullableSchemaArbitrary(int depth) {
 
   @Provide
   Arbitrary<JtdTestSchema> jtdSchemas() {
-    return jtdSchemaArbitrary(MAX_DEPTH);
+    return jtdSchemaArbitrary(3);
   }
 
   @Property(generation = GenerationMode.AUTO)
   void exhaustiveJtdValidation(@ForAll("jtdSchemas") JtdPropertyTest.JtdTestSchema schema) {
-    LOG.finer(() -> "Executing exhaustiveJtdValidation property test");
+    LOG.finer(() -> "Executing exhaustiveValidation property test");
 
     final var schemaDescription = describeJtdSchema(schema);
 

json-java21-jtd/src/test/java/json/java21/jtd/JtdPropertyTest.java

@@ -443,7 +443,7 @@ public void testRefSchemaRecursiveBad() {
   }
 
   /// Micro test to debug int32 validation with decimal values
-  /// Should reject non-integer values like 3.14 for int32 type
+  /// Should reject noninteger values like 3.14 for int32 type
   @Test
   public void testInt32RejectsDecimal() {
     JsonValue schema = Json.parse("{\"type\": \"int32\"}");
@@ -627,7 +627,7 @@ public void testDiscriminatorInElementsSchema() {
   /// Test case from JtdExhaustiveTest property test failure
   /// Nested elements containing properties schemas should reject additional properties
   /// Schema: {"elements":{"elements":{"properties":{}}}}
-  /// Document: [[{},{},[{},{extraProperty":"extra-value"}]]
+  /// Document: [[{},{},[{},{extraProperty":"extra-value"}]
   /// This should fail validation but currently passes incorrectly
   @Test
   public void testNestedElementsPropertiesRejectsAdditionalProperties() {
@@ -901,7 +901,7 @@ public void testInt8RangeValidationWithDoubleValues() {
 
       LOG.fine(() -> "Testing int8 range with Double value: " + outOfRange + 
                " (JsonNumber.toLong(): " + 
-               ((JsonNumber)outOfRange).toLong() + ")");
+               outOfRange.toLong() + ")");
 
       // This should fail but currently passes due to the bug
       assertThat(result.isValid())
@@ -1043,7 +1043,7 @@ public void testJsonNumberToNumberReturnsDouble() {
 
     // Verify that JsonNumber works properly for typical JSON numbers
     assertThat(numberValue).isInstanceOf(JsonNumber.class);
-    long longValue = ((JsonNumber) numberValue).toLong();
+    long longValue = numberValue.toLong();
 
     LOG.info(() -> "JsonNumber.toLong() returns: " + longValue + 
                    " for value: " + numberValue);