Add 12-hour format support with AM/PM and hourIn12

Add 12-hour format support with AM/PM and hourIn12

Author: amirroid

README.md

@@ -117,6 +117,8 @@ Any missing field (like time) will default to current system time.
 | `d`    | 1 or 2-digit day    | `9`                 |
 | `HH`   | Hour (24h, 2-digit) | `14`                |
 | `H`    | Hour (24h)          | `14`                |
+| `hh`   | Hour (12h, 2-digit) | `09`                |
+| `h`    | Hour (12h)          | `9`                 |
 | `mm`   | Minutes (2-digit)   | `03`                |
 | `m`    | Minutes             | `3`                 |
 | `ss`   | Seconds (2-digit)   | `07`                |

jalalidate/src/commonMain/kotlin/ir/amirroid/jalalidate/date/JalaliDateTime.kt

@@ -28,6 +28,12 @@ public class JalaliDateTime {
     public val minute: Int
     public val second: Int
 
+    public val hourIn12: Int
+        get() {
+            val h = hour % 12
+            return if (h == 0) 12 else h
+        }
+
     public val gregorian: LocalDateTime
         get() = algorithm.toGregorian(this)
 

jalalidate/src/commonMain/kotlin/ir/amirroid/jalalidate/formatter/FormatPart.kt

@@ -56,6 +56,35 @@ internal class NumericPart(
     }
 }
 
