add currency formatter stuff from #6653 (salvaged it because it seems abandoned)

Author: westnordost

app/src/androidMain/kotlin/de/westnordost/streetcomplete/util/locale/CurrencyFormatter.android.kt

@@ -0,0 +1,16 @@
+package de.westnordost.streetcomplete.util.locale
+
+import java.text.NumberFormat
+import java.util.Locale
+
+actual class CurrencyFormatter actual constructor(locale: androidx.compose.ui.text.intl.Locale?) {
+
+    private val formatter =
+        if (locale == null) NumberFormat.getCurrencyInstance()
+        else NumberFormat.getCurrencyInstance(locale.platformLocale)
+
+    actual fun format(value: Double): String =
+        formatter.format(value)
+
+    actual val currencyCode: String? get() = formatter.currency?.currencyCode
+}

app/src/commonMain/kotlin/de/westnordost/streetcomplete/util/locale/CurrencyFormatElements.kt

@@ -0,0 +1,70 @@
+package de.westnordost.streetcomplete.util.locale
+
+import androidx.compose.ui.text.intl.Locale
+
+/**
+ * Information about how a currency should be formatted in the current locale
+ */
+data class CurrencyFormatElements(
+    /** The currency symbol (e.g. "€", "$", "£") */
+    val symbol: String,
+    /** Whether the symbol comes before the amount (true for "$10", false for "10 €") */
+    val isSymbolBeforeAmount: Boolean,
+    /** Whether there is a whitespace between the currency symbol and the amount */
+    val hasWhitespace: Boolean,
+    /** Number of decimal places (e.g. 2 for EUR/USD, 0 for JPY) */
+    val decimalDigits: Int,
+    /** Decimal separator, e.g. the comma in "1.500,00$" */
+    val decimalSeparator: Char?,
+    /** Grouping separator, e.g. the dot in "1.500,00$" */
+    val groupingSeparator: Char?
+) {
+    companion object {
+        fun of(locale: Locale?): CurrencyFormatElements =
+            ofOrNull(locale) ?: defaultFallback(locale)
+
+        private fun ofOrNull(locale: Locale?): CurrencyFormatElements? {
+            val formatter = CurrencyFormatter(locale)
+            val d = "\\p{Nd}" // digit
+            val a = "[^\\p{Nd}]" // not a digit
+            // e.g.  US          $    1  ,   500      .  00
+            // or    NO          kr   1  ␣   500      ,  00
+            // or    DE               1  .   500      ,  00      €
+            // or    JP          ￥   1  ,   500
+            val regex = Regex("($a+)?$d($a)?$d{3}(?:($a)($d+))?($a+)?")
+            val matchResult = regex.matchEntire(formatter.format(1500.00)) ?: return null
+            val values = matchResult.groupValues
+            val symbolBefore = values[1].takeIf { it.isNotEmpty() }
+            val groupingSeparator = values[2].firstOrNull()
+            val decimalSeparator = values[3].firstOrNull()
+            val fractionDigits = values[4].length
+            val symbolAfter = values[5].takeIf { it.isNotEmpty() }
+
+            // huh, there's either something both in front and end or neither? Don't know what this is, then!
+            if (symbolAfter != null && symbolBefore != null) return null
+            val symbol = symbolBefore ?: symbolAfter ?: return null
+            val symbolOnly = symbol.trim()
+
+            return CurrencyFormatElements(
+                symbol = symbolOnly,
+                isSymbolBeforeAmount = symbolBefore != null,
+                hasWhitespace = symbolOnly != symbol,
+                decimalDigits = fractionDigits,
+                decimalSeparator = decimalSeparator,
+                groupingSeparator = groupingSeparator,
+            )
+        }
+
+        private fun defaultFallback(locale: Locale?): CurrencyFormatElements {
+            val numberFormatter = NumberFormatter(locale)
+            return CurrencyFormatElements(
+                symbol = "¤",
+                isSymbolBeforeAmount = true,
+                hasWhitespace = true,
+                decimalDigits = 2,
+                decimalSeparator = numberFormatter.decimalSeparator,
+                groupingSeparator = numberFormatter.groupingSeparator
+            )
+        }
+    }
+}

app/src/commonMain/kotlin/de/westnordost/streetcomplete/util/locale/CurrencyFormatter.kt

@@ -0,0 +1,21 @@
+package de.westnordost.streetcomplete.util.locale
+
+import androidx.compose.ui.text.intl.Locale
+
+/**
+ * Locale-aware formatting of currencies
+ *
+ * @param locale Locale to use. If [locale] is `null`, the default locale (for formatting) will be
+ *   used. Note that the region **must** be specified in the locale for this formatter to format
+ *   correctly, otherwise it doesn't know which currency to use
+ */
+expect class CurrencyFormatter(locale: Locale? = null) {
+    /**
+     * @param value the value to format, e.g. 3.0
+     * @return the formatted input value, e.g. € 3.00
+     */
+    fun format(value: Double): String
+
+    /** ISO 4217 currency code */
+    val currencyCode: String?
+}

app/src/commonTest/kotlin/de/westnordost/streetcomplete/util/locale/CurrencyFormatElementsTest.kt

