Jackson Kondor interop

kondor-jackson/build.gradle.kts

@@ -0,0 +1,105 @@
+import org.gradle.api.tasks.testing.logging.TestLogEvent
+
+plugins {
+    `common-kotlin`
+    id("maven-publish")
+    id("signing")
+}
+
+tasks.withType<GenerateModuleMetadata> {
+    enabled = false
+}
+
+java {
+    withJavadocJar()
+    withSourcesJar()
+}
+
+dependencies {
+    implementation(project(":kondor-core"))
+    api(libs.jUnit.api)
+
+    implementation(libs.kotlin.jdk8)
+    implementation(libs.kotlin.reflect) //needed for source generator
+    implementation(libs.kotlinPoet)
+    implementation(group = "com.fasterxml.jackson.core", name = "jackson-databind", version = "2.18.2")
+}
+
+@Suppress("UnstableApiUsage")
+testing {
+    suites {
+        getByName<JvmTestSuite>("test") {
+            useJUnitJupiter(libs.versions.jUnit.get())
+            dependencies {
+                implementation(libs.striKt)
+                implementation(project(":kondor-tools"))
+            }
+            targets {
+                all {
+                    testTask.configure {
+                        maxHeapSize = "2g"
+                        testLogging {
+                            events = setOf(
+                                TestLogEvent.SKIPPED,
+                                TestLogEvent.FAILED,
+                                TestLogEvent.PASSED
+                            )
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+
+publishing {
+    publications {
+        create<MavenPublication>("mavenJava") {
+            from(components.getByName("java"))
+            groupId = project.group.toString()
+            artifactId = project.name
+            version = project.version.toString()
+
+            pom {
+                name = "kondor-tools"
+                description = "A suite of tools to work with Kondor json library"
+                url = "https://github.com/uberto/kondor-json"
+                inceptionYear = "2021"
+                scm {
+                    url = "https://github.com/uberto/kondor-json"
+                    connection = "https://github.com/uberto/kondor-json.git"
+                    developerConnection = "git@github.com:uberto/kondor-json.git"
+                }
+                licenses {
+                    license {
+                        name = "The Apache Software License, Version 2.0"
+                        url = "http://www.apache.org/licenses/LICENSE-2.0.txt"
+                        distribution = "repo"
+                    }
+                }
+                developers {
+                    developer {
+                        id = "UbertoBarbini"
+                        name = "Uberto Barbini"
+                        email = "uberto.gama@gmail.com"
+                    }
+                }
+            }
+        }
+    }
+    repositories {
+        maven {
+            name = "OSSRH"
+            url = uri("https://oss.sonatype.org/service/local/staging/deploy/maven2/")
+            credentials {
+                username = findProperty("nexusUsername").toString()
+                password = findProperty("nexusPassword").toString()
+            }
+        }
+    }
+}
+
+signing {
+    sign(publishing.publications.getByName("mavenJava"))
+}

kondor-jackson/src/main/kotlin/com/ubertob/kondor/jackson/KondorAdaptors.kt

@@ -0,0 +1,83 @@
+package com.ubertob.kondor.jackson
+
+import com.fasterxml.jackson.databind.node.*
+import com.fasterxml.jackson.databind.node.ArrayNode
+import com.fasterxml.jackson.databind.node.BooleanNode
+import com.fasterxml.jackson.databind.node.NullNode
+import com.fasterxml.jackson.databind.node.ObjectNode
+import com.ubertob.kondor.json.ObjectNodeConverter
+import com.ubertob.kondor.json.jsonnode.*
+import java.math.BigDecimal
+import java.math.BigInteger
+import com.fasterxml.jackson.databind.JsonNode as JJsonNode
+import com.ubertob.kondor.json.jsonnode.JsonNode as KJsonNode
+
+fun <T: Any> ObjectNodeConverter<T>.toJacksonJsonNode(t: T): ObjectNode = this.toJsonNode(t).toJacksonJsonNode()
+
+fun KJsonNode.toJacksonJsonNode(): JJsonNode {
+    val json: JsonNodeFactory = JsonNodeFactory.instance
+
+    return when (this) {
+        is JsonNodeArray -> toJacksonJsonNode(json)
+        is JsonNodeBoolean -> toJacksonJsonNode(json)
+        is JsonNodeNull -> toJacksonJsonNode(json)
+        is JsonNodeNumber -> toJacksonJsonNode(json)
+        is JsonNodeObject -> toJacksonJsonNode(json)
+        is JsonNodeString -> toJacksonJsonNode(json)
+    }
+}
+
+fun JsonNodeString.toJacksonJsonNode(json: JsonNodeFactory = JsonNodeFactory.instance) = json.textNode(this.text)
+fun JsonNodeNumber.toJacksonJsonNode(json: JsonNodeFactory = JsonNodeFactory.instance) = this.num.toNumericNode(json)
+fun JsonNodeBoolean.toJacksonJsonNode(json: JsonNodeFactory = JsonNodeFactory.instance) = json.booleanNode(this.boolean)
+fun JsonNodeNull.toJacksonJsonNode(json: JsonNodeFactory = JsonNodeFactory.instance) = json.nullNode()
+fun JsonNodeObject.toJacksonJsonNode(json: JsonNodeFactory = JsonNodeFactory.instance) = _fieldMap.entries
+    .fold(json.objectNode()) { obj, node ->
+        obj.set<JJsonNode>(node.key, node.value.toJacksonJsonNode())
+        obj
+    }
+
+fun JsonNodeArray.toJacksonJsonNode(json: JsonNodeFactory = JsonNodeFactory.instance): ArrayNode =
+    elements.fold(json.arrayNode()) { array, node -> array.add(node.toJacksonJsonNode()) }
+
+fun TextNode.toKondorJsonNode() = JsonNodeString(textValue())
+fun NumericNode.toKondorJsonNode() = JsonNodeNumber(decimalValue())
+fun BooleanNode.toKondorJsonNode() = JsonNodeBoolean(booleanValue())
+fun NullNode.toKondorJsonNode() = JsonNodeNull
+fun ArrayNode.toKondorJsonNode() =
+    JsonNodeArray(mapIndexedNotNull { i, node -> node.toKondorJsonNode() })
+
+fun JJsonNode.toKondorJsonNode(): KJsonNode {
+    return when (this) {
+        is TextNode -> toKondorJsonNode()
+        is NumericNode -> toKondorJsonNode()
+        is BooleanNode -> toKondorJsonNode()
+        is NullNode -> toKondorJsonNode()
+        is ArrayNode -> toKondorJsonNode()
+        is ObjectNode -> toKondorJsonNode()
+        else -> throw IllegalArgumentException("Unknown Jackson JsonNode: $this")
+    }
+}
+
+fun ObjectNode.toKondorJsonNode(): JsonNodeObject {
+    val map = properties().associate { (key, node) -> key to node.toKondorJsonNode() }
+
+    return JsonNodeObject(map)
+}
+
+private fun Number.toNumericNode(json: JsonNodeFactory): ValueNode {
+    return when (this) {
+        is Byte-> json.numberNode(this)
+        is Short-> json.numberNode(this)
+        is Int -> json.numberNode(this)
+        is Long -> json.numberNode(this)
+        is BigInteger -> json.numberNode(this)
+        is Float -> json.numberNode(this)
+        is Double -> json.numberNode(this)
+        is BigDecimal -> json.numberNode(this)
+        else -> throw IllegalArgumentException("Unknown number type: $this")
+    }
+}
+
+fun <T: Any> T.intoJacksonJsonNode(converter: ObjectNodeConverter<T>): ObjectNode = converter.toJacksonJsonNode(this)
+