Merge branch 'default-command-perms'

idofront-catalog-shaded/src/main/java/com/mineinabyss/idofront/IdofrontPlugin.kt

@@ -1,14 +1,38 @@
 package com.mineinabyss.idofront
 
+import com.mineinabyss.idofront.commands.brigadier.Args
+import com.mineinabyss.idofront.commands.brigadier.ArgsMinecraft
+import com.mineinabyss.idofront.commands.brigadier.commands
+import com.mineinabyss.idofront.commands.brigadier.executes
 import com.mineinabyss.idofront.di.DI
 import com.mineinabyss.idofront.plugin.listeners
 import com.mineinabyss.idofront.serialization.recipes.options.IngredientOptionsListener
+import kotlinx.coroutines.flow.merge
+import org.bukkit.entity.Player
 import org.bukkit.plugin.java.JavaPlugin
 
 class IdofrontPlugin : JavaPlugin() {
     override fun onEnable() {
         val recipeOptionsListener = IngredientOptionsListener(this)
         DI.add(recipeOptionsListener)
         listeners(recipeOptionsListener)
+
+        commands {
+            "idofront" {
+                "msg" {
+                    executes(
+                        Args.string(),
+                        ArgsMinecraft.player().resolve()
+                            .map { it.single() }
+                            .default { sender as? Player ?: fail("Receiver should be player") },
+                        Args.integer(min = 0).default { 1 }
+                    ) { msg, player, times ->
+                        repeat(times) {
+                            player.sendMessage(msg)
+                        }
+                    }
+                }
+            }
+        }
     }
 }

idofront-commands/src/main/kotlin/com/mineinabyss/idofront/commands/brigadier/ArgumentExecutes.kt

@@ -0,0 +1,62 @@
+package com.mineinabyss.idofront.commands.brigadier
+
+import com.mineinabyss.idofront.commands.brigadier.context.IdoCommandContext
+import com.mojang.brigadier.arguments.ArgumentType
+
+
+inline fun <reified A: Any> IdoCommand.executes(
+    a: ArgumentType<A>,
+    crossinline run: IdoCommandContext.(A) -> Unit
+) {
+    executesDefaulting(a) { (a) -> run(arg<A>(a)) }
+}
+
+inline fun <reified A: Any, reified B: Any> IdoCommand.executes(
+    a: ArgumentType<A>,
+    b: ArgumentType<B>,
+    crossinline run: IdoCommandContext.(A, B) -> Unit
+) {
+    executesDefaulting(a, b) { (a, b) -> run(arg<A>(a), arg<B>(b)) }
+}
+
+inline fun <reified A: Any, reified B: Any, reified C: Any> IdoCommand.executes(
+    a: ArgumentType<A>,
+    b: ArgumentType<B>,
+    c: ArgumentType<C>,
+    crossinline run: IdoCommandContext.(A, B, C) -> Unit
+) {
+    executesDefaulting(a, b, c) { (a, b, c) -> run(arg<A>(a), arg<B>(b), arg<C>(c)) }
+}
+
+inline fun <reified A: Any, reified B: Any, reified C: Any, reified D: Any> IdoCommand.executes(
+    a: ArgumentType<A>,
+    b: ArgumentType<B>,
+    c: ArgumentType<C>,
+    d: ArgumentType<D>,
+    crossinline run: IdoCommandContext.(A, B, C, D) -> Unit
+) {
+    executesDefaulting(a, b, c, d) { (a, b, c, d) -> run(arg<A>(a), arg<B>(b), arg<C>(c), arg<D>(d)) }
+}
+
+inline fun <reified A: Any, reified B: Any, reified C: Any, reified D: Any, reified E: Any> IdoCommand.executes(
+    a: ArgumentType<A>,
+    b: ArgumentType<B>,
+    c: ArgumentType<C>,
+    d: ArgumentType<D>,
+    e: ArgumentType<E>,
+    crossinline run: IdoCommandContext.(A, B, C, D, E) -> Unit
+) {
+    executesDefaulting(a, b, c, d, e) { (a, b, c, d, e) -> run(arg<A>(a), arg<B>(b), arg<C>(c), arg<D>(d), arg<E>(e)) }
+}
+
+inline fun <reified A: Any, reified B: Any, reified C: Any, reified D: Any, reified E: Any, reified F: Any> IdoCommand.executes(
+    a: ArgumentType<A>,
+    b: ArgumentType<B>,
+    c: ArgumentType<C>,
+    d: ArgumentType<D>,
+    e: ArgumentType<E>,
+    f: ArgumentType<F>,
+    crossinline run: IdoCommandContext.(A, B, C, D, E, F) -> Unit
+) {
+    executesDefaulting(a, b, c, d, e, f) { run(arg<A>(it[0]), arg<B>(it[1]), arg<C>(it[2]), arg<D>(it[3]), arg<E>(it[4]), arg<F>(it[5])) }
+}

