├── .gitignore
├── protocol
    ├── build.gradle.kts
    └── src
    │   ├── test
    │       ├── resources
    │       │   └── protocol
    │       │   │   ├── success_empty.xml
    │       │   │   ├── call_empty.xml
    │       │   │   ├── success_single.xml
    │       │   │   ├── call_single.xml
    │       │   │   ├── success_multiple.xml
    │       │   │   ├── fault.xml
    │       │   │   └── call_multiple.xml
    │       └── kotlin
    │       │   ├── SerializerTest.kt
    │       │   └── DeserializerTest.kt
    │   └── main
    │       └── kotlin
    │           ├── Fault.kt
    │           ├── MethodCall.kt
    │           ├── Value.kt
    │           ├── MethodResponse.kt
    │           ├── Util.kt
    │           ├── Serializer.kt
    │           └── Deserializer.kt
├── gradle
    └── wrapper
    │   ├── gradle-wrapper.jar
    │   └── gradle-wrapper.properties
├── gradle.properties
├── ktor-client-xmlrpc
    ├── build.gradle.kts
    └── src
    │   ├── main
    │       └── kotlin
    │       │   └── Library.kt
    │   └── test
    │       └── kotlin
    │           └── LibraryTest.kt
├── ktor-server-xmlrpc
    ├── build.gradle.kts
    └── src
    │   ├── main
    │       └── kotlin
    │       │   └── Library.kt
    │   └── test
    │       └── kotlin
    │           └── LibraryTest.kt
├── settings.gradle.kts
├── .github
    └── workflows
    │   ├── check.yml
    │   └── publish.yml
├── README.md
├── gradlew.bat
├── gradlew
└── LICENSE


/.gitignore:
--------------------------------------------------------------------------------
1 | .idea/
2 | .gradle/
3 | build/


--------------------------------------------------------------------------------
/protocol/build.gradle.kts:
--------------------------------------------------------------------------------
1 | dependencies {
2 |     testImplementation(kotlin("test-junit5"))
3 | }
4 | 


--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ascheja/xml-rpc-kt/HEAD/gradle/wrapper/gradle-wrapper.jar


--------------------------------------------------------------------------------
/gradle.properties:
--------------------------------------------------------------------------------
1 | kotlin.code.style=official
2 | kotlin.mpp.enableGranularSourceSetsMetadata=true
3 | kotlin.native.enableDependencyPropagation=false
4 | 


--------------------------------------------------------------------------------
/protocol/src/test/resources/protocol/success_empty.xml:
--------------------------------------------------------------------------------
1 | <?xml version='1.0' encoding='UTF-8'?>
2 | <methodResponse>
3 |     <params/>
4 | </methodResponse>
5 | 


--------------------------------------------------------------------------------
/protocol/src/test/resources/protocol/call_empty.xml:
--------------------------------------------------------------------------------
1 | <?xml version='1.0' encoding='UTF-8'?>
2 | <methodCall>
3 |     <methodName>examples.getStateName</methodName>
4 |     <params/>
5 | </methodCall>
6 | 


--------------------------------------------------------------------------------
/protocol/src/main/kotlin/Fault.kt:
--------------------------------------------------------------------------------
1 | /*
2 |  * Copyright (c) 2022 Andreas Scheja. Use of this source code is governed by the Apache 2.0 license.
3 |  */
4 | 
5 | package org.ascheja.xmlrpc.protocol
6 | 
7 | public data class Fault(val value: Value)
8 | 


--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.properties:
--------------------------------------------------------------------------------
1 | distributionBase=GRADLE_USER_HOME
2 | distributionPath=wrapper/dists
3 | distributionUrl=https\://services.gradle.org/distributions/gradle-7.6-bin.zip
4 | zipStoreBase=GRADLE_USER_HOME
5 | zipStorePath=wrapper/dists
6 | 


--------------------------------------------------------------------------------
/ktor-client-xmlrpc/build.gradle.kts:
--------------------------------------------------------------------------------
 1 | val ktorVersion = "2.3.12"
 2 | 
 3 | dependencies {
 4 |     api(project(":protocol"))
 5 |     api("io.ktor:ktor-client-core:$ktorVersion")
 6 | 
 7 |     testImplementation(kotlin("test-junit5"))
 8 |     testImplementation("io.ktor:ktor-client-mock:$ktorVersion")
 9 | }
10 | 


--------------------------------------------------------------------------------
/ktor-server-xmlrpc/build.gradle.kts:
--------------------------------------------------------------------------------
 1 | val ktorVersion = "2.3.12"
 2 | 
 3 | dependencies {
 4 |     api(project(":protocol"))
 5 |     api("io.ktor:ktor-server-core:$ktorVersion")
 6 | 
 7 |     testImplementation(kotlin("test-junit5"))
 8 |     testImplementation("io.ktor:ktor-server-test-host:$ktorVersion")
 9 | }
10 | 


--------------------------------------------------------------------------------
/protocol/src/test/resources/protocol/success_single.xml:
--------------------------------------------------------------------------------
 1 | <?xml version='1.0' encoding='UTF-8'?>
 2 | <methodResponse>
 3 |     <params>
 4 |         <param>
 5 |             <value>
 6 |                 <string>South Dakota</string>
 7 |             </value>
 8 |         </param>
 9 |     </params>
10 | </methodResponse>
11 | 


--------------------------------------------------------------------------------
/settings.gradle.kts:
--------------------------------------------------------------------------------
 1 | 
 2 | buildscript {
 3 |     repositories {
 4 |         gradlePluginPortal()
 5 |         mavenCentral()
 6 |     }
 7 | 
 8 |     dependencies {
 9 |         classpath(kotlin("stdlib-jdk8"))
10 |     }
11 | }
12 | 
13 | rootProject.name = "xml-rpc-kt"
14 | include(":protocol", ":ktor-client-xmlrpc", ":ktor-server-xmlrpc")
15 | 


--------------------------------------------------------------------------------
/protocol/src/test/resources/protocol/call_single.xml:
--------------------------------------------------------------------------------
 1 | <?xml version='1.0' encoding='UTF-8'?>
 2 | <methodCall>
 3 |     <methodName>examples.getStateName</methodName>
 4 |     <params>
 5 |         <param>
 6 |             <value>
 7 |                 <array>
 8 |                     <data/>
 9 |                 </array>
10 |             </value>
11 |         </param>
12 |     </params>
13 | </methodCall>
14 | 


--------------------------------------------------------------------------------
/protocol/src/test/resources/protocol/success_multiple.xml:
--------------------------------------------------------------------------------
 1 | <?xml version='1.0' encoding='UTF-8'?>
 2 | <methodResponse>
 3 |     <params>
 4 |         <param>
 5 |             <value>
 6 |                 <string>South Dakota</string>
 7 |             </value>
 8 |         </param>
 9 |         <param>
10 |             <value>
11 |                 <string>North Dakota</string>
12 |             </value>
13 |         </param>
14 |     </params>
15 | </methodResponse>
16 | 


--------------------------------------------------------------------------------
/.github/workflows/check.yml:
--------------------------------------------------------------------------------
 1 | name: Gradle check
 2 | on:
 3 |   push:
 4 |     branches: [ main ]
 5 |   pull_request:
 6 |     branches: [ main ]
 7 | jobs:
 8 |   build:
 9 |     runs-on: ubuntu-latest
10 |     steps:
11 |       - uses: actions/checkout@v2
12 |       - name: Set up JDK 11
13 |         uses: actions/setup-java@v2
14 |         with:
15 |           java-version: '11'
16 |           distribution: 'zulu'
17 |       - name: Build with Gradle
18 |         uses: gradle/gradle-build-action@937999e9cc2425eddc7fd62d1053baf041147db7
19 |         with:
20 |           arguments: check
21 | 


--------------------------------------------------------------------------------
/protocol/src/test/resources/protocol/fault.xml:
--------------------------------------------------------------------------------
 1 | <?xml version='1.0' encoding='UTF-8'?>
 2 | <methodResponse>
 3 |     <fault>
 4 |         <value>
 5 |             <struct>
 6 |                 <member>
 7 |                     <name>faultCode</name>
 8 |                     <value>
 9 |                         <int>4</int>
10 |                     </value>
11 |                 </member>
12 |                 <member>
13 |                     <name>faultString</name>
14 |                     <value>
15 |                         <string>Too many parameters.</string>
16 |                     </value>
17 |                 </member>
18 |             </struct>
19 |         </value>
20 |     </fault>
21 | </methodResponse>
22 | 


