it's relovution, Johny

0.0.3

.github/workflows/kdocs.yml

@@ -17,5 +17,5 @@ jobs:
         uses: peaceiris/actions-gh-pages@v3
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
-          publish_dir: ./docs/build/dokka/html
+          publish_dir: ./build/dokka/html
           publish_branch: kdocs

CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.1.0
+
+* All the platform specific logged factories has been renamed
+
+## 0.0.3
+
+* Fixes in `JVM` logging
+
+## 0.0.2
+
+* New logger `TagLogger` and now extension `Any#logger` will use it to decrease objects allocations
+* Now it is possible to create `KSLog` using any iterable
+* Now it is possible to create `KSLog` using vararg log levels
+
 ## 0.0.1
 
 * Project has been inited

gradle.properties

@@ -9,5 +9,5 @@ android.enableJetifier=true
 # Project data
 
 group=dev.inmo
-version=0.0.1
+version=0.1.0
-android_code_version=1
+android_code_version=4

src/commonMain/kotlin/AutoLoggers.kt

@@ -2,7 +2,5 @@ package dev.inmo.kslog.common
 
 val Any.logTag
     get() = this::class.simpleName ?: error("Unable to retrieve log tag")
-val Any.logger
+val Any.logger: KSLog
-    get() = CallbackKSLog { l, t, m, e ->
+    get() = TagLogger(logTag)
-        KSLog.default.performLog(l, t ?: logTag, m, e)
-    }

src/commonMain/kotlin/KSLog.kt

@@ -37,18 +37,32 @@ class CallbackKSLog(
 }
 
 
-expect fun KSLog(
+fun KSLog(
     defaultTag: String,
     filter: (l: LogLevel, t: String, m: String, Throwable?) -> Boolean
-) : KSLog
+) : KSLog = KSLog { l, t, m, e ->
+    if (filter(l, t ?: defaultTag, m, e)) {
+        KSLog.default.performLog(l, t ?: defaultTag, m, e)
+    }
+}
 
 fun KSLog(
     defaultTag: String,
-    levels: Set<LogLevel>
+    levels: Iterable<LogLevel>
-): KSLog = KSLog (defaultTag) { l, _, _, _ ->
+): KSLog {
-    l in levels
+    val levels = levels.toSet()
+    return KSLog (defaultTag) { l, _, _, _ ->
+        l in levels
+    }
 }
 