@@ -0,0 +1,78 @@
+package de.westnordost.streetcomplete.util.locale
+
+import androidx.compose.ui.text.intl.Locale
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class CurrencyFormatElementsTest {
+
+    @Test fun `of Germany Euro`() {
+        assertEquals(
+            CurrencyFormatElements(
+                symbol = "€",
+                isSymbolBeforeAmount = false,
+                hasWhitespace = true,
+                decimalDigits = 2,
+                decimalSeparator = ',',
+                groupingSeparator = '.',
+            ),
+            CurrencyFormatElements.of(Locale("de-DE"))
+        )
+    }
+
+    @Test fun `of Ireland Euro`() {
+        assertEquals(
+            CurrencyFormatElements(
+                symbol = "€",
+                isSymbolBeforeAmount = true,
+                hasWhitespace = false,
+                decimalDigits = 2,
+                decimalSeparator = '.',
+                groupingSeparator = ',',
+            ),
+            CurrencyFormatElements.of(Locale("en-IE"))
+        )
+    }
+
+    @Test fun `of Japan Yen`() {
+        assertEquals(
+            CurrencyFormatElements(
+                symbol = "￥",
+                isSymbolBeforeAmount = true,
+                hasWhitespace = false,
+                decimalDigits = 0,
+                decimalSeparator = null,
+                groupingSeparator = ',',
+            ),
+            CurrencyFormatElements.of(Locale("ja-JP"))
+        )
+    }
+
+    @Test fun `of US Dollar`() {
+        assertEquals(
+            CurrencyFormatElements(
+                symbol = "$",
+                isSymbolBeforeAmount = true,
+                hasWhitespace = false,
+                decimalDigits = 2,
+                decimalSeparator = '.',
+                groupingSeparator = ',',
+            ),
+            CurrencyFormatElements.of(Locale("en-US"))
+        )
+    }
+
+    @Test fun `of Norway Krona`() {
+        assertEquals(
+            CurrencyFormatElements(
+                symbol = "kr",
+                isSymbolBeforeAmount = true,
+                hasWhitespace = true,
+                decimalDigits = 2,
+                decimalSeparator = ',',
+                groupingSeparator = '\u00A0',
+            ),
+            CurrencyFormatElements.of(Locale("nb-NO"))
+        )
+    }
+}

app/src/commonTest/kotlin/de/westnordost/streetcomplete/util/locale/CurrencyFormatterTest.kt

@@ -0,0 +1,46 @@
+package de.westnordost.streetcomplete.util.locale
+
+import androidx.compose.ui.text.intl.Locale
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+internal class CurrencyFormatterTest {
+    @Test fun `euro in Germany`() {
+        val f = formatter("de-DE")
+        assertEquals("1.538,00\u00A0€", f.format(1538.0))
+        assertEquals("EUR", f.currencyCode)
+    }
+
+    @Test fun `Ireland euro in Ireland`() {
+        val f = formatter("en-IE")
+        assertEquals("€1,538.00", f.format(1538.0))
+        assertEquals("EUR", f.currencyCode)
+    }
+
+    @Test fun `yen in Japan`() {
+        val f = formatter("ja-JP")
+        assertEquals("￥1,538", f.format(1538.00))
+        assertEquals("JPY", f.currencyCode)
+    }
+
+    @Test fun `dollar in US`() {
+        val f = formatter("en-US")
+        assertEquals("$1,538.00", f.format(1538.00))
+        assertEquals("USD", f.currencyCode)
+    }
+
+    @Test fun `krona in Norway`() {
+        val f = formatter("nb-NO")
+        assertEquals("kr\u00A01\u00A0538,00", f.format(1538.00))
+        assertEquals("NOK", f.currencyCode)
+    }
+
+    @Test fun `riyal in Saudi Arabia`() {
+        val f = formatter("ar-SA")
+        assertEquals("\u200F١٬٥٣٨٫٠٠\u00A0ر.س.\u200F", f.format(1538.00))
+        assertEquals("SAR", f.currencyCode)
+    }
+
+    private fun formatter(localeTag: String) =
+        CurrencyFormatter(Locale(localeTag))
+}

app/src/iosMain/kotlin/de/westnordost/streetcomplete/util/locale/CurrencyFormatter.ios.kt

@@ -0,0 +1,20 @@
+package de.westnordost.streetcomplete.util.locale
+
+import androidx.compose.ui.text.intl.Locale
+import platform.Foundation.NSLocaleCurrencyCode
+import platform.Foundation.NSNumber
+import platform.Foundation.NSNumberFormatter
+import platform.Foundation.NSNumberFormatterCurrencyStyle
+
+actual class CurrencyFormatter actual constructor(locale: Locale?) {
+
+    private val formatter = NSNumberFormatter().also {
+        if (locale != null) it.locale = locale.platformLocale
+        it.numberStyle = NSNumberFormatterCurrencyStyle
+    }
+
+    actual fun format(value: Double): String =
+        formatter.stringFromNumber(NSNumber(value)) ?: ""
+
+    actual val currencyCode: String? get() = formatter.currencyCode
+}