Add support for decoding

Author: Clément Petit

formats/properties/api/kotlinx-serialization-properties.api

@@ -50,6 +50,7 @@ public abstract class kotlinx/serialization/properties/StringProperties : kotlin
 	public static final field Default Lkotlinx/serialization/properties/StringProperties$Default;
 	public synthetic fun <init> (Lkotlinx/serialization/properties/PropertiesConf;Lkotlinx/serialization/properties/Properties;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
 	public synthetic fun <init> (Lkotlinx/serialization/properties/PropertiesConf;Lkotlinx/serialization/properties/Properties;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun decodeFromString (Lkotlinx/serialization/DeserializationStrategy;Ljava/lang/String;)Ljava/lang/Object;
 	public final fun encodeToString (Lkotlinx/serialization/SerializationStrategy;Ljava/lang/Object;)Ljava/lang/String;
 	public fun getSerializersModule ()Lkotlinx/serialization/modules/SerializersModule;
 }

formats/properties/commonMain/src/kotlinx/serialization/properties/StringProperties.kt

@@ -40,6 +40,48 @@ public sealed class StringProperties(
         return builder.toString()
     }
 
+    /**
+     * Decodes properties from the given [string] to a value of type [T] using the given [deserializer].
+     * [String] values are converted to respective primitive types using default conversion methods.
+     * [T] may contain properties of nullable types; they will be filled by non-null values from the [map], if present.
+     */
+    public fun <T> decodeFromString(deserializer: DeserializationStrategy<T>, string: String): T {
+        val result = mutableMapOf<String, String>()
+        for (line in string.logicalLines()) {
+            println("line=`$line`")
+            val parsedLine = line.unescaped()
+            println("parsedLine=`$parsedLine`")
+            var keyEnd = parsedLine.length
+            for (i in parsedLine.indices) {
+                if (parsedLine[i] in separators) {
+                    keyEnd = i
+                    break
+                }
+            }
+
+            var valueBegin = parsedLine.length
+            var separatorFound = false
+            for (i in keyEnd..parsedLine.lastIndex) {
+                if (separatorFound && parsedLine[i] != ' ') {
+                    valueBegin = i
+                    break
+                }
+                if (parsedLine[i] in nonBlankSeparators) {
+                    separatorFound = true
+                }
+                if (parsedLine[i] !in separators) {
+                    valueBegin = i
+                    break
+                }
+            }
+
+            result[parsedLine.substring(0, keyEnd)] = parsedLine.substring(valueBegin)
+        }
+        println(result)
+        println(result.keys)
+        return properties.decodeFromStringMap(deserializer, result)
+    }
+
     /**
      * A [Properties] instance that can be used as default and does not have any [SerializersModule] installed.
      */
@@ -70,13 +112,14 @@ public fun StringProperties(builderAction: PropertiesBuilder.() -> Unit = {}): S
 public inline fun <reified T> StringProperties.encodeToString(value: T): String =
     encodeToString(serializersModule.serializer(), value)
 
-///**
-// * Decodes properties from given [propertiesString], assigns them to an object using serializer for reified type [T] and returns this object.
-// * [String] values are converted to respective primitive types using default conversion methods.
-// * [T] may contain properties of nullable types; they will be filled by non-null values from the [map], if present.
-// */
-//@ExperimentalSerializationApi
-//public inline fun <reified T> StringProperties.decodeFromString(propertiesString: String): T = TODO()
+/**
+ * Decodes properties from given [propertiesString], assigns them to an object using serializer for reified type [T] and returns this object.
+ * [String] values are converted to respective primitive types using default conversion methods.
+ * [T] may contain properties of nullable types; they will be filled by non-null values from the [map], if present.
+ */
+@ExperimentalSerializationApi
+public inline fun <reified T> StringProperties.decodeFromString(propertiesString: String): T =
+    decodeFromString(serializersModule.serializer(), propertiesString)
 
 @ExperimentalSerializationApi
 public class PropertiesBuilder internal constructor(from: PropertiesConf) {
@@ -125,3 +168,56 @@ public enum class KeyValueSeparator(private val c: Char) {
 
     public fun char(): Char = c
 }
+
+private val nonBlankSeparators = setOf('=', ':')
+private val separators = nonBlankSeparators + ' '
+private val wellKnownEscapeChars = mapOf(
+    '\\' to '\\',
+    'n' to '\n',
+    'r' to '\r',
+    't' to '\t'
+)
+
+private fun String.unescaped(): String {
+    val sb = StringBuilder(this.length)
+    var i = 0
+    while (i < this.length) {
+        if (i < this.length - 1 && this[i] == '\\') {
+            if (this[i + 1] in wellKnownEscapeChars) {
+                sb.append(wellKnownEscapeChars[this[i + 1]])
+                i += 2
+            } else {
+                i++
+            }
+        } else {
+            sb.append(this[i])
+            i++
+        }
+    }
+    return sb.toString()
+}
+
+private fun String.logicalLines(): List<String> {
+    val commentFilter = "[ \\t\\f]*[#!].*".toRegex()
+    val lines = lines()
+        .filterNot { it.isBlank() || commentFilter.matches(it) }
+        .toMutableList()
+    val logicalLines = mutableListOf<String>()
+
+    var currentLine = ""
+    for (line in lines) {
+        val trimmedLine = line.trimStart()
+        if (trimmedLine.endsWith("\\")) {
+            currentLine += trimmedLine.dropLast(1)
+        } else {
+            currentLine += trimmedLine
+            logicalLines.add(currentLine)
+            currentLine = ""
+        }
+    }
+    if (currentLine.isNotBlank()) {
+        logicalLines.add(currentLine)
+    }
+
+    return logicalLines
+}