Allow printing datetime formats as Kotlin code

dkhalanskyjb · dkhalanskyjb · commit a03691bd9f35 · 2024-02-27T12:05:03.000+01:00
diff --git a/core/common/src/format/DateTimeComponents.kt b/core/common/src/format/DateTimeComponents.kt
@@ -513,6 +513,10 @@ internal val timeZoneField = GenericFieldSpec(PropertyAccessor(DateTimeComponent
 internal class TimeZoneIdDirective(private val knownZones: Set<String>) :
     StringFieldFormatDirective<DateTimeComponentsContents>(timeZoneField, knownZones) {
 
+    override val builderRepresentation: String
+        get() =
+            "${DateTimeFormatBuilder.WithDateTimeComponents::timeZoneId.name}()"
+
     override fun equals(other: Any?): Boolean = other is TimeZoneIdDirective && other.knownZones == knownZones
     override fun hashCode(): Int = knownZones.hashCode()
 }
diff --git a/core/common/src/format/DateTimeFormat.kt b/core/common/src/format/DateTimeFormat.kt
@@ -36,6 +36,19 @@ public sealed interface DateTimeFormat<T> {
      * @return the parsed value, or `null` if the input string is not in the expected format or the value is invalid.
      */
     public fun parseOrNull(input: CharSequence): T?
+
+    public companion object {
+        /**
+         * Produces Kotlin code that, when pasted into a Kotlin source file, creates a [DateTimeFormat] instance that
+         * behaves identically to [format].
+         *
+         * The typical use case for this is to create a [DateTimeFormat] instance using a non-idiomatic approach and
+         * then convert it to a builder DSL.
+         */
+        public fun formatAsKotlinBuilderDsl(format: DateTimeFormat<*>): String = when (format) {
+            is AbstractDateTimeFormat<*, *> -> format.actualFormat.builderString(allFormatConstants)
+        }
+    }
 }
 
 /**
@@ -111,3 +124,14 @@ internal sealed class AbstractDateTimeFormat<T, U : Copyable<U>> : DateTimeForma
         Parser(actualFormat.parser()).matchOrNull(input, emptyIntermediate)?.let { valueFromIntermediateOrNull(it) }
 
 }
+
+private val allFormatConstants: List<Pair<String, CachedFormatStructure<*>>> by lazy {
+    fun unwrap(format: DateTimeFormat<*>): CachedFormatStructure<*> = (format as AbstractDateTimeFormat<*, *>).actualFormat
+    // the formats are ordered vaguely by decreasing length, as the topmost among suitable ones is chosen.
+    listOf(
+        "${DateTimeFormatBuilder.WithDateTimeComponents::dateTimeComponents.name}(DateTimeComponents.Formats.RFC_1123)" to
+            unwrap(DateTimeComponents.Formats.RFC_1123),
+        "${DateTimeFormatBuilder.WithDateTimeComponents::dateTimeComponents.name}(DateTimeComponents.Formats.ISO_DATE_TIME_OFFSET)" to
+            unwrap(DateTimeComponents.Formats.ISO_DATE_TIME_OFFSET),
+    )
+}
diff --git a/core/common/src/format/DateTimeFormatBuilder.kt b/core/common/src/format/DateTimeFormatBuilder.kt
@@ -382,3 +382,91 @@ internal interface AbstractDateTimeFormatBuilder<Target, ActualSelf> :
 
     fun build(): CachedFormatStructure<Target> = CachedFormatStructure(actualBuilder.build().formats)
 }
+
+internal fun <T> FormatStructure<T>.builderString(constants: List<Pair<String, CachedFormatStructure<*>>>): String =
+    when (this) {
+        is BasicFormatStructure -> directive.builderRepresentation
+        is ConstantFormatStructure -> if (string.length == 1) {
+            "${DateTimeFormatBuilder::char.name}(${string[0].toKotlinCode()})"
+        } else {
+            "${DateTimeFormatBuilder::chars.name}(${string.toKotlinCode()})"
+        }
+
+        is SignedFormatStructure -> {
+            if (format is BasicFormatStructure && format.directive is UtcOffsetWholeHoursDirective) {
+                format.directive.builderRepresentation
+            } else {
+                buildString {
+                    if (withPlusSign) appendLine("withSharedSign(outputPlus = true) {")
+                    else appendLine("withSharedSign {")
+                    appendLine(format.builderString(constants).prependIndent(CODE_INDENT))
+                    append("}")
+                }
+            }
+        }
+
+        is OptionalFormatStructure -> buildString {
+            if (onZero == "") {
+                appendLine("${DateTimeFormatBuilder::optional.name} {")
+            } else {
+                appendLine("${DateTimeFormatBuilder::optional.name}(${onZero.toKotlinCode()}) {")
+            }
+            val subformat = format.builderString(constants)
+            if (subformat.isNotEmpty()) {
+                appendLine(subformat.prependIndent(CODE_INDENT))
+            }
+            append("}")
+        }
+
+        is AlternativesParsingFormatStructure -> buildString {
+            append("${DateTimeFormatBuilder::alternativeParsing.name}(")
+            for (alternative in formats) {
+                appendLine("{")
+                val subformat = alternative.builderString(constants)
+                if (subformat.isNotEmpty()) {
+                    appendLine(subformat.prependIndent(CODE_INDENT))
+                }
+                append("}, ")
+            }
+            if (this[length - 2] == ',') {
+                repeat(2) {
+                    deleteAt(length - 1)
+                }
+            }
+            appendLine(") {")
+            appendLine(mainFormat.builderString(constants).prependIndent(CODE_INDENT))
+            append("}")
+        }
+
+        is ConcatenatedFormatStructure -> buildString {
+            if (formats.isNotEmpty()) {
+                var index = 0
+                loop@ while (index < formats.size) {
+                    searchConstant@ for (constant in constants) {
+                        val constantDirectives = constant.second.formats
+                        if (formats.size - index >= constantDirectives.size) {
+                            for (i in constantDirectives.indices) {
+                                if (formats[index + i] != constantDirectives[i]) {
+                                    continue@searchConstant
+                                }
+                            }
+                            append(constant.first)
+                            index += constantDirectives.size
+                            if (index < formats.size) {
+                                appendLine()
+                            }
+                            continue@loop
+                        }
+                    }
+                    if (index == formats.size - 1) {
+                        append(formats.last().builderString(constants))
+                    } else {
+                        appendLine(formats[index].builderString(constants))
+                    }
+                    ++index
+                }
+            }
+        }
+    }
+
+private const val CODE_INDENT = "    "
diff --git a/core/common/src/format/LocalDateFormat.kt b/core/common/src/format/LocalDateFormat.kt
@@ -55,6 +55,12 @@ public class MonthNames(
     }
 }
 
+internal fun MonthNames.toKotlinCode(): String = when (this.names) {
+    MonthNames.ENGLISH_FULL.names -> "MonthNames.${DayOfWeekNames.Companion::ENGLISH_FULL.name}"
+    MonthNames.ENGLISH_ABBREVIATED.names -> "MonthNames.${DayOfWeekNames.Companion::ENGLISH_ABBREVIATED.name}"
+    else -> names.joinToString(", ", "MonthNames(", ")", transform = String::toKotlinCode)
+}
+
 /**
  * A description of how day of week names are formatted.
  */
@@ -103,6 +109,12 @@ public class DayOfWeekNames(
     }
 }
 
+internal fun DayOfWeekNames.toKotlinCode(): String = when (this.names) {
+    DayOfWeekNames.ENGLISH_FULL.names -> "DayOfWeekNames.${DayOfWeekNames.Companion::ENGLISH_FULL.name}"
+    DayOfWeekNames.ENGLISH_ABBREVIATED.names -> "DayOfWeekNames.${DayOfWeekNames.Companion::ENGLISH_ABBREVIATED.name}"
+    else -> names.joinToString(", ", "DayOfWeekNames(", ")", transform = String::toKotlinCode)
+}
+
 internal fun <T> requireParsedField(field: T?, name: String): T {
     if (field == null) {
         throw DateTimeFormatException("Can not create a $name from the given input: the field $name is missing")
@@ -178,6 +190,16 @@ private class YearDirective(private val padding: Padding, private val isYearOfEr
         spacePadding = padding.spaces(4),
         outputPlusOnExceededWidth = 4,
     ) {
+    override val builderRepresentation: String
+        get() = when (padding) {
+            Padding.ZERO -> "${DateTimeFormatBuilder.WithDate::year.name}()"
+            else -> "${DateTimeFormatBuilder.WithDate::year.name}(${padding.toKotlinCode()})"
+        }.let {
+            if (isYearOfEra) {
+                it + YEAR_OF_ERA_COMMENT
+            } else it
+        }
+
     override fun equals(other: Any?): Boolean =
         other is YearDirective && padding == other.padding && isYearOfEra == other.isYearOfEra
 
@@ -190,12 +212,23 @@ private class ReducedYearDirective(val base: Int, private val isYearOfEra: Boole
         digits = 2,
         base = base,
     ) {
+    override val builderRepresentation: String
+        get() =
+            "${DateTimeFormatBuilder.WithDate::yearTwoDigits.name}($base)".let {
+                if (isYearOfEra) {
+                    it + YEAR_OF_ERA_COMMENT
+                } else it
+            }
+
     override fun equals(other: Any?): Boolean =
         other is ReducedYearDirective && base == other.base && isYearOfEra == other.isYearOfEra
 
     override fun hashCode(): Int = base.hashCode() * 31 + isYearOfEra.hashCode()
 }
 
+private const val YEAR_OF_ERA_COMMENT =
+    " /** TODO: the original format had an `y` directive, so the behavior is different on years earlier than 1 AD. See the [kotlinx.datetime.format.byUnicodePattern] documentation for details. */"
+
 /**
  * A special directive for year-of-era that behaves equivalently to [DateTimeFormatBuilder.WithDate.year].
  * This is the result of calling [byUnicodePattern] on a pattern that uses the ubiquitous "y" symbol.
@@ -232,12 +265,22 @@ private class MonthDirective(private val padding: Padding) :
         minDigits = padding.minDigits(2),
         spacePadding = padding.spaces(2),
     ) {
+    override val builderRepresentation: String
+        get() = when (padding) {
+            Padding.ZERO -> "${DateTimeFormatBuilder.WithDate::monthNumber.name}()"
+            else -> "${DateTimeFormatBuilder.WithDate::monthNumber.name}(${padding.toKotlinCode()})"
+        }
+
     override fun equals(other: Any?): Boolean = other is MonthDirective && padding == other.padding
     override fun hashCode(): Int = padding.hashCode()
 }
 
 private class MonthNameDirective(private val names: MonthNames) :
     NamedUnsignedIntFieldFormatDirective<DateFieldContainer>(DateFields.month, names.names, "monthName") {
+    override val builderRepresentation: String
+        get() =
+            "${DateTimeFormatBuilder.WithDate::monthName.name}(${names.toKotlinCode()})"
+
     override fun equals(other: Any?): Boolean = other is MonthNameDirective && names.names == other.names.names
     override fun hashCode(): Int = names.names.hashCode()
 }
@@ -248,12 +291,23 @@ private class DayDirective(private val padding: Padding) :
         minDigits = padding.minDigits(2),
         spacePadding = padding.spaces(2),
     ) {
+    override val builderRepresentation: String
+        get() = when (padding) {
+            Padding.ZERO -> "${DateTimeFormatBuilder.WithDate::dayOfMonth.name}()"
+            else -> "${DateTimeFormatBuilder.WithDate::dayOfMonth.name}(${padding.toKotlinCode()})"
+        }
+
     override fun equals(other: Any?): Boolean = other is DayDirective && padding == other.padding
     override fun hashCode(): Int = padding.hashCode()
 }
 
 private class DayOfWeekDirective(private val names: DayOfWeekNames) :
     NamedUnsignedIntFieldFormatDirective<DateFieldContainer>(DateFields.isoDayOfWeek, names.names, "dayOfWeekName") {
+
+    override val builderRepresentation: String
+        get() =
+            "${DateTimeFormatBuilder.WithDate::dayOfWeek.name}(${names.toKotlinCode()})"
+
     override fun equals(other: Any?): Boolean = other is DayOfWeekDirective && names.names == other.names.names
     override fun hashCode(): Int = names.names.hashCode()
 }
diff --git a/core/common/src/format/LocalTimeFormat.kt b/core/common/src/format/LocalTimeFormat.kt
@@ -134,6 +134,12 @@ private class HourDirective(private val padding: Padding) :
         minDigits = padding.minDigits(2),
         spacePadding = padding.spaces(2)
     ) {
+    override val builderRepresentation: String
+        get() = when (padding) {
+            Padding.ZERO -> "${DateTimeFormatBuilder.WithTime::hour.name}()"
+            else -> "${DateTimeFormatBuilder.WithTime::hour.name}(${padding.toKotlinCode()})"
+        }
+
     override fun equals(other: Any?): Boolean = other is HourDirective && padding == other.padding
     override fun hashCode(): Int = padding.hashCode()
 }
@@ -143,6 +149,12 @@ private class AmPmHourDirective(private val padding: Padding) :
         TimeFields.hourOfAmPm, minDigits = padding.minDigits(2),
         spacePadding = padding.spaces(2)
     ) {
+    override val builderRepresentation: String
+        get() = when (padding) {
+            Padding.ZERO -> "${DateTimeFormatBuilder.WithTime::amPmHour.name}()"
+            else -> "${DateTimeFormatBuilder.WithTime::amPmHour.name}(${padding.toKotlinCode()})"
+        }
+
     override fun equals(other: Any?): Boolean = other is AmPmHourDirective && padding == other.padding
     override fun hashCode(): Int = padding.hashCode()
 }
@@ -155,6 +167,11 @@ private class AmPmMarkerDirective(private val amString: String, private val pmSt
         ),
         "AM/PM marker"
     ) {
+
+    override val builderRepresentation: String
+        get() =
+            "${DateTimeFormatBuilder.WithTime::amPmMarker.name}($amString, $pmString)"
+
     override fun equals(other: Any?): Boolean =
         other is AmPmMarkerDirective && amString == other.amString && pmString == other.pmString
 
@@ -167,6 +184,13 @@ private class MinuteDirective(private val padding: Padding) :
         minDigits = padding.minDigits(2),
         spacePadding = padding.spaces(2)
     ) {
+
+    override val builderRepresentation: String
+        get() = when (padding) {
+            Padding.ZERO -> "${DateTimeFormatBuilder.WithTime::minute.name}()"
+            else -> "${DateTimeFormatBuilder.WithTime::minute.name}(${padding.toKotlinCode()})"
+        }
+
     override fun equals(other: Any?): Boolean = other is MinuteDirective && padding == other.padding
     override fun hashCode(): Int = padding.hashCode()
 }
@@ -177,6 +201,13 @@ private class SecondDirective(private val padding: Padding) :
         minDigits = padding.minDigits(2),
         spacePadding = padding.spaces(2)
     ) {
+
+    override val builderRepresentation: String
+        get() = when (padding) {
+            Padding.ZERO -> "${DateTimeFormatBuilder.WithTime::second.name}()"
+            else -> "${DateTimeFormatBuilder.WithTime::second.name}(${padding.toKotlinCode()})"
+        }
+
     override fun equals(other: Any?): Boolean = other is SecondDirective && padding == other.padding
     override fun hashCode(): Int = padding.hashCode()
 }
@@ -192,6 +223,20 @@ internal class FractionalSecondDirective(
         maxDigits,
         zerosToAdd
     ) {
+
+    override val builderRepresentation: String
+        get() {
+            val ref = "secondFraction" // can't directly reference `secondFraction` due to resolution ambiguity
+            // we ignore `grouping`, as it's not representable in the end users' code
+            return when {
+                minDigits == 1 && maxDigits == 9 -> "$ref()"
+                minDigits == 1 -> "$ref(maxLength = $maxDigits)"
+                maxDigits == 1 -> "$ref(minLength = $minDigits)"
+                maxDigits == minDigits -> "$ref($minDigits)"
+                else -> "$ref($minDigits, $maxDigits)"
+            }
+        }
+
     override fun equals(other: Any?): Boolean =
         other is FractionalSecondDirective && minDigits == other.minDigits && maxDigits == other.maxDigits
 
diff --git a/core/common/src/format/UtcOffsetFormat.kt b/core/common/src/format/UtcOffsetFormat.kt
@@ -196,6 +196,11 @@ internal class UtcOffsetWholeHoursDirective(private val padding: Padding) :
         minDigits = padding.minDigits(2),
         spacePadding = padding.spaces(2)
     ) {
+
+    override val builderRepresentation: String
+        get() =
+            "${DateTimeFormatBuilder.WithUtcOffset::offsetHours.name}(${padding.toKotlinCode()})"
+
     override fun equals(other: Any?): Boolean = other is UtcOffsetWholeHoursDirective && padding == other.padding
     override fun hashCode(): Int = padding.hashCode()
 }
@@ -205,6 +210,13 @@ private class UtcOffsetMinuteOfHourDirective(private val padding: Padding) :
         OffsetFields.minutesOfHour,
         minDigits = padding.minDigits(2), spacePadding = padding.spaces(2)
     ) {
+
+    override val builderRepresentation: String
+        get() = when (padding) {
+            Padding.NONE -> "${DateTimeFormatBuilder.WithUtcOffset::offsetMinutesOfHour.name}()"
+            else -> "${DateTimeFormatBuilder.WithUtcOffset::offsetMinutesOfHour.name}(${padding.toKotlinCode()})"
+        }
+
     override fun equals(other: Any?): Boolean = other is UtcOffsetMinuteOfHourDirective && padding == other.padding
     override fun hashCode(): Int = padding.hashCode()
 }
@@ -214,6 +226,13 @@ private class UtcOffsetSecondOfMinuteDirective(private val padding: Padding) :
         OffsetFields.secondsOfMinute,
         minDigits = padding.minDigits(2), spacePadding = padding.spaces(2)
     ) {
+
+    override val builderRepresentation: String
+        get() = when (padding) {
+            Padding.NONE -> "${DateTimeFormatBuilder.WithUtcOffset::offsetSecondsOfMinute.name}()"
+            else -> "${DateTimeFormatBuilder.WithUtcOffset::offsetSecondsOfMinute.name}(${padding.toKotlinCode()})"
+        }
+
     override fun equals(other: Any?): Boolean = other is UtcOffsetSecondOfMinuteDirective && padding == other.padding
     override fun hashCode(): Int = padding.hashCode()
 }
diff --git a/core/common/src/internal/format/FieldFormatDirective.kt b/core/common/src/internal/format/FieldFormatDirective.kt
@@ -27,6 +27,11 @@ internal interface FieldFormatDirective<in Target> {
      * The parser structure that parses the field.
      */
     fun parser(): ParserStructure<Target>
+
+    /**
+     * The string with the code that, when evaluated in the builder context, appends the directive.
+     */
+    val builderRepresentation: String
 }
 
 /**
diff --git a/core/common/src/internal/toKotlinCode.kt b/core/common/src/internal/toKotlinCode.kt
