Release 2025-05-04 14:13:28 +0000

.github/workflows/release.yaml

@@ -1,6 +1,11 @@
 name: release
 on:
   workflow_dispatch:
+
+permissions:
+  contents: read
+  pull-requests: write
+
 jobs:
   gitPrRelease:
     name: git-pr-release

build.gradle.kts

@@ -16,7 +16,7 @@ val jacksonVersion = libs.versions.jackson.get()
 val generatedSrcPath = "${layout.buildDirectory.get()}/generated/kotlin"
 
 group = groupStr
-version = "${jacksonVersion}-beta20"
+version = "${jacksonVersion}-beta21"
 
 repositories {
     mavenCentral()

gradle/libs.versions.toml

@@ -1,6 +1,6 @@
 [versions]
 kotlin = "1.9.25" # Mainly for CI, it can be rewritten by environment variable.
-jackson = "2.18.3"
+jackson = "2.19.0"
 
 # test libs
 junit = "5.12.2"
@@ -14,10 +14,10 @@ jackson-annotations = { module = "com.fasterxml.jackson.core:jackson-annotations
 # test libs
 kotlin-reflect = { module = "org.jetbrains.kotlin:kotlin-reflect" }
 junit-bom = { module = "org.junit:junit-bom", version.ref = "junit" }
-mockk = "io.mockk:mockk:1.14.0"
+mockk = "io.mockk:mockk:1.14.2"
 jackson-xml = { module = "com.fasterxml.jackson.dataformat:jackson-dataformat-xml", version.ref = "jackson" }
 jackson-csv = { module = "com.fasterxml.jackson.dataformat:jackson-dataformat-csv", version.ref = "jackson" }
 jackson-jsr310 = { module = "com.fasterxml.jackson.datatype:jackson-datatype-jsr310", version.ref = "jackson" }
 
 [plugins]
-kotlinter = { id = "org.jmailen.kotlinter", version = "5.0.1" }
+kotlinter = { id = "org.jmailen.kotlinter", version = "5.0.2" }

src/main/kotlin/io/github/projectmapk/jackson/module/kogera/Extensions.kt

@@ -55,10 +55,8 @@ public fun ObjectMapper.registerKotlinModule(
 
 public inline fun <reified T> jacksonTypeRef(): TypeReference<T> = object : TypeReference<T>() {}
 
-/**
- * It is public due to Kotlin restrictions, but should not be used externally.
- */
-public inline fun <reified T> Any?.checkTypeMismatch(): T {
+@PublishedApi
+internal inline fun <reified T> Any?.checkTypeMismatch(): T {
     // Basically, this check assumes that T is non-null and the value is null.
     // Since this can be caused by both input or ObjectMapper implementation errors,
     // a more abstract RuntimeJsonMappingException is thrown.
@@ -84,10 +82,19 @@ public inline fun <reified T> Any?.checkTypeMismatch(): T {
 public inline fun <reified T> ObjectMapper.readValue(jp: JsonParser): T = readValue(jp, jacksonTypeRef<T>())
     .checkTypeMismatch()
 
-// TODO: After importing 2.19, import the changes in kotlin-module and uncomment the tests.
-public inline fun <reified T> ObjectMapper.readValues(
-    jp: JsonParser
-): MappingIterator<T> = readValues(jp, jacksonTypeRef<T>())
+/**
+ * Shorthand for [ObjectMapper.readValues].
+ * @throws RuntimeJsonMappingException Especially if [T] is non-null and the value read is null.
+ *   Other cases where the read value is of a different type than [T]
+ *   due to an incorrect customization to [ObjectMapper].
+ */
+public inline fun <reified T> ObjectMapper.readValues(jp: JsonParser): MappingIterator<T> {
+    val values = readValues(jp, jacksonTypeRef<T>())
+
+    return object : MappingIterator<T>(values) {
+        override fun nextValue(): T = super.nextValue().checkTypeMismatch()
+    }
+}
 
 /**
  * Shorthand for [ObjectMapper.readValue].

src/main/kotlin/io/github/projectmapk/jackson/module/kogera/annotationIntrospector/KotlinPrimaryAnnotationIntrospector.kt

@@ -1,5 +1,7 @@
 package io.github.projectmapk.jackson.module.kogera.annotationIntrospector
 
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.fasterxml.jackson.annotation.OptBoolean
 import com.fasterxml.jackson.databind.JavaType
 import com.fasterxml.jackson.databind.introspect.Annotated
 import com.fasterxml.jackson.databind.introspect.AnnotatedField
@@ -26,29 +28,37 @@ internal class KotlinPrimaryAnnotationIntrospector(
     private val nullToEmptyMap: Boolean,
     private val cache: ReflectionCache
 ) : NopAnnotationIntrospector() {
+    // If a new isRequired is explicitly specified or the old required is true, those values take precedence.
+    // In other cases, override is done by KotlinModule.
+    private fun JsonProperty.forceRequiredByAnnotation(): Boolean? = when {
+        isRequired != OptBoolean.DEFAULT -> isRequired.asBoolean()
+        required -> true
+        else -> null
+    }
+
     // If JsonProperty.required is true, the behavior is clearly specified and the result is paramount.
     // Otherwise, the required is determined from the configuration and the definition on Kotlin.
     override fun hasRequiredMarker(m: AnnotatedMember): Boolean? {
-        val byAnnotation = _findAnnotation(m, JSON_PROPERTY_CLASS)
-            ?.let { if (it.required) return true else false }
+        return cache.getJmClass(m.member.declaringClass)?.let { jmClass ->
+            // To avoid overwriting processing by other modules, annotations are checked after JmClass has been obtained
+            _findAnnotation(m, JSON_PROPERTY_CLASS)
+                ?.forceRequiredByAnnotation()
+                ?.let { return it }
 
-        return cache.getJmClass(m.member.declaringClass)?.let {
             when (m) {
-                is AnnotatedField -> m.hasRequiredMarker(it)
-                is AnnotatedMethod -> m.getRequiredMarkerFromCorrespondingAccessor(it)
-                is AnnotatedParameter -> m.hasRequiredMarker(it)
+                is AnnotatedField -> m.hasRequiredMarker(jmClass)
+                is AnnotatedMethod -> m.getRequiredMarkerFromCorrespondingAccessor(jmClass)
+                is AnnotatedParameter -> m.hasRequiredMarker(jmClass)
                 else -> null
             }
-        } ?: byAnnotation // If a JsonProperty is available, use it to reduce processing costs.
+        }
     }
 
     // Functions that call this may return incorrect results for value classes whose value type is Collection or Map,
     // but this is a rare case and difficult to handle, so it is not supported.
     private fun JavaType.hasDefaultEmptyValue() = (nullToEmptyCollection && isCollectionLikeType) ||
         (nullToEmptyMap && isMapLikeType)
 
-    // The nullToEmpty option also affects serialization,
-    // but deserialization is preferred because there is currently no way to distinguish between contexts.
     private fun AnnotatedField.hasRequiredMarker(jmClass: JmClass): Boolean? {
         // Direct access to `AnnotatedField` is only performed if there is no accessor (defined as JvmField),
         // so if an accessor is defined, it is ignored.
@@ -57,7 +67,7 @@ internal class KotlinPrimaryAnnotationIntrospector(
             // only a check for the existence of a getter is performed.
             // https://youtrack.jetbrains.com/issue/KT-6519
             ?.let {
-                if (it.getterName == null) !(it.returnType.isNullable || type.hasDefaultEmptyValue()) else null
+                if (it.getterName == null) !it.returnType.isNullable else null
             }
     }
 
@@ -68,12 +78,8 @@ internal class KotlinPrimaryAnnotationIntrospector(
     ): Boolean? = when (parameterCount) {
         0 -> jmClass.findPropertyByGetter(member)?.isRequiredByNullability()
         1 -> {
-            if (this.getParameter(0).type.hasDefaultEmptyValue()) {
-                false
-            } else {
-                val memberSignature = member.toSignature()
-                jmClass.properties.find { it.setterSignature == memberSignature }?.isRequiredByNullability()
-            }
+            val memberSignature = member.toSignature()
+            jmClass.properties.find { it.setterSignature == memberSignature }?.isRequiredByNullability()
         }
         else -> null
     }

src/test/kotlin/io/github/projectmapk/jackson/module/kogera/deser/valueInstantiator/argumentBucket/ArgumentBucketTest.kt

@@ -11,10 +11,6 @@ import org.junit.jupiter.api.Nested
 import org.junit.jupiter.api.Test
 
 private class ArgumentBucketTest {
-    val mockConverters: List<ValueClassUnboxConverter<Any>?> = mockk {
-        every { this@mockk[any()] } returns null
-    }
-
     fun mockValueParameter(mockVararg: Boolean = false, mockOptional: Boolean = false) = mockk<JmValueParameter> {
         every { isVararg } returns mockVararg
         every { isOptional } returns mockOptional
@@ -27,7 +23,7 @@ private class ArgumentBucketTest {
             val generator = BucketGenerator(
                 (0..31).map { String::class.java },
                 (0..31).map { mockValueParameter() },
-                mockConverters
+                emptyList()
             )
             val result = generator.generate()
 
@@ -51,7 +47,7 @@ private class ArgumentBucketTest {
                     Double::class.java
                 ),
                 (1..8).map { mockValueParameter() },
-                mockConverters
+                emptyList()
             )
             val result = generator.generate()
 
@@ -70,7 +66,7 @@ private class ArgumentBucketTest {
             val generator = BucketGenerator(
                 (0..32).map { String::class.java },
                 (0..32).map { mockValueParameter() },
-                mockConverters
+                emptyList()
             )
             val result = generator.generate()
 
@@ -89,7 +85,7 @@ private class ArgumentBucketTest {
         val generator = BucketGenerator(
             (0..32).map { String::class.java },
             (0..32).map { mockValueParameter() },
-            mockConverters
+            List(33) { null }
         )
         val sut = generator.generate()
 

src/test/kotlin/io/github/projectmapk/jackson/module/kogera/zIntegration/deser/HasRequiredMarkerTest.kt

@@ -108,10 +108,10 @@ class HasRequiredMarkerTest {
 
             assertFalse(desc.isRequired("nullableProp"))
             assertFalse(desc.isRequired("nullableField"))
-            assertFalse(desc.isRequired("collectionProp"))
-            assertFalse(desc.isRequired("collectionField"))
-            assertFalse(desc.isRequired("mapProp"))
-            assertFalse(desc.isRequired("mapField"))
+            assertTrue(desc.isRequired("collectionProp"))
+            assertTrue(desc.isRequired("collectionField"))
+            assertTrue(desc.isRequired("mapProp"))
+            assertTrue(desc.isRequired("mapField"))
             assertTrue(desc.isRequired("nonNullProp"))
             assertTrue(desc.isRequired("nonNullField"))
         }

src/test/kotlin/io/github/projectmapk/jackson/module/kogera/zIntegration/ser/HasRequiredMarkerTest.kt

@@ -67,9 +67,8 @@ class HasRequiredMarkerTest {
         val map: Map<*, *> = emptyMap<Any, Any>()
     }
 
-    // @see KotlinPrimaryAnnotationIntrospector::AnnotatedField.hasRequiredMarker
     @Test
-    fun failing() {
+    fun `nullToEmpty does not affect for field`() {
         val nullToDefaultMapper = ObjectMapper().registerModule(
             KotlinModule.Builder()
                 .enable(KotlinFeature.NullToEmptyCollection)
@@ -78,13 +77,7 @@ class HasRequiredMarkerTest {
         )
         val desc = nullToDefaultMapper.introspectSer<NullToDefaultTarget>()
 
-        assertFalse(
-            desc.isRequired("collection"),
-            "KotlinPrimaryAnnotationIntrospector::AnnotatedField.hasRequiredMarker fixed"
-        )
-        assertFalse(
-            desc.isRequired("map"),
-            "KotlinPrimaryAnnotationIntrospector::AnnotatedField.hasRequiredMarker fixed"
-        )
+        assertTrue(desc.isRequired("collection"))
+        assertTrue(desc.isRequired("map"))
     }
 }

src/test/kotlin/io/github/projectmapk/jackson/module/kogera/zPorted/ReadValueTest.kt

@@ -21,7 +21,7 @@ class ReadValueTest {
             val src = defaultMapper.createParser("null")
             assertThrows<RuntimeJsonMappingException> {
                 defaultMapper.readValue<String>(src)
-            }.printStackTrace()
+            }
         }
 
         @Test

src/test/kotlin/io/github/projectmapk/jackson/module/kogera/zPorted/ReadValuesTest.kt

@@ -38,9 +38,7 @@ class ReadValuesTest {
             val itr = mapper.readValues<String>(src)
 
             assertEquals("foo", itr.next())
-            // TODO: It is expected to be checked after importing 2.19.
-            // assertThrows<RuntimeJsonMappingException> {
-            assertDoesNotThrow {
+            assertThrows<RuntimeJsonMappingException> {
                 itr.next()
             }
         }
@@ -51,9 +49,7 @@ class ReadValuesTest {
             val itr = mapper.readValues<String>(src)
 
             assertEquals("foo", itr.nextValue())
-            // TODO: It is expected to be checked after importing 2.19.
-            // assertThrows<RuntimeJsonMappingException> {
-            assertDoesNotThrow {
+            assertThrows<RuntimeJsonMappingException> {
                 itr.nextValue()
             }
         }

src/test/kotlin/io/github/projectmapk/jackson/module/kogera/zPorted/test/github/GitHub281.kt

@@ -0,0 +1,60 @@
+package io.github.projectmapk.jackson.module.kogera.zPorted.test.github
+
+import com.fasterxml.jackson.annotation.JsonIdentityInfo
+import com.fasterxml.jackson.annotation.JsonTypeInfo
+import com.fasterxml.jackson.annotation.ObjectIdGenerators
+import io.github.projectmapk.jackson.module.kogera.KotlinFeature
+import io.github.projectmapk.jackson.module.kogera.jacksonObjectMapper
+import io.github.projectmapk.jackson.module.kogera.readValue
+import io.github.projectmapk.jackson.module.kogera.testPrettyWriter
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+class GitHub281 {
+    @JsonTypeInfo(use = JsonTypeInfo.Id.MINIMAL_CLASS, include = JsonTypeInfo.As.PROPERTY, property = "@type")
+    @JsonIdentityInfo(generator = ObjectIdGenerators.IntSequenceGenerator::class, property = "@id")
+    interface Entity
+
+    object NumberEntity : Entity
+
+    data class NumberValue(val value: Int) {
+        val entity = NumberEntity
+    }
+
+    private val json = """
+        [ {
+          "value" : 10,
+          "entity" : {
+            "@type" : ".GitHub281${'$'}NumberEntity",
+            "@id" : 1
+          }
+        }, {
+          "value" : 11,
+          "entity" : 1
+        } ]
+        """.trimIndent()
+
+    @Test
+    fun `test writing involving type, id and object`() {
+        val input = listOf(NumberValue(10), NumberValue(11))
+
+        val output = jacksonObjectMapper()
+            .testPrettyWriter()
+            .writeValueAsString(input)
+
+        assertEquals(json, output)
+    }
+
+    @Test
+    fun `test reading involving type, id and object`() {
+        val output = jacksonObjectMapper { disable(KotlinFeature.SingletonSupport) }
+            .readValue<List<NumberValue>>(json)
+
+        assertEquals(2, output.size)
+        val (a, b) = output
+        assertEquals(NumberEntity::class.java, a.entity.javaClass)
+        assertEquals(NumberEntity::class.java, b.entity.javaClass)
+        assertEquals(10, a.value)
+        assertEquals(11, b.value)
+    }
+}