idofront-commands/src/main/kotlin/com/mineinabyss/idofront/commands/brigadier/ArgumentPlayerExecutes.kt

@@ -0,0 +1,62 @@
+package com.mineinabyss.idofront.commands.brigadier
+
+import com.mineinabyss.idofront.commands.brigadier.context.IdoPlayerCommandContext
+import com.mojang.brigadier.arguments.ArgumentType
+
+
+inline fun <reified A: Any> IdoCommand.playerExecutes(
+    a: ArgumentType<A>,
+    crossinline run: IdoPlayerCommandContext.(A) -> Unit
+) {
+    playerExecutesDefaulting(a) { (a) -> run(arg<A>(a)) }
+}
+
+inline fun <reified A: Any, reified B: Any> IdoCommand.playerExecutes(
+    a: ArgumentType<A>,
+    b: ArgumentType<B>,
+    crossinline run: IdoPlayerCommandContext.(A, B) -> Unit
+) {
+    playerExecutesDefaulting(a, b) { (a, b) -> run(arg<A>(a), arg<B>(b)) }
+}
+
+inline fun <reified A: Any, reified B: Any, reified C: Any> IdoCommand.playerExecutes(
+    a: ArgumentType<A>,
+    b: ArgumentType<B>,
+    c: ArgumentType<C>,
+    crossinline run: IdoPlayerCommandContext.(A, B, C) -> Unit
+) {
+    playerExecutesDefaulting(a, b, c) { (a, b, c) -> run(arg<A>(a), arg<B>(b), arg<C>(c)) }
+}
+
+inline fun <reified A: Any, reified B: Any, reified C: Any, reified D: Any> IdoCommand.playerExecutes(
+    a: ArgumentType<A>,
+    b: ArgumentType<B>,
+    c: ArgumentType<C>,
+    d: ArgumentType<D>,
+    crossinline run: IdoPlayerCommandContext.(A, B, C, D) -> Unit
+) {
+    playerExecutesDefaulting(a, b, c, d) { (a, b, c, d) -> run(arg<A>(a), arg<B>(b), arg<C>(c), arg<D>(d)) }
+}
+
+inline fun <reified A: Any, reified B: Any, reified C: Any, reified D: Any, reified E: Any> IdoCommand.playerExecutes(
+    a: ArgumentType<A>,
+    b: ArgumentType<B>,
+    c: ArgumentType<C>,
+    d: ArgumentType<D>,
+    e: ArgumentType<E>,
+    crossinline run: IdoPlayerCommandContext.(A, B, C, D, E) -> Unit
+) {
+    playerExecutesDefaulting(a, b, c, d, e) { (a, b, c, d, e) -> run(arg<A>(a), arg<B>(b), arg<C>(c), arg<D>(d), arg<E>(e)) }
+}
+
+inline fun <reified A: Any, reified B: Any, reified C: Any, reified D: Any, reified E: Any, reified F: Any> IdoCommand.playerExecutes(
+    a: ArgumentType<A>,
+    b: ArgumentType<B>,
+    c: ArgumentType<C>,
+    d: ArgumentType<D>,
+    e: ArgumentType<E>,
+    f: ArgumentType<F>,
+    crossinline run: IdoPlayerCommandContext.(A, B, C, D, E, F) -> Unit
+) {
+    playerExecutesDefaulting(a, b, c, d, e, f) { run(arg<A>(it[0]), arg<B>(it[1]), arg<C>(it[2]), arg<D>(it[3]), arg<E>(it[4]), arg<F>(it[5])) }
+}

