refactor: Plugin and Plugin Service

Author: DaRacci

Minix-API/src/main/kotlin/dev/racci/minix/api/extension/ExtensionSkeleton.kt

@@ -7,6 +7,7 @@ import dev.racci.minix.api.plugin.MinixPlugin
 import dev.racci.minix.api.plugin.logger.MinixLogger
 import kotlinx.collections.immutable.ImmutableSet
 import kotlinx.coroutines.CoroutineScope
+import org.jetbrains.annotations.ApiStatus.ScheduledForRemoval
 import org.koin.core.qualifier.Qualifier
 import kotlin.reflect.KClass
 
@@ -35,6 +36,7 @@ interface ExtensionSkeleton<P : MinixPlugin> : WithPlugin<P>, Qualifier {
     val name: String
 
     /** The MinixLogger instance from the plugin. */
+    @get:ScheduledForRemoval(inVersion = "4.0.0")
     @Deprecated("Use the WithPlugin extension instead.", ReplaceWith("WithPlugin<*>.log", "dev.racci.minix.api.extensions.ExPlugin"))
     val log: MinixLogger
 

Minix-API/src/main/kotlin/dev/racci/minix/api/plugin/MinixPlugin.kt

@@ -3,12 +3,12 @@ package dev.racci.minix.api.plugin
 import dev.racci.minix.api.annotations.MappedPlugin
 import dev.racci.minix.api.annotations.MinixDsl
 import dev.racci.minix.api.data.PluginUpdater
-import dev.racci.minix.api.plugin.logger.MinixLogger
 import dev.racci.minix.api.services.PluginService
+import dev.racci.minix.api.updater.Version
 import dev.racci.minix.api.utils.safeCast
-import org.bstats.bukkit.Metrics
 import org.bukkit.plugin.java.JavaPlugin
 import org.jetbrains.annotations.ApiStatus
+import org.jetbrains.annotations.ApiStatus.ScheduledForRemoval
 import org.koin.core.component.get
 import kotlin.reflect.KClass
 import kotlin.reflect.full.findAnnotation
@@ -20,16 +20,20 @@ import kotlin.reflect.full.isSubclassOf
  * systems of Minix.
  */
 abstract class MinixPlugin : JavaPlugin(), SusPlugin {
-    @get:ApiStatus.Internal // Public to be used within the plugin service impl
+    @get:ApiStatus.Internal
+    // Public to be used within the plugin service impl
+    @Deprecated("Useless and uses unneeded resources.")
+    @get:ScheduledForRemoval(inVersion = "4.0.0")
     val annotation by lazy { this::class.findAnnotation<MappedPlugin>() }
 
-    override val bStatsId: Int? by lazy { annotation?.bStatsId.takeIf { it != -1 } }
-    override val bindToKClass: KClass<out MinixPlugin>? by lazy { annotation?.bindToKClass.takeIf { it?.isSubclassOf(MinixPlugin::class) == true }.safeCast() }
+    final override val log get() = get<PluginService>()[this].log
+    final override val bStatsId = this::class.findAnnotation<MappedPlugin>()?.bStatsId.takeIf { it != -1 }
+    final override val metrics get() = get<PluginService>()[this].metrics
+    final override val version by lazy { Version(description.version) }
 
-    val log: MinixLogger get() = get<PluginService>()[this].log
-    val metrics: Metrics? get() = get<PluginService>()[this].metrics
+    override val updater: PluginUpdater? = null
 
-    open val updater: PluginUpdater? = null
+    override val bindToKClass = this::class.findAnnotation<MappedPlugin>()?.bindToKClass?.takeIf { it.isSubclassOf(MinixPlugin::class) }.safeCast<KClass<out MinixPlugin>>()
 
     @ApiStatus.Internal
     @ApiStatus.NonExtendable
@@ -50,11 +54,15 @@ abstract class MinixPlugin : JavaPlugin(), SusPlugin {
     }
 
     @MinixDsl
+    @Deprecated("Use the MappedPlugin annotation instead")
+    @ScheduledForRemoval(inVersion = "4.0.0")
     protected suspend fun extensions(builder: suspend ExtensionsBuilder.() -> Unit) {
         builder(get<PluginService>()[this].extensionsBuilder)
     }
 
     @MinixDsl
+    @Deprecated("Use the MappedPlugin annotation instead")
+    @ScheduledForRemoval(inVersion = "4.0.0")
     inner class ExtensionsBuilder {
 
         @MinixDsl

Minix-API/src/main/kotlin/dev/racci/minix/api/plugin/SusPlugin.kt

@@ -1,40 +1,60 @@
 package dev.racci.minix.api.plugin
 
+import dev.racci.minix.api.data.PluginUpdater
+import dev.racci.minix.api.plugin.logger.MinixLogger
+import dev.racci.minix.api.updater.Version
+import org.apiguardian.api.API
+import org.bstats.bukkit.Metrics
 import org.bukkit.plugin.Plugin
+import org.jetbrains.annotations.ApiStatus.ScheduledForRemoval
 import org.koin.core.component.KoinComponent
 import kotlin.reflect.KClass
 
+@API(status = API.Status.MAINTAINED, since = "1.0.0")
 interface SusPlugin : Plugin, KoinComponent {
 
+    /** The plugin's [MinixLogger] instance. */
+    val log: MinixLogger
+
+    /** The plugin's bStats ID. */
     val bStatsId: Int?
+
+    /** The plugin's bStats metrics instance. */
+    val metrics: Metrics?
+
+    /** The plugin's version instance. */
+    val version: Version
+
+    /** The plugin's auto-updater. */
+    val updater: PluginUpdater?
+
+    @Deprecated("Use the MappedPlugin annotation instead.")
+    @get:ScheduledForRemoval(inVersion = "4.0.0")
     val bindToKClass: KClass<out MinixPlugin>?
 
     /**
      * This is called when the server picks up your Plugin and has begun loading it.
      */
-    suspend fun handleLoad() {}
+    suspend fun handleLoad() = Unit
 
     /**
      * This is called Once the Plugin is ready to accept and register
      * events, commands etc.
      */
-    suspend fun handleEnable() {}
+    suspend fun handleEnable() = Unit
 
     /**
      * This will be called after your Plugin is done loading
      * and Minix has finished its loading process for your Plugin.
      */
-    suspend fun handleAfterLoad() {}
+    suspend fun handleAfterLoad() = Unit
 
-    /**
-     * This will be called after your Plugin is finished enabling,
-     * and Minix and finished all of the enable logic for your plugin.
-     */
-    suspend fun handleAfterEnable() {}
+    /** This is called after [handleEnable] and after plugin service has finished processing the plugin. */
+    suspend fun handleAfterEnable() = Unit
 
     /**
      * This is triggered when your Plugin is being disabled by the Server,
      * Please use this to clean up your Plugin to not leak resources.
      */
-    suspend fun handleDisable() {}
+    suspend fun handleDisable() = Unit
 }

Minix-API/src/main/kotlin/dev/racci/minix/api/plugin/logger/MinixLogger.kt

@@ -5,11 +5,13 @@ import com.github.ajalt.mordant.rendering.TextAlign
 import com.github.ajalt.mordant.rendering.TextColors
 import com.github.ajalt.mordant.rendering.Whitespace
 import com.github.ajalt.mordant.terminal.Terminal
+import dev.racci.minix.api.annotations.MinixInternal
 import dev.racci.minix.api.exceptions.LevelConversionException
 import dev.racci.minix.api.exceptions.NoTraceException
 import dev.racci.minix.api.utils.kotlin.fromOrdinal
 import dev.racci.minix.api.utils.kotlin.toSafeString
 import dev.racci.minix.api.utils.unsafeCast
+import kotlinx.atomicfu.AtomicBoolean
 import kotlinx.atomicfu.AtomicRef
 import kotlinx.atomicfu.atomic
 import org.apache.logging.log4j.spi.StandardLevel
@@ -19,9 +21,28 @@ import kotlin.reflect.KFunction
 import kotlin.reflect.full.declaredMemberFunctions
 import kotlin.reflect.jvm.isAccessible
 
+@OptIn(MinixInternal::class)
 @API(status = API.Status.EXPERIMENTAL, since = "3.2.0")
 abstract class MinixLogger {
 
+    @MinixInternal
+    private val atomicLock: AtomicBoolean = atomic(false)
+
+    @MinixInternal
+    private val atomicLevel: AtomicRef<LoggingLevel>
+
+    val level get() = atomicLevel.value
+
+    @MinixInternal
+    fun lockLevel() {
+        this.atomicLock.compareAndSet(expect = false, update = true)
+    }
+
+    @MinixInternal
+    fun unlockLevel() {
+        this.atomicLock.compareAndSet(expect = true, update = false)
+    }
+
     constructor(level: LoggingLevel) {
         this.atomicLevel = atomic(level)
     }
@@ -38,20 +59,21 @@ abstract class MinixLogger {
         this.atomicLevel = atomic(LoggingLevel.fromSlF4(level))
     }
 
-    private val atomicLevel: AtomicRef<LoggingLevel>
-    val level get() = atomicLevel.value
-
     /**
      * @param level The [LoggingLevel] to test.
      * @return `true` if the given [LoggingLevel] can display.
      */
     fun isEnabled(level: LoggingLevel): Boolean = level.ordinal <= this.level.ordinal
 
     /**
+     * Sets the [LoggingLevel] of this logger.
+     * If [atomicLock] is `true` this will not change the level.
+     *
      * @param level the [LoggingLevel] to log at.
      * @return The previous [LoggingLevel] and makes a trace log, or if the same just returns.
      */
     fun setLevel(level: LoggingLevel): LoggingLevel {
+        if (this.atomicLock.value) return this.level
         if (level == this.level) return level
 
         val previous = this.atomicLevel.getAndSet(level)
@@ -130,7 +152,7 @@ abstract class MinixLogger {
         msg: () -> Any?
     ): RuntimeException {
         log(FormattedMessage(msg, scope, LoggingLevel.FATAL, t, TextColors.brightRed))
-        return NoTraceException()
+        return NoTraceException(cause = t)
     }
 
     open fun trace(
@@ -176,7 +198,7 @@ abstract class MinixLogger {
         msg: String? = null
     ): RuntimeException {
         log(FormattedMessage(msg, scope, LoggingLevel.FATAL, t, TextColors.brightRed))
-        return NoTraceException()
+        return NoTraceException(cause = t)
     }
 
     /**