+fun KSLog(
+    defaultTag: String,
+    firstLevel: LogLevel,
+    secondLevel: LogLevel,
+    vararg otherLevels: LogLevel
+): KSLog = KSLog(defaultTag, setOf(firstLevel, secondLevel, *otherLevels))
+
 fun KSLog(
     defaultTag: String,
     minLoggingLevel: LogLevel = LogLevel.VERBOSE

src/commonMain/kotlin/MessageFormatterTypealias.kt

@@ -0,0 +1,5 @@
+package dev.inmo.kslog.common
+
+typealias MessageFormatter = (l: LogLevel, t: String, m: String, Throwable?) -> String
+val defaultMessageFormatter: MessageFormatter = { l, t, m, _ -> "[$l] $t - $m" }
+

src/commonMain/kotlin/TagLogger.kt

@@ -0,0 +1,10 @@
+package dev.inmo.kslog.common
+
+import kotlin.jvm.JvmInline
+
+@JvmInline
+value class TagLogger(val tag: String) : KSLog {
+    override fun performLog(level: LogLevel, tag: String?, message: String, throwable: Throwable?) {
+        KSLog.performLog(level, tag ?: tag, message, throwable)
+    }
+}

src/jsMain/kotlin/ActualLogger.kt

@@ -1,11 +1,12 @@
 package dev.inmo.kslog.common
 
-fun KSLog(
+fun KSJSLog(
-    messageFormatter: (l: LogLevel, t: String?, m: String, Throwable?) -> String,
+    defaultTag: String,
+    messageFormatter: MessageFormatter = defaultMessageFormatter,
     filter: (l: LogLevel, t: String?, m: String, Throwable?) -> Boolean
 ) = KSLog { l, t, m, e ->
     if (!filter(l, t, m, e)) return@KSLog
-    val text = messageFormatter(l,t,m,e)
+    val text = messageFormatter(l, t?:defaultTag, m, e)
     val args = e ?.let {
         arrayOf(text, e)
     } ?: arrayOf(text)
@@ -19,12 +20,29 @@ fun KSLog(
     }
 }
 
-actual fun KSLog(
+fun KSJSLog(
     defaultTag: String,
-    filter: (l: LogLevel, t: String, m: String, Throwable?) -> Boolean
+    messageFormatter: MessageFormatter = defaultMessageFormatter,
+    levels: Iterable<LogLevel>
 ): KSLog {
-    return KSLog(
+    val levels = levels.toSet()
-        { l, t, m, _ -> "[$l] ${t ?: defaultTag} - $m" },
+    return KSJSLog (defaultTag, messageFormatter) { l, _, _, _ ->
-        { l, t, m, e -> filter(l, t ?: defaultTag, m, e) }
+        l in levels
-    )
+    }
+}
+
+fun KSJSLog(
+    defaultTag: String,
+    messageFormatter: MessageFormatter = defaultMessageFormatter,
+    firstLevel: LogLevel,
+    secondLevel: LogLevel,
+    vararg otherLevels: LogLevel
+): KSLog = KSJSLog (defaultTag, messageFormatter, setOf(firstLevel, secondLevel, *otherLevels))
+
+fun KSJSLog(
+    defaultTag: String,
+    messageFormatter: MessageFormatter = defaultMessageFormatter,
+    minLoggingLevel: LogLevel = LogLevel.VERBOSE
+): KSLog = KSJSLog (defaultTag, messageFormatter) { l, _, _, _ ->
+    minLoggingLevel.ordinal <= l.ordinal
 }

src/jvmMain/kotlin/ActualLogger.kt

@@ -2,13 +2,14 @@ package dev.inmo.kslog.common
 
 import java.util.logging.Level
 
-fun KSLog(
+fun KSJVMLog(
+    defaultTag: String,
     logger: java.util.logging.Logger,
-    filter: (l: LogLevel, t: String?, m: String, Throwable?) -> Boolean,
+    messageFormatter: MessageFormatter = defaultMessageFormatter,
-    messageFormatter: (l: LogLevel, t: String?, m: String, Throwable?) -> String
+    filter: (l: LogLevel, t: String?, m: String, Throwable?) -> Boolean
 ) = KSLog { l, t, m, e ->
     if (!filter(l, t, m, e)) return@KSLog
-    val text = messageFormatter(l,t,m,e)
+    val text = messageFormatter(l,t ?: defaultTag,m,e)
     logger.log(
         when(l) {
             LogLevel.VERBOSE -> Level.FINEST
@@ -23,24 +24,32 @@ fun KSLog(
     )
 }
 
-fun KSLog(
+fun KSJVMLog(
     defaultTag: String,
     logger: java.util.logging.Logger,
-    filter: (l: LogLevel, t: String, m: String, Throwable?) -> Boolean = { _, _, _, _ -> true }
+    messageFormatter: MessageFormatter = defaultMessageFormatter,
+    levels: Iterable<LogLevel>
 ): KSLog {
-    return KSLog(
+    val levels = levels.toSet()
-        logger,
+    return KSJVMLog (defaultTag, logger, messageFormatter) { l, _, _, _ ->
-        { l, t, m, e -> filter(l, t ?: defaultTag, m, e) }
+        l in levels
-    ) { _, t, m, _ -> "${t ?: defaultTag} - $m" }
+    }
 }
 
-actual fun KSLog(
+fun KSJVMLog(
     defaultTag: String,
-    filter: (l: LogLevel, t: String, m: String, Throwable?) -> Boolean
+    logger: java.util.logging.Logger,
-): KSLog {
+    messageFormatter: MessageFormatter = defaultMessageFormatter,
-    return KSLog(
+    firstLevel: LogLevel,
-        defaultTag,
+    secondLevel: LogLevel,
-        logger = java.util.logging.Logger.getAnonymousLogger(),
+    vararg otherLevels: LogLevel
-        filter = { l, t, m, e -> filter(l, t, m, e) }
+): KSLog = KSJVMLog (defaultTag, logger, messageFormatter, setOf(firstLevel, secondLevel, *otherLevels))
-    )
+
+fun KSJVMLog(
+    defaultTag: String,
+    logger: java.util.logging.Logger,
+    messageFormatter: MessageFormatter = defaultMessageFormatter,
+    minLoggingLevel: LogLevel = LogLevel.VERBOSE
+): KSLog = KSJVMLog (defaultTag, logger, messageFormatter) { l, _, _, _ ->
+    minLoggingLevel.ordinal <= l.ordinal
 }

src/main/kotlin/ActualLogger.kt

@@ -2,20 +2,42 @@ package dev.inmo.kslog.common
 
 import android.util.Log
 
-actual fun KSLog(
+fun KSAndroidLog(
     defaultTag: String,
     filter: (l: LogLevel, t: String, m: String, Throwable?) -> Boolean
-): KSLog {
+) = KSLog { l, t, m, e ->
-    return KSLog { l, t, m, e ->
+    if (!filter(l, t ?: defaultTag, m, e)) return@KSLog
-        val tag = t ?: defaultTag
+    val tag = t ?: defaultTag
-        if (!filter(l, t ?: defaultTag, m, e)) return@KSLog
+    when(l) {
-        when(l) {
+        LogLevel.VERBOSE -> Log.v(tag, m, e)
-            LogLevel.VERBOSE -> Log.v(tag, m, e)
+        LogLevel.INFO -> Log.i(tag, m, e)
-            LogLevel.INFO -> Log.i(tag, m, e)
+        LogLevel.WARNING -> Log.w(tag, m, e)
-            LogLevel.WARNING -> Log.w(tag, m, e)
+        LogLevel.ERROR -> Log.e(tag, m, e)
-            LogLevel.ERROR -> Log.e(tag, m, e)
+        LogLevel.ASSERT -> Log.wtf(tag, m, e)
-            LogLevel.ASSERT -> Log.wtf(tag, m, e)
+        LogLevel.DEBUG -> Log.d(tag, m, e)
-            LogLevel.DEBUG -> Log.d(tag, m, e)
-        }
     }
 }
+
+fun KSAndroidLog(
+    defaultTag: String,
+    levels: Iterable<LogLevel>
+): KSLog {
+    val levels = levels.toSet()
+    return KSAndroidLog (defaultTag) { l, _, _, _ ->
+        l in levels
+    }
+}
+
+inline fun KSAndroidLog(
+    defaultTag: String,
+    firstLevel: LogLevel,
+    secondLevel: LogLevel,
+    vararg otherLevels: LogLevel
+): KSLog = KSAndroidLog(defaultTag, setOf(firstLevel, secondLevel, *otherLevels))
+
+fun KSAndroidLog(
+    defaultTag: String,
+    minLoggingLevel: LogLevel = LogLevel.VERBOSE
+): KSLog = KSAndroidLog (defaultTag) { l, _, _, _ ->
+    minLoggingLevel.ordinal <= l.ordinal
+}