idofront-commands/src/main/kotlin/com/mineinabyss/idofront/commands/brigadier/IdoArgument.kt

@@ -1,9 +1,12 @@
 package com.mineinabyss.idofront.commands.brigadier
 
+import com.mineinabyss.idofront.commands.brigadier.context.IdoCommandContext
 import kotlin.reflect.KProperty
 
 class IdoArgument<T>(
     val name: String,
+    val resolve: ((IdoCommandContext, Any) -> T)? = null,
+    val default: ((IdoCommandContext) -> T)? = null,
 ) {
     operator fun getValue(thisRef: Any?, property: KProperty<*>): IdoArgument<T> {
         return this

idofront-commands/src/main/kotlin/com/mineinabyss/idofront/commands/brigadier/IdoArgumentBuilder.kt

@@ -1,8 +1,68 @@
 package com.mineinabyss.idofront.commands.brigadier
 
+import com.github.shynixn.mccoroutine.bukkit.asyncDispatcher
+import com.github.shynixn.mccoroutine.bukkit.scope
+import com.mineinabyss.idofront.commands.brigadier.context.IdoCommandContext
+import com.mineinabyss.idofront.commands.brigadier.context.IdoSuggestionsContext
+import com.mojang.brigadier.StringReader
 import com.mojang.brigadier.arguments.ArgumentType
+import com.mojang.brigadier.context.CommandContext
+import com.mojang.brigadier.suggestion.SuggestionProvider
+import com.mojang.brigadier.suggestion.Suggestions
+import com.mojang.brigadier.suggestion.SuggestionsBuilder
+import io.papermc.paper.command.brigadier.CommandSourceStack
+import kotlinx.coroutines.future.future
+import org.bukkit.Bukkit
+import java.util.concurrent.CompletableFuture
 
-data class IdoArgumentBuilder<T>(
-    val type: ArgumentType<out T>,
-    val suggestions: (suspend IdoSuggestionsContext.() -> Unit)? = null,
-)
+data class IdoArgumentType<T>(
+    val nativeType: ArgumentType<Any>,
+    val name: String? = null,
+    val resolve: ((IdoCommandContext, Any) -> T)? = null,
+    val suggestions: ((CommandContext<Any>, SuggestionsBuilder) -> CompletableFuture<Suggestions>)? = null,
+    val commandExamples: MutableCollection<String>,
+    val default: (IdoCommandContext.() -> T)? = null,
+) : ArgumentType<T> {
+    fun createType() = nativeType
+
+    override fun parse(reader: StringReader?) =
+        error("IdoArgumentType should not be parsed directly, call createType() instead.")
+
+    inline fun suggests(crossinline suggestions: suspend IdoSuggestionsContext.() -> Unit): IdoArgumentType<T> =
+        copy(
+            suggestions = { context, builder ->
+                val plugin = Bukkit.getPluginManager().getPlugin("Idofront")!!
+                plugin.scope.future(plugin.asyncDispatcher) {
+                    suggestions(IdoSuggestionsContext(context as CommandContext<CommandSourceStack>, builder))
+                    builder.build()
+                }
+            }
+        )
+
+    fun suggests(provider: SuggestionProvider<CommandSourceStack>): IdoArgumentType<T> = copy(
+        suggestions = { context, suggestions ->
+            provider.getSuggestions(
+                context as CommandContext<CommandSourceStack>,
+                suggestions
+            )
+        },
+    )
+
+    fun default(default: IdoCommandContext.() -> T): IdoArgumentType<T> =
+        copy(default = default)
+
+    inline fun <R> map(crossinline transform: IdoCommandContext.(T) -> R): IdoArgumentType<R> =
+        IdoArgumentType(
+            nativeType = nativeType,
+            name = name,
+            resolve = { context, value ->
+                resolve
+                    ?.let { transform(context, it(context, value)) }
+                    ?: transform(context, value as T)
+            },
+            suggestions = suggestions,
+            commandExamples = commandExamples,
+        )
+
+    fun named(name: String) = copy(name = name)
+}