Merge branch 'baseline'

Author: yttrian

.gitignore

@@ -108,7 +108,7 @@ fabric.properties
 ### Gradle template
 .gradle
 **/build/
-!src/**/build/
+!koncorda/src/**/build/
 
 # Ignore Gradle GUI config
 gradle-app.setting

README.md

@@ -1,3 +1,40 @@
 # koncorda
 
-A small DSL for quickly bot creation with JDA.
+A small DSL for quickly creating a command bot with [JDA](https://github.com/DV8FromTheWorld/JDA).
+Inspired by [Ktor](https://github.com/ktorio/ktor). 
+
+# Getting started
+
+Using Koncorda is easy, especially with the `koncorda` entrypoint.
+
+```kotlin
+fun main() {
+    koncorda {
+        commmands {
+            tail("hello") {
+                event.respond("Hello world!")
+            }
+        }
+    }.start()
+}
+```
+
+DSLs like `command` make adding new functionality as easy as possible. 
+The above example creates a bot that responds "Hello world!" to `!hello`.
+
+Extending the configuration is possible by implementing KoncordaConfig. By default, it defines basic needs for getting
+a bot running like `DISCORD_TOKEN` and `COMMAND_PREFIX` which by default come from the environment. For more info, check
+out the [konfy](https://github.com/TanVD/konfy) project.
+
+To see what a more complex usage looks like, check out the TestBot under the tests source.
+
+# Logging
+
+While Koncorda is intended to be somewhat opinionated, you are free to chose your SLF4J implementation. 
+Logback is recommended for the sole reason that it's what the Ktor project generator suggests.
+
+```kotlin
+dependecies {
+    implementation("ch.qos.logback:logback-classic:1.2.3")
+}
+```

build.gradle.kts

@@ -1,16 +1,31 @@
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
+group = "org.yttr"
+version = "0.0.1"
+
 plugins {
-    kotlin("jvm") version "1.4.21"
+    id("tanvd.kosogor") version "1.0.10" apply true
+    id("io.gitlab.arturbosch.detekt") version "1.15.0" apply true
+    kotlin("jvm") version "1.4.21" apply false
 }
 
-group = "org.yttr"
-version = "0.1.0"
+subprojects {
+    apply {
+        plugin("kotlin")
+        plugin("tanvd.kosogor")
+        plugin("io.gitlab.arturbosch.detekt")
+        plugin("maven-publish")
+    }
 
-repositories {
-    mavenCentral()
-}
+    repositories {
+        jcenter()
+    }
 
-tasks.withType<KotlinCompile>() {
-    kotlinOptions.jvmTarget = "1.8"
+    tasks.withType<KotlinCompile>() {
+        kotlinOptions {
+            jvmTarget = "1.8"
+            languageVersion = "1.4"
+            apiVersion = "1.4"
+        }
+    }
 }

koncorda/build.gradle.kts

@@ -0,0 +1,29 @@
+import tanvd.kosogor.proxy.publishJar
+
+group = rootProject.group
+version = rootProject.version
+
+dependencies {
+    implementation("net.dv8tion:JDA:4.2.0_227") {
+        exclude(module = "opus-java")
+    }
+    implementation("tanvd.konfy:konfy:0.1.18")
+    testImplementation("ch.qos.logback:logback-classic:1.2.3")
+}
+
+publishJar {
+    enablePublication = true
+}
+
+publishing {
+    repositories {
+        maven {
+            name = "GitHubPackages"
+            url = uri("https://maven.pkg.github.com/yttrian/koncorda")
+            credentials {
+                username = System.getenv("GITHUB_ACTOR")
+                password = System.getenv("GITHUB_TOKEN")
+            }
+        }
+    }
+}

koncorda/src/main/kotlin/CreationDsl.kt

@@ -0,0 +1,5 @@
+package org.yttr.koncorda
+
+@DslMarker
+@Target(AnnotationTarget.FUNCTION)
+annotation class CreationDsl

koncorda/src/main/kotlin/Koncorda.kt

@@ -0,0 +1,68 @@
+package org.yttr.koncorda
+
+import net.dv8tion.jda.api.JDABuilder
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent
+import net.dv8tion.jda.api.hooks.ListenerAdapter
+import org.yttr.koncorda.command.Command
+import org.yttr.koncorda.config.DefaultKoncordaConfig
+import org.yttr.koncorda.config.KoncordaConfig
+import tanvd.konfy.ConfigView
+
+/**
+ * The Discord bot application, with useful DSLs for setting up different features.
+ */
+class Koncorda(val config: KoncordaConfig) : ConfigView, ListenerAdapter() {
+    private val baseCommands = mutableListOf<Command.Branch>()
+
+    /**
+     * Complete the JDA builder and start the bot
+     * @param lowMemory Whether or not to use JDA's low memory profile
+     */
+    fun start(lowMemory: Boolean = false) = if (lowMemory) {
+        JDABuilder.createLight(config.discordToken)
+    } else {
+        JDABuilder.createDefault(config.discordToken)
+    }.addEventListeners(this).setEnabledIntents(config.gatewayIntents).build()
+
+    internal fun addBaseCommand(command: Command.Branch) = baseCommands.add(command)
+
+    override fun onMessageReceived(event: MessageReceivedEvent) {
+        // ignore improper messages
+        if (event.isIgnorable) return
+
+        // split the args
+        val args = event.message.contentStripped.trim().split(" ")
+
+        // find the command handler, if it exists
+        when (val baseCommand = allBaseCommands()[args.first()]) {
+            is Command.Leaf -> baseCommand
+            is Command.Branch -> baseCommand[args.drop(1)]
+            else -> null
+        }?.let {
+            if (it.check(event)) it(event, args) else {
+                event.channel.sendMessage("You are not allowed to use that command.").queue()
+            }
+        }
+    }
+
+    private fun allBaseCommands(): Map<String, Command> = baseCommands
+        .map { it.routes }
+        .fold(emptyMap()) { acc, baseRoute ->
+            acc + baseRoute
+        }
+
+    private val MessageReceivedEvent.isIgnorable
+        get() = author.isBot || isWebhookMessage
+}
+
+/**
+ * Commands DSL, an easy way of registering command handlers and the path to them with Koncorda.
+ */
+fun Koncorda.commands(prefix: String = config.commandPrefix, build: Command.Branch.() -> Unit) =
+    addBaseCommand(Command.Branch(prefix = prefix).apply(build))
+
+/**
+ * The simplest way to start building a bot with Koncorda. Make sure to add .start() to the end!
+ */
+fun koncorda(config: KoncordaConfig = DefaultKoncordaConfig, init: Koncorda.() -> Unit) =
+    Koncorda(config).apply(init)

koncorda/src/main/kotlin/command/Command.kt

@@ -0,0 +1,112 @@
+package org.yttr.koncorda.command
+
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent
+import org.yttr.koncorda.CreationDsl
+import org.yttr.koncorda.command.check.CommandCheck
+
+/**
+ * A callable bot command.
+ */
+sealed class Command(
+    protected val depth: Int,
+    private val prefix: String = ""
+) {
+    protected val checks: MutableSet<CommandCheck> = mutableSetOf()
+    protected val nextDepth = depth + 1
+
+    /**
+     * Represents a command branch.
+     * @param handler action to perform when branch is called a terminal, defaults to autogenerated help
+     * @param prefix the command prefix, only used by the base route!
+     */
+    class Branch(depth: Int = 0, handler: CommandHandler? = null, prefix: String = "") : Command(depth, prefix) {
+        val routes = mutableMapOf<String, Command>()
+        private val fallback by lazy {
+            if (handler != null) Leaf(depth, handler) else {
+                val autoHelpCommandHandler = object : CommandHandler {
+                    override fun CommandCall.handle() {
+                        val path = args.joinToString(" ")
+                        val validSubcommands = routes.keys.joinToString { "`$it`" }
+                        event.respond("Valid subcommands for `$path` are $validSubcommands.")
+                    }
+                }
+                Leaf(depth, autoHelpCommandHandler, true).also { it.checks.addAll(checks) }
+            }
+        }
+
+        /**
+         * Try to follow a path to a terminal.
+         * Cannot tailrec optimize: https://stackoverflow.com/a/44626117
+         */
+        operator fun get(path: List<String>): Leaf {
+            val arg = path.firstOrNull() ?: return fallback
+
+            return when (val foundCommand = routes[arg]) {
+                is Branch -> foundCommand[path.drop(1)]
+                is Leaf -> foundCommand
+                else -> fallback
+            }
+        }
+
+        override fun addCheck(addedCheck: CommandCheck) {
+            this.checks += addedCheck
+            this.routes.values.forEach { it.addCheck(addedCheck) }
+        }
+    }
+
+    /**
+     * Represents the end of a branch where a command will be handled.
+     */
+    class Leaf(
+        depth: Int,
+        private val handler: CommandHandler,
+        private val help: Boolean = false
+    ) : Command(depth) {
+        operator fun invoke(event: MessageReceivedEvent, args: List<String>) = with(handler) {
+            CommandCall(event, if (help) args.take(depth) else args.drop(depth)).handle()
+        }
+
+        override fun addCheck(addedCheck: CommandCheck) {
+            this.checks += addedCheck
+        }
+    }
+
+    /**
+     * Build a branch.
+     */
+    @CreationDsl
+    fun Branch.branch(arg: String, handler: CommandHandler? = null, build: Branch.() -> Unit) {
+        routes["$prefix$arg"] = Branch(nextDepth, handler).apply(build)
+    }
+
+    /**
+     * Set the handler.
+     */
+    @CreationDsl
+    fun Branch.leaf(arg: String, handler: CommandHandler) {
+        routes["$prefix$arg"] = Leaf(nextDepth, handler)
+    }
+
+    /**
+     * Set the handler.
+     */
+    @CreationDsl
+    fun Branch.leaf(arg: String, handler: CommandCall.() -> Unit) {
+        routes["$prefix$arg"] = Leaf(nextDepth, object : CommandHandler {
+            override fun CommandCall.handle() = handler()
+        })
+    }
+
+    /**
+     * Create a checked branch.
+     */
+    fun Branch.check(check: CommandCheck, build: Branch.() -> Unit) {
+        val checkedBranch = Branch().also(build)
+        checkedBranch.addCheck(check)
+        this.routes += checkedBranch.routes
+    }
+
+    abstract fun addCheck(addedCheck: CommandCheck)
+
+    fun check(event: MessageReceivedEvent) = checks.all { it.check(event) }
+}

koncorda/src/main/kotlin/command/CommandCall.kt

@@ -0,0 +1,12 @@
+package org.yttr.koncorda.command
+
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent
+
+data class CommandCall(val event: MessageReceivedEvent, val args: List<String>) {
+    /**
+     * Respond to the event.
+     */
+    fun MessageReceivedEvent.respond(content: String) {
+        if (content.isNotBlank()) channel.sendMessage(content).queue()
+    }
+}

koncorda/src/main/kotlin/command/CommandHandler.kt

@@ -0,0 +1,11 @@
+package org.yttr.koncorda.command
+
+/**
+ * A command handler.
+ */
+interface CommandHandler {
+    /**
+     * Handle the message event for a command invocation.
+     */
+    fun CommandCall.handle()
+}

koncorda/src/main/kotlin/command/check/CommandCheck.kt

@@ -0,0 +1,7 @@
+package org.yttr.koncorda.command.check
+
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent
+
+interface CommandCheck {
+    fun check(event: MessageReceivedEvent): Boolean
+}