add KotlinLogging to support class level logging - a suggestion for i…

…ssue #12 (#13)

add KotlinLogging to support class level logging
This is another flavour of how to obtain a logger that might be the preferred way it the future.

src/main/kotlin/mu/KotlinLogging.kt

@@ -0,0 +1,14 @@
+package mu
+
+import mu.internal.KLoggerFactory
+
+
+object KotlinLogging {
+    /**
+     * This methods allow defining the logger in a file in the following way:
+     * val logger = KotlinLogging.logger {}
+     */
+    fun logger(func: () -> Unit): KLogger = KLoggerFactory.logger(func)
+
+    fun logger(name: String): KLogger = KLoggerFactory.logger(name)
+}

src/main/kotlin/mu/internal/KLoggerFactory.kt

@@ -16,17 +16,23 @@ internal object KLoggerFactory {
      * get logger for the class
      */
     inline internal fun logger(loggable: KLoggable): KLogger =
-            wrapJLogger(jLogger(KLoggerNameResolver.name(loggable.javaClass)))
+            logger(KLoggerNameResolver.name(loggable.javaClass))
 
     /**
      * get logger by explicit name
      */
     inline internal fun logger(name: String): KLogger = wrapJLogger(jLogger(name))
 
+    /**
+     * get logger for the method, assuming it was declared at the logger file/class
+     */
+    inline internal fun logger(noinline func: () -> Unit): KLogger =
+            logger(KLoggerNameResolver.name(func))
+
     /**
      * get a java logger by name
      */
-    inline internal fun jLogger(name: String): Logger = LoggerFactory.getLogger(name)
+    inline private fun jLogger(name: String): Logger = LoggerFactory.getLogger(name)
 
     /**
      * wrap java logger based on location awareness
@@ -37,6 +43,5 @@ internal object KLoggerFactory {
             else
                 LocationIgnorantKLogger(jLogger)
 
-
 }
 

src/main/kotlin/mu/internal/KLoggerNameResolver.kt

@@ -9,6 +9,19 @@ import java.lang.reflect.Modifier
 @Suppress("NOTHING_TO_INLINE")
 internal object KLoggerNameResolver {
 
+    /**
+     * get class name for function by the package of the function
+     */
+    inline internal fun name(noinline func: () -> Unit): String {
+        val name = func.javaClass.name
+        val slicedName = when {
+            name.contains("Kt$") -> name.substringBefore("Kt$")
+            name.contains("$") -> name.substringBefore("$")
+            else -> name
+        }
+        return slicedName
+    }
+
     /**
      * get class name for java class (that usually represents kotlin class)
      */
@@ -23,7 +36,7 @@ internal object KLoggerNameResolver {
         if (clazz.enclosingClass != null) {
             try {
                 val field = clazz.enclosingClass.getField(clazz.simpleName)
-                if (Modifier.isStatic(field.modifiers) && field.type == clazz ) {
+                if (Modifier.isStatic(field.modifiers) && field.type == clazz) {
                     // && field.get(null) === obj
                     // the above might be safer but problematic with initialization order
                     return clazz.enclosingClass

src/test/kotlin/mu/KotlinLoggingTest.kt

@@ -0,0 +1,21 @@
+package mu
+
+import org.junit.Assert.*
+import org.junit.Test
+
+val logger = KotlinLogging.logger {  }
+
+class ForKotlinLoggingTest {
+    val loggerInClass = KotlinLogging.logger {  }
+    companion object {
+        val loggerInCompanion = KotlinLogging.logger {  }
+    }
+}
+class KotlinLoggingTest {
+
+    @Test fun testLoggerName() {
+        assertEquals("mu.KotlinLoggingTest", logger.name)
+        assertEquals("mu.ForKotlinLoggingTest", ForKotlinLoggingTest().loggerInClass.name)
+        assertEquals("mu.ForKotlinLoggingTest", ForKotlinLoggingTest.loggerInCompanion.name)
+    }
+}