Allow to add arbitrary values to PropertyBag

build.gradle.kts

@@ -41,6 +41,7 @@ kotlin {
                 implementation(kotlin("stdlib"))
                 implementation(kotlin("test"))
                 implementation("org.junit.jupiter:junit-jupiter-api:5.10.2")
+                implementation("org.junit.jupiter:junit-jupiter-params:5.10.2")
                 runtimeOnly("org.junit.jupiter:junit-jupiter-engine:5.10.2")
             }
         }

src/commonMain/kotlin/io/github/detekt/sarif4k/JsonElementExtensions.kt

@@ -0,0 +1,62 @@
+package io.github.detekt.sarif4k
+
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonNull
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+
+// Extracted from https://github.com/Kotlin/kotlinx.serialization/issues/296#issuecomment-1859572541
+private fun Any?.toJsonElement(): JsonElement = when (this) {
+    null -> JsonNull
+    is JsonElement -> this
+    is Map<*, *> -> toJsonElement()
+    is Collection<*> -> toJsonElement()
+    is Boolean -> JsonPrimitive(this)
+    is Number -> JsonPrimitive(this)
+    is String -> JsonPrimitive(this)
+    is Enum<*> -> JsonPrimitive(this.toString())
+    is ByteArray -> this.toList().toJsonElement()
+    is CharArray -> this.toList().toJsonElement()
+    is ShortArray -> this.toList().toJsonElement()
+    is IntArray -> this.toList().toJsonElement()
+    is LongArray -> this.toList().toJsonElement()
+    is FloatArray -> this.toList().toJsonElement()
+    is DoubleArray -> this.toList().toJsonElement()
+    is BooleanArray -> this.toList().toJsonElement()
+    is Array<*> -> toJsonElement()
+    else -> error("Can't serialize unknown type: $this")
+}
+
+internal fun Map<*, *>.toJsonElement(): JsonObject {
+    val map = this.map { (key, value) ->
+        key as? String ?: error("$key is not allowed as JSON key, please use a String!")
+        key to value.toJsonElement()
+    }
+    return JsonObject(map.toMap())
+}
+
+private fun Collection<*>.toJsonElement(): JsonArray {
+    return JsonArray(this.map { it.toJsonElement() })
+}
+
+private fun Array<*>.toJsonElement(): JsonArray {
+    return JsonArray(this.map { it.toJsonElement() })
+}
+
+private fun JsonElement.toNativeObject(): Any? = when (this) {
+    JsonNull -> null
+    is JsonArray -> this.map { it.toNativeObject() }
+    is JsonObject -> this.toNativeObject()
+    is JsonPrimitive -> if (isString) content else {
+        content
+            .toBooleanStrictOrNull()
+            ?: content.toLongOrNull()
+            ?: content.toDoubleOrNull()
+            ?: error("Unknown primitive: $content")
+    }
+}
+
+internal fun JsonObject.toNativeObject(): Map<String, Any?> {
+    return this.map { (key, value) -> key to value.toNativeObject() }.toMap()
+}

src/commonMain/kotlin/io/github/detekt/sarif4k/Merging.kt

@@ -1,4 +1,5 @@
 @file:JvmName("Merging")
+
 package io.github.detekt.sarif4k
 
 import kotlin.jvm.JvmName
@@ -10,7 +11,12 @@ fun SarifSchema210.merge(other: SarifSchema210): SarifSchema210 {
     val mergedExternalProperties = (inlineExternalProperties.orEmpty() + other.inlineExternalProperties.orEmpty())
         .takeIf { it.isNotEmpty() }
 
-    val mergedProperties = properties.merge(other.properties)
+    val mergedProperties = when {
+        properties != null && other.properties != null -> properties.merge(other.properties)
+        properties != null -> properties
+        other.properties != null -> other.properties
+        else -> null
+    }
 
     val mergedRuns = runs.merge(other.runs)
 
@@ -23,14 +29,19 @@ fun SarifSchema210.merge(other: SarifSchema210): SarifSchema210 {
     )
 }
 
