major refactor

2025-08-18 00:11:20 +02:00
parent fee1c346a3
commit fc416d3bbb
9 changed files with 84 additions and 55 deletions
--- a/src/commonMain/kotlin/com/infendro/cli/command/Command.kt
+++ b/src/commonMain/kotlin/com/infendro/cli/command/Command.kt
@@ -0,0 +1,178 @@
+package com.infendro.cli.command
+
+import com.infendro.cli.Execution
+import com.infendro.cli.argument.Argument
+import com.infendro.cli.exception.build.*
+import com.infendro.cli.exception.run.ArgumentCountException
+import com.infendro.cli.exception.run.InvalidArgumentException
+import com.infendro.cli.exception.run.UnknownArgumentException
+import com.infendro.cli.exception.run.UnknownCommandException
+import com.infendro.cli.util.Regex.ARGUMENT
+import com.infendro.cli.util.Regex.ARGUMENT_NAME
+import com.infendro.cli.util.Regex.COMMAND_NAME
+
+class Command private constructor(
+    private val index: Int,
+    private val name: String?,
+    private val commands: List<Command>,
+    private val arguments: List<Argument<*>>,
+    private val block: Execution.() -> Unit,
+) {
+    private val nextIndex: Int
+        get() = index + 1
+
+    fun run(
+        args: Array<String>,
+    ) {
+        val index = args
+            .withIndex()
+            .find { (_, value) -> value.startsWith("--") }
+            ?.index ?: args.size
+
+        val cmd = args.slice(0..<index)
+        val arg = args.slice(index..<args.size)
+
+        try {
+            run(cmd, arg)
+        } catch (e: UnknownCommandException) {
+            println("""unknown command "${e.command}"""")
+        } catch (e: InvalidArgumentException) {
+            println("""invalid argument "${e.argument}"""")
+        } catch (e: UnknownArgumentException) {
+            println("""unknown argument "${e.argument}"""")
+        } catch (e: ArgumentCountException) {
+            when {
+                e.min == e.max -> println("""argument "${e.argument}" must appear ${e.min} times""")
+                e.max == Int.MAX_VALUE -> println("""argument "${e.argument}" must appear at least ${e.min} times""")
+                else -> println("""argument "${e.argument}" must appear between ${e.min} and ${e.max} times""")
+            }
+        }
+    }
+
+    private fun run(
+        cmd: List<String>,
+        arg: List<String>,
+    ) {
+        if (index == cmd.lastIndex) {
+            Execution(
+                parseCmd(cmd),
+                parseArg(arg),
+            ).block()
+        } else {
+            val command = commands.firstOrNull() { it.name == cmd[nextIndex] || it.name == null }
+                ?: throw UnknownCommandException(cmd[nextIndex])
+            command.run(cmd, arg)
+        }
+    }
+
+    private fun parseCmd(
+        cmd: List<String>,
+    ): List<Execution.Cmd> {
+        return cmd.map { Execution.Cmd(it) }
+    }
+
+    private fun parseArg(
+        arg: List<String>,
+    ): List<Execution.Arg> {
+        val result = mutableListOf<Execution.Arg>()
+
+        for (argument in arg) {
+            val match = ARGUMENT.matchEntire(argument)
+                ?: throw InvalidArgumentException(argument)
+
+            val name = match.groups["name"]!!.value
+            val value = match.groups["value"]?.value
+
+            if (arguments.none { it.name == name })
+                throw UnknownArgumentException(name)
+
+            result += Execution.Arg(name, value)
+        }
+
+        arguments
+            .forEach { argument ->
+                val count = result.count { it.name == argument.name }
+                if (count !in argument.min..argument.max)
+                    throw ArgumentCountException(argument.name, argument.min, argument.max)
+            }
+
+        return result
+    }
+
+    class Builder internal constructor(
+        private val index: Int,
+        private val name: String?,
+    ) {
+        private val commands = mutableListOf<Command>()
+        private val arguments = mutableListOf<Argument<*>>()
+        private lateinit var block: Execution.() -> Unit
+
+        private val nextIndex: Int
+            get() = index + 1
+
+        fun command(
+            name: String? = null,
+            block: Builder.(Key) -> Unit,
+        ) {
+            if (name != null && !COMMAND_NAME.matches(name))
+                throw IllegalCommandNameException(name)
+
+            if (commands.any { it.name == name })
+                throw DuplicateCommandException(name)
+
+            val builder = Builder(nextIndex, name)
+            builder.block(Key(nextIndex))
+            val command = builder.build()
+
+            commands.add(command)
+        }
+
+        fun argument(
+            argument: Argument<*>,
+        ) {
+            if (!ARGUMENT_NAME.matches(argument.name))
+                throw IllegalArgumentNameException(argument.name)
+
+            if (arguments.any { it.name == argument.name })
+                throw DuplicateArgumentException(argument.name)
+
+            arguments.add(argument)
+        }
+
+        fun arguments(
+            vararg arguments: Argument<*>,
+        ) {
+            for (argument in arguments) {
+                argument(argument)
+            }
+        }
+
+        fun execute(
+            block: Execution.() -> Unit,
+        ) {
+            if (this::block.isInitialized)
+                throw DuplicateExecuteException()
+
+            this.block = block
+        }
+
+        fun build(): Command {
+            if (!this::block.isInitialized)
+                throw NoExecuteException()
+
+            return Command(index, name, commands, arguments, block)
+        }
+    }
+
+    class Key(
+        internal val index: Int,
+    )
+}
+
+fun cli(
+    block: Command.Builder.() -> Unit,
+): Command {
+    val builder = Command.Builder(-1, null)
+    builder.block()
+    return builder.build()
+}