consolidate platforms with non-delegating impl (#350)

create directMain source set as base for all non-delegating platforms - platforms that use kotlin-logging to 
write the logs with native kotlin functions and not via other libs or platform constructs.

This change the js/linux/etc' platforms. Some duplication was removed. And the way it is now configured changed.
`KotlinLoggingConfiguration` now contains:
- logLevel
- formatter
- appender

Those interfaces changed. Logger now calls the appender that is responsible to call the formatter - unlike previously where it called the formatter and passed the message to the appender.
Appender don't need to check if log is enabled, and has a single method:
`fun log(loggingEvent: KLoggingEvent)` (which contains also payload).
Formatter has a single method:
`fun formatMessage(loggingEvent: KLoggingEvent): String` which returns a formatted message.


* old upper case names in js are now deprecated and delegating to those.

Author: oshai

build.gradle.kts

@@ -146,16 +146,19 @@ kotlin {
                 implementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:${extra["coroutines_version"]}")
             }
         }
-        val jsMain by getting {
+        val directMain by creating {
             dependsOn(commonMain)
         }
+        val jsMain by getting {
+            dependsOn(directMain)
+        }
         val jsTest by getting {
             dependencies {
                 implementation(kotlin("test-js"))
             }
         }
         val nativeMain by creating {
-            dependsOn(commonMain)
+            dependsOn(directMain)
         }
         val nativeTest by creating {
             dependencies {

src/directMain/kotlin/io/github/oshai/kotlinlogging/Appender.kt

@@ -0,0 +1,14 @@
+package io.github.oshai.kotlinlogging
+
+public interface Appender {
+  public fun log(loggingEvent: KLoggingEvent)
+}
+
+public abstract class FormattingAppender : Appender {
+  public abstract fun logFormattedMessage(loggingEvent: KLoggingEvent, formattedMessage: Any?)
+  override fun log(loggingEvent: KLoggingEvent) {
+    KotlinLoggingConfiguration.formatter.formatMessage(loggingEvent).let {
+      logFormattedMessage(loggingEvent, it)
+    }
+  }
+}

src/directMain/kotlin/io/github/oshai/kotlinlogging/Formatter.kt

@@ -0,0 +1,44 @@
+package io.github.oshai.kotlinlogging
+
+public interface Formatter {
+
+  public fun formatMessage(loggingEvent: KLoggingEvent): String
+}
+
+public class DefaultMessageFormatter(private val includePrefix: Boolean = true) : Formatter {
+
+  override fun formatMessage(loggingEvent: KLoggingEvent): String {
+    with(loggingEvent) {
+      return buildString {
+        append(prefix(level, loggerName))
+        marker?.getName()?.let {
+          append(it)
+          append(" ")
+        }
+        append(message)
+        append(cause.throwableToString())
+      }
+    }
+  }
+
+  private fun prefix(level: Level, loggerName: String): String {
+    return if (includePrefix) {
+      "${level.name}: [$loggerName] "
+    } else {
+      ""
+    }
+  }
+
+  private fun Throwable?.throwableToString(): String {
+    if (this == null) {
+      return ""
+    }
+    var msg = ""
+    var current = this
+    while (current != null && current.cause != current) {
+      msg += ", Caused by: '${current.message}'"
+      current = current.cause
+    }
+    return msg
+  }
+}

src/directMain/kotlin/io/github/oshai/kotlinlogging/KLoggingEvent.kt

@@ -0,0 +1,24 @@
+package io.github.oshai.kotlinlogging
+
+public data class KLoggingEvent(
+  public val level: Level,
+  public val marker: Marker?,
+  public val loggerName: String,
+  public val message: String? = null,
+  public val cause: Throwable? = null,
+  public val payload: Map<String, Any>? = null,
+) {
+  public constructor(
+    level: Level,
+    marker: Marker?,
+    loggerName: String,
+    eventBuilder: KLoggingEventBuilder
+  ) : this(
+    level,
+    marker,
+    loggerName,
+    eventBuilder.message,
+    eventBuilder.cause,
+    eventBuilder.payload
+  )
+}

src/directMain/kotlin/io/github/oshai/kotlinlogging/KotlinLoggingConfiguration.kt

@@ -0,0 +1,7 @@
+package io.github.oshai.kotlinlogging
+
+public expect object KotlinLoggingConfiguration {
+  public var logLevel: Level
+  public var formatter: Formatter
+  public var appender: Appender
+}

src/nativeMain/kotlin/io/github/oshai/kotlinlogging/KotlinLoggingLevel.kt renamed to src/directMain/kotlin/io/github/oshai/kotlinlogging/KotlinLoggingLevel.kt

@@ -0,0 +1,28 @@
+package io.github.oshai.kotlinlogging.internal
+
+import io.github.oshai.kotlinlogging.KLogger
+import io.github.oshai.kotlinlogging.KLoggingEvent
+import io.github.oshai.kotlinlogging.KLoggingEventBuilder
+import io.github.oshai.kotlinlogging.KotlinLoggingConfiguration
+import io.github.oshai.kotlinlogging.Level
+import io.github.oshai.kotlinlogging.Level.OFF
+import io.github.oshai.kotlinlogging.Marker
+import io.github.oshai.kotlinlogging.isLoggingEnabled
+
+internal class KLoggerDirect(override val name: String) : KLogger {
+
+  override fun at(level: Level, marker: Marker?, block: KLoggingEventBuilder.() -> Unit) {
+    if (isLoggingEnabledFor(level, marker)) {
+      KLoggingEventBuilder().apply(block).run {
+        when (level) {
+          OFF -> Unit
+          else -> KotlinLoggingConfiguration.appender.log(KLoggingEvent(level, marker, name, this))
+        }
+      }
+    }
+  }
+
+  override fun isLoggingEnabledFor(level: Level, marker: Marker?): Boolean {
+    return level.isLoggingEnabled()
+  }
+}

src/jsMain/kotlin/io/github/oshai/kotlinlogging/internal/ErrorMessageProducer.kt renamed to src/directMain/kotlin/io/github/oshai/kotlinlogging/internal/ErrorMessageProducer.kt

@@ -4,5 +4,5 @@ import io.github.oshai.kotlinlogging.KLogger
 
 internal actual object KLoggerFactory {
 
-  actual fun logger(name: String): KLogger = KLoggerNative(name)
+  actual fun logger(name: String): KLogger = KLoggerDirect(name)
 }