--------------------------------------------------------------------------------
/protocol/src/main/kotlin/MethodCall.kt:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2022 Andreas Scheja. Use of this source code is governed by the Apache 2.0 license.
 3 |  */
 4 | 
 5 | package org.ascheja.xmlrpc.protocol
 6 | 
 7 | import org.w3c.dom.Document
 8 | import javax.xml.parsers.DocumentBuilder
 9 | 
10 | public data class MethodCall(
11 |     val methodName: String,
12 |     val params: List<Value>
13 | ) {
14 |     public constructor(methodName: String, vararg params: Value) : this(methodName, params.toList())
15 | 
16 |     public fun toDocument(): Document {
17 |         val document = createDocumentBuilder().newDocument()
18 |         with(Serializer(document)) {
19 |             appendToElement(document)
20 |         }
21 |         return document
22 |     }
23 | 
24 |     public companion object {
25 |         public fun parse(block: (DocumentBuilder) -> Document): MethodCall {
26 |             return Deserializer().parseMethodCall(block(createDocumentBuilder()).documentElement)
27 |         }
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/.github/workflows/publish.yml:
--------------------------------------------------------------------------------
 1 | name: Publish package to Sonatype OSSRH
 2 | on:
 3 |   push:
 4 |     tags:
 5 |       - "*"
 6 | jobs:
 7 |   publish:
 8 |     runs-on: ubuntu-latest
 9 |     steps:
10 |       - uses: actions/checkout@v2
11 |       - uses: actions/setup-java@v2
12 |         with:
13 |           java-version: '11'
14 |           distribution: 'zulu'
15 |       - name: Validate Gradle wrapper
16 |         uses: gradle/wrapper-validation-action@e6e38bacfdf1a337459f332974bb2327a31aaf4b
17 |       - name: Publish package
18 |         uses: gradle/gradle-build-action@937999e9cc2425eddc7fd62d1053baf041147db7
19 |         with:
20 |           arguments: publishToOssrh closeAndReleaseOssrhStagingRepository
21 |         env:
22 |           OSSRH_USERNAME: ${{ secrets.OSSRH_USERNAME }}
23 |           OSSRH_TOKEN: ${{ secrets.OSSRH_TOKEN }}
24 |           GPG_PRIVATE_KEY: ${{ secrets.GPG_PRIVATE_KEY }}
25 |           GPG_KEY_ID: ${{ secrets.GPG_KEY_ID }}
26 |           GPG_PASSPHRASE: ${{ secrets.GPG_PASSPHRASE }}
27 | 


--------------------------------------------------------------------------------
/protocol/src/main/kotlin/Value.kt:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2022 Andreas Scheja. Use of this source code is governed by the Apache 2.0 license.
 3 |  */
 4 | 
 5 | package org.ascheja.xmlrpc.protocol
 6 | 
 7 | import java.util.Base64
 8 | 
 9 | public sealed interface Value
10 | 
11 | public data class IntegerValue(val value: Int) : Value
12 | 
13 | public data class BooleanValue(val value: Boolean) : Value
14 | 
15 | public data class StringValue(val value: String) : Value
16 | 
17 | public data class DoubleValue(val value: Double) : Value
18 | 
19 | public data class DateTimeIso8601Value(val value: String) : Value
20 | 
21 | public data class Base64Value(val value: String) : Value {
22 |     public fun toByteArray(): ByteArray = Base64.getDecoder().decode(value)
23 | }
24 | 
25 | public data class StructValue(val members: Map<String, Value>) : Value {
26 |     public constructor(vararg members: Pair<String, Value>) : this(members.toMap())
27 | }
28 | 
29 | public data class ArrayValue(val data: List<Value>) : Value {
30 |     public constructor(vararg data: Value) : this(data.toList())
31 | }
32 | 


--------------------------------------------------------------------------------
/protocol/src/main/kotlin/MethodResponse.kt:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2022 Andreas Scheja. Use of this source code is governed by the Apache 2.0 license.
 3 |  */
 4 | 
 5 | package org.ascheja.xmlrpc.protocol
 6 | 
 7 | import org.w3c.dom.Document
 8 | import javax.xml.parsers.DocumentBuilder
 9 | 
10 | public sealed interface MethodResponse {
11 | 
12 |     public fun toDocument(): Document {
13 |         val document = createDocumentBuilder().newDocument()
14 |         with(Serializer(document)) {
15 |             appendToElement(document)
16 |         }
17 |         return document
18 |     }
19 | 
20 |     public companion object {
21 |         public fun parse(block: (DocumentBuilder) -> Document): MethodResponse {
22 |             return Deserializer().parseMethodResponse(block(createDocumentBuilder()).documentElement)
23 |         }
24 |     }
25 | }
26 | 
27 | public data class MethodResponseSuccess(
28 |     val params: List<Value>
29 | ) : MethodResponse {
30 | 
31 |     public constructor(vararg params: Value) : this(params.toList())
32 | }
33 | 
34 | public data class MethodResponseFault(
35 |     val faultCode: Int,
36 |     val faultString: String
37 | ) : MethodResponse
38 | 


--------------------------------------------------------------------------------
/ktor-server-xmlrpc/src/main/kotlin/Library.kt:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2024 Andreas Scheja. Use of this source code is governed by the Apache 2.0 license.
 3 |  */
 4 | 
 5 | package org.ascheja.xmlrpc.ktor.server
 6 | 
 7 | import io.ktor.http.ContentType
 8 | import io.ktor.http.HttpStatusCode
 9 | import io.ktor.server.application.ApplicationCall
10 | import io.ktor.server.application.call
11 | import io.ktor.server.request.contentType
12 | import io.ktor.server.request.receive
13 | import io.ktor.server.response.respond
14 | import io.ktor.server.response.respondBytes
15 | import io.ktor.server.routing.Route
16 | import io.ktor.server.routing.post
17 | import org.ascheja.xmlrpc.protocol.MethodCall
18 | import org.ascheja.xmlrpc.protocol.MethodResponse
19 | import org.ascheja.xmlrpc.protocol.writeToByteArray
20 | import java.io.ByteArrayInputStream
21 | 
22 | public fun Route.xmlRpc(path: String, handler: suspend ApplicationCall.(MethodCall) -> MethodResponse) {
23 |     post(path) {
24 |         if (call.request.contentType() != ContentType.Application.Xml) {
25 |             return@post call.respond(HttpStatusCode.NotAcceptable, "")
26 |         }
27 |         val methodCall = ByteArrayInputStream(call.receive<ByteArray>()).use { input ->
28 |             MethodCall.parse { it.parse(input) }
29 |         }
30 |         val methodResponse = call.handler(methodCall)
31 |         call.respondBytes(ContentType.Application.Xml, HttpStatusCode.OK) {
32 |             methodResponse.toDocument().writeToByteArray()
33 |         }
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | xml-rpc for Kotlin/Jvm
 2 | ======================
 3 | [![Maven Central](https://img.shields.io/maven-central/v/org.ascheja.xmlrpc/protocol)](https://mvnrepository.com/artifact/org.ascheja.xmlrpc)
 4 | 
 5 | Kotlin binding for [xml-rpc](http://xmlrpc.com)
 6 | 
 7 | 
 8 | Add the dependency to your project
 9 | ----------------------------------
10 | 
11 | ### Client dependency using Ktor
12 | ```
13 | implementation("org.ascheja.xmlrpc:ktor-client-xmlrpc:VERSION")
14 | ```
15 | 
16 | ### Server dependency using Ktor
17 | ```
18 | implementation("org.ascheja.xmlrpc:ktor-server-xmlrpc:VERSION")
19 | ```
20 | 
21 | ### If you want to provide the transport yourself and just need the protocol
22 | ```
23 | implementation("org.ascheja.xmlrpc:protocol:VERSION")
24 | ```
25 | 
26 | Getting started
27 | ---------------
28 | 
29 | ### Client
30 | ```kotlin
31 | val client: HttpClient = createHttpClient()
32 | val call = MethodCall("some-method", IntegerValue(42), StringValue("some-string"))
33 | val response = client.xmlRpc("https://some-server/rpc", call) as MethodResponseSuccess // or check for MethodResponseFault if you set the parameter `throwOnFault = false`
34 | val firstParam = response.params.firstOrNull() as? StringValue ?: error("expected first parameter of response to be a StringValue")
35 | ```
36 | 
37 | ### Server
38 | ```kotlin
39 | embeddedServer(Netty) {
40 |     routing {
41 |         xmlRpc("/rpc") { request ->
42 |             when (request.methodName) {
43 |                 "ping" -> MethodResponseSuccess(StringValue("pong"))
44 |                 else -> MethodResponseFault(42, "unknown method ${request.methodName}")
45 |             }
46 |         }
47 |     }
48 | }.start(wait = true)
49 | ```
50 | 


--------------------------------------------------------------------------------
/ktor-client-xmlrpc/src/main/kotlin/Library.kt:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2024 Andreas Scheja. Use of this source code is governed by the Apache 2.0 license.
 3 |  */
 4 | 
 5 | package org.ascheja.xmlrpc.ktor.client
 6 | 
 7 | import io.ktor.client.HttpClient
 8 | import io.ktor.client.call.body
 9 | import io.ktor.client.request.header
10 | import io.ktor.client.request.post
11 | import io.ktor.client.request.setBody
12 | import io.ktor.http.ContentType
13 | import io.ktor.http.HttpHeaders
14 | import io.ktor.http.content.ByteArrayContent
15 | import org.ascheja.xmlrpc.protocol.MethodCall
16 | import org.ascheja.xmlrpc.protocol.MethodResponse
17 | import org.ascheja.xmlrpc.protocol.MethodResponseFault
18 | import org.ascheja.xmlrpc.protocol.writeTo
19 | import java.io.ByteArrayInputStream
20 | import java.io.ByteArrayOutputStream
21 | 
22 | public class XmlRpcFault(public val methodResponse: MethodResponseFault) : RuntimeException()
23 | 
24 | public suspend fun HttpClient.xmlRpc(
25 |     urlString: String,
26 |     methodCall: MethodCall,
27 |     throwOnFault: Boolean = true
28 | ): MethodResponse {
29 |     val response = post(urlString) {
30 |         header(HttpHeaders.Accept, ContentType.Application.Xml)
31 |         setBody(
32 |             ByteArrayContent(
33 |                 ByteArrayOutputStream().use {
34 |                     methodCall.toDocument().writeTo(it)
35 |                     it.toByteArray()
36 |                 },
37 |                 ContentType.Application.Xml,
38 |             )
39 |         )
40 |     }
41 |     val methodResponse = ByteArrayInputStream(response.body<ByteArray>()).use { body ->
42 |         MethodResponse.parse { it.parse(body) }
43 |     }
44 |     if (methodResponse is MethodResponseFault && throwOnFault) throw XmlRpcFault(methodResponse)
45 |     return methodResponse
46 | }
47 | 


--------------------------------------------------------------------------------
/protocol/src/test/resources/protocol/call_multiple.xml:
--------------------------------------------------------------------------------
 1 | <?xml version='1.0' encoding='UTF-8'?>
 2 | <methodCall>
 3 |     <methodName>examples.getStateName</methodName>
 4 |     <params>
 5 |         <param>
 6 |             <value>
 7 |                 <i4>41</i4>
 8 |             </value>
 9 |         </param>
10 |         <param>
11 |             <value>
12 |                 <array>
13 |                     <data>
14 |                         <value>
15 |                             <boolean>1</boolean>
16 |                         </value>
17 |                         <value>
18 |                             <double>-12.214</double>
19 |                         </value>
20 |                         <value>
21 |                             <datetime.iso8601>19980717T14:08:55</datetime.iso8601>
22 |                         </value>
23 |                         <value>
24 |                             <base64>eW91IGNhbid0IHJlYWQgdGhpcyE=</base64>
25 |                         </value>
26 |                     </data>
27 |                 </array>
28 |             </value>
29 |         </param>
30 |         <param>
31 |             <value>
32 |                 <struct>
33 |                     <member>
34 |                         <name>something</name>
35 |                         <value>
36 |                             <string>4</string>
37 |                         </value>
38 |                     </member>
39 |                 </struct>
40 |             </value>
41 |         </param>
42 |         <param>
43 |             <value>
44 |                 <array>
45 |                     <data>
46 |                         <value>
47 |                             <string>40</string>
48 |                         </value>
49 |                     </data>
50 |                 </array>
51 |             </value>
52 |         </param>
53 |     </params>
54 | </methodCall>
55 | 


--------------------------------------------------------------------------------
/protocol/src/main/kotlin/Util.kt:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2022 Andreas Scheja. Use of this source code is governed by the Apache 2.0 license.
 3 |  */
 4 | 
 5 | package org.ascheja.xmlrpc.protocol
 6 | 
 7 | import org.w3c.dom.Document
 8 | import java.io.ByteArrayOutputStream
 9 | import java.io.OutputStream
10 | import javax.xml.parsers.DocumentBuilder
11 | import javax.xml.parsers.DocumentBuilderFactory
12 | import javax.xml.transform.OutputKeys
13 | import javax.xml.transform.Transformer
14 | import javax.xml.transform.TransformerFactory
15 | import javax.xml.transform.dom.DOMSource
16 | import javax.xml.transform.stream.StreamResult
17 | 
18 | private val declarationBytes = "<?xml version='1.0' encoding='UTF-8'?>".toByteArray()
19 | 
20 | internal fun createDocumentBuilder(): DocumentBuilder {
21 |     return DocumentBuilderFactory.newInstance().newDocumentBuilder()
22 | }
23 | 
24 | internal fun createDefaultTransformer(prettyPrint: Boolean): Transformer {
25 |     return TransformerFactory.newInstance().newTransformer().apply {
26 |         if (prettyPrint) {
27 |             setOutputProperty(OutputKeys.INDENT, "yes")
28 |         }
29 |         setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes")
30 |     }
31 | }
32 | 
33 | public fun Document.writeToByteArray(prettyPrint: Boolean = true): ByteArray {
34 |     return ByteArrayOutputStream().use { out ->
35 |         writeTo(out, prettyPrint)
36 |         out.toByteArray()
37 |     }
38 | }
39 | 
40 | public fun Document.writeTo(out: OutputStream, prettyPrint: Boolean = true) {
41 |     out.write(declarationBytes)
42 |     if (prettyPrint) out.write(System.lineSeparator().toByteArray())
43 |     createDefaultTransformer(prettyPrint).transform(DOMSource(this), StreamResult(out))
44 | }
45 | 
46 | public fun Document.writeToString(prettyPrint: Boolean = true): String {
47 |     return writeToByteArray(prettyPrint).toString(Charsets.UTF_8)
48 | }
49 | 


--------------------------------------------------------------------------------
/ktor-server-xmlrpc/src/test/kotlin/LibraryTest.kt:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2022 Andreas Scheja. Use of this source code is governed by the Apache 2.0 license.
 3 |  */
 4 | 
 5 | package org.ascheja.xmlrpc.ktor.server
 6 | 
 7 | import io.ktor.http.HttpHeaders
 8 | import io.ktor.http.HttpMethod
 9 | import io.ktor.server.application.Application
10 | import io.ktor.server.application.ApplicationCall
11 | import io.ktor.server.routing.routing
12 | import io.ktor.server.testing.handleRequest
13 | import io.ktor.server.testing.setBody
14 | import io.ktor.server.testing.withTestApplication
15 | import org.ascheja.xmlrpc.protocol.BooleanValue
16 | import org.ascheja.xmlrpc.protocol.MethodCall
17 | import org.ascheja.xmlrpc.protocol.MethodResponse
18 | import org.ascheja.xmlrpc.protocol.MethodResponseSuccess
19 | import org.ascheja.xmlrpc.protocol.writeToByteArray
20 | import org.junit.jupiter.api.Test
21 | import java.io.ByteArrayInputStream
22 | import kotlin.test.assertEquals
23 | 
24 | class LibraryTest {
25 | 
26 |     private lateinit var handler: suspend ApplicationCall.(MethodCall) -> MethodResponse
27 | 
28 |     private val moduleFn: Application.() -> Unit = {
29 |         routing {
30 |             xmlRpc("/xmlrpc", handler)
31 |         }
32 |     }
33 | 
34 |     @Test
35 |     fun `handler is called with methodCall and methodResponse is returned`() {
36 |         val methodCall = MethodCall("test")
37 |         val methodResponse = MethodResponseSuccess(BooleanValue(true))
38 |         handler = {
39 |             assertEquals(methodCall, it)
40 |             methodResponse
41 |         }
42 |         withTestApplication(moduleFn) {
43 |             val call = handleRequest(HttpMethod.Post, "/xmlrpc") {
44 |                 addHeader(HttpHeaders.ContentType, "application/xml")
45 |                 setBody(methodCall.toDocument().writeToByteArray())
46 |             }
47 |             assertEquals(
48 |                 methodResponse,
49 |                 MethodResponse.parse { it.parse(ByteArrayInputStream(call.response.byteContent)) }
50 |             )
51 |         }
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/gradlew.bat:
--------------------------------------------------------------------------------
 1 | @rem
 2 | @rem Copyright 2015 the original author or authors.
 3 | @rem
 4 | @rem Licensed under the Apache License, Version 2.0 (the "License");
 5 | @rem you may not use this file except in compliance with the License.
 6 | @rem You may obtain a copy of the License at
 7 | @rem
 8 | @rem      https://www.apache.org/licenses/LICENSE-2.0
 9 | @rem
10 | @rem Unless required by applicable law or agreed to in writing, software
11 | @rem distributed under the License is distributed on an "AS IS" BASIS,
12 | @rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | @rem See the License for the specific language governing permissions and
14 | @rem limitations under the License.
15 | @rem
16 | 
17 | @if "%DEBUG%" == "" @echo off
18 | @rem ##########################################################################
19 | @rem
20 | @rem  Gradle startup script for Windows
21 | @rem
22 | @rem ##########################################################################
23 | 
24 | @rem Set local scope for the variables with windows NT shell
25 | if "%OS%"=="Windows_NT" setlocal
26 | 
27 | set DIRNAME=%~dp0
28 | if "%DIRNAME%" == "" set DIRNAME=.
29 | set APP_BASE_NAME=%~n0
30 | set APP_HOME=%DIRNAME%
31 | 
32 | @rem Resolve any "." and ".." in APP_HOME to make it shorter.
33 | for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
34 | 
35 | @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
36 | set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
37 | 
38 | @rem Find java.exe
39 | if defined JAVA_HOME goto findJavaFromJavaHome
40 | 
41 | set JAVA_EXE=java.exe
42 | %JAVA_EXE% -version >NUL 2>&1
43 | if "%ERRORLEVEL%" == "0" goto execute
44 | 
45 | echo.
46 | echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
47 | echo.
48 | echo Please set the JAVA_HOME variable in your environment to match the
49 | echo location of your Java installation.
50 | 
51 | goto fail
52 | 
53 | :findJavaFromJavaHome
54 | set JAVA_HOME=%JAVA_HOME:"=%
55 | set JAVA_EXE=%JAVA_HOME%/bin/java.exe
56 | 
57 | if exist "%JAVA_EXE%" goto execute
58 | 
59 | echo.
60 | echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
61 | echo.
62 | echo Please set the JAVA_HOME variable in your environment to match the
63 | echo location of your Java installation.
64 | 
65 | goto fail
66 | 
67 | :execute
68 | @rem Setup the command line
69 | 
70 | set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
71 | 
72 | 
73 | @rem Execute Gradle
74 | "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
75 | 
76 | :end
77 | @rem End local scope for the variables with windows NT shell
78 | if "%ERRORLEVEL%"=="0" goto mainEnd
79 | 
80 | :fail
81 | rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
82 | rem the _cmd.exe /c_ return code!
83 | if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
84 | exit /b 1
85 | 
86 | :mainEnd
87 | if "%OS%"=="Windows_NT" endlocal
88 | 
89 | :omega
90 | 


--------------------------------------------------------------------------------
/protocol/src/test/kotlin/SerializerTest.kt:
--------------------------------------------------------------------------------
 1 | package org.ascheja.xmlrpc.protocol
 2 | 
 3 | import org.junit.jupiter.api.Test
 4 | import kotlin.test.assertEquals
 5 | 
 6 | class SerializerTest {
 7 | 
 8 |     @Test
 9 |     fun `serialize method call empty`() {
10 |         assertEquals(
11 |             javaClass.getResource("/protocol/call_empty.xml")!!.readText(),
12 |             MethodCall("examples.getStateName", emptyList()).toDocument().writeToString().replace("\r", "")
13 |         )
14 |     }
15 | 
16 |     @Test
17 |     fun `serialize method call with single parameter`() {
18 |         assertEquals(
19 |             javaClass.getResource("/protocol/call_single.xml")!!.readText(),
20 |             MethodCall(
21 |                 "examples.getStateName",
22 |                 ArrayValue()
23 |             ).toDocument().writeToString().replace("\r", "")
24 |         )
25 |     }
26 | 
27 |     @Test
28 |     fun `serialize method call with multiple parameters`() {
29 |         assertEquals(
30 |             javaClass.getResource("/protocol/call_multiple.xml")!!.readText().replace("i4>", "int>"),
31 |             MethodCall(
32 |                 "examples.getStateName",
33 |                 IntegerValue(41),
34 |                 ArrayValue(
35 |                     BooleanValue(true),
36 |                     DoubleValue(-12.214),
37 |                     DateTimeIso8601Value("19980717T14:08:55"),
38 |                     Base64Value("eW91IGNhbid0IHJlYWQgdGhpcyE="),
39 |                 ),
40 |                 StructValue(
41 |                     "something" to StringValue("4")
42 |                 ),
43 |                 ArrayValue(
44 |                     StringValue("40")
45 |                 )
46 |             ).toDocument().writeToString().replace("\r", "")
47 |         )
48 |     }
49 | 
50 |     @Test
51 |     fun `serialize method response with fault`() {
52 |         assertEquals(
53 |             javaClass.getResource("/protocol/fault.xml")!!.readText(),
54 |             MethodResponseFault(
55 |                 4,
56 |                 "Too many parameters."
57 |             ).toDocument().writeToString().replace("\r", "")
58 |         )
59 |     }
60 | 
61 |     @Test
62 |     fun `serialize method response with success empty parameters`() {
63 |         assertEquals(
64 |             javaClass.getResource("/protocol/success_empty.xml")!!.readText(),
65 |             MethodResponseSuccess().toDocument().writeToString().replace("\r", "")
66 |         )
67 |     }
68 | 
69 |     @Test
70 |     fun `serialize method response with success single parameter`() {
71 |         assertEquals(
72 |             javaClass.getResource("/protocol/success_single.xml")!!.readText(),
73 |             MethodResponseSuccess(StringValue("South Dakota")).toDocument().writeToString().replace("\r", "")
74 |         )
75 |     }
76 | 
77 |     @Test
78 |     fun `serialize method response with success multiple parameters`() {
79 |         assertEquals(
80 |             javaClass.getResource("/protocol/success_multiple.xml")!!.readText(),
81 |             MethodResponseSuccess(StringValue("South Dakota"), StringValue("North Dakota")).toDocument().writeToString().replace("\r", ""),
82 |         )
83 |     }
84 | }
85 | 


--------------------------------------------------------------------------------
/protocol/src/test/kotlin/DeserializerTest.kt:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2022 Andreas Scheja. Use of this source code is governed by the Apache 2.0 license.
 3 |  */
 4 | 
 5 | package org.ascheja.xmlrpc.protocol
 6 | 
 7 | import org.junit.jupiter.api.Test
 8 | import kotlin.test.assertEquals
 9 | 
10 | class DeserializerTest {
11 | 
12 |     @Test
13 |     fun `deserialize method call empty`() {
14 |         assertEquals(
15 |             MethodCall("examples.getStateName", emptyList()),
16 |             MethodCall.parse { it.parse(javaClass.getResourceAsStream("/protocol/call_empty.xml")!!) }
17 |         )
18 |     }
19 | 
20 |     @Test
21 |     fun `deserialize method call with single parameter`() {
22 |         assertEquals(
23 |             MethodCall(
24 |                 "examples.getStateName",
25 |                 ArrayValue()
26 |             ),
27 |             MethodCall.parse { it.parse(javaClass.getResourceAsStream("/protocol/call_single.xml")!!) }
28 |         )
29 |     }
30 | 
31 |     @Test
32 |     fun `deserialize method call with multiple parameters`() {
33 |         assertEquals(
34 |             MethodCall(
35 |                 "examples.getStateName",
36 |                 IntegerValue(41),
37 |                 ArrayValue(
38 |                     BooleanValue(true),
39 |                     DoubleValue(-12.214),
40 |                     DateTimeIso8601Value("19980717T14:08:55"),
41 |                     Base64Value("eW91IGNhbid0IHJlYWQgdGhpcyE="),
42 |                 ),
43 |                 StructValue(
44 |                     "something" to StringValue("4")
45 |                 ),
46 |                 ArrayValue(
47 |                     StringValue("40")
48 |                 )
49 |             ),
50 |             MethodCall.parse { it.parse(javaClass.getResourceAsStream("/protocol/call_multiple.xml")!!) }
51 |         )
52 |     }
53 | 
54 |     @Test
55 |     fun `deserialize method response with fault`() {
56 |         assertEquals(
57 |             MethodResponseFault(
58 |                 4,
59 |                 "Too many parameters."
60 |             ),
61 |             MethodResponse.parse { it.parse(javaClass.getResourceAsStream("/protocol/fault.xml")!!) }
62 |         )
63 |     }
64 | 
65 |     @Test
66 |     fun `deserialize method response with success empty parameters`() {
67 |         assertEquals(
68 |             MethodResponseSuccess(),
69 |             MethodResponse.parse { it.parse(javaClass.getResourceAsStream("/protocol/success_empty.xml")!!) }
70 |         )
71 |     }
72 | 
73 |     @Test
74 |     fun `deserialize method response with success single parameter`() {
75 |         assertEquals(
76 |             MethodResponseSuccess(StringValue("South Dakota")),
77 |             MethodResponse.parse { it.parse(javaClass.getResourceAsStream("/protocol/success_single.xml")!!) }
78 |         )
79 |     }
80 | 
81 |     @Test
82 |     fun `deserialize method response with success multiple parameters`() {
83 |         assertEquals(
84 |             MethodResponseSuccess(StringValue("South Dakota"), StringValue("North Dakota")),
85 |             MethodResponse.parse { it.parse(javaClass.getResourceAsStream("/protocol/success_multiple.xml")!!) }
86 |         )
87 |     }
88 | }
89 | 


--------------------------------------------------------------------------------
/protocol/src/main/kotlin/Serializer.kt:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2022 Andreas Scheja. Use of this source code is governed by the Apache 2.0 license.
 3 |  */
 4 | 
 5 | package org.ascheja.xmlrpc.protocol
 6 | 
 7 | import org.w3c.dom.Document
 8 | import org.w3c.dom.Element
 9 | import org.w3c.dom.Node
10 | 
11 | internal class Serializer internal constructor(private val document: Document) {
12 | 
13 |     internal fun MethodCall.appendToElement(root: Node) {
14 |         val methodCallElement = root.appendChild(createElement("methodCall"))
15 |         methodCallElement.appendNewElementWithTextContent("methodName", methodName)
16 |         val paramsElement = methodCallElement.appendNewElement("params")
17 |         for (value in params) {
18 |             val paramElement = paramsElement.appendNewElement("param")
19 |             value.appendToElement(paramElement)
20 |         }
21 |     }
22 | 
23 |     internal fun MethodResponse.appendToElement(root: Node) {
24 |         val methodResponse = root.appendChild(createElement("methodResponse"))
25 |         when (this) {
26 |             is MethodResponseFault -> {
27 |                 val faultElement = methodResponse.appendNewElement("fault")
28 |                 StructValue(
29 |                     "faultCode" to IntegerValue(faultCode),
30 |                     "faultString" to StringValue(faultString)
31 |                 ).appendToElement(faultElement)
32 |             }
33 |             is MethodResponseSuccess -> {
34 |                 val paramsElement = methodResponse.appendNewElement("params")
35 |                 for (value in params) {
36 |                     val paramElement = paramsElement.appendNewElement("param")
37 |                     value.appendToElement(paramElement)
38 |                 }
39 |             }
40 |         }
41 |     }
42 | 
43 |     internal fun Value.appendToElement(parent: Node) {
44 |         val valueElement = parent.appendNewElement("value")
45 |         when (this) {
46 |             is ArrayValue -> {
47 |                 val arrayElement = valueElement.appendNewElement("array")
48 |                 val dataElement = arrayElement.appendNewElement("data")
49 |                 for (value in data) {
50 |                     value.appendToElement(dataElement)
51 |                 }
52 |             }
53 |             is Base64Value -> valueElement.appendNewElementWithTextContent("base64", value)
54 |             is BooleanValue -> valueElement.appendNewElementWithTextContent("boolean", if (value) "1" else "0")
55 |             is DateTimeIso8601Value -> valueElement.appendNewElementWithTextContent("datetime.iso8601", value)
56 |             is DoubleValue -> valueElement.appendNewElementWithTextContent("double", value.toString())
57 |             is IntegerValue -> valueElement.appendNewElementWithTextContent("int", value.toString())
58 |             is StringValue -> valueElement.appendNewElementWithTextContent("string", value)
59 |             is StructValue -> {
60 |                 val structElement = valueElement.appendNewElement("struct")
61 |                 for ((name, value) in members) {
62 |                     val memberElement = structElement.appendNewElement("member")
63 |                     memberElement.appendNewElementWithTextContent("name", name)
64 |                     value.appendToElement(memberElement)
65 |                 }
66 |             }
67 |         }
68 |     }
69 | 
70 |     private fun createElement(tagName: String) = document.createElement(tagName)
71 | 
72 |     private fun createElementWithTextContent(tagName: String, text: String): Element {
73 |         return createElement(tagName).apply {
74 |             textContent = text
75 |         }
76 |     }
77 | 
78 |     private fun Node.appendNewElement(tagName: String) = appendChild(createElement(tagName))
79 | 
80 |     private fun Node.appendNewElementWithTextContent(tagName: String, text: String) = appendChild(createElementWithTextContent(tagName, text))
81 | }
82 | 


--------------------------------------------------------------------------------
/ktor-client-xmlrpc/src/test/kotlin/LibraryTest.kt:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright (c) 2022 Andreas Scheja. Use of this source code is governed by the Apache 2.0 license.
  3 |  */
  4 | 
  5 | package org.ascheja.xmlrpc.ktor.client
  6 | 
  7 | import io.ktor.client.HttpClient
  8 | import io.ktor.client.engine.mock.MockEngine
  9 | import io.ktor.client.engine.mock.respond
 10 | import io.ktor.client.engine.mock.toByteReadPacket
 11 | import io.ktor.http.ContentType
 12 | import io.ktor.http.HttpHeaders
 13 | import io.ktor.http.HttpStatusCode
 14 | import io.ktor.http.content.OutgoingContent
 15 | import io.ktor.http.headersOf
 16 | import io.ktor.utils.io.core.readBytes
 17 | import kotlinx.coroutines.runBlocking
 18 | import org.ascheja.xmlrpc.protocol.IntegerValue
 19 | import org.ascheja.xmlrpc.protocol.MethodCall
 20 | import org.ascheja.xmlrpc.protocol.MethodResponse
 21 | import org.ascheja.xmlrpc.protocol.MethodResponseFault
 22 | import org.ascheja.xmlrpc.protocol.MethodResponseSuccess
 23 | import org.ascheja.xmlrpc.protocol.writeToByteArray
 24 | import org.junit.jupiter.api.Test
 25 | import org.junit.jupiter.api.fail
 26 | import java.io.ByteArrayInputStream
 27 | import kotlin.test.assertEquals
 28 | 
 29 | class LibraryTest {
 30 | 
 31 |     companion object {
 32 |         private const val serviceUrl = "https://some-service/some-path"
 33 |     }
 34 | 
 35 |     @Test
 36 |     fun `successful response is returned`() {
 37 |         val methodCall = MethodCall("whatIsTheQuestion")
 38 |         val methodResponse = MethodResponseSuccess(IntegerValue(42))
 39 |         val client = HttpClient(
 40 |             createMockEngine(methodCall, methodResponse)
 41 |         )
 42 |         assertEquals(
 43 |             methodResponse,
 44 |             runBlocking { client.xmlRpc(serviceUrl, methodCall) }
 45 |         )
 46 |     }
 47 | 
 48 |     @Test
 49 |     fun `fault response is returned if throwOnFault is deactivated`() {
 50 |         val methodCall = MethodCall("whatIsTheQuestion")
 51 |         val methodResponse = MethodResponseFault(42, "no more numbers")
 52 |         val client = HttpClient(
 53 |             createMockEngine(methodCall, methodResponse)
 54 |         )
 55 |         assertEquals(
 56 |             methodResponse,
 57 |             runBlocking { client.xmlRpc(serviceUrl, methodCall, false) }
 58 |         )
 59 |     }
 60 | 
 61 |     @Test
 62 |     fun `fault response is thrown if throwOnFault is activated`() {
 63 |         val methodCall = MethodCall("whatIsTheQuestion")
 64 |         val methodResponse = MethodResponseFault(42, "no more numbers")
 65 |         val client = HttpClient(
 66 |             createMockEngine(methodCall, methodResponse)
 67 |         )
 68 |         try {
 69 |             runBlocking { client.xmlRpc(serviceUrl, methodCall, true) }
 70 |             fail("shouldn't go here")
 71 |         } catch (e: XmlRpcFault) {
 72 |             assertEquals(
 73 |                 methodResponse,
 74 |                 e.methodResponse
 75 |             )
 76 |         }
 77 |     }
 78 | 
 79 |     private fun createMockEngine(expectedCall: MethodCall, response: MethodResponse): MockEngine {
 80 |         return MockEngine { request ->
 81 |             assertEquals(serviceUrl, request.url.toString())
 82 |             assertEquals(ContentType.Application.Xml, request.body.contentType)
 83 |             val methodCall = MethodCall.parse {
 84 |                 it.parse(
 85 |                     ByteArrayInputStream(
 86 |                         runBlocking {
 87 |                             when (val body = request.body) {
 88 |                                 is OutgoingContent.ByteArrayContent -> body.bytes()
 89 |                                 is OutgoingContent.NoContent, is OutgoingContent.ProtocolUpgrade -> byteArrayOf()
 90 |                                 is OutgoingContent.ReadChannelContent -> body.toByteReadPacket().readBytes()
 91 |                                 is OutgoingContent.WriteChannelContent -> body.toByteReadPacket().readBytes()
 92 |                             }
 93 |                         }
 94 |                     )
 95 |                 )
 96 |             }
 97 |             assertEquals(
 98 |                 expectedCall,
 99 |                 methodCall
100 |             )
101 |             respond(
102 |                 response.toDocument().writeToByteArray(),
103 |                 HttpStatusCode.OK,
104 |                 headersOf(HttpHeaders.ContentType, ContentType.Application.Xml.toString())
105 |             )
106 |         }
107 |     }
108 | }
109 | 


--------------------------------------------------------------------------------
/protocol/src/main/kotlin/Deserializer.kt:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2022 Andreas Scheja. Use of this source code is governed by the Apache 2.0 license.
 3 |  */
 4 | 
 5 | package org.ascheja.xmlrpc.protocol
 6 | 
 7 | import org.w3c.dom.Element
 8 | 
 9 | internal class Deserializer internal constructor() {
10 | 
11 |     companion object {
12 | 
13 |         private fun Element.associateChildren(): Map<String, Element> = buildMap {
14 |             for (i in 0 until childNodes.length) {
15 |                 val child = childNodes.item(i) as? Element ?: continue
16 |                 put(child.tagName, child)
17 |             }
18 |         }
19 | 
20 |         private fun <T> Element.mapChildren(block: (Element) -> T): List<T> = buildList {
21 |             for (i in 0 until childNodes.length) {
22 |                 val child = childNodes.item(i) as? Element ?: continue
23 |                 add(block(child))
24 |             }
25 |         }
26 |     }
27 | 
28 |     internal fun parseMethodCall(methodCallElement: Element): MethodCall {
29 |         if (methodCallElement.tagName != "methodCall") error("not a method call")
30 |         val children = methodCallElement.associateChildren()
31 |         return MethodCall(
32 |             children["methodName"]?.textContent ?: error("missing methodName"),
33 |             children["params"]?.mapChildren { paramElement ->
34 |                 if (paramElement.tagName != "param") error("expecting <param>, got <${paramElement.tagName}>")
35 |                 parseValue(paramElement.associateChildren()["value"] ?: error("<param> missing a <value>"))
36 |             } ?: emptyList()
37 |         )
38 |     }
39 | 
40 |     internal fun parseMethodResponse(methodResponseElement: Element): MethodResponse {
41 |         if (methodResponseElement.tagName != "methodResponse") error("not a method response")
42 |         val children = methodResponseElement.associateChildren()
43 |         if (children.size != 1) error("<methodResponse> with invalid size: ${children.size}")
44 |         val (tagName, element) = children.entries.first()
45 |         return when (tagName) {
46 |             "fault" -> {
47 |                 val faultStruct = parseValue(
48 |                     element.associateChildren()["value"] ?: error("missing <value> in <fault>")
49 |                 ) as? StructValue ?: error("expected <fault>'s <value> to be a <struct>")
50 |                 MethodResponseFault(
51 |                     (faultStruct.members["faultCode"] as? IntegerValue)?.value ?: error("missing faultCode in <fault>"),
52 |                     (faultStruct.members["faultString"] as? StringValue)?.value ?: error("missing faultString in <fault>")
53 |                 )
54 |             }
55 |             "params" -> {
56 |                 MethodResponseSuccess(
57 |                     element.mapChildren { paramElement ->
58 |                         if (paramElement.tagName != "param") error("expecting <param>, got <${paramElement.tagName}>")
59 |                         parseValue(paramElement.associateChildren()["value"] ?: error("<param> missing a <value>"))
60 |                     }
61 |                 )
62 |             }
63 |             else -> error("unexpected <$tagName> in <methodResponse>")
64 |         }
65 |     }
66 | 
67 |     internal fun parseValue(valueElement: Element): Value {
68 |         val children = valueElement.associateChildren()
69 |         if (children.size != 1) error("<value> with invalid size: ${children.size}")
70 |         val (tagName, element) = children.entries.first()
71 |         return when (tagName) {
72 |             "i4", "int" -> IntegerValue(element.textContent.toInt())
73 |             "string" -> StringValue(element.textContent)
74 |             "boolean" -> BooleanValue(element.textContent.toInt() == 1)
75 |             "double" -> DoubleValue(element.textContent.toDouble())
76 |             "datetime.iso8601" -> DateTimeIso8601Value(element.textContent)
77 |             "base64" -> Base64Value(element.textContent)
78 |             "struct" -> StructValue(
79 |                 element.mapChildren { memberElement ->
80 |                     val memberChildren = memberElement.associateChildren()
81 |                     Pair(
82 |                         memberChildren["name"]?.textContent ?: error("<member> missing <name>"),
83 |                         parseValue(memberChildren["value"] ?: error("<member> missing <value>"))
84 |                     )
85 |                 }.toMap()
86 |             )
87 |             "array" -> {
88 |                 val dataElement = element.associateChildren()["data"] ?: error("missing <data> element in <array>")
89 |                 ArrayValue(dataElement.mapChildren(::parseValue))
90 |             }
91 |             else -> error("unknown value type <$tagName>")
92 |         }
93 |     }
94 | }
95 | 


--------------------------------------------------------------------------------
/gradlew:
--------------------------------------------------------------------------------
  1 | #!/bin/sh
  2 | 
  3 | #
  4 | # Copyright © 2015-2021 the original authors.
  5 | #
  6 | # Licensed under the Apache License, Version 2.0 (the "License");
  7 | # you may not use this file except in compliance with the License.
  8 | # You may obtain a copy of the License at
  9 | #
 10 | #      https://www.apache.org/licenses/LICENSE-2.0
 11 | #
 12 | # Unless required by applicable law or agreed to in writing, software
 13 | # distributed under the License is distributed on an "AS IS" BASIS,
 14 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 15 | # See the License for the specific language governing permissions and
 16 | # limitations under the License.
 17 | #
 18 | 
 19 | ##############################################################################
 20 | #
 21 | #   Gradle start up script for POSIX generated by Gradle.
 22 | #
 23 | #   Important for running:
 24 | #
 25 | #   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
 26 | #       noncompliant, but you have some other compliant shell such as ksh or
 27 | #       bash, then to run this script, type that shell name before the whole
 28 | #       command line, like:
 29 | #
 30 | #           ksh Gradle
 31 | #
 32 | #       Busybox and similar reduced shells will NOT work, because this script
 33 | #       requires all of these POSIX shell features:
 34 | #         * functions;
 35 | #         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
 36 | #           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
 37 | #         * compound commands having a testable exit status, especially «case»;
 38 | #         * various built-in commands including «command», «set», and «ulimit».
 39 | #
 40 | #   Important for patching:
 41 | #
 42 | #   (2) This script targets any POSIX shell, so it avoids extensions provided
 43 | #       by Bash, Ksh, etc; in particular arrays are avoided.
 44 | #
 45 | #       The "traditional" practice of packing multiple parameters into a
 46 | #       space-separated string is a well documented source of bugs and security
 47 | #       problems, so this is (mostly) avoided, by progressively accumulating
 48 | #       options in "$@", and eventually passing that to Java.
 49 | #
 50 | #       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
 51 | #       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
 52 | #       see the in-line comments for details.
 53 | #
 54 | #       There are tweaks for specific operating systems such as AIX, CygWin,
 55 | #       Darwin, MinGW, and NonStop.
 56 | #
 57 | #   (3) This script is generated from the Groovy template
 58 | #       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
 59 | #       within the Gradle project.
 60 | #
 61 | #       You can find Gradle at https://github.com/gradle/gradle/.
 62 | #
 63 | ##############################################################################
 64 | 
 65 | # Attempt to set APP_HOME
 66 | 
 67 | # Resolve links: $0 may be a link
 68 | app_path=$0
 69 | 
 70 | # Need this for daisy-chained symlinks.
 71 | while
 72 |     APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
 73 |     [ -h "$app_path" ]
 74 | do
 75 |     ls=$( ls -ld "$app_path" )
 76 |     link=${ls#*' -> '}
 77 |     case $link in             #(
 78 |       /*)   app_path=$link ;; #(
 79 |       *)    app_path=$APP_HOME$link ;;
 80 |     esac
 81 | done
 82 | 
 83 | APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
 84 | 
 85 | APP_NAME="Gradle"
 86 | APP_BASE_NAME=${0##*/}
 87 | 
 88 | # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 89 | DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 90 | 
 91 | # Use the maximum available, or set MAX_FD != -1 to use that value.
 92 | MAX_FD=maximum
 93 | 
 94 | warn () {
 95 |     echo "$*"
 96 | } >&2
 97 | 
 98 | die () {
 99 |     echo
100 |     echo "$*"
101 |     echo
102 |     exit 1
103 | } >&2
104 | 
105 | # OS specific support (must be 'true' or 'false').
106 | cygwin=false
107 | msys=false
108 | darwin=false
109 | nonstop=false
110 | case "$( uname )" in                #(
111 |   CYGWIN* )         cygwin=true  ;; #(
112 |   Darwin* )         darwin=true  ;; #(
113 |   MSYS* | MINGW* )  msys=true    ;; #(
114 |   NONSTOP* )        nonstop=true ;;
115 | esac
116 | 
117 | CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
118 | 
119 | 
120 | # Determine the Java command to use to start the JVM.
121 | if [ -n "$JAVA_HOME" ] ; then
122 |     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
123 |         # IBM's JDK on AIX uses strange locations for the executables
124 |         JAVACMD=$JAVA_HOME/jre/sh/java
125 |     else
126 |         JAVACMD=$JAVA_HOME/bin/java
127 |     fi
128 |     if [ ! -x "$JAVACMD" ] ; then
129 |         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
130 | 
131 | Please set the JAVA_HOME variable in your environment to match the
132 | location of your Java installation."
133 |     fi
134 | else
135 |     JAVACMD=java
136 |     which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
137 | 
138 | Please set the JAVA_HOME variable in your environment to match the
139 | location of your Java installation."
140 | fi
141 | 
142 | # Increase the maximum file descriptors if we can.
143 | if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
144 |     case $MAX_FD in #(
145 |       max*)
146 |         MAX_FD=$( ulimit -H -n ) ||
147 |             warn "Could not query maximum file descriptor limit"
148 |     esac
149 |     case $MAX_FD in  #(
150 |       '' | soft) :;; #(
151 |       *)
152 |         ulimit -n "$MAX_FD" ||
153 |             warn "Could not set maximum file descriptor limit to $MAX_FD"
154 |     esac
155 | fi
156 | 
157 | # Collect all arguments for the java command, stacking in reverse order:
158 | #   * args from the command line
159 | #   * the main class name
160 | #   * -classpath
161 | #   * -D...appname settings
162 | #   * --module-path (only if needed)
163 | #   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
164 | 
165 | # For Cygwin or MSYS, switch paths to Windows format before running java
166 | if "$cygwin" || "$msys" ; then
167 |     APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
168 |     CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
169 | 
170 |     JAVACMD=$( cygpath --unix "$JAVACMD" )
171 | 
172 |     # Now convert the arguments - kludge to limit ourselves to /bin/sh
173 |     for arg do
174 |         if
175 |             case $arg in                                #(
176 |               -*)   false ;;                            # don't mess with options #(
177 |               /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
178 |                     [ -e "$t" ] ;;                      #(
179 |               *)    false ;;
180 |             esac
181 |         then
182 |             arg=$( cygpath --path --ignore --mixed "$arg" )
183 |         fi
184 |         # Roll the args list around exactly as many times as the number of
185 |         # args, so each arg winds up back in the position where it started, but
186 |         # possibly modified.
187 |         #
188 |         # NB: a `for` loop captures its iteration list before it begins, so
189 |         # changing the positional parameters here affects neither the number of
190 |         # iterations, nor the values presented in `arg`.
191 |         shift                   # remove old arg
192 |         set -- "$@" "$arg"      # push replacement arg
193 |     done
194 | fi
195 | 
196 | # Collect all arguments for the java command;
197 | #   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
198 | #     shell script including quotes and variable substitutions, so put them in
199 | #     double quotes to make sure that they get re-expanded; and
200 | #   * put everything else in single quotes, so that it's not re-expanded.
201 | 
202 | set -- \
203 |         "-Dorg.gradle.appname=$APP_BASE_NAME" \
204 |         -classpath "$CLASSPATH" \
205 |         org.gradle.wrapper.GradleWrapperMain \
206 |         "$@"
207 | 
208 | # Use "xargs" to parse quoted args.
209 | #
210 | # With -n1 it outputs one arg per line, with the quotes and backslashes removed.
211 | #
212 | # In Bash we could simply go:
213 | #
214 | #   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
215 | #   set -- "${ARGS[@]}" "$@"
216 | #
217 | # but POSIX shell has neither arrays nor command substitution, so instead we
218 | # post-process each arg (as a line of input to sed) to backslash-escape any
219 | # character that might be a shell metacharacter, then use eval to reverse
220 | # that process (while maintaining the separation between arguments), and wrap
221 | # the whole thing up as a single "set" statement.
222 | #
223 | # This will of course break if any of these variables contains a newline or
224 | # an unmatched quote.
225 | #
226 | 
227 | eval "set -- $(
228 |         printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
229 |         xargs -n1 |
230 |         sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
231 |         tr '\n' ' '
232 |     )" '"$@"'
233 | 
234 | exec "$JAVACMD" "$@"
235 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                                  Apache License
  2 |                            Version 2.0, January 2004
  3 |                         http://www.apache.org/licenses/
  4 | 
  5 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 |    1. Definitions.
  8 | 
  9 |       "License" shall mean the terms and conditions for use, reproduction,
 10 |       and distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 |       "Licensor" shall mean the copyright owner or entity authorized by
 13 |       the copyright owner that is granting the License.
 14 | 
 15 |       "Legal Entity" shall mean the union of the acting entity and all
 16 |       other entities that control, are controlled by, or are under common
 17 |       control with that entity. For the purposes of this definition,
 18 |       "control" means (i) the power, direct or indirect, to cause the
 19 |       direction or management of such entity, whether by contract or
 20 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 21 |       outstanding shares, or (iii) beneficial ownership of such entity.
 22 | 
 23 |       "You" (or "Your") shall mean an individual or Legal Entity
 24 |       exercising permissions granted by this License.
 25 | 
 26 |       "Source" form shall mean the preferred form for making modifications,
 27 |       including but not limited to software source code, documentation
 28 |       source, and configuration files.
 29 | 
 30 |       "Object" form shall mean any form resulting from mechanical
 31 |       transformation or translation of a Source form, including but
 32 |       not limited to compiled object code, generated documentation,
 33 |       and conversions to other media types.
 34 | 
 35 |       "Work" shall mean the work of authorship, whether in Source or
 36 |       Object form, made available under the License, as indicated by a
 37 |       copyright notice that is included in or attached to the work
 38 |       (an example is provided in the Appendix below).
 39 | 
 40 |       "Derivative Works" shall mean any work, whether in Source or Object
 41 |       form, that is based on (or derived from) the Work and for which the
 42 |       editorial revisions, annotations, elaborations, or other modifications
 43 |       represent, as a whole, an original work of authorship. For the purposes
 44 |       of this License, Derivative Works shall not include works that remain
 45 |       separable from, or merely link (or bind by name) to the interfaces of,
 46 |       the Work and Derivative Works thereof.
 47 | 
 48 |       "Contribution" shall mean any work of authorship, including
 49 |       the original version of the Work and any modifications or additions
 50 |       to that Work or Derivative Works thereof, that is intentionally
 51 |       submitted to Licensor for inclusion in the Work by the copyright owner
 52 |       or by an individual or Legal Entity authorized to submit on behalf of
 53 |       the copyright owner. For the purposes of this definition, "submitted"
 54 |       means any form of electronic, verbal, or written communication sent
 55 |       to the Licensor or its representatives, including but not limited to
 56 |       communication on electronic mailing lists, source code control systems,
 57 |       and issue tracking systems that are managed by, or on behalf of, the
 58 |       Licensor for the purpose of discussing and improving the Work, but
 59 |       excluding communication that is conspicuously marked or otherwise
 60 |       designated in writing by the copyright owner as "Not a Contribution."
 61 | 
 62 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 63 |       on behalf of whom a Contribution has been received by Licensor and
 64 |       subsequently incorporated within the Work.
 65 | 
 66 |    2. Grant of Copyright License. Subject to the terms and conditions of
 67 |       this License, each Contributor hereby grants to You a perpetual,
 68 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 69 |       copyright license to reproduce, prepare Derivative Works of,
 70 |       publicly display, publicly perform, sublicense, and distribute the
 71 |       Work and such Derivative Works in Source or Object form.
 72 | 
 73 |    3. Grant of Patent License. Subject to the terms and conditions of
 74 |       this License, each Contributor hereby grants to You a perpetual,
 75 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 76 |       (except as stated in this section) patent license to make, have made,
 77 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 78 |       where such license applies only to those patent claims licensable
 79 |       by such Contributor that are necessarily infringed by their
 80 |       Contribution(s) alone or by combination of their Contribution(s)
 81 |       with the Work to which such Contribution(s) was submitted. If You
 82 |       institute patent litigation against any entity (including a
 83 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 84 |       or a Contribution incorporated within the Work constitutes direct
 85 |       or contributory patent infringement, then any patent licenses
 86 |       granted to You under this License for that Work shall terminate
 87 |       as of the date such litigation is filed.
 88 | 
 89 |    4. Redistribution. You may reproduce and distribute copies of the
 90 |       Work or Derivative Works thereof in any medium, with or without
 91 |       modifications, and in Source or Object form, provided that You
 92 |       meet the following conditions:
 93 | 
 94 |       (a) You must give any other recipients of the Work or
 95 |           Derivative Works a copy of this License; and
 96 | 
 97 |       (b) You must cause any modified files to carry prominent notices
 98 |           stating that You changed the files; and
 99 | 
100 |       (c) You must retain, in the Source form of any Derivative Works
101 |           that You distribute, all copyright, patent, trademark, and
102 |           attribution notices from the Source form of the Work,
103 |           excluding those notices that do not pertain to any part of
104 |           the Derivative Works; and
105 | 
106 |       (d) If the Work includes a "NOTICE" text file as part of its
107 |           distribution, then any Derivative Works that You distribute must
108 |           include a readable copy of the attribution notices contained
109 |           within such NOTICE file, excluding those notices that do not
110 |           pertain to any part of the Derivative Works, in at least one
111 |           of the following places: within a NOTICE text file distributed
112 |           as part of the Derivative Works; within the Source form or
113 |           documentation, if provided along with the Derivative Works; or,
114 |           within a display generated by the Derivative Works, if and
115 |           wherever such third-party notices normally appear. The contents
116 |           of the NOTICE file are for informational purposes only and
117 |           do not modify the License. You may add Your own attribution
118 |           notices within Derivative Works that You distribute, alongside
119 |           or as an addendum to the NOTICE text from the Work, provided
120 |           that such additional attribution notices cannot be construed
121 |           as modifying the License.
122 | 
123 |       You may add Your own copyright statement to Your modifications and
124 |       may provide additional or different license terms and conditions
125 |       for use, reproduction, or distribution of Your modifications, or
126 |       for any such Derivative Works as a whole, provided Your use,
127 |       reproduction, and distribution of the Work otherwise complies with
128 |       the conditions stated in this License.
129 | 
130 |    5. Submission of Contributions. Unless You explicitly state otherwise,
131 |       any Contribution intentionally submitted for inclusion in the Work
132 |       by You to the Licensor shall be under the terms and conditions of
133 |       this License, without any additional terms or conditions.
134 |       Notwithstanding the above, nothing herein shall supersede or modify
135 |       the terms of any separate license agreement you may have executed
136 |       with Licensor regarding such Contributions.
137 | 
138 |    6. Trademarks. This License does not grant permission to use the trade
139 |       names, trademarks, service marks, or product names of the Licensor,
140 |       except as required for reasonable and customary use in describing the
141 |       origin of the Work and reproducing the content of the NOTICE file.
142 | 
143 |    7. Disclaimer of Warranty. Unless required by applicable law or
144 |       agreed to in writing, Licensor provides the Work (and each
145 |       Contributor provides its Contributions) on an "AS IS" BASIS,
146 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 |       implied, including, without limitation, any warranties or conditions
148 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 |       PARTICULAR PURPOSE. You are solely responsible for determining the
150 |       appropriateness of using or redistributing the Work and assume any
151 |       risks associated with Your exercise of permissions under this License.
152 | 
153 |    8. Limitation of Liability. In no event and under no legal theory,
154 |       whether in tort (including negligence), contract, or otherwise,
155 |       unless required by applicable law (such as deliberate and grossly
156 |       negligent acts) or agreed to in writing, shall any Contributor be
157 |       liable to You for damages, including any direct, indirect, special,
158 |       incidental, or consequential damages of any character arising as a
159 |       result of this License or out of the use or inability to use the
160 |       Work (including but not limited to damages for loss of goodwill,
161 |       work stoppage, computer failure or malfunction, or any and all
162 |       other commercial damages or losses), even if such Contributor
163 |       has been advised of the possibility of such damages.
164 | 
165 |    9. Accepting Warranty or Additional Liability. While redistributing
166 |       the Work or Derivative Works thereof, You may choose to offer,
167 |       and charge a fee for, acceptance of support, warranty, indemnity,
168 |       or other liability obligations and/or rights consistent with this
169 |       License. However, in accepting such obligations, You may act only
170 |       on Your own behalf and on Your sole responsibility, not on behalf
171 |       of any other Contributor, and only if You agree to indemnify,
172 |       defend, and hold each Contributor harmless for any liability
173 |       incurred by, or claims asserted against, such Contributor by reason
174 |       of your accepting any such warranty or additional liability.
175 | 
176 |    END OF TERMS AND CONDITIONS
177 | 
178 |    APPENDIX: How to apply the Apache License to your work.
179 | 
180 |       To apply the Apache License to your work, attach the following
181 |       boilerplate notice, with the fields enclosed by brackets "[]"
182 |       replaced with your own identifying information. (Don't include
183 |       the brackets!)  The text should be enclosed in the appropriate
184 |       comment syntax for the file format. We also recommend that a
185 |       file or class name and description of purpose be included on the
186 |       same "printed page" as the copyright notice for easier
187 |       identification within third-party archives.
188 | 
189 |    Copyright 2022 ascheja
190 | 
191 |    Licensed under the Apache License, Version 2.0 (the "License");
192 |    you may not use this file except in compliance with the License.
193 |    You may obtain a copy of the License at
194 | 
195 |        http://www.apache.org/licenses/LICENSE-2.0
196 | 
197 |    Unless required by applicable law or agreed to in writing, software
198 |    distributed under the License is distributed on an "AS IS" BASIS,
199 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 |    See the License for the specific language governing permissions and
201 |    limitations under the License.
202 | 


--------------------------------------------------------------------------------