Merge branch '2.19' into 3.x

Author: cowtowncoder

ion/src/main/java/tools/jackson/dataformat/ion/IonParser.java

@@ -488,6 +488,17 @@ private IonValue getIonValue() throws JacksonException {
         }
         IonValue v = l.get(0);
         v.removeFromContainer();
+
+        if (!IonReadFeature.READ_NULL_AS_IONVALUE.enabledIn(_formatFeatures)) {
+            // 2025-04-11, seadbrane: The default is to read 'null' as an Ion Null object.
+            // However, there is no way to determine from the serialized ion data if a 'null'
+            // was an IonNullValue or a 'null' container type such as IonNullStruct or IonNullList.
+            // So if READ_NULL_AS_IONVALUE is disabled, then return 'null' if the _valueToken
+            // is 'null' and the Ion value read is not container type already.
+            if (v.isNullValue() && _valueToken == JsonToken.VALUE_NULL && !IonType.isContainer(v.getType())) {
+                return null;
+            }
+        }
         return v;
     }
 

ion/src/main/java/tools/jackson/dataformat/ion/IonReadFeature.java

@@ -9,6 +9,19 @@
  */
 public enum IonReadFeature implements FormatFeature
 {
+    /**
+     * Whether to convert "null" to an IonValueNull (true);
+     * or leave as a java null (false) when deserializing.
+     *<p>
+     * Enabled by default for backwards compatibility as that has been the behavior
+     * of `jackson-dataformat-ion` since 2.13.
+     *
+     * @see <a href="https://amzn.github.io/ion-docs/docs/spec.html#annot">The Ion Specification</a>
+     *
+     * @since 2.19.0
+     */
+    READ_NULL_AS_IONVALUE(true),
+
     /**
      * Whether to expect Ion native Type Id construct for indicating type (true);
      * or "generic" type property (false) when deserializing.

ion/src/main/java/tools/jackson/dataformat/ion/ionvalue/IonValueDeserializer.java

@@ -26,9 +26,26 @@
  */
 class IonValueDeserializer extends ValueDeserializer<IonValue>
 {
+    private final JavaType _targetType;
+
+    public IonValueDeserializer() {
+        _targetType = null;
+    }
+
+    public IonValueDeserializer(JavaType targetType) {
+        _targetType = targetType;
+    }
+
     @Override
-    public IonValue deserialize(JsonParser jp, DeserializationContext ctxt)
-        throws JacksonException
+    public ValueDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) {
+        JavaType contextualType = (property != null)
+            ? property.getType()
+            : ctxt.getContextualType(); // fallback
+        return new IonValueDeserializer(contextualType);
+    }
+
+    @Override
+    public IonValue deserialize(JsonParser jp, DeserializationContext ctxt) throws JacksonException
     {
         Object embeddedObject = jp.getEmbeddedObject();
         if (embeddedObject instanceof IonValue) {
@@ -60,13 +77,31 @@ public Object getNullValue(DeserializationContext ctxt) throws JacksonException
             if (embeddedObj instanceof IonValue) {
                 IonValue iv = (IonValue) embeddedObj;
                 if (iv.isNullValue()) {
+                    if (IonType.isContainer(iv.getType())) {
+                        return iv;
+                    }
+                    IonType containerType = getIonContainerType();
+                    if (containerType != null) {
+                        IonSystem ionSystem = ((IonParser) parser).getIonSystem();
+                        return ionSystem.newNull(containerType);
+                    }
                     return iv;
                 }
             }
         }
         return super.getNullValue(ctxt);
     }
 
+    private IonType getIonContainerType() {
+        if (_targetType != null) {
+            Class<?> clazz = _targetType.getRawClass();
+            if (IonStruct.class.isAssignableFrom(clazz)) return IonType.STRUCT;
+            if (IonList.class.isAssignableFrom(clazz)) return IonType.LIST;
+            if (IonSexp.class.isAssignableFrom(clazz)) return IonType.SEXP;
+        }
+        return null;
+    }
+
     @Override
     public AccessPattern getNullAccessPattern() {
         return AccessPattern.DYNAMIC;

ion/src/test/java/tools/jackson/dataformat/ion/ionvalue/IonValueDeserializerTest.java

@@ -15,6 +15,7 @@
 import tools.jackson.databind.util.AccessPattern;
 import tools.jackson.dataformat.ion.IonFactory;
 import tools.jackson.dataformat.ion.IonObjectMapper;
+import tools.jackson.dataformat.ion.IonReadFeature;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNull;
@@ -73,6 +74,11 @@ static class IonValueData extends Data<IonValue> {
             .propertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE)
             .build();
 
+    private static final IonObjectMapper ION_MAPPER_READ_NULL_DISABLED = IonObjectMapper.builder(ionF)
+            .propertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE)
+            .disable(IonReadFeature.READ_NULL_AS_IONVALUE)
+            .build();
+
     @Test
     public void shouldBeAbleToDeserialize() throws Exception {
         IonValue ion = ion("{a:1, b:2, c:3}");
@@ -97,24 +103,48 @@ public void shouldBeAbleToDeserializeIncludingNullList() throws Exception {
         assertEquals(ion("null.list"), data.getAllData().get("c"));
     }
 
+    @Test
+    public void shouldBeAbleToDeserializeNullToIonNull() throws Exception {
+        verifyNullDeserialization("{c:null}", SYSTEM.newNull(), null);
+    }
+
     @Test
     public void shouldBeAbleToDeserializeNullList() throws Exception {
-        IonValue ion = ion("{c:null.list}");
+        verifyNullDeserialization("{c:null.list}", SYSTEM.newNullList());
+    }
 
-        IonValueData data = ION_VALUE_MAPPER.readValue(ion, IonValueData.class);
 
-        assertEquals(1, data.getAllData().size());
-        assertEquals(SYSTEM.newNullList(), data.getAllData().get("c"));
-    }
 
     @Test
     public void shouldBeAbleToDeserializeNullStruct() throws Exception {
-        IonValue ion = ion("{c:null.struct}");
+        verifyNullDeserialization("{c:null.struct}", SYSTEM.newNullStruct());
+    }
 
-        IonValueData data = ION_VALUE_MAPPER.readValue(ion, IonValueData.class);
+    @Test
+    public void shouldBeAbleToDeserializeNullSexp() throws Exception {
+        verifyNullDeserialization("{c:null.sexp}", SYSTEM.newNullSexp());
+    }
+
+    private void verifyNullDeserialization(String ionString, IonValue expected) throws Exception {
+         verifyNullDeserialization(ionString, expected, expected);
+    }
+
+    private void verifyNullDeserialization(String ionString, IonValue expected, IonValue expectedReadNullDisabled) throws Exception {
+        verifyNullDeserialization(ION_VALUE_MAPPER, ionString, expected);
+        verifyNullDeserialization(ION_MAPPER_READ_NULL_DISABLED, ionString, expectedReadNullDisabled);
+    }
+
+    private void verifyNullDeserialization(IonObjectMapper mapper, String ionString, IonValue expected) throws Exception {
+        IonValueData data = mapper.readValue(ionString, IonValueData.class);
 
         assertEquals(1, data.getAllData().size());
-        assertEquals(SYSTEM.newNullStruct(), data.getAllData().get("c"));
+        assertEquals(expected, data.getAllData().get("c"));
+
+        IonValue ion = ion(ionString);
+        data = mapper.readValue(ion, IonValueData.class);
+
+        assertEquals(1, data.getAllData().size());
+        assertEquals(expected, data.getAllData().get("c"));
     }
 
     @Test
@@ -160,6 +190,27 @@ public void shouldBeAbleToSerializeAndDeserializePojo() throws Exception {
         assertEquals(source, result);
     }
 
+    @Test
+    public void shouldBeAbleToSerializeAndDeserializeIonValueDataWithIncludeNonNull() throws Exception {
+        IonValueData source = new IonValueData();
+        source.put("a", SYSTEM.newInt(1));
+        source.put("b", SYSTEM.newNull());
+        source.put("c", null);
+        IonObjectMapper mapper = ION_VALUE_MAPPER
+                .rebuild()
+                .changeDefaultPropertyInclusion(
+                        incl -> incl.withValueInclusion(JsonInclude.Include.NON_NULL)
+                                .withContentInclusion(JsonInclude.Include.NON_NULL))
+                .build();
+
+        String data = mapper.writeValueAsString(source);
+        assertEquals("{a:1,b:null}", data);
+        // Now remove the null element for the comparison below.
+        source.getAllData().remove("c");
+        IonValueData result = mapper.readValue(data, IonValueData.class);
+        assertEquals(source, result);
+    }
+
     @Test
     public void shouldBeAbleToSerializeAndDeserializeStringData() throws Exception {
         StringData source = new StringData();
@@ -168,7 +219,17 @@ public void shouldBeAbleToSerializeAndDeserializeStringData() throws Exception {
 
         IonValue data = ION_VALUE_MAPPER.writeValueAsIonValue(source);
         StringData result = ION_VALUE_MAPPER.readValue(data, StringData.class);
+        assertEquals(source, result);
+    }
+
+    @Test
+    public void shouldBeAbleToSerializeAndDeserializeStringDataAsString() throws Exception {
+        StringData source = new StringData();
+        source.put("a", "1");
+        source.put("b", null);
 
+        String data = ION_VALUE_MAPPER.writeValueAsString(source);
+        StringData result = ION_VALUE_MAPPER.readValue(data, StringData.class);
         assertEquals(source, result);
     }
 

release-notes/CREDITS-2.x

@@ -381,3 +381,7 @@ Cormac Redmond (@credmond)
 Manuel Sugawara (@sugmanue)
  * Contributed #568: Improve ASCII decoding performance for `CBORParser`
   (2.19.0)
+
+Josh Curry (@seadbrane)
+ * Reported, contributed fix for #571: Unable to deserialize a pojo with IonStruct
+  (2.19.0)

release-notes/VERSION-2.x

@@ -14,6 +14,9 @@ Active maintainers:
 === Releases ===
 ------------------------------------------------------------------------
 
+#571: Unable to deserialize a pojo with IonStruct
+ (reported, fix contributed by Josh C)
+
 2.19.0-rc2 (07-Apr-2025)
 
 #300: (smile) Floats are encoded with sign extension while doubles without