Merge pull request #120 from SpigotBasics/dev

added ArgumentPathBuilder, renamed ParsedCommand classes
SpigotBasics · Feb 12, 2024 · 4c6ff11 · 4c6ff11
2 parents ed05d32 + 0fe4bcb
commit 4c6ff11
Show file tree

Hide file tree

Showing 37 changed files with 195 additions and 182 deletions.
diff --git a/common/src/main/kotlin/com/github/spigotbasics/common/Dictionary.kt b/common/src/main/kotlin/com/github/spigotbasics/common/Dictionary.kt
@@ -2,20 +2,11 @@ package com.github.spigotbasics.common
 
 import java.util.TreeMap
 
-/**
- * A case-insensitive map.
- *
- * @param T The type of the values in the map.
- * @constructor Create empty Dictionary
- */
-class Dictionary<T> : MutableMap<String, T>, TreeMap<String, T>(String.CASE_INSENSITIVE_ORDER) {
+class Dictionary<T> : Map<String, T>, TreeMap<String, T>(String.CASE_INSENSITIVE_ORDER) {
     companion object {
-        fun fromEnum(
-            enumClass: Class<out Enum<*>>,
-            lowercase: Boolean = false,
-        ): Dictionary<Enum<*>> {
-            val dictionary = Dictionary<Enum<*>>()
-            for (enumConstant in enumClass.enumConstants) {
+        inline fun <reified E : Enum<E>> fromEnumClass(lowercase: Boolean = false): Dictionary<E> {
+            val dictionary = Dictionary<E>()
+            for (enumConstant in enumValues<E>()) {
                 val name = if (lowercase) enumConstant.name.lowercase() else enumConstant.name
                 dictionary[name] = enumConstant
             }

diff --git a/core/src/main/kotlin/com/github/spigotbasics/core/command/BasicsCommand.kt b/core/src/main/kotlin/com/github/spigotbasics/core/command/BasicsCommand.kt
@@ -43,7 +43,7 @@ class BasicsCommand internal constructor(
             val args = origArgs.toMutableList()
 
             val context =
-                BasicsCommandContext(
+                RawCommandContext(
                     sender = sender,
                     command = this,
                     label = commandLabel,
@@ -97,7 +97,7 @@ class BasicsCommand internal constructor(
             location: Location?,
         ): MutableList<String> {
             val context =
-                BasicsCommandContext(
+                RawCommandContext(
                     sender = sender,
                     command = this,
                     label = alias,

diff --git a/core/src/main/kotlin/com/github/spigotbasics/core/command/BasicsCommandBuilder.kt b/core/src/main/kotlin/com/github/spigotbasics/core/command/BasicsCommandBuilder.kt
@@ -32,21 +32,21 @@ class BasicsCommandBuilder(
 
     fun tabCompleter(tabCompleter: BasicsTabCompleter) = apply { this.tabCompleter = tabCompleter }
 
-    fun executor(executor: (BasicsCommandContext) -> CommandResult?) =
+    fun executor(executor: (RawCommandContext) -> CommandResult?) =
         apply {
             this.executor =
                 object : BasicsCommandExecutor(module) {
-                    override fun execute(context: BasicsCommandContext): CommandResult? {
+                    override fun execute(context: RawCommandContext): CommandResult? {
                         return executor(context)
                     }
                 }
         }
 
-    fun tabCompleter(tabCompleter: (BasicsCommandContext) -> MutableList<String>?) =
+    fun tabCompleter(tabCompleter: (RawCommandContext) -> MutableList<String>?) =
         apply {
             this.tabCompleter =
                 object : BasicsTabCompleter {
-                    override fun tabComplete(context: BasicsCommandContext): MutableList<String>? {
+                    override fun tabComplete(context: RawCommandContext): MutableList<String>? {
                         return tabCompleter(context)
                     }
                 }

diff --git a/core/src/main/kotlin/com/github/spigotbasics/core/command/BasicsCommandContextHandler.kt b/core/src/main/kotlin/com/github/spigotbasics/core/command/BasicsCommandContextHandler.kt
@@ -47,7 +47,7 @@ abstract class BasicsCommandContextHandler(
         }
 
         @Throws(BasicsCommandException::class)
-        fun failIfFlagsLeft(context: BasicsCommandContext) {
+        fun failIfFlagsLeft(context: RawCommandContext) {
             if (context.flags.isEmpty()) return
             throw CommandResult.unknownFlag(context.flags[0]).asException()
         }

diff --git a/core/src/main/kotlin/com/github/spigotbasics/core/command/BasicsCommandExecutor.kt b/core/src/main/kotlin/com/github/spigotbasics/core/command/BasicsCommandExecutor.kt
@@ -10,9 +10,9 @@ abstract class BasicsCommandExecutor(
 ) : BasicsCommandContextHandler(), BasicsTabCompleter {
     constructor(module: BasicsModule) : this(module.coreMessages, module.messageFactory)
 
-    abstract fun execute(context: BasicsCommandContext): CommandResult?
+    abstract fun execute(context: RawCommandContext): CommandResult?
 
-    override fun tabComplete(context: BasicsCommandContext): MutableList<String>? {
+    override fun tabComplete(context: RawCommandContext): MutableList<String>? {
         return null
     }
 }
diff --git a/core/src/main/kotlin/com/github/spigotbasics/core/command/BasicsTabCompleter.kt b/core/src/main/kotlin/com/github/spigotbasics/core/command/BasicsTabCompleter.kt
@@ -1,5 +1,5 @@
 package com.github.spigotbasics.core.command
 
 interface BasicsTabCompleter {
-    fun tabComplete(context: BasicsCommandContext): MutableList<String>?
+    fun tabComplete(context: RawCommandContext): MutableList<String>?
 }
diff --git a/core/src/main/kotlin/com/github/spigotbasics/core/command/CommandResult.kt b/core/src/main/kotlin/com/github/spigotbasics/core/command/CommandResult.kt
@@ -6,25 +6,25 @@ import org.bukkit.entity.Player
 import org.bukkit.permissions.Permission
 
 abstract class CommandResult private constructor() {
-    abstract fun process(context: BasicsCommandContext)
+    abstract fun process(context: RawCommandContext)
 
     @Throws(BasicsCommandException::class)
     fun asException(): BasicsCommandException {
         return BasicsCommandException(this)
     }
 
     companion object {
-        private fun fromContext(action: ((BasicsCommandContext) -> Unit)): CommandResult {
+        private fun fromContext(action: ((RawCommandContext) -> Unit)): CommandResult {
             return object : CommandResult() {
-                override fun process(context: BasicsCommandContext) {
+                override fun process(context: RawCommandContext) {
                     action(context)
                 }
             }
         }
 
         fun fromMessage(action: ((CoreMessages) -> Message)): CommandResult {
             return object : CommandResult() {
-                override fun process(context: BasicsCommandContext) {
+                override fun process(context: RawCommandContext) {
                     action(context.command.coreMessages).sendToSender(context.sender)
                 }
             }
@@ -51,7 +51,7 @@ abstract class CommandResult private constructor() {
 
         fun usage(usage: String? = null): CommandResult {
             return object : CommandResult() {
-                override fun process(context: BasicsCommandContext) {
+                override fun process(context: RawCommandContext) {
                     context.command.messageFactory
                         // TODO: Configurable
                         .createMessage(
@@ -66,31 +66,31 @@ abstract class CommandResult private constructor() {
 
         fun playerNotFound(name: String): CommandResult {
             return object : CommandResult() {
-                override fun process(context: BasicsCommandContext) {
+                override fun process(context: RawCommandContext) {
                     context.command.coreMessages.playerNotFound(name).sendToSender(context.sender)
                 }
             }
         }
 
         fun unknownFlag(flag: String): CommandResult {
             return object : CommandResult() {
-                override fun process(context: BasicsCommandContext) {
+                override fun process(context: RawCommandContext) {
                     context.command.coreMessages.unknownOption(flag).sendToSender(context.sender)
                 }
             }
         }
 
         fun invalidArgument(argument: String): CommandResult {
             return object : CommandResult() {
-                override fun process(context: BasicsCommandContext) {
+                override fun process(context: RawCommandContext) {
                     context.command.coreMessages.invalidArgument(argument).sendToSender(context.sender)
                 }
             }
         }
 
         fun noPermission(permission: Permission): CommandResult {
             return object : CommandResult() {
-                override fun process(context: BasicsCommandContext) {
+                override fun process(context: RawCommandContext) {
                     context.command.coreMessages.noPermission(permission).sendToSender(context.sender)
                 }
             }

diff --git a/...sics/core/command/BasicsCommandContext.kt → ...tbasics/core/command/RawCommandContext.kt b/...sics/core/command/BasicsCommandContext.kt → ...tbasics/core/command/RawCommandContext.kt
@@ -3,7 +3,7 @@ package com.github.spigotbasics.core.command
 import org.bukkit.Location
 import org.bukkit.command.CommandSender
 
-data class BasicsCommandContext(
+data class RawCommandContext(
     val sender: CommandSender,
     val command: BasicsCommand,
     val label: String,

diff --git a/core/src/main/kotlin/com/github/spigotbasics/core/command/parsed/ArgumentPath.kt b/core/src/main/kotlin/com/github/spigotbasics/core/command/parsed/ArgumentPath.kt
@@ -7,7 +7,7 @@ import com.github.spigotbasics.core.messages.Message
 import org.bukkit.command.CommandSender
 import org.bukkit.permissions.Permission
 
-class ArgumentPath<T : CommandContext>(
+class ArgumentPath<T : ParsedCommandContext>(
     val senderArgument: SenderType<*>,
     val arguments: List<CommandArgument<*>>,
     val permission: List<Permission> = emptyList(),

diff --git a/core/src/main/kotlin/com/github/spigotbasics/core/command/parsed/ArgumentPathBuilder.kt b/core/src/main/kotlin/com/github/spigotbasics/core/command/parsed/ArgumentPathBuilder.kt
@@ -1,3 +1,29 @@
 package com.github.spigotbasics.core.command.parsed
 
-class ArgumentPathBuilder
+import org.bukkit.command.CommandSender
+import org.bukkit.permissions.Permission
+
+class ArgumentPathBuilder<T : ParsedCommandContext> {
+    private var senderType: SenderType<*> = AnySender
+    private var arguments = emptyList<CommandArgument<*>>()
+    private var permissions = emptyList<Permission>()
+    private var contextBuilder: ((CommandSender, List<Any?>) -> T)? = null
+
+    private fun senderType(senderType: SenderType<*>) = apply { this.senderType = senderType }
+
+    fun playerOnly() = apply { senderType(PlayerSender) }
+
+    fun permissions(vararg permissions: Permission) = apply { this.permissions = permissions.toList() }
+
+    fun arguments(vararg arguments: CommandArgument<*>) = apply { this.arguments = arguments.toList() }
+
+    fun contextBuilder(contextBuilder: (CommandSender, List<Any?>) -> T) = apply { this.contextBuilder = contextBuilder }
+
+    fun build() =
+        ArgumentPath(
+            senderType,
+            arguments,
+            permissions,
+            contextBuilder ?: error("Context builder not set"),
+        )
+}
diff --git a/core/src/main/kotlin/com/github/spigotbasics/core/command/parsed/ParsedCommandBuilder.kt b/core/src/main/kotlin/com/github/spigotbasics/core/command/parsed/ParsedCommandBuilder.kt
@@ -2,14 +2,14 @@ package com.github.spigotbasics.core.command
 
 import com.github.spigotbasics.common.Either
 import com.github.spigotbasics.core.command.parsed.ArgumentPath
-import com.github.spigotbasics.core.command.parsed.CommandContext
-import com.github.spigotbasics.core.command.parsed.CommandExecutor
+import com.github.spigotbasics.core.command.parsed.ParsedCommandContext
+import com.github.spigotbasics.core.command.parsed.ParsedCommandContextExecutor
 import com.github.spigotbasics.core.command.parsed.ParsedCommandExecutor
 import com.github.spigotbasics.core.messages.Message
 import com.github.spigotbasics.core.module.BasicsModule
 import org.bukkit.permissions.Permission
 
-class ParsedCommandBuilder<T : CommandContext>(
+class ParsedCommandBuilder<T : ParsedCommandContext>(
     private val module: BasicsModule,
     private val name: String,
     private val permission: Permission,
@@ -20,8 +20,8 @@ class ParsedCommandBuilder<T : CommandContext>(
     private var aliases: List<String> = emptyList()
     private var executor: BasicsCommandExecutor? = null
     private var tabCompleter: BasicsTabCompleter? = null
-    private var parsedExecutor: CommandExecutor<T>? = null
-    private var argumentPaths: List<ArgumentPath<T>>? = null
+    private var parsedExecutor: ParsedCommandContextExecutor<T>? = null
+    private var argumentPaths: MutableList<ArgumentPath<T>> = mutableListOf()
 
     fun description(description: String) = apply { this.description = description }
 
@@ -31,19 +31,21 @@ class ParsedCommandBuilder<T : CommandContext>(
             this.usage = usage
         }
 
-    fun paths(argumentPaths: List<ArgumentPath<T>>) = apply { this.argumentPaths = argumentPaths }
+    fun path(argumentPath: ArgumentPath<T>) = apply { this.argumentPaths.add(argumentPath) }
 
-    fun paths(vararg argumentPaths: ArgumentPath<T>) = apply { this.argumentPaths = argumentPaths.toList() }
+    fun paths(argumentPaths: List<ArgumentPath<T>>) = apply { this.argumentPaths.addAll(argumentPaths) }
 
-    fun executor(executor: CommandExecutor<T>) = apply { this.parsedExecutor = executor }
+    fun paths(vararg argumentPaths: ArgumentPath<T>) = apply { this.argumentPaths.addAll(argumentPaths) }
+
+    fun executor(executor: ParsedCommandContextExecutor<T>) = apply { this.parsedExecutor = executor }
 
     private fun executor(executor: BasicsCommandExecutor) = apply { this.executor = executor }
 
     private fun executor(command: ParsedCommandExecutor<T>) =
         apply {
             this.executor =
                 object : BasicsCommandExecutor(module) {
-                    override fun execute(context: BasicsCommandContext): CommandResult? {
+                    override fun execute(context: RawCommandContext): CommandResult? {
                         val result = command.execute(context.sender, context.args)
 
                         if (result is Either.Left) {
@@ -59,7 +61,7 @@ class ParsedCommandBuilder<T : CommandContext>(
                         return null
                     }
 
-                    override fun tabComplete(context: BasicsCommandContext): MutableList<String> {
+                    override fun tabComplete(context: RawCommandContext): MutableList<String> {
                         return command.tabComplete(context.sender, context.args).toMutableList()
                     }
                 }
@@ -75,7 +77,7 @@ class ParsedCommandBuilder<T : CommandContext>(
         val command =
             ParsedCommandExecutor(
                 parsedExecutor ?: error("parsedExecutor must be set"),
-                argumentPaths ?: error("Argument paths must be set"),
+                argumentPaths,
             )
         executor(command)
         val info =

diff --git a/...ics/core/command/parsed/CommandContext.kt → ...re/command/parsed/ParsedCommandContext.kt b/...ics/core/command/parsed/CommandContext.kt → ...re/command/parsed/ParsedCommandContext.kt
@@ -1,3 +1,3 @@
 package com.github.spigotbasics.core.command.parsed
 
-interface CommandContext
+interface ParsedCommandContext
diff --git a/...cs/core/command/parsed/CommandExecutor.kt → ...nd/parsed/ParsedCommandContextExecutor.kt b/...cs/core/command/parsed/CommandExecutor.kt → ...nd/parsed/ParsedCommandContextExecutor.kt
@@ -2,7 +2,7 @@ package com.github.spigotbasics.core.command.parsed
 
 import org.bukkit.command.CommandSender
 
-interface CommandExecutor<T : CommandContext> {
+interface ParsedCommandContextExecutor<T : ParsedCommandContext> {
     fun execute(
         sender: CommandSender,
         context: T,

diff --git a/core/src/main/kotlin/com/github/spigotbasics/core/command/parsed/ParsedCommandExecutor.kt b/core/src/main/kotlin/com/github/spigotbasics/core/command/parsed/ParsedCommandExecutor.kt
@@ -6,8 +6,8 @@ import com.github.spigotbasics.core.messages.Message
 import org.bukkit.command.CommandSender
 import org.bukkit.permissions.Permission
 
-class ParsedCommandExecutor<T : CommandContext>(
-    private val executor: CommandExecutor<T>,
+class ParsedCommandExecutor<T : ParsedCommandContext>(
+    private val executor: ParsedCommandContextExecutor<T>,
     private val paths: List<ArgumentPath<T>>,
 ) {
 //    fun execute(input: List<String>) {

diff --git a/core/src/main/kotlin/com/github/spigotbasics/core/module/AbstractBasicsModule.kt b/core/src/main/kotlin/com/github/spigotbasics/core/module/AbstractBasicsModule.kt
@@ -4,7 +4,9 @@ import com.github.spigotbasics.core.NamespacedNamespacedKeyFactory
 import com.github.spigotbasics.core.command.BasicsCommandBuilder
 import com.github.spigotbasics.core.command.BasicsCommandManager
 import com.github.spigotbasics.core.command.ParsedCommandBuilder
-import com.github.spigotbasics.core.command.parsed.CommandContext
+import com.github.spigotbasics.core.command.parsed.ArgumentPathBuilder
+import com.github.spigotbasics.core.command.parsed.CommandArgument
+import com.github.spigotbasics.core.command.parsed.ParsedCommandContext
 import com.github.spigotbasics.core.config.ConfigName
 import com.github.spigotbasics.core.config.SavedConfig
 import com.github.spigotbasics.core.event.BasicsEventBus
@@ -153,10 +155,15 @@ abstract class AbstractBasicsModule(context: ModuleInstantiationContext) : Basic
         return BasicsCommandBuilder(this, name, permission)
     }
 
-    final override fun <T : CommandContext> createParsedCommand(
+    final override fun <T : ParsedCommandContext> createParsedCommand(
         name: String,
         permission: Permission,
     ): ParsedCommandBuilder<T> {
         return ParsedCommandBuilder(this, name, permission)
     }
+
+    final override fun <T : ParsedCommandContext> createArgumentPath(vararg arguments: CommandArgument<*>) =
+        ArgumentPathBuilder<T>().arguments(
+            *arguments,
+        )
 }
diff --git a/core/src/main/kotlin/com/github/spigotbasics/core/module/BasicsModule.kt b/core/src/main/kotlin/com/github/spigotbasics/core/module/BasicsModule.kt
@@ -5,7 +5,9 @@ import com.github.spigotbasics.core.NamespacedNamespacedKeyFactory
 import com.github.spigotbasics.core.command.BasicsCommandBuilder
 import com.github.spigotbasics.core.command.BasicsCommandManager
 import com.github.spigotbasics.core.command.ParsedCommandBuilder
-import com.github.spigotbasics.core.command.parsed.CommandContext
+import com.github.spigotbasics.core.command.parsed.ArgumentPathBuilder
+import com.github.spigotbasics.core.command.parsed.CommandArgument
+import com.github.spigotbasics.core.command.parsed.ParsedCommandContext
 import com.github.spigotbasics.core.config.ConfigName
 import com.github.spigotbasics.core.config.SavedConfig
 import com.github.spigotbasics.core.event.BasicsEventBus
@@ -155,7 +157,7 @@ interface BasicsModule {
         permission: Permission,
     ): BasicsCommandBuilder
 
-    fun <T : CommandContext> createParsedCommand(
+    fun <T : ParsedCommandContext> createParsedCommand(
         name: String,
         permission: Permission,
     ): ParsedCommandBuilder<T>
@@ -184,4 +186,6 @@ interface BasicsModule {
 
         return "${info.name}-$newPath"
     }
+
+    fun <T : ParsedCommandContext> createArgumentPath(vararg arguments: CommandArgument<*>): ArgumentPathBuilder<T>
 }
diff --git a/...cast/src/main/kotlin/com/github/spigotbasics/modules/basicsbroadcast/BroadcastExecutor.kt b/...cast/src/main/kotlin/com/github/spigotbasics/modules/basicsbroadcast/BroadcastExecutor.kt
@@ -1,13 +1,13 @@
 package com.github.spigotbasics.modules.basicsbroadcast
 
-import com.github.spigotbasics.core.command.BasicsCommandContext
 import com.github.spigotbasics.core.command.BasicsCommandExecutor
 import com.github.spigotbasics.core.command.CommandResult
+import com.github.spigotbasics.core.command.RawCommandContext
 import org.bukkit.entity.Player
 import org.bukkit.util.StringUtil
 
 class BroadcastExecutor(private val module: BasicsBroadcastModule) : BasicsCommandExecutor(module) {
-    override fun execute(context: BasicsCommandContext): CommandResult {
+    override fun execute(context: RawCommandContext): CommandResult {
         context.readFlags()
 
         val parseMini = context.popFlag("--parsed")
@@ -28,7 +28,7 @@ class BroadcastExecutor(private val module: BasicsBroadcastModule) : BasicsComma
         return CommandResult.SUCCESS
     }
 
-    override fun tabComplete(context: BasicsCommandContext): MutableList<String> {
+    override fun tabComplete(context: RawCommandContext): MutableList<String> {
         val options = mutableListOf<String>()
         if (context.sender.hasPermission(module.parsedPerm)) {
             options += "--parsed"