Enhanced String.replaceWithArgs to support non-positional format specifiers (%s, %d) when only one argument is provided

Author: Wojciech Liberda

components/resources/library/src/commonMain/kotlin/org/jetbrains/compose/resources/StringResourcesUtils.kt

@@ -4,9 +4,23 @@ import org.jetbrains.compose.resources.plural.PluralCategory
 import kotlin.io.encoding.Base64
 import kotlin.io.encoding.ExperimentalEncodingApi
 
-private val SimpleStringFormatRegex = Regex("""%(\d+)\$[ds]""")
-internal fun String.replaceWithArgs(args: List<String>) = SimpleStringFormatRegex.replace(this) { matchResult ->
-    args[matchResult.groupValues[1].toInt() - 1]
+private val SimpleStringFormatRegex = Regex("""%(?:([1-9]\d*)\$)?[ds]""")
+internal fun String.replaceWithArgs(args: List<String>): String {
+    if (!SimpleStringFormatRegex.containsMatchIn(this)) return this
+
+    return SimpleStringFormatRegex.replace(this) { match ->
+        val placeholderNumber = match.groups[1]?.value?.toIntOrNull()
+        val index = when {
+            placeholderNumber != null -> placeholderNumber - 1
+            args.size == 1 -> 0
+            else -> {
+                throw IllegalArgumentException(
+                    "Formatting failed: Non-positional placeholder '${match.value}' is ambiguous when multiple arguments are provided in \"$this\""
+                )
+            }
+        }
+        args[index]
+    }
 }
 
 internal sealed interface StringItem {
@@ -16,14 +30,15 @@ internal sealed interface StringItem {
 }
 
 private val stringItemsCache = AsyncCache<String, StringItem>()
+
 //@TestOnly
 internal fun dropStringItemsCache() {
     stringItemsCache.clear()
 }
 
 internal suspend fun getStringItem(
     resourceItem: ResourceItem,
-    resourceReader: ResourceReader
+    resourceReader: ResourceReader,
 ): StringItem = stringItemsCache.getOrLoad(
     key = "${resourceItem.path}/${resourceItem.offset}-${resourceItem.size}"
 ) {

components/resources/library/src/commonTest/kotlin/org/jetbrains/compose/resources/StringFormatTest.kt

@@ -180,4 +180,34 @@ class StringFormatTest {
         // Only the first argument should be used, ignoring the rest
         assertEquals("Hello Alice!", result)
     }
-}
+
+    @Test
+    fun `replaceWithArgs handle single argument format`() {
+        val template = "Hello %s!"
+        val args = listOf("Alice")
+
+        val result = template.replaceWithArgs(args)
+
+        assertEquals("Hello Alice!", result)
+    }
+
+    @Test
+    fun `replaceWithArgs handle multiple placeholders for single argument`() {
+        val template = "%1\$s and %1\$s are best friends!"
+        val args = listOf("Alice")
+
+        val result = template.replaceWithArgs(args)
+
+        assertEquals("Alice and Alice are best friends!", result)
+    }
+
+    @Test
+    fun `replaceWithArgs throw exception when multiple arguments with single placeholder format`() {
+        val template = "Hello %s, you have %d new messages!"
+        val args = listOf("Alice", "15")
+
+        assertFailsWith<IllegalArgumentException> {
+            template.replaceWithArgs(args)
+        }
+    }
+}