JAVA-5894 Refactor BsonNamingStrategy into fun interface

bson-kotlinx/src/main/kotlin/org/bson/codecs/kotlinx/BsonConfiguration.kt

@@ -15,6 +15,9 @@
  */
 package org.bson.codecs.kotlinx
 
+import kotlinx.serialization.ExperimentalSerializationApi
+import org.bson.codecs.kotlinx.utils.BsonCodecUtils.convertCamelCase
+
 /**
  * Bson Configuration for serialization
  *
@@ -37,13 +40,32 @@ public data class BsonConfiguration(
 /**
  * Optional BSON naming strategy for a field.
  *
- * @since 5.4
+ * @since 5.6
  */
-public enum class BsonNamingStrategy {
+@OptIn(ExperimentalSerializationApi::class)
+public fun interface BsonNamingStrategy {
+
+    public fun transformName(serialName: String): String
+
+    public companion object {
+        /**
+         * A strategy that transforms serial names from camel case to snake case — lowercase characters with words
+         * separated by underscores.
+         */
+        public val SNAKE_CASE: BsonNamingStrategy =
+            object : BsonNamingStrategy {
+                override fun transformName(serialName: String): String = convertCamelCase(serialName, '_')
+                override fun toString() = "BsonNamingStrategySnakeCase"
+            }
 
-    /**
-     * A strategy that transforms serial names from camel case to snake case — lowercase characters with words separated
-     * by underscores.
-     */
-    SNAKE_CASE,
+        /**
+         * A strategy that transforms serial names from camel case to kebab case — lowercase characters with words
+         * separated by hyphens.
+         */
+        public val KEBAB_CASE: BsonNamingStrategy =
+            object : BsonNamingStrategy {
+                override fun transformName(serialName: String): String = convertCamelCase(serialName, '-')
+                override fun toString() = "BsonNamingStrategyKebabCase"
+            }
+    }
 }

bson-kotlinx/src/main/kotlin/org/bson/codecs/kotlinx/BsonDecoder.kt

@@ -133,7 +133,7 @@ internal sealed class AbstractBsonDecoder(
 
         return name?.let {
             val index =
-                if (configuration.bsonNamingStrategy == BsonNamingStrategy.SNAKE_CASE) {
+                if (configuration.bsonNamingStrategy != null) {
                     getCachedElementNamesByDescriptor(descriptor)[it]?.let { name -> descriptor.getElementIndex(name) }
                         ?: UNKNOWN_NAME
                 } else {

bson-kotlinx/src/main/kotlin/org/bson/codecs/kotlinx/BsonEncoder.kt

@@ -31,7 +31,6 @@ import org.bson.BsonValue
 import org.bson.BsonWriter
 import org.bson.codecs.BsonValueCodec
 import org.bson.codecs.EncoderContext
-import org.bson.codecs.kotlinx.utils.BsonCodecUtils.convertCamelCase
 import org.bson.types.ObjectId
 
 /**
@@ -204,14 +203,7 @@ internal open class BsonEncoderImpl(
     }
 
     internal fun encodeName(value: Any) {
-        val name =
-            value.toString().let {
-                if (configuration.bsonNamingStrategy == BsonNamingStrategy.SNAKE_CASE) {
-                    convertCamelCase(it, '_')
-                } else {
-                    it
-                }
-            }
+        val name = value.toString().let { configuration.bsonNamingStrategy?.transformName(it) ?: it }
         writer.writeName(name)
         state = STATE.VALUE
     }

bson-kotlinx/src/main/kotlin/org/bson/codecs/kotlinx/JsonBsonDecoder.kt

@@ -31,7 +31,7 @@ import org.bson.AbstractBsonReader
 import org.bson.BsonBinarySubType
 import org.bson.BsonType
 import org.bson.UuidRepresentation
-import org.bson.codecs.kotlinx.utils.BsonCodecUtils.toJsonNamingStrategy
+import org.bson.codecs.kotlinx.utils.BsonCodecUtils.asJsonNamingStrategy
 import org.bson.internal.UuidHelper
 
 @OptIn(ExperimentalSerializationApi::class)
@@ -43,7 +43,7 @@ internal interface JsonBsonDecoder : BsonDecoder, JsonDecoder {
         explicitNulls = configuration.explicitNulls
         encodeDefaults = configuration.encodeDefaults
         classDiscriminator = configuration.classDiscriminator
-        namingStrategy = configuration.bsonNamingStrategy.toJsonNamingStrategy()
+        namingStrategy = configuration.bsonNamingStrategy.asJsonNamingStrategy()
         serializersModule = [email protected]
     }
 

bson-kotlinx/src/main/kotlin/org/bson/codecs/kotlinx/JsonBsonEncoder.kt

@@ -30,7 +30,7 @@ import kotlinx.serialization.json.int
 import kotlinx.serialization.json.long
 import kotlinx.serialization.modules.SerializersModule
 import org.bson.BsonWriter
-import org.bson.codecs.kotlinx.utils.BsonCodecUtils.toJsonNamingStrategy
+import org.bson.codecs.kotlinx.utils.BsonCodecUtils.asJsonNamingStrategy
 import org.bson.types.Decimal128
 
 @OptIn(ExperimentalSerializationApi::class)
@@ -53,7 +53,7 @@ internal class JsonBsonEncoder(
         explicitNulls = configuration.explicitNulls
         encodeDefaults = configuration.encodeDefaults
         classDiscriminator = configuration.classDiscriminator
-        namingStrategy = configuration.bsonNamingStrategy.toJsonNamingStrategy()
+        namingStrategy = configuration.bsonNamingStrategy.asJsonNamingStrategy()
         serializersModule = [email protected]
     }
 

bson-kotlinx/src/main/kotlin/org/bson/codecs/kotlinx/utils/BsonCodecUtils.kt

@@ -125,25 +125,25 @@ internal object BsonCodecUtils {
 
     internal fun cacheElementNamesByDescriptor(descriptor: SerialDescriptor, configuration: BsonConfiguration) {
         val convertedNameMap =
-            when (configuration.bsonNamingStrategy) {
-                BsonNamingStrategy.SNAKE_CASE -> {
-                    val snakeCasedNames = descriptor.elementNames.associateWith { name -> convertCamelCase(name, '_') }
-
-                    snakeCasedNames.entries
-                        .groupBy { entry -> entry.value }
-                        .filter { group -> group.value.size > 1 }
-                        .entries
-                        .fold(StringBuilder("")) { acc, group ->
-                            val keys = group.value.joinToString(", ") { entry -> entry.key }
-                            acc.append("$keys in ${descriptor.serialName} generate same name: ${group.key}.\n")
-                        }
-                        .toString()
-                        .takeIf { it.trim().isNotEmpty() }
-                        ?.let { errorMessage: String -> throw SerializationException(errorMessage) }
+            if (configuration.bsonNamingStrategy != null) {
+                val transformedNames =
+                    descriptor.elementNames.associateWith(configuration.bsonNamingStrategy::transformName)
+
+                transformedNames.entries
+                    .groupBy { entry -> entry.value }
+                    .filter { group -> group.value.size > 1 }
+                    .entries
+                    .fold(StringBuilder("")) { acc, group ->
+                        val keys = group.value.joinToString(", ") { entry -> entry.key }
+                        acc.append("$keys in ${descriptor.serialName} generate same name: ${group.key}.\n")
+                    }
+                    .toString()
+                    .takeIf { it.trim().isNotEmpty() }
+                    ?.let { errorMessage: String -> throw SerializationException(errorMessage) }
 
-                    snakeCasedNames.entries.associate { it.value to it.key }
-                }
-                else -> emptyMap()
+                transformedNames.entries.associate { it.value to it.key }
+            } else {
+                emptyMap()
             }
 
         cachedElementNamesByDescriptor[descriptor.serialName] = convertedNameMap
@@ -185,10 +185,9 @@ internal object BsonCodecUtils {
             }
         }
 
-    internal fun BsonNamingStrategy?.toJsonNamingStrategy(): JsonNamingStrategy? {
-        return when (this) {
-            BsonNamingStrategy.SNAKE_CASE -> JsonNamingStrategy.SnakeCase
-            else -> null
-        }
+    internal fun BsonNamingStrategy?.asJsonNamingStrategy(): JsonNamingStrategy? {
+        this ?: return null
+
+        return JsonNamingStrategy { descriptor, index, serialName -> this.transformName(serialName) }
     }
 }

bson-kotlinx/src/test/kotlin/org/bson/codecs/kotlinx/KotlinSerializerCodecTest.kt

@@ -1139,6 +1139,16 @@ class KotlinSerializerCodecTest {
         assertRoundTrips(expected, dataClass, BsonConfiguration(bsonNamingStrategy = BsonNamingStrategy.SNAKE_CASE))
     }
 
+    @Test
+    fun testKebabCaseNamingStrategy() {
+        val expected =
+            """{"two-words": "", "my-property": "", "camel_-case_-underscores": "", "url-mapping": "",
+            | "my-http-auth": "", "my-http2-api-key": "", "my-http2fast-api-key": ""}"""
+                .trimMargin()
+        val dataClass = DataClassWithCamelCase()
+        assertRoundTrips(expected, dataClass, BsonConfiguration(bsonNamingStrategy = BsonNamingStrategy.KEBAB_CASE))
+    }
+
     @Test
     fun testSameSnakeCaseName() {
         val expected = """{"my_http_auth": "", "my_http_auth1": ""}"""