[+] Kotlinize, Coroutines, Async inputs

build.gradle

@@ -13,7 +13,7 @@ group 'org.hydev.mcpm'
 version '1.0.0.788'
 
 application {
-    mainClass = 'org.hydev.mcpm.client.arguments.ArgsParser'
+    mainClass = 'org.hydev.mcpm.CliEntryKt'
 }
 
 repositories {
@@ -94,11 +94,13 @@ dependencies {
 
     // https://mvnrepository.com/artifact/org.jetbrains.kotlin/kotlin-stdlib
     implementation 'org.jetbrains.kotlin:kotlin-stdlib:1.8.0'
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4'
 
     // Unit tests
     testImplementation 'org.junit.jupiter:junit-jupiter-api:5.9.0'
     testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.9.0'
     testRuntimeOnly 'org.slf4j:slf4j-simple:2.0.4'
+    testImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-test:1.6.4'
 }
 
 processResources {

crawl.sh

@@ -14,7 +14,7 @@ $PY -m tools.run org.hydev.mcpm.server.SpigetCrawler
 $PY -m tools.run org.hydev.mcpm.server.spiget.CreateDatabase
 
 # Zstd compression
-rm -rf .mcpm/db.zst
-zstd -f -19 -T36 .mcpm/db
+zstd -f -19 -T36 .mcpm/db -o .mcpm/db.zst1
+mv -f .mcpm/db.zst1 .mcpm/db.zst
 
 popd

mcpm

@@ -5,4 +5,4 @@ set -e
 ./gradlew :compileJava
 classpath=$(./gradlew :printCp 2>& 1>/dev/null)
 
-java -cp "$classpath" org.hydev.mcpm.client.arguments.ArgsParser "$@"
+$JAVA_HOME/bin/java -cp "$classpath" org.hydev.mcpm.CliEntryKt "$@"

src/main/java/org/hydev/mcpm/CliEntry.kt

@@ -0,0 +1,26 @@
+package org.hydev.mcpm
+
+import net.sourceforge.argparse4j.inf.ArgumentParserException
+import org.hydev.mcpm.client.arguments.ArgsParserFactory
+import org.hydev.mcpm.client.interaction.StdLogger
+import org.hydev.mcpm.utils.ColorLogger
+
+/**
+ * CLI Entry point
+ *
+ * @author Azalea (https://github.com/hykilpikonna)
+ * @since 2023-01-02
+ */
+suspend fun main(args: Array<String>)
+{
+    val parser = ArgsParserFactory.baseArgsParser()
+
+    try
+    {
+        parser.parse(args, StdLogger())
+    }
+    catch (e: ArgumentParserException)
+    {
+        parser.fail(e, StdLogger())
+    }
+}

src/main/java/org/hydev/mcpm/SpigotEntry.kt

@@ -1,12 +1,17 @@
 package org.hydev.mcpm
 
+import kotlinx.coroutines.DelicateCoroutinesApi
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
 import net.sourceforge.argparse4j.inf.ArgumentParserException
 import org.bukkit.command.Command
 import org.bukkit.command.CommandExecutor
 import org.bukkit.command.CommandSender
+import org.bukkit.entity.Player
 import org.bukkit.plugin.java.JavaPlugin
 import org.hydev.mcpm.client.arguments.ArgsParserFactory
 import org.hydev.mcpm.client.interaction.SpigotUserHandler
+import org.hydev.mcpm.client.interaction.StdLogger
 import org.hydev.mcpm.utils.ColorLogger
 
 /**
@@ -38,6 +43,9 @@ class SpigotEntry : JavaPlugin(), CommandExecutor
 
         // Register mcpm command
         getCommand("mcpm")!!.setExecutor(this)
+
+        // Register event listeners
+        server.pluginManager.registerEvents(interaction, this)
     }
 
     /**
@@ -48,24 +56,28 @@ class SpigotEntry : JavaPlugin(), CommandExecutor
         logger.info("Disabled!")
     }
 
+    @OptIn(DelicateCoroutinesApi::class)
     override fun onCommand(sender: CommandSender, command: Command, label: String, args: Array<String>): Boolean
     {
-        val log = ColorLogger.toMinecraft(sender)
-        try
-        {
-            parser.parse(args, log)
-        }
-        catch (e: ArgumentParserException)
-        {
-            parser.fail(e, log)
+        val log = interaction.create(sender)
+        // Run async
+        GlobalScope.launch {
+            try
+            {
+                parser.parse(args, log)
+            }
+            catch (e: ArgumentParserException)
+            {
+                parser.fail(e, log)
+            }
         }
         return true
     }
 
     override fun onTabComplete(sender: CommandSender, command: Command, alias: String, args: Array<String>): List<String>?
     {
         if (command.name.lowercase() != "mcpm") return null
-        return if (args.size == 1) parser.rawSubparsers.map { it.name() }
+        return if (args.size == 1) parser.rawSubparsers.map { it.name }
         else null
     }
 }

src/main/java/org/hydev/mcpm/client/arguments/ArgsParser.kt

@@ -0,0 +1,92 @@
+package org.hydev.mcpm.client.arguments
+
+import net.sourceforge.argparse4j.ArgumentParsers
+import net.sourceforge.argparse4j.inf.*
+import org.hydev.mcpm.client.arguments.parsers.CommandHandler
+import org.hydev.mcpm.client.arguments.parsers.CommandParser
+import org.hydev.mcpm.client.interaction.ILogger
+import java.io.PrintWriter
+import java.io.StringWriter
+
+/**
+ * Handles parsing command arguments into CommandEntry objects (to be dispatched to Controller).
+ * For steps to add a new command, see Command.java.
+ */
+class ArgsParser(val rawSubparsers: List<CommandParser>)
+{
+    val help: String
+    val parser: ArgumentParser = ArgumentParsers.newFor("mcpm").addHelp(false).build()
+
+    /**
+     * Creates a new ArgsParser object with a list of CommandParsers.
+     *
+     * @param allParsers A list of all CommandParser objects that this ArgsParser can parse.
+     */
+    init
+    {
+        val parsers = parser.addSubparsers()
+        for (parser in rawSubparsers)
+        {
+            val subparser = parsers.addParser(parser.name, false)
+            parser.configure(subparser)
+            subparser.setDefault("handler", parser)
+            subparser.addArgument("-h", "--help").action(PrintHelpAction(subparser))
+        }
+
+        // Create help string and help command
+        help = "mcpm: Minecraft Plugin Package Manager\n" +
+            rawSubparsers.filter { it.description.isNotBlank() }
+                .map { "&f/mcpm ${it.name} &6- ${it.description}&r\n" }.joinToString("") +
+            "To view the help message of a command, use /mcpm <command> -h"
+
+        val helpSub = parsers.addParser("help", false)
+        helpSub.setDefault("handler", object : CommandHandler
+        {
+            override suspend fun run(details: Namespace, log: ILogger) = log.print(help)
+        })
+    }
+
+    /**
+     * Parses arguments into a CommandEntry object.
+     *
+     * @param arguments A list of string arguments. Example: [ "load", "pluginA", "pluginB" ].
+     * @param log Logger
+     * @throws ArgumentParserException Thrown when arguments are not parsed correctly.
+     * For default handling, pass this to ArgsParser#fail.
+     */
+    @Throws(ArgumentParserException::class)
+    suspend fun parse(arguments: Array<String>, log: ILogger)
+    {
+        // If no args are present, add help
+        if (arguments.isEmpty())
+        {
+            log.print(help)
+            return
+        }
+
+        try
+        {
+            val namespace = parser.parseArgs(arguments)
+            val handleObject = runCatching { namespace.get<CommandHandler>("handler") }.getOrNull()
+                ?: throw ArgumentParserException("Unrecognized command.", parser)
+            handleObject.run(namespace, log)
+        }
+        catch (e: HelpException)
+        {
+            log.print("&e" + e.help())
+        }
+    }
+
+    /**
+     * Writes the error message to stdout (along with help details if needed).
+     *
+     * @param e The error object that was caught from #parse.
+     */
+    fun fail(e: ArgumentParserException?, log: ILogger)
+    {
+        val writer = StringWriter()
+        val printer = PrintWriter(writer)
+        parser.handleError(e, printer)
+        log.print("&c$writer")
+    }
+}