Refactor

hexagontk · Jan 1, 2024 · e12b5f0 · e12b5f0
1 parent 8d32795
commit e12b5f0
Show file tree

Hide file tree

Showing 15 changed files with 80 additions and 70 deletions.
diff --git a/handlers/src/test/kotlin/com/hexagonkt/handlers/ExceptionHandlerTest.kt b/handlers/src/test/kotlin/com/hexagonkt/handlers/ExceptionHandlerTest.kt
@@ -49,7 +49,7 @@ internal class ExceptionHandlerTest {
 
         ChainHandler(
             ExceptionHandler<String, Exception>(Exception::class, false) { c, _ -> c.with("ok") },
-            ExceptionHandler<String, Exception>(Exception::class, false) { c, _ -> error("Fail") },
+            ExceptionHandler(Exception::class, false) { _, _ -> error("Fail") },
             OnHandler { error("Error") }
         )
         .process(EventContext("test", { true }))

diff --git a/http/http_handlers/api/http_handlers.api b/http/http_handlers/api/http_handlers.api
@@ -193,6 +193,9 @@ public final class com/hexagonkt/http/handlers/HandlersKt {
 	public static synthetic fun process$default (Lkotlin/jvm/functions/Function1;Lcom/hexagonkt/http/model/HttpRequest;Ljava/util/Map;ILjava/lang/Object;)Lcom/hexagonkt/http/handlers/HttpContext;
 }
 
+public abstract interface class com/hexagonkt/http/handlers/HttpCallback : kotlin/jvm/functions/Function1 {
+}
+
 public final class com/hexagonkt/http/handlers/HttpContext : com/hexagonkt/handlers/Context {
 	public fun <init> (Lcom/hexagonkt/handlers/Context;)V
 	public fun <init> (Lcom/hexagonkt/http/model/HttpCall;Lkotlin/jvm/functions/Function1;Ljava/util/List;ILjava/lang/Exception;Ljava/util/Map;Z)V
@@ -299,6 +302,9 @@ public final class com/hexagonkt/http/handlers/HttpController$DefaultImpls {
 	public static fun process (Lcom/hexagonkt/http/handlers/HttpController;Lcom/hexagonkt/http/model/HttpRequestPort;)Lcom/hexagonkt/http/handlers/HttpContext;
 }
 
+public abstract interface class com/hexagonkt/http/handlers/HttpExceptionCallback : kotlin/jvm/functions/Function2 {
+}
+
 public abstract interface class com/hexagonkt/http/handlers/HttpHandler : com/hexagonkt/handlers/Handler {
 	public abstract fun addPrefix (Ljava/lang/String;)Lcom/hexagonkt/http/handlers/HttpHandler;
 	public abstract fun byMethod ()Ljava/util/Map;

diff --git a/http/http_handlers/src/main/kotlin/com/hexagonkt/http/handlers/AfterHandler.kt b/http/http_handlers/src/main/kotlin/com/hexagonkt/http/handlers/AfterHandler.kt
@@ -9,22 +9,22 @@ import kotlin.reflect.KClass
 
 data class AfterHandler(
     override val handlerPredicate: HttpPredicate = HttpPredicate(),
-    val block: HttpCallback
+    val block: HttpCallbackType
 ) : HttpHandler, Handler<HttpCall> by AfterHandler(handlerPredicate, toCallback(block)) {
 
     constructor(
         methods: Set<HttpMethod> = emptySet(),
         pattern: String = "",
         exception: KClass<out Exception>? = null,
         status: HttpStatus? = null,
-        block: HttpCallback,
+        block: HttpCallbackType,
     ) :
         this(HttpPredicate(methods, pattern, exception, status), block)
 
-    constructor(method: HttpMethod, pattern: String = "", block: HttpCallback) :
+    constructor(method: HttpMethod, pattern: String = "", block: HttpCallbackType) :
         this(setOf(method), pattern, block = block)
 
-    constructor(pattern: String, block: HttpCallback) :
+    constructor(pattern: String, block: HttpCallbackType) :
         this(emptySet(), pattern, block = block)
 
     override fun addPrefix(prefix: String): HttpHandler =

diff --git a/http/http_handlers/src/main/kotlin/com/hexagonkt/http/handlers/BeforeHandler.kt b/http/http_handlers/src/main/kotlin/com/hexagonkt/http/handlers/BeforeHandler.kt
@@ -9,22 +9,22 @@ import kotlin.reflect.KClass
 
 data class BeforeHandler(
     override val handlerPredicate: HttpPredicate = HttpPredicate(),
-    val block: HttpCallback,
+    val block: HttpCallbackType,
 ) : HttpHandler, Handler<HttpCall> by BeforeHandler(handlerPredicate, toCallback(block)) {
 
     constructor(
         methods: Set<HttpMethod> = emptySet(),
         pattern: String = "",
         exception: KClass<out Exception>? = null,
         status: HttpStatus? = null,
-        block: HttpCallback,
+        block: HttpCallbackType,
     ) :
         this(HttpPredicate(methods, pattern, exception, status), block)
 
-    constructor(method: HttpMethod, pattern: String = "", block: HttpCallback) :
+    constructor(method: HttpMethod, pattern: String = "", block: HttpCallbackType) :
         this(setOf(method), pattern, block = block)
 
-    constructor(pattern: String, block: HttpCallback) :
+    constructor(pattern: String, block: HttpCallbackType) :
         this(emptySet(), pattern, block = block)
 
     override fun addPrefix(prefix: String): HttpHandler =

diff --git a/http/http_handlers/src/main/kotlin/com/hexagonkt/http/handlers/ExceptionHandler.kt b/http/http_handlers/src/main/kotlin/com/hexagonkt/http/handlers/ExceptionHandler.kt
@@ -8,7 +8,7 @@ import kotlin.reflect.KClass
 data class ExceptionHandler<E : Exception>(
     val exception: KClass<E>,
     val clear: Boolean = true,
-    val block: HttpExceptionCallback<E>
+    val block: HttpExceptionCallbackType<E>
 ) : HttpHandler, Handler<HttpCall> by ExceptionHandler(exception, clear, toCallback(block)) {
 
     override val handlerPredicate: HttpPredicate = HttpPredicate()

diff --git a/http/http_handlers/src/main/kotlin/com/hexagonkt/http/handlers/FilterHandler.kt b/http/http_handlers/src/main/kotlin/com/hexagonkt/http/handlers/FilterHandler.kt
@@ -9,22 +9,22 @@ import kotlin.reflect.KClass
 
 data class FilterHandler(
     override val handlerPredicate: HttpPredicate = HttpPredicate(),
-    val block: HttpCallback
+    val block: HttpCallbackType
 ) : HttpHandler, Handler<HttpCall> by FilterHandler(handlerPredicate, toCallback(block)) {
 
     constructor(
         methods: Set<HttpMethod> = emptySet(),
         pattern: String = "",
         exception: KClass<out Exception>? = null,
         status: HttpStatus? = null,
-        block: HttpCallback,
+        block: HttpCallbackType,
     ) :
         this(HttpPredicate(methods, pattern, exception, status), block)
 
-    constructor(method: HttpMethod, pattern: String = "", block: HttpCallback) :
+    constructor(method: HttpMethod, pattern: String = "", block: HttpCallbackType) :
         this(setOf(method), pattern, block = block)
 
-    constructor(pattern: String, block: HttpCallback) :
+    constructor(pattern: String, block: HttpCallbackType) :
         this(emptySet(), pattern, block = block)
 
     override fun addPrefix(prefix: String): HttpHandler =

diff --git a/http/http_handlers/src/main/kotlin/com/hexagonkt/http/handlers/HandlerBuilder.kt b/http/http_handlers/src/main/kotlin/com/hexagonkt/http/handlers/HandlerBuilder.kt
@@ -32,7 +32,7 @@ class HandlerBuilder(var handlers: List<HttpHandler> = emptyList()) {
 
     fun on(
         predicate: HttpPredicate = HttpPredicate(),
-        callback: HttpCallback
+        callback: HttpCallbackType
     ) {
         use(OnHandler(predicate, callback))
     }
@@ -42,22 +42,22 @@ class HandlerBuilder(var handlers: List<HttpHandler> = emptyList()) {
         pattern: String = "",
         exception: KClass<out Exception>? = null,
         status: HttpStatus? = null,
-        callback: HttpCallback,
+        callback: HttpCallbackType,
     ) {
         use(OnHandler(methods, pattern, exception, status, callback))
     }
 
-    fun on(method: HttpMethod, pattern: String = "", callback: HttpCallback) {
+    fun on(method: HttpMethod, pattern: String = "", callback: HttpCallbackType) {
         use(OnHandler(method, pattern, callback))
     }
 
-    fun on(pattern: String, callback: HttpCallback) {
+    fun on(pattern: String, callback: HttpCallbackType) {
         use(OnHandler(pattern, callback))
     }
 
     fun filter(
         predicate: HttpPredicate = HttpPredicate(),
-        callback: HttpCallback
+        callback: HttpCallbackType
     ) {
         use(FilterHandler(predicate, callback))
     }
@@ -67,24 +67,24 @@ class HandlerBuilder(var handlers: List<HttpHandler> = emptyList()) {
         pattern: String = "",
         exception: KClass<out Exception>? = null,
         status: HttpStatus? = null,
-        callback: HttpCallback,
+        callback: HttpCallbackType,
     ) {
         use(
             FilterHandler(methods, pattern, exception, status, callback)
         )
     }
 
-    fun filter(method: HttpMethod, pattern: String = "", callback: HttpCallback) {
+    fun filter(method: HttpMethod, pattern: String = "", callback: HttpCallbackType) {
         use(FilterHandler(method, pattern, callback))
     }
 
-    fun filter(pattern: String, callback: HttpCallback) {
+    fun filter(pattern: String, callback: HttpCallbackType) {
         use(FilterHandler(pattern, callback))
     }
 
     fun after(
         predicate: HttpPredicate = HttpPredicate(),
-        callback: HttpCallback
+        callback: HttpCallbackType
     ) {
         use(AfterHandler(predicate, callback))
     }
@@ -94,22 +94,22 @@ class HandlerBuilder(var handlers: List<HttpHandler> = emptyList()) {
         pattern: String = "",
         exception: KClass<out Exception>? = null,
         status: HttpStatus? = null,
-        callback: HttpCallback,
+        callback: HttpCallbackType,
     ) {
         use(AfterHandler(methods, pattern, exception, status, callback))
     }
 
-    fun after(method: HttpMethod, pattern: String = "", callback: HttpCallback) {
+    fun after(method: HttpMethod, pattern: String = "", callback: HttpCallbackType) {
         use(AfterHandler(method, pattern, callback))
     }
 
-    fun after(pattern: String, callback: HttpCallback) {
+    fun after(pattern: String, callback: HttpCallbackType) {
         use(AfterHandler(pattern, callback))
     }
 
     fun before(
         predicate: HttpPredicate = HttpPredicate(),
-        callback: HttpCallback
+        callback: HttpCallbackType
     ) {
         use(BeforeHandler(predicate, callback))
     }
@@ -119,64 +119,64 @@ class HandlerBuilder(var handlers: List<HttpHandler> = emptyList()) {
         pattern: String = "",
         exception: KClass<out Exception>? = null,
         status: HttpStatus? = null,
-        callback: HttpCallback,
+        callback: HttpCallbackType,
     ) {
         use(BeforeHandler(methods, pattern, exception, status, callback))
     }
 
-    fun before(method: HttpMethod, pattern: String = "", callback: HttpCallback) {
+    fun before(method: HttpMethod, pattern: String = "", callback: HttpCallbackType) {
         use(BeforeHandler(method, pattern, callback))
     }
 
-    fun before(pattern: String, callback: HttpCallback) {
+    fun before(pattern: String, callback: HttpCallbackType) {
         use(BeforeHandler(pattern, callback))
     }
 
     fun <T : Exception> exception(
-        exception: KClass<T>, clear: Boolean = true, callback: HttpExceptionCallback<T>
+        exception: KClass<T>, clear: Boolean = true, callback: HttpExceptionCallbackType<T>
     ) {
         use(ExceptionHandler(exception, clear, callback))
     }
 
     inline fun <reified T : Exception> exception(
-        clear: Boolean = true, noinline callback: HttpExceptionCallback<T>,
+        clear: Boolean = true, noinline callback: HttpExceptionCallbackType<T>,
     ) {
         use(ExceptionHandler(T::class, clear, callback))
     }
 
-    fun get(pattern: String = "", callback: HttpCallback) {
+    fun get(pattern: String = "", callback: HttpCallbackType) {
         use(Get(pattern, callback))
     }
 
-    fun ws(pattern: String = "", callback: HttpCallback) {
+    fun ws(pattern: String = "", callback: HttpCallbackType) {
         use(Ws(pattern, callback))
     }
 
-    fun head(pattern: String = "", callback: HttpCallback) {
+    fun head(pattern: String = "", callback: HttpCallbackType) {
         use(Head(pattern, callback))
     }
 
-    fun post(pattern: String = "", callback: HttpCallback) {
+    fun post(pattern: String = "", callback: HttpCallbackType) {
         use(Post(pattern, callback))
     }
 
-    fun put(pattern: String = "", callback: HttpCallback) {
+    fun put(pattern: String = "", callback: HttpCallbackType) {
         use(Put(pattern, callback))
     }
 
-    fun delete(pattern: String = "", callback: HttpCallback) {
+    fun delete(pattern: String = "", callback: HttpCallbackType) {
         use(Delete(pattern, callback))
     }
 
-    fun trace(pattern: String = "", callback: HttpCallback) {
+    fun trace(pattern: String = "", callback: HttpCallbackType) {
         use(Trace(pattern, callback))
     }
 
-    fun options(pattern: String = "", callback: HttpCallback) {
+    fun options(pattern: String = "", callback: HttpCallbackType) {
         use(Options(pattern, callback))
     }
 
-    fun patch(pattern: String = "", callback: HttpCallback) {
+    fun patch(pattern: String = "", callback: HttpCallbackType) {
         use(Patch(pattern, callback))
     }
 }
diff --git a/http/http_handlers/src/main/kotlin/com/hexagonkt/http/handlers/Handlers.kt b/http/http_handlers/src/main/kotlin/com/hexagonkt/http/handlers/Handlers.kt
@@ -13,31 +13,34 @@ import java.lang.IllegalStateException
 import java.math.BigInteger
 import java.security.cert.X509Certificate
 
-// TODO Inline these type aliases and reuse their names in interfaces (better for extension)
-typealias HttpCallback = HttpContext.() -> HttpContext
-typealias HttpExceptionCallback<T> = HttpContext.(T) -> HttpContext
+typealias HttpCallbackType = HttpContext.() -> HttpContext
+typealias HttpExceptionCallbackType<T> = HttpContext.(T) -> HttpContext
+
+interface HttpCallback : (HttpContext) -> HttpContext
+// TODO Use this type to implement the RFC 7807 exception handler
+interface HttpExceptionCallback<T> : (HttpContext, T) -> HttpContext
 
 private val logger: Logger by lazy { Logger(HttpHandler::class.java.packageName) }
 private val BODY_TYPES_NAMES: String by lazy {
     val bodyTypes = setOf(String::class, ByteArray::class, Int::class, Long::class)
     bodyTypes.joinToString(", ") { it.simpleName.toString() }
 }
 
-internal fun toCallback(block: HttpCallback): (Context<HttpCall>) -> Context<HttpCall> =
+internal fun toCallback(block: HttpCallbackType): (Context<HttpCall>) -> Context<HttpCall> =
     { context -> HttpContext(context).block() }
 
 internal fun <E : Exception> toCallback(
-    block: HttpExceptionCallback<E>
+    block: HttpExceptionCallbackType<E>
 ): (Context<HttpCall>, E) -> Context<HttpCall> =
     { context, e -> HttpContext(context).block(e) }
 
-fun HttpCallback.process(
+fun HttpCallbackType.process(
     request: HttpRequest,
     attributes: Map<*, *> = emptyMap<Any, Any>()
 ): HttpContext =
     this(HttpContext(request = request, attributes = attributes))
 
-fun HttpCallback.process(
+fun HttpCallbackType.process(
     method: HttpMethod = GET,
     protocol: HttpProtocol = HTTP,
     host: String = "localhost",
@@ -91,31 +94,31 @@ fun path(contextPath: String = "", handlers: List<HttpHandler>): PathHandler =
                 PathHandler(contextPath, it)
         }
 
-fun Get(pattern: String = "", callback: HttpCallback): OnHandler =
+fun Get(pattern: String = "", callback: HttpCallbackType): OnHandler =
     OnHandler(GET, pattern, callback)
 
-fun Ws(pattern: String = "", callback: HttpCallback): OnHandler =
+fun Ws(pattern: String = "", callback: HttpCallbackType): OnHandler =
     Get(pattern, callback)
 
-fun Head(pattern: String = "", callback: HttpCallback): OnHandler =
+fun Head(pattern: String = "", callback: HttpCallbackType): OnHandler =
     OnHandler(HEAD, pattern, callback)
 
-fun Post(pattern: String = "", callback: HttpCallback): OnHandler =
+fun Post(pattern: String = "", callback: HttpCallbackType): OnHandler =
     OnHandler(POST, pattern, callback)
 
-fun Put(pattern: String = "", callback: HttpCallback): OnHandler =
+fun Put(pattern: String = "", callback: HttpCallbackType): OnHandler =
     OnHandler(PUT, pattern, callback)
 
-fun Delete(pattern: String = "", callback: HttpCallback): OnHandler =
+fun Delete(pattern: String = "", callback: HttpCallbackType): OnHandler =
     OnHandler(DELETE, pattern, callback)
 
-fun Trace(pattern: String = "", callback: HttpCallback): OnHandler =
+fun Trace(pattern: String = "", callback: HttpCallbackType): OnHandler =
     OnHandler(TRACE, pattern, callback)
 
-fun Options(pattern: String = "", callback: HttpCallback): OnHandler =
+fun Options(pattern: String = "", callback: HttpCallbackType): OnHandler =
     OnHandler(OPTIONS, pattern, callback)
 
-fun Patch(pattern: String = "", callback: HttpCallback): OnHandler =
+fun Patch(pattern: String = "", callback: HttpCallbackType): OnHandler =
     OnHandler(PATCH, pattern, callback)
 
 fun bodyToBytes(body: Any): ByteArray =

diff --git a/http/http_handlers/src/main/kotlin/com/hexagonkt/http/handlers/OnHandler.kt b/http/http_handlers/src/main/kotlin/com/hexagonkt/http/handlers/OnHandler.kt
@@ -9,22 +9,22 @@ import kotlin.reflect.KClass
 
 data class OnHandler(
     override val handlerPredicate: HttpPredicate = HttpPredicate(),
-    val block: HttpCallback,
+    val block: HttpCallbackType,
 ) : HttpHandler, Handler<HttpCall> by OnHandler(handlerPredicate, toCallback(block)) {
 
     constructor(
         methods: Set<HttpMethod> = emptySet(),
         pattern: String = "",
         exception: KClass<out Exception>? = null,
         status: HttpStatus? = null,
-        block: HttpCallback,
+        block: HttpCallbackType,
     ) :
         this(HttpPredicate(methods, pattern, exception, status), block)
 
-    constructor(method: HttpMethod, pattern: String = "", block: HttpCallback) :
+    constructor(method: HttpMethod, pattern: String = "", block: HttpCallbackType) :
         this(setOf(method), pattern, block = block)
 
-    constructor(pattern: String, block: HttpCallback) :
+    constructor(pattern: String, block: HttpCallbackType) :
         this(emptySet(), pattern, block = block)
 
     override fun addPrefix(prefix: String): HttpHandler =