Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

feat: add YamlContentPolymorphicSerializer, similar to JsonContentPolymorphicSerializer #607

Merged
merged 10 commits into from
Nov 14, 2024
Original file line number Diff line number Diff line change
@@ -0,0 +1,66 @@
/*

Copyright 2018-2023 Charles Korn.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

https://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

*/

package com.charleskorn.kaml

import kotlinx.serialization.DeserializationStrategy
import kotlinx.serialization.ExperimentalSerializationApi
import kotlinx.serialization.InternalSerializationApi
import kotlinx.serialization.KSerializer
import kotlinx.serialization.SerializationException
import kotlinx.serialization.descriptors.PolymorphicKind
import kotlinx.serialization.descriptors.SerialDescriptor
import kotlinx.serialization.descriptors.buildSerialDescriptor
import kotlinx.serialization.encoding.Decoder
import kotlinx.serialization.encoding.Encoder
import kotlinx.serialization.serializerOrNull
import kotlin.reflect.KClass

@OptIn(ExperimentalSerializationApi::class)
public abstract class YamlContentPolymorphicSerializer<T : Any>(private val baseClass: KClass<T>) : KSerializer<T> {
@OptIn(InternalSerializationApi::class)
override val descriptor: SerialDescriptor = buildSerialDescriptor(
"${YamlContentPolymorphicSerializer::class.simpleName}<${baseClass.simpleName}>",
PolymorphicKind.SEALED,
)

@OptIn(InternalSerializationApi::class)
override fun serialize(encoder: Encoder, value: T) {
val actualSerializer = encoder.serializersModule.getPolymorphic(baseClass, value)
?: value::class.serializerOrNull()
?: throwSubtypeNotRegistered(value::class, baseClass)
@Suppress("UNCHECKED_CAST")
(actualSerializer as KSerializer<T>).serialize(encoder, value)
}

override fun deserialize(decoder: Decoder): T {
return decoder.decodeSerializableValue(selectDeserializer((decoder as YamlInput).node))
}

public abstract fun selectDeserializer(node: YamlNode): DeserializationStrategy<T>

private fun throwSubtypeNotRegistered(subClass: KClass<*>, baseClass: KClass<*>): Nothing {
val subClassName = subClass.simpleName ?: "$subClass"
throw SerializationException(
"""
Class '$subClassName' is not registered for polymorphic serialization in the scope of '${baseClass.simpleName}'.
Mark the base class as 'sealed' or register the serializer explicitly.
""".trimIndent(),
)
}
}
27 changes: 21 additions & 6 deletions src/commonMain/kotlin/com/charleskorn/kaml/YamlInput.kt
Original file line number Diff line number Diff line change
Expand Up @@ -49,7 +49,13 @@ public sealed class YamlInput(
is YamlScalar -> when {
descriptor.kind is PrimitiveKind || descriptor.kind is SerialKind.ENUM || descriptor.isInline -> YamlScalarInput(node, yaml, context, configuration)
descriptor.kind is SerialKind.CONTEXTUAL -> createContextual(node, yaml, context, configuration, descriptor)
descriptor.kind is PolymorphicKind -> throw MissingTypeTagException(node.path)
descriptor.kind is PolymorphicKind -> {
if (descriptor.isContentBasedPolymorphic) {
createContextual(node, yaml, context, configuration, descriptor)
} else {
throw MissingTypeTagException(node.path)
}
}
else -> throw IncorrectTypeException("Expected ${descriptor.kind.friendlyDescription}, but got a scalar value", node.path)
}

Expand All @@ -63,11 +69,18 @@ public sealed class YamlInput(
is StructureKind.CLASS, StructureKind.OBJECT -> YamlObjectInput(node, yaml, context, configuration)
is StructureKind.MAP -> YamlMapInput(node, yaml, context, configuration)
is SerialKind.CONTEXTUAL -> createContextual(node, yaml, context, configuration, descriptor)
is PolymorphicKind -> when (configuration.polymorphismStyle) {
PolymorphismStyle.None ->
throw IncorrectTypeException("Encountered a polymorphic map descriptor but PolymorphismStyle is 'None'", node.path)
PolymorphismStyle.Tag -> throw MissingTypeTagException(node.path)
PolymorphismStyle.Property -> createPolymorphicMapDeserializer(node, yaml, context, configuration)
is PolymorphicKind -> {
if (descriptor.isContentBasedPolymorphic) {
createContextual(node, yaml, context, configuration, descriptor)
} else {
when (configuration.polymorphismStyle) {
PolymorphismStyle.None ->
throw IncorrectTypeException("Encountered a polymorphic map descriptor but PolymorphismStyle is 'None'", node.path)

PolymorphismStyle.Tag -> throw MissingTypeTagException(node.path)
PolymorphismStyle.Property -> createPolymorphicMapDeserializer(node, yaml, context, configuration)
}
}
}
else -> throw IncorrectTypeException("Expected ${descriptor.kind.friendlyDescription}, but got a map", node.path)
}
Expand Down Expand Up @@ -115,6 +128,8 @@ public sealed class YamlInput(
private fun YamlMap.withoutKey(key: String): YamlMap {
return this.copy(entries = entries.filterKeys { it.content != key })
}

private val SerialDescriptor.isContentBasedPolymorphic get() = serialName.startsWith(YamlContentPolymorphicSerializer::class.simpleName!!)
Copy link
Owner

@charleskorn charleskorn Nov 3, 2024

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Rather than checking the name like this, what if we introduced an annotation that is added to the SerialDescriptor created by YamlContentPolymorphicSerializer, then checked for its presence here?

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The annotation is implemented as internal for now. Or should it be public?

Copy link
Owner

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

internal seems fine to me, it's an implementation detail.

}

override fun <T> decodeSerializableValue(deserializer: DeserializationStrategy<T>): T {
Expand Down
Jojo4GH marked this conversation as resolved.
Show resolved Hide resolved
Original file line number Diff line number Diff line change
@@ -0,0 +1,195 @@
/*

Copyright 2018-2023 Charles Korn.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

https://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

*/

package com.charleskorn.kaml

import com.charleskorn.kaml.testobjects.TestSealedStructure
import com.charleskorn.kaml.testobjects.polymorphicModule
import io.kotest.assertions.asClue
import io.kotest.assertions.throwables.shouldThrow
import io.kotest.matchers.shouldBe
import kotlinx.serialization.DeserializationStrategy
import kotlinx.serialization.SerializationException
import kotlinx.serialization.builtins.ListSerializer
import kotlinx.serialization.builtins.nullable

class YamlContentPolymorphicSerializerTest : FlatFunSpec({
context("a YAML parser") {
context("parsing polymorphic values with PolymorphismStyle.None") {
val polymorphicYaml = Yaml(
serializersModule = polymorphicModule,
configuration = YamlConfiguration(polymorphismStyle = PolymorphismStyle.None),
)

context("given some input where the value should be a sealed class") {
val input = """
value: "asdfg"
""".trimIndent()

val result = polymorphicYaml.decodeFromString(TestSealedStructureBasedOnContentSerializer, input)

test("deserializes it to a Kotlin object") {
result shouldBe TestSealedStructure.SimpleSealedString("asdfg")
}
}

context("given some input where the value should be a sealed class (inline)") {
val input = """
"abcdef"
""".trimIndent()

val result = polymorphicYaml.decodeFromString(TestSealedStructureBasedOnContentSerializer, input)

test("deserializes it to a Kotlin object") {
result shouldBe TestSealedStructure.InlineSealedString("abcdef")
}
}

context("given some input missing without the serializer") {
val input = """
value: "asdfg"
""".trimIndent()

test("throws an exception with the correct location information") {
val exception = shouldThrow<IncorrectTypeException> {
polymorphicYaml.decodeFromString(TestSealedStructure.serializer(), input)
}

exception.asClue {
it.message shouldBe "Encountered a polymorphic map descriptor but PolymorphismStyle is 'None'"
it.line shouldBe 1
it.column shouldBe 1
it.path shouldBe YamlPath.root
}
}
}

context("given some input representing a list of polymorphic objects") {
val input = """
- value: null
- value: -987
- value: 654
- "testing"
- value: "tests"
""".trimIndent()

val result = polymorphicYaml.decodeFromString(
ListSerializer(TestSealedStructureBasedOnContentSerializer),
input,
)

test("deserializes it to a Kotlin object") {
result shouldBe listOf(
TestSealedStructure.SimpleSealedString(null),
TestSealedStructure.SimpleSealedInt(-987),
TestSealedStructure.SimpleSealedInt(654),
TestSealedStructure.InlineSealedString("testing"),
TestSealedStructure.SimpleSealedString("tests"),
)
}
}

context("given some input with a tag and a type property") {
val input = """
!<sealedInt>
kind: sealedString
value: "asdfg"
""".trimIndent()

test("throws an exception with the correct location information") {
val exception = shouldThrow<IncorrectTypeException> {
polymorphicYaml.decodeFromString(TestSealedStructureBasedOnContentSerializer, input)
}

exception.asClue {
it.message shouldBe "Encountered a tagged polymorphic descriptor but PolymorphismStyle is 'None'"
it.line shouldBe 1
it.column shouldBe 1
it.path shouldBe YamlPath.root
}
}
}
}
}
context("a YAML serializer") {
context("serializing polymorphic values with custom serializer") {
val polymorphicYaml = Yaml(
serializersModule = polymorphicModule,
configuration = YamlConfiguration(polymorphismStyle = PolymorphismStyle.Tag),
)

context("serializing a sealed type") {
val input = TestSealedStructure.SimpleSealedInt(5)
val output = polymorphicYaml.encodeToString(TestSealedStructureBasedOnContentSerializer, input)
val expectedYaml = """
value: 5
""".trimIndent()

test("returns the value serialized in the expected YAML form") {
output shouldBe expectedYaml
}
}

context("serializing a list of polymorphic values") {
val input = listOf(
TestSealedStructure.SimpleSealedInt(5),
TestSealedStructure.SimpleSealedString("some test"),
TestSealedStructure.SimpleSealedInt(-20),
TestSealedStructure.InlineSealedString("testing"),
TestSealedStructure.SimpleSealedString(null),
null,
)

val output = polymorphicYaml.encodeToString(
ListSerializer(TestSealedStructureBasedOnContentSerializer.nullable),
input,
)

val expectedYaml = """
- value: 5
- value: "some test"
- value: -20
- "testing"
- value: null
- null
""".trimIndent()

test("returns the value serialized in the expected YAML form") {
output shouldBe expectedYaml
}
}
}
}
})

object TestSealedStructureBasedOnContentSerializer : YamlContentPolymorphicSerializer<TestSealedStructure>(
TestSealedStructure::class,
) {
override fun selectDeserializer(node: YamlNode): DeserializationStrategy<TestSealedStructure> = when (node) {
is YamlScalar -> TestSealedStructure.InlineSealedString.serializer()
is YamlMap -> when (val value: YamlNode? = node["value"]) {
is YamlScalar -> when {
value.content.toIntOrNull() == null -> TestSealedStructure.SimpleSealedString.serializer()
else -> TestSealedStructure.SimpleSealedInt.serializer()
}
is YamlNull -> TestSealedStructure.SimpleSealedString.serializer()
else -> throw SerializationException("Unsupported property type for TestSealedStructure.value: ${value?.let { it::class.simpleName}}")
}
else -> throw SerializationException("Unsupported node type for TestSealedStructure: ${node::class.simpleName}")
}
}