* Jdk11 client is a default one; removed the one based on Unirest

* Code for publication to MavenCentral
* Cleanup

Author: aartiPl

build.gradle.kts

@@ -1,27 +1,21 @@
 val kotlinVersion = "2.1.21"
 
 plugins {
+    idea
     kotlin("jvm") version "2.1.21"
     id("com.adarshr.test-logger") version "4.0.0"
-    `maven-publish`
-    signing
-    idea
+    id("com.vanniktech.maven.publish") version "0.33.0"
 }
 
 group = "net.igsoft"
-version = "0.5.0"
+version = "0.6.0"
 
 repositories {
     mavenCentral()
 }
 
-java {
-    toolchain {
-        languageVersion.set(JavaLanguageVersion.of(17))
-    }
-
-    withJavadocJar()
-    withSourcesJar()
+kotlin {
+    jvmToolchain(17)
 }
 
 testlogger {
@@ -33,77 +27,52 @@ tasks.test {
     useJUnitPlatform()
 }
 
-val licencesSpec = Action<MavenPomLicenseSpec> {
-    license {
-        name.set("MIT License")
-        url.set("https://opensource.org/licenses/MIT")
-    }
-}
-
-val developersSpec = Action<MavenPomDeveloperSpec> {
-    developer {
-        id.set("aartiPl")
-        name.set("Marcin Kuszczak")
-        email.set("aarti@interia.pl")
-    }
-}
-
-val scmSpec = Action<MavenPomScm> {
-    connection.set("scm:git:git://https://github.com/aartiPl/funclient.git")
-    developerConnection.set("scm:git:ssh:https://github.com/aartiPl/funclient.git")
-    url.set("https://github.com/aartiPl/funclient/tree/master")
-}
-
-publishing {
-    publications {
-        create<MavenPublication>("funclient") {
-            artifactId = "funclient"
-            from(components["java"])
-
-            pom {
-                name.set("funclient")
-                description.set("FunClient - HTTP client - functional way")
-                url.set("https://github.com/aartiPl/funclient")
+mavenPublishing {
+    pom {
+        name.set("funclient")
+        description.set("FunClient - HTTP client - functional way")
+        url.set("https://github.com/aartiPl/funclient")
 
-                licenses(licencesSpec)
-                developers(developersSpec)
-                scm(scmSpec)
+        licenses {
+            license {
+                name.set("MIT License")
+                url.set("https://opensource.org/licenses/MIT")
             }
         }
-    }
-
-    repositories {
-        maven {
-            val releasesRepoUrl = "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
-            val snapshotsRepoUrl = "https://oss.sonatype.org/content/repositories/snapshots/"
-            url = uri(if (project.version.toString().endsWith("SNAPSHOT")) snapshotsRepoUrl else releasesRepoUrl)
-
-            credentials {
-                username = project.findProperty("sonatype.user") as String? ?: System.getenv("SONATYPE_USER")
-                password = project.findProperty("sonatype.password") as String? ?: System.getenv("SONATYPE_PASSWORD")
+        developers {
+            developer {
+                id.set("aartiPl")
+                name.set("Marcin Kuszczak")
+                email.set("aarti@interia.pl")
             }
         }
+        scm {
+            connection.set("scm:git:git://https://github.com/aartiPl/funclient.git")
+            developerConnection.set("scm:git:ssh:https://github.com/aartiPl/funclient.git")
+            url.set("https://github.com/aartiPl/funclient/tree/master")
+        }
     }
-}
 
-signing {
-    sign(publishing.publications["funclient"])
+    publishToMavenCentral()
+    signAllPublications()
 }
 
 dependencies {
     implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlinVersion")
     implementation("org.jetbrains.kotlin:kotlin-reflect:$kotlinVersion")
+
     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.2")
 
     implementation("org.apache.commons:commons-lang3:3.17.0")
-    implementation("com.konghq:unirest-java:3.14.5")
     implementation("com.google.code.gson:gson:2.13.1")
 
-    testImplementation("org.junit.platform:junit-platform-suite-engine:1.9.0")
-    testImplementation("org.junit.platform:junit-platform-suite-api:1.9.0")
-    testImplementation("org.junit.platform:junit-platform-suite-commons:1.9.0")
-    testImplementation("org.junit.jupiter:junit-jupiter-engine:5.9.0")
-    testImplementation("org.junit.jupiter:junit-jupiter-params:5.9.0")
+    val junitVersion = "6.0.0-M1"
+    testImplementation("org.junit.platform:junit-platform-suite-engine:$junitVersion")
+    testImplementation("org.junit.platform:junit-platform-suite-api:$junitVersion")
+    testImplementation("org.junit.platform:junit-platform-suite-commons:$junitVersion")
+    testImplementation("org.junit.jupiter:junit-jupiter-engine:$junitVersion")
+    testImplementation("org.junit.jupiter:junit-jupiter-params:$junitVersion")
+
     testImplementation("com.willowtreeapps.assertk:assertk-jvm:0.28.1")
     testImplementation("io.mockk:mockk:1.14.4")
 }

src/main/kotlin/net/igsoft/funclient/FunClient.kt

@@ -1,44 +1,48 @@
 package net.igsoft.funclient
 
 import com.google.gson.Gson
-import kong.unirest.Unirest
-import net.igsoft.funclient.handler.ResponseHandler
 import net.igsoft.funclient.model.*
+import java.net.http.HttpClient
+import java.net.http.HttpRequest
+import java.net.http.HttpResponse
+import kotlin.io.path.Path
 
-//TODO: create common content types
+//NOTE: Doesn't work with JDK8
+@Suppress("unused")
 class FunClient(val gson: Gson) {
-    init {
-        //socket timeout - time to receive the data
-        // 300_000 == 5m
-        Unirest.config().reset().socketTimeout(300_000).connectTimeout(2_000)
-    }
-
-    fun <T> execute(request: Request, responseHandler: ResponseHandler<T>): T {
-        return responseHandler.handle(request, execute(request), gson)
-    }
+    private val client = HttpClient.newHttpClient()
 
     fun execute(request: Request): Response {
-        val uniRequest = Unirest.request(request.method.name, request.url.toString())
+        val httpRequestBuilder = HttpRequest.newBuilder()
+
+        when (request.method) {
+            Method.GET -> httpRequestBuilder.GET()
+            Method.POST -> httpRequestBuilder.POST(resolveBody(request))
+            Method.PUT -> httpRequestBuilder.PUT(resolveBody(request))
+            Method.DELETE -> httpRequestBuilder.DELETE()
+            Method.PATCH -> httpRequestBuilder.method("PATCH", resolveBody(request))
+            Method.HEAD -> httpRequestBuilder.method("HEAD", resolveBody(request))
+            Method.OPTIONS -> httpRequestBuilder.method("OPTIONS", resolveBody(request))
+        }
+
+        httpRequestBuilder.uri(request.url.toURI())
 
         for (header in request.headers.all.entries) {
             for (value in header.value) {
-                uniRequest.header(header.key, value)
+                httpRequestBuilder.header(header.key, value)
             }
         }
 
-        val finalRequest = when (request.body) {
-            is StringBody -> uniRequest.body(request.body.string)
-            is FileBody -> uniRequest.body(request.body.file.readBytes())
-            is ObjectBody<*> -> uniRequest.body(gson.toJson(request.body.value))
-            is EmptyBody -> uniRequest
-            else -> throw IllegalStateException("Unknown body type: ${request.body::class.simpleName}")
-        }
-
-        val response = finalRequest.asString()
+        val response = client.send(httpRequestBuilder.build(), HttpResponse.BodyHandlers.ofString())
 
-        val headersBuilder = Headers.builder()
-        response.headers.all().forEach { headersBuilder.append(it.name, it.value) }
+        return RawResponse(response.statusCode(), Headers(response.headers().map()), StringBody(response.body()))
+    }
 
-        return RawResponse(response.status, headersBuilder.build(), StringBody(response.body))
+    private fun resolveBody(request: Request): HttpRequest.BodyPublisher = when (request.body) {
+        is StringBody -> HttpRequest.BodyPublishers.ofString(request.body.string)
+        is EmptyBody -> HttpRequest.BodyPublishers.noBody()
+        is FileBody -> HttpRequest.BodyPublishers.ofFile(Path(request.body.file.path))
+        is ObjectBody<*> -> HttpRequest.BodyPublishers.ofString(gson.toJson(request.body.value))
+        else -> throw IllegalStateException("Unknown body type: ${request.body::class.simpleName}")
     }
 }