+internal class AmPmPart : FormatPart {
+    override val name: String = "amPm"
+
+    private val extractor: (JalaliDateTime) -> String = { date ->
+        if (date.hour < 12) "AM" else "PM"
+    }
+
+    private val parser: (String) -> Int? = { text ->
+        when (text.uppercase()) {
+            "AM" -> 0
+            "PM" -> 1
+            else -> null
+        }
+    }
+
+    override fun format(date: JalaliDateTime): String = extractor(date)
+
+    override fun parse(input: String, pos: Int): ParseResult {
+        val match = Regex("(AM|PM)", RegexOption.IGNORE_CASE)
+            .find(input, pos)
+            ?: throw IllegalArgumentException("Expected AM/PM at position $pos")
+
+        val value = parser(match.value)
+            ?: throw IllegalArgumentException("Invalid AM/PM value '${match.value}'")
+
+        return ParseResult(value, pos + match.value.length)
+    }
+}
+
 internal sealed class NamedPart(
     private val full: Boolean,
     private val locale: Locale

jalalidate/src/commonMain/kotlin/ir/amirroid/jalalidate/formatter/JalaliDateTimeFormatter.kt

@@ -3,6 +3,7 @@ package ir.amirroid.jalalidate.formatter
 import ir.amirroid.jalalidate.algorithm.JalaliAlgorithm
 import ir.amirroid.jalalidate.configuration.JalaliDateGlobalConfiguration
 import ir.amirroid.jalalidate.date.JalaliDateTime
+import kotlin.compareTo
 
 public enum class Padding { ZERO, SPACE }
 
@@ -13,7 +14,7 @@ public class JalaliDateTimeFormatter {
     private var locale = JalaliDateGlobalConfiguration.formatterLocale
 
     public fun byUnicodePattern(pattern: String): JalaliDateTimeFormatter {
-        val regex = "(yyyy|yy|MMMM|MMM|MM|M|dd|d|HH|H|mm|m|ss|s|EEEE|EEE|E)".toRegex()
+        val regex = "(yyyy|yy|MMMM|MMM|MM|M|dd|d|HH|H|hh|h|mm|m|ss|s|EEEE|EEE|E|a)".toRegex()
         var lastIndex = 0
         for (match in regex.findAll(pattern)) {
             if (lastIndex < match.range.first) {
@@ -44,6 +45,8 @@ public class JalaliDateTimeFormatter {
     public fun monthOneDigit(): JalaliDateTimeFormatter =
         addNumericPart("month", { it.jalaliMonth }, 1, Padding.ZERO)
 
+    public fun amPm(): JalaliDateTimeFormatter = addAmPm()
+
     public fun monthFullName(): JalaliDateTimeFormatter {
         parts += MonthNamePart(full = true, locale = locale)
         return this
@@ -98,6 +101,11 @@ public class JalaliDateTimeFormatter {
         return this
     }
 
+    private fun addAmPm(): JalaliDateTimeFormatter {
+        parts.add(AmPmPart())
+        return this
+    }
+
     private fun mapPatternToFormatPart(token: String): FormatPart = when (token) {
         "yyyy" -> NumericPart("year", { it.jalaliYear }, 4, Padding.ZERO)
         "yy" -> NumericPart("yearShort", { it.jalaliYear % 100 }, 2, Padding.ZERO)
@@ -119,12 +127,17 @@ public class JalaliDateTimeFormatter {
         "HH" -> NumericPart("hour", { it.hour }, 2, Padding.ZERO)
         "H" -> NumericPart("hour", { it.hour }, 1, Padding.ZERO)
 
+        "hh" -> NumericPart("hour", { it.hourIn12 }, 2, Padding.ZERO)
+        "h" -> NumericPart("hour", { it.hourIn12 }, 1, Padding.ZERO)
+
         "mm" -> NumericPart("minute", { it.minute }, 2, Padding.ZERO)
         "m" -> NumericPart("minute", { it.minute }, 1, Padding.ZERO)
 
         "ss" -> NumericPart("second", { it.second }, 2, Padding.ZERO)
         "s" -> NumericPart("second", { it.second }, 1, Padding.ZERO)
 
+        "a" -> AmPmPart()
+
         else -> LiteralPart(token)
     }
 
@@ -151,10 +164,18 @@ public class JalaliDateTimeFormatter {
         val year = values["year"] ?: 1300
         val month = values["month"] ?: 1
         val day = values["day"] ?: 1
-        val hour = values["hour"] ?: 0
+        var hour = values["hour"] ?: 0
         val minute = values["minute"] ?: 0
         val second = values["second"] ?: 0
 
+        values["amPm"]?.let { amPm ->
+            hour = when (amPm) {
+                0 -> if (hour == 12) 0 else hour
+                1 -> if (hour < 12) hour + 12 else hour
+                else -> hour
+            }
+        }
+
         return JalaliDateTime(year, month, day, hour, minute, second, algorithm)
     }
 }

jalalidate/src/commonTest/kotlin/ir/amirroid/jalalidate/birashk/FormatTest.kt

@@ -148,4 +148,40 @@ class FormatTest {
         val formatted = date.format { byUnicodePattern("E") }
         assertEquals("1", formatted)
     }
+
+
+    @Test
+    fun testFormatAmMarker() {
+        val date = JalaliDateTime(1402, 7, 15, 9, 30, 0)
+        val formatted = date.format { byUnicodePattern("hh:mm a") }
+        assertEquals("09:30 AM", formatted)
+    }
+
+    @Test
+    fun testFormatPmMarker() {
+        val date = JalaliDateTime(1402, 7, 15, 18, 45, 0)
+        val formatted = date.format { byUnicodePattern("hh:mm a") }
+        assertEquals("06:45 PM", formatted)
+    }
+
+    @Test
+    fun testAmPmAtBoundaryNoon() {
+        val date = JalaliDateTime(1402, 7, 15, 12, 0, 0)
+        val formatted = date.format { byUnicodePattern("hh:mm a") }
+        assertEquals("12:00 PM", formatted)
+    }
+
+    @Test
+    fun testAmPmAtBoundaryMidnight() {
+        val date = JalaliDateTime(1402, 7, 15, 0, 0, 0)
+        val formatted = date.format { byUnicodePattern("hh:mm a") }
+        assertEquals("12:00 AM", formatted)
+    }
+
+    @Test
+    fun testFullPatternWithAmPm() {
+        val date = JalaliDateTime(1402, 1, 1, 23, 15, 0)
+        val formatted = date.format { byUnicodePattern("yyyy/MM/dd hh:mm a") }
+        assertEquals("1402/01/01 11:15 PM", formatted)
+    }
 }

jalalidate/src/commonTest/kotlin/ir/amirroid/jalalidate/birashk/ParseTest.kt

@@ -1,6 +1,8 @@
 package ir.amirroid.jalalidate.birashk
 
 import ir.amirroid.jalalidate.algorithm.defaults.BirashkAlgorithm
+import ir.amirroid.jalalidate.date.JalaliDateTime
+import ir.amirroid.jalalidate.format
 import ir.amirroid.jalalidate.formatter.JalaliDateTimeFormatter
 import kotlin.test.Test
 import kotlin.test.assertEquals
@@ -219,4 +221,68 @@ class ParseTest {
         assertEquals(6, date.jalaliMonth)
         assertEquals(9, date.jalaliDay)
     }
+
+    @Test
+    fun testParseAmPattern() {
+        val input = "1402/07/15 09:30:00 AM"
+        val formatter = JalaliDateTimeFormatter()
+            .byUnicodePattern("yyyy/MM/dd hh:mm:ss a")
+
+        val date = formatter.parse(input, algorithm)
+        assertEquals(1402, date.jalaliYear)
+        assertEquals(7, date.jalaliMonth)
+        assertEquals(15, date.jalaliDay)
+        assertEquals(9, date.hour)
+        assertEquals(30, date.minute)
+        assertEquals(0, date.second)
+    }
+
+    @Test
+    fun testParsePmPattern() {
+        val input = "1402/07/15 09:30:00 PM"
+        val formatter = JalaliDateTimeFormatter()
+            .byUnicodePattern("yyyy/MM/dd hh:mm:ss a")
+
+        val date = formatter.parse(input, algorithm)
+        assertEquals(1402, date.jalaliYear)
+        assertEquals(7, date.jalaliMonth)
+        assertEquals(15, date.jalaliDay)
+        assertEquals(21, date.hour)
+        assertEquals(30, date.minute)
+        assertEquals(0, date.second)
+    }
+
+    @Test
+    fun testParseNoonBoundary() {
+        val input = "1402/07/15 12:00:00 PM"
+        val formatter = JalaliDateTimeFormatter()
+            .byUnicodePattern("yyyy/MM/dd hh:mm:ss a")
+
+        val date = formatter.parse(input, algorithm)
+        assertEquals(12, date.hour)
+    }
+
+    @Test
+    fun testParseMidnightBoundary() {
+        val input = "1402/07/15 12:00:00 AM"
+        val formatter = JalaliDateTimeFormatter()
+            .byUnicodePattern("yyyy/MM/dd hh:mm:ss a")
+
+        val date = formatter.parse(input, algorithm)
+        assertEquals(0, date.hour)
+    }
+
+    @Test
+    fun testParseAmPmWithTextMixPattern() {
+        val input = "شنبه 1402/01/01 11:15 PM"
+        val formatter = JalaliDateTimeFormatter()
+            .byUnicodePattern("EEEE yyyy/MM/dd hh:mm a")
+
+        val date = formatter.parse(input, algorithm)
+        assertEquals(1402, date.jalaliYear)
+        assertEquals(1, date.jalaliMonth)
+        assertEquals(1, date.jalaliDay)
+        assertEquals(23, date.hour)
+        assertEquals(15, date.minute)
+    }
 }

jalalidate/src/commonTest/kotlin/ir/amirroid/jalalidate/khayyam/FormatTest.kt

@@ -147,4 +147,39 @@ class FormatTest {
         val formatted = date.format { byUnicodePattern("E") }
         assertEquals("1", formatted)
     }
+
+    @Test
+    fun testFormatAmMarker() {
+        val date = JalaliDateTime(1402, 7, 15, 9, 30, 0)
+        val formatted = date.format { byUnicodePattern("hh:mm a") }
+        assertEquals("09:30 AM", formatted)
+    }
+
+    @Test
+    fun testFormatPmMarker() {
+        val date = JalaliDateTime(1402, 7, 15, 18, 45, 0)
+        val formatted = date.format { byUnicodePattern("hh:mm a") }
+        assertEquals("06:45 PM", formatted)
+    }
+
+    @Test
+    fun testAmPmAtBoundaryNoon() {
+        val date = JalaliDateTime(1402, 7, 15, 12, 0, 0)
+        val formatted = date.format { byUnicodePattern("hh:mm a") }
+        assertEquals("12:00 PM", formatted)
+    }
+
+    @Test
+    fun testAmPmAtBoundaryMidnight() {
+        val date = JalaliDateTime(1402, 7, 15, 0, 0, 0)
+        val formatted = date.format { byUnicodePattern("hh:mm a") }
+        assertEquals("12:00 AM", formatted)
+    }
+
+    @Test
+    fun testFullPatternWithAmPm() {
+        val date = JalaliDateTime(1402, 1, 1, 23, 15, 0)
+        val formatted = date.format { byUnicodePattern("yyyy/MM/dd hh:mm a") }
+        assertEquals("1402/01/01 11:15 PM", formatted)
+    }
 }

jalalidate/src/commonTest/kotlin/ir/amirroid/jalalidate/khayyam/ParseTest.kt

@@ -219,4 +219,68 @@ class ParseTest {
         assertEquals(6, date.jalaliMonth)
         assertEquals(9, date.jalaliDay)
     }
+
+    @Test
+    fun testParseAmPattern() {
+        val input = "1402/07/15 09:30:00 AM"
+        val formatter = JalaliDateTimeFormatter()
+            .byUnicodePattern("yyyy/MM/dd hh:mm:ss a")
+
+        val date = formatter.parse(input, algorithm)
+        assertEquals(1402, date.jalaliYear)
+        assertEquals(7, date.jalaliMonth)
+        assertEquals(15, date.jalaliDay)
+        assertEquals(9, date.hour)
+        assertEquals(30, date.minute)
+        assertEquals(0, date.second)
+    }
+
+    @Test
+    fun testParsePmPattern() {
+        val input = "1402/07/15 09:30:00 PM"
+        val formatter = JalaliDateTimeFormatter()
+            .byUnicodePattern("yyyy/MM/dd hh:mm:ss a")
+
+        val date = formatter.parse(input, algorithm)
+        assertEquals(1402, date.jalaliYear)
+        assertEquals(7, date.jalaliMonth)
+        assertEquals(15, date.jalaliDay)
+        assertEquals(21, date.hour)
+        assertEquals(30, date.minute)
+        assertEquals(0, date.second)
+    }
+
+    @Test
+    fun testParseNoonBoundary() {
+        val input = "1402/07/15 12:00:00 PM"
+        val formatter = JalaliDateTimeFormatter()
+            .byUnicodePattern("yyyy/MM/dd hh:mm:ss a")
+
+        val date = formatter.parse(input, algorithm)
+        assertEquals(12, date.hour)
+    }
+
+    @Test
+    fun testParseMidnightBoundary() {
+        val input = "1402/07/15 12:00:00 AM"
+        val formatter = JalaliDateTimeFormatter()
+            .byUnicodePattern("yyyy/MM/dd hh:mm:ss a")
+
+        val date = formatter.parse(input, algorithm)
+        assertEquals(0, date.hour)
+    }
+
+    @Test
+    fun testParseAmPmWithTextMixPattern() {
+        val input = "شنبه 1402/01/01 11:15 PM"
+        val formatter = JalaliDateTimeFormatter()
+            .byUnicodePattern("EEEE yyyy/MM/dd hh:mm a")
+
+        val date = formatter.parse(input, algorithm)
+        assertEquals(1402, date.jalaliYear)
+        assertEquals(1, date.jalaliMonth)
+        assertEquals(1, date.jalaliDay)
+        assertEquals(23, date.hour)
+        assertEquals(15, date.minute)
+    }
 }