Merge dev branch

.github/workflows/build.yml

@@ -2,9 +2,11 @@ name: Build Gradle project
 
 on:
   push:
+    branches:
+    - "main"
 
 jobs:
-  build-gradle-project:
+  build-and-release:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4

.github/workflows/test-build.yml

@@ -0,0 +1,20 @@
+on:
+  push:
+    branches:
+    - "dev"
+
+jobs:
+  test-build-gradle-project:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-java@v3
+        with:
+          distribution: temurin
+          java-version: 17
+      - name: Checkout project sources
+        uses: actions/checkout@v3
+      - name: Setup Gradle
+        uses: gradle/gradle-build-action@v2
+      - name: Run build with Gradle Wrapper
+        run: ./gradlew build

api/build.gradle.kts

@@ -1,12 +1,18 @@
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
-    `maven-publish`
+    kotlin("jvm") version "1.7.10"
     id("com.github.johnrengelman.shadow") version "7.0.0"
+    `maven-publish`
+}
+
+repositories {
+    mavenCentral()
 }
 
 dependencies {
     compileOnly(kotlin("reflect"))
+    implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk7:1.7.10")
 }
 
 tasks.test {
@@ -25,6 +31,13 @@ tasks {
     build {
         dependsOn(shadowJar)
     }
+    shadowJar {
+        mergeServiceFiles()
+//        exclude {
+////            it.path.startsWith("kotlin") && !it.path.contains("reactive")
+//            it.name.startsWith("kotlin")
+//        }
+    }
 }
 
 tasks.withType<com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar> {

api/src/main/kotlin/com/mattmx/ktgui/GuiManager.kt

@@ -18,13 +18,14 @@ import org.bukkit.event.player.PlayerQuitEvent
 import org.bukkit.event.server.PluginDisableEvent
 import org.bukkit.plugin.java.JavaPlugin
 import org.jetbrains.annotations.ApiStatus
+import java.util.Collections
 
 /**
  * Handles all GUI click events, as well
  * as events we might need to know while in a GUI.
  */
 object GuiManager : Listener {
-    private val players = hashMapOf<Player, IGuiScreen>()
+    private val players = Collections.synchronizedMap(hashMapOf<Player, IGuiScreen>())
     private var initialized = false
     private val defaultConfiguration = Configuration()
     private val configurations = hashMapOf<JavaPlugin, Configuration>()
@@ -106,7 +107,9 @@ object GuiManager : Listener {
         val gui = e.player.getOpenGui()
         gui?.let {
             gui.quit(e)
-            gui.destroy()
+            if (getPlayers(gui).isEmpty()) {
+                gui.destroy()
+            }
             players.remove(e.player)
         }
     }
@@ -126,8 +129,11 @@ object GuiManager : Listener {
     fun forceClose(player: Player) {
         val gui = player.getOpenGui()
         gui?.let {
-            gui.destroy()
+            if (getPlayers(gui).isEmpty()) {
+                gui.destroy()
+            }
             players.remove(player)
+            player.openInventory.close()
         }
     }
 

api/src/main/kotlin/com/mattmx/ktgui/commands/SimpleCommandBuilder.kt

@@ -32,6 +32,9 @@ open class SimpleCommandBuilder(
     var noPermissions: (CommandInvocation.() -> Unit)? = null
         private set
 
+    constructor(name: String) : this(name, null)
+    constructor(name: String, vararg alias: String) : this(name, null, *alias)
+
     infix fun permission(permission: String) : SimpleCommandBuilder {
         this.permission = permission
         return this

api/src/main/kotlin/com/mattmx/ktgui/commands/declarative/CommandContext.kt

@@ -3,7 +3,7 @@ package com.mattmx.ktgui.commands.declarative
 import kotlin.properties.ReadOnlyProperty
 import kotlin.reflect.KProperty
 
-class CommandContext<S : CommandSender>(
+open class CommandContext<S : CommandSender>(
     val sender: S,
     val args: Array<String>,
 ) {

api/src/main/kotlin/com/mattmx/ktgui/commands/stringbuilder/MissingArgContext.kt

@@ -0,0 +1,9 @@
+package com.mattmx.ktgui.commands.stringbuilder
+
+import com.mattmx.ktgui.commands.stringbuilder.arg.Argument
+import org.bukkit.command.CommandSender
+
+class MissingArgContext<T : CommandSender>(
+    val missingArgument: Argument<*>,
+    args: List<String>
+) : RawCommandContext<T>(args)

api/src/main/kotlin/com/mattmx/ktgui/commands/stringbuilder/RawCommandContext.kt

@@ -0,0 +1,9 @@
+package com.mattmx.ktgui.commands.stringbuilder
+
+import org.bukkit.command.CommandSender
+
+open class RawCommandContext<T : CommandSender>(
+    val rawArgs: List<String>
+) {
+
+}

api/src/main/kotlin/com/mattmx/ktgui/commands/stringbuilder/RunnableCommandContext.kt

@@ -0,0 +1,22 @@
+package com.mattmx.ktgui.commands.stringbuilder
+
+import com.mattmx.ktgui.commands.stringbuilder.arg.ArgumentContext
+import com.mattmx.ktgui.utils.JavaCompatibility
+import org.bukkit.command.CommandSender
+import kotlin.properties.ReadOnlyProperty
+import kotlin.reflect.KProperty
+
+class RunnableCommandContext<T : CommandSender>(
+    private val providedArgs: HashMap<String, ArgumentContext<*>>,
+    rawArgs: List<String>
+) : RawCommandContext<T>(rawArgs) {
+
+    fun argument() = ReadOnlyProperty { owner: Nothing?, prop: KProperty<*> ->
+        //  todo might be optional
+        providedArgs[prop.name] ?: error("Unknown argument '${prop.name}'")
+    }
+
+    @JavaCompatibility
+    fun <S> getArgument(name: String) = providedArgs[name]?.let { it as ArgumentContext<S> }
+
+}

api/src/main/kotlin/com/mattmx/ktgui/commands/stringbuilder/StringCommand.kt

@@ -0,0 +1,173 @@
+package com.mattmx.ktgui.commands.stringbuilder
+
+import com.mattmx.ktgui.commands.stringbuilder.arg.Argument
+import com.mattmx.ktgui.commands.stringbuilder.arg.ArgumentContext
+import com.mattmx.ktgui.commands.stringbuilder.syntax.CommandDeclarationSyntax
+import com.mattmx.ktgui.commands.stringbuilder.syntax.Parser
+import com.mattmx.ktgui.commands.stringbuilder.syntax.SubCommandDeclarationSyntax
+import com.mattmx.ktgui.commands.stringbuilder.syntax.VariableDeclarationSyntax
+import com.mattmx.ktgui.commands.usage.CommandUsageOptions
+import com.mattmx.ktgui.configuration.Configuration
+import org.bukkit.command.CommandSender
+import java.util.Optional
+
+class StringCommand<T : CommandSender>(
+    source: String
+) {
+    lateinit var name: String
+    var aliases = arrayOf<String>()
+    var subcommands = arrayOf<StringCommand<*>>()
+    var expectedArguments = arrayOf<Argument<*>>()
+    private var permission: Optional<(RunnableCommandContext<T>) -> Boolean> = Optional.empty()
+    private var runs: Optional<(RunnableCommandContext<T>) -> Unit> = Optional.empty()
+    private var missing: Optional<(MissingArgContext<T>) -> Unit> = Optional.empty()
+
+    init {
+        val parsed = Parser(source).parse()
+
+        for (syntax in parsed) {
+            when (syntax) {
+                is VariableDeclarationSyntax -> {
+                    expectedArguments += Argument<Any>(
+                        syntax.getName(),
+                        syntax.getType(),
+                        null,
+                        !syntax.getType().isOptional
+                    )
+                }
+
+                is CommandDeclarationSyntax -> {
+                    // todo should be top level only
+                    name = syntax.getName()
+                }
+
+                is SubCommandDeclarationSyntax -> {
+                    name = syntax.getName()
+                }
+            }
+        }
+    }
+
+    infix fun missing(block: MissingArgContext<T>.() -> Unit) = apply {
+        this.missing = Optional.of(block)
+    }
+
+    infix fun runs(block: RunnableCommandContext<T>.() -> Unit) = apply {
+        this.runs = Optional.of(block)
+    }
+
+    infix fun args(block: ArgumentOptions<T>.() -> Unit) = apply {
+        ArgumentOptions<T>(this).apply(block)
+    }
+
+    class ArgumentOptions<T : CommandSender>(private val command: StringCommand<T>) {
+        operator fun String.invoke(block: Argument<*>.() -> Unit) =
+            command.expectedArguments.firstOrNull { it.name() == this }
+                ?.apply(block)
+                ?: error("Unregistered argument '$this'.")
+    }
+
+    inline operator fun <V : CommandSender> String.invoke(block: StringCommand<V>.() -> Unit) =
+        StringCommand<V>(this).let {
+            // todo could also have parameters
+            subcommands += it
+        }
+
+    fun getSuggestions(context: RawCommandContext<T>): List<String> {
+        val currentArgument = getCurrentArgument(context)
+        val suggestions = currentArgument?.suggestions()?.invoke(context) ?: return emptyList()
+        val lastArgument = context.rawArgs.lastOrNull() ?: ""
+        return suggestions.filter { suggestion -> suggestion.startsWith(lastArgument, true) }.toList()
+    }
+
+    /**
+     * Used to find the current argument, presuming we are on the current sub-command
+     *
+     * @param args the current arguments of the command invocation
+     * @param sender command sender
+     * @return the current argument or null if it is invalid
+     */
+    private fun getCurrentArgument(context: RawCommandContext<T>): Argument<*>? {
+        if (expectedArguments.isEmpty()) return null
+
+        // Greedy arguments will eat the rest of the arguments todo
+        if (expectedArguments.first().type().isVararg) return expectedArguments.first()
+
+        repeat(expectedArguments.size) { argIndex ->
+            val registered = expectedArguments.getOrNull(argIndex) ?: return null
+            val comparing = context.rawArgs.getOrNull(argIndex) ?: return null
+            // todo need to think about optional args!!! wtf do we do there
+        }
+
+        return null
+    }
+
+    operator fun unaryPlus() = register()
+
+    fun register() = apply {
+
+    }
+
+    fun invoke(context: RawCommandContext<T>) {
+
+        // Set variables
+        val argumentValues = hashMapOf<String, ArgumentContext<*>>()
+        for ((index, arg) in expectedArguments.withIndex()) {
+            // todo var offset for sub-commands?
+            val value = if (arg.type().isVararg) {
+                context.rawArgs.subList(index, context.rawArgs.size).joinToString(" ")
+            } else context.rawArgs.getOrNull(index)
+
+            if (arg.isRequired() && value == null) {
+                val missingArgContext = MissingArgContext<T>(arg, context.rawArgs)
+                missing.ifPresent { it.invoke(missingArgContext) }
+                return
+            } else {
+                argumentValues[arg.name()] = ArgumentContext(Optional.ofNullable(value), arg as Argument<String>)
+            }
+        }
+
+        val runnableContext = RunnableCommandContext<T>(argumentValues, context.rawArgs)
+        runs.ifPresent { it.invoke(runnableContext) }
+    }
+
+    /**
+     * Builds a usage for this command.
+     * You can create your own method with the [Configuration] class.
+     *
+     * @return a formatted string for usage of the command
+     */
+    fun getUsage(options: CommandUsageOptions = CommandUsageOptions()): String {
+        var builder = "${options.namePrefix}$name${options.gap}"
+        if (subcommands.isNotEmpty())
+            builder += subcommands.joinToString(options.subCommands.divider) { subcommand -> subcommand.name }
+        else {
+            var end = ""
+            builder += expectedArguments.joinToString(" ") { arg ->
+
+                val suggestions =
+                    if (options.arguments.showSuggestions) {
+                        val suggestions = arg.getDefaultSuggestions()
+                        if (!suggestions.isNullOrEmpty()) {
+                            val opt = options.arguments
+                            "${opt.suggestionsChar}${opt.suggestionsPrefix}${suggestions.joinToString(opt.suggestionsDivider)}${opt.suggestionsSuffix}"
+                        } else "${options.arguments.typeChar}${arg.type().typeName}"
+                    } else "${options.arguments.typeChar}${arg.type().typeName}"
+
+                // Apply descriptions
+                if (options.arguments.showDescriptions) {
+                    val extra =
+                        if (arg.isRequired()) options.arguments.descriptionsRequired else options.arguments.descriptionsOptional
+                    end += "\n${options.arguments.descriptionsPrefix}${arg.name()}${options.arguments.descriptionDivider}${arg.description()}$extra"
+                }
+
+                "${options.arguments.prefix}${arg.name()}${if (arg.isRequired()) options.arguments.required else options.arguments.optional}$suggestions${options.arguments.suffix}"
+            }
+            builder += end
+        }
+        return builder
+    }
+}
+
+inline operator fun <T : CommandSender> String.invoke(block: StringCommand<T>.() -> Unit) =
+    StringCommand<T>(this).apply(block)

api/src/main/kotlin/com/mattmx/ktgui/commands/stringbuilder/arg/Argument.kt

@@ -0,0 +1,39 @@
+package com.mattmx.ktgui.commands.stringbuilder.arg
+
+import com.mattmx.ktgui.commands.stringbuilder.RawCommandContext
+import com.mattmx.ktgui.commands.stringbuilder.syntax.VariableType
+import org.bukkit.command.CommandSender
+import java.util.*
+
+class Argument<T>(
+    private val name: String,
+    private val type: VariableType,
+    var description: String? = null,
+    private val required: Boolean = true
+) {
+    private var suggests = Optional.empty<(RawCommandContext<*>) -> List<String>?>()
+
+    fun name() = name
+
+    fun description() = description ?: ""
+
+    fun type() = type
+
+    fun isRequired() = required
+
+    fun suggests(suggest: RawCommandContext<*>.() -> List<String>?) = apply {
+        this.suggests = Optional.of(suggest)
+    }
+
+    fun suggestions() = suggests.orElse(null)
+
+    fun getDefaultSuggestions() = if (suggests.isPresent) {
+        val context = RawCommandContext<CommandSender>(emptyList())
+        suggests.get().invoke(context)
+    } else listOf()
+
+    enum class Type {
+        SINGLE,
+        GREEDY
+    }
+}