-fun PropertyBag?.merge(other: PropertyBag?): PropertyBag? {
-    return (this?.tags.orEmpty() + other?.tags.orEmpty())
-        .distinct()
-        .takeIf { it.isNotEmpty() }
-        ?.let { PropertyBag(it) }
+private fun PropertyBag.merge(other: PropertyBag): PropertyBag {
+    val aTags = this["tags"] as? Collection<*>
+    val bTags = other["tags"] as? Collection<*>
+    val tags = if (aTags != null && bTags != null) {
+        mapOf("tags" to (aTags + bTags).distinct())
+    } else {
+        emptyMap()
+    }
+
+    return PropertyBag(this + other + tags)
 }
 
-fun List<Run>.merge(other: List<Run>): List<Run> {
+private fun List<Run>.merge(other: List<Run>): List<Run> {
     val runsByTool = (this + other).groupBy { it.tool.driver.fullName }
 
     return runsByTool.mapValues { (_, runs) ->

src/commonMain/kotlin/io/github/detekt/sarif4k/SarifDataBindings.kt

@@ -8,6 +8,8 @@ import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
 import kotlinx.serialization.descriptors.SerialDescriptor
 import kotlinx.serialization.encoding.Decoder
 import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.json.JsonObject
+import kotlin.jvm.JvmInline
 
 /*
  * Using https://app.quicktype.io/ to generate from schema
@@ -339,13 +341,41 @@ data class Address (
  *
  * Key/value pairs that provide additional information about the version control details.
  */
-@Serializable
-data class PropertyBag (
+@Serializable(with = PropertyBag.Companion::class)
+@JvmInline
+value class PropertyBag(
+    private val value: Map<String, Any?>,
+) : Map<String, Any?> by value {
     /**
      * A set of distinct strings that provide additional information.
      */
-    val tags: List<String>? = null
-)
+    val tags: List<String>?
+        get() = try {
+            val tagList = value["tags"] as Collection<*>?
+            tagList?.mapIndexed { position, it ->
+                try {
+                    it as String
+                } catch (e: ClassCastException) {
+                    throw IllegalStateException("the tag \"$it\" at the position $position is not a String", e)
+                }
+            }
+        } catch (e: ClassCastException) {
+            throw IllegalStateException("tags should be a collection", e)
+        }
+
+    companion object : KSerializer<PropertyBag> {
+        override val descriptor: SerialDescriptor = JsonObject.serializer().descriptor
+
+        override fun deserialize(decoder: Decoder): PropertyBag {
+            val jsonObject = decoder.decodeSerializableValue(JsonObject.serializer())
+            return PropertyBag(jsonObject.toNativeObject())
+        }
+
+        override fun serialize(encoder: Encoder, value: PropertyBag) {
+            encoder.encodeSerializableValue(JsonObject.serializer(), value.toJsonElement())
+        }
+    }
+}
 
 /**
  * A single artifact. In some cases, this artifact might be nested within another artifact.

src/jvmTest/kotlin/io/github/detekt/sarif4k/PropertyBagTest.kt

@@ -0,0 +1,80 @@
+package io.github.detekt.sarif4k
+
+import kotlinx.serialization.json.Json
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.Arguments
+import org.junit.jupiter.params.provider.MethodSource
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.fail
+
+class PropertyBagTest {
+
+    @ParameterizedTest
+    @MethodSource("data")
+    fun encode(value: Map<String, Any?>, json: String) {
+        assertEquals(json, Json.encodeToString(PropertyBag.serializer(), PropertyBag(value)))
+    }
+
+    @ParameterizedTest
+    @MethodSource("data")
+    fun decode(value: Map<String, Any?>, json: String) {
+        assertEquals(PropertyBag(value), Json.decodeFromString(PropertyBag.serializer(), json))
+    }
+
+    @Test
+    fun noTags() {
+        assertEquals(null, PropertyBag(mapOf()).tags)
+    }
+
+    @Test
+    fun nullTags() {
+        assertEquals(null, PropertyBag(mapOf("tags" to null)).tags)
+    }
+
+    @Test
+    fun emptyTags() {
+        assertEquals(emptyList(), PropertyBag(mapOf("tags" to emptyList<Nothing>())).tags)
+    }
+
+    @Test
+    fun tags() {
+        assertEquals(listOf("foo", "bar"), PropertyBag(mapOf("tags" to listOf("foo", "bar"))).tags)
+    }
+
+    @Test
+    fun incorrectTags_noList() {
+        try {
+            PropertyBag(mapOf("tags" to 1)).tags
+            fail()
+        } catch (e: IllegalStateException) {
+            assertEquals("tags should be a collection", e.message)
+            assertNotNull(e.cause)
+        }
+    }
+
+    @Test
+    fun incorrectTags_noString() {
+        try {
+            PropertyBag(mapOf("tags" to listOf("foo", true, "bar"))).tags
+            fail()
+        } catch (e: IllegalStateException) {
+            assertEquals("the tag \"true\" at the position 1 is not a String", e.message)
+            assertNotNull(e.cause)
+        }
+    }
+
+    companion object {
+        @JvmStatic
+        fun data(): List<Arguments> {
+            return listOf(
+                mapOf<String, Any?>() to """{}""",
+                mapOf("foo" to null) to """{"foo":null}""",
+                mapOf("foo" to mapOf("bar" to listOf("1", 2L, false, 3.5))) to """{"foo":{"bar":["1",2,false,3.5]}}""",
+                mapOf("tags" to null) to """{"tags":null}""",
+                mapOf("tags" to emptyList<Nothing>()) to """{"tags":[]}""",
+            ).map { (first, second) -> Arguments.of(first, second) }
+        }
+    }
+}

src/jvmTest/kotlin/io/github/detekt/sarif4k/SarifMergingTest.kt

@@ -2,7 +2,6 @@ package io.github.detekt.sarif4k
 
 import io.github.detekt.sarif4k.util.resourceAsTextContent
 import org.junit.jupiter.api.Test
-import java.io.File
 import kotlin.test.assertEquals
 
 class SarifMergingTest {

src/jvmTest/kotlin/io/github/detekt/sarif4k/SarifSerializerTest.kt

@@ -45,8 +45,11 @@ class SarifSerializerTest {
                                     )
                                 ),
                                 properties = PropertyBag(
-                                    tags = listOf("tag")
-                                )
+                                    mapOf(
+                                        "tags" to listOf("tag"),
+                                        "foo" to mapOf("bar" to "buz")
+                                    )
+                                ),
                             )
                         )
                     ),

src/jvmTest/resources/input_1.sarif.json

@@ -102,6 +102,9 @@
     "tags": [
       "tag",
       "tag1"
-    ]
+    ],
+    "foo": {
+      "bar": "buz"
+    }
   }
 }

src/jvmTest/resources/input_2.sarif.json

@@ -102,6 +102,7 @@
     "tags": [
       "tag",
       "tag2"
-    ]
+    ],
+    "bar": 5
   }
 }

src/jvmTest/resources/output.sarif.json

@@ -174,6 +174,10 @@
             "tag",
             "tag1",
             "tag2"
-        ]
+        ],
+        "foo": {
+            "bar": "buz"
+        },
+        "bar": 5
     }
 }

src/jvmTest/resources/output_different_tool.sarif.json

@@ -189,6 +189,9 @@
         "tags": [
             "tag",
             "tag1"
-        ]
+        ],
+        "foo": {
+            "bar": "buz"
+        }
     }
 }

src/jvmTest/resources/test.sarif.json

@@ -25,7 +25,10 @@
               "properties": {
                 "tags": [
                   "tag"
-                ]
+                ],
+                "foo": {
+                  "bar": "buz"
+                }
               }
             }
           ],