initial commit

src/commonMain/kotlin/com/infendro/cli/Command.kt

@@ -0,0 +1,162 @@
+package com.infendro.cli
+
+import com.infendro.cli.Regex.ARGUMENT
+import com.infendro.cli.Regex.ARGUMENT_NAME
+import com.infendro.cli.Regex.COMMAND_NAME
+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
+
+class Command private constructor(
+    private val name: String,
+    private val commands: List<Command>,
+    private val arguments: List<Argument<*>>,
+    private val block: Execution.() -> Unit,
+) {
+    fun run(
+        args: Array<String>,
+    ) {
+        val index = args
+            .withIndex()
+            .find { (_, value) -> value.startsWith("--") }
+            ?.index ?: args.size
+
+        val c = args.slice(0..<index)
+        val a = args.slice(index..<args.size)
+
+        try {
+            run(c, a)
+        } 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>, args: List<String>,
+    ) {
+        if (cmd.isEmpty()) {
+            val arguments = parseArguments(args)
+            execute(arguments)
+        } else {
+            val command = commands.find { it.name == cmd[0] }
+                ?: throw UnknownCommandException(cmd[0])
+            command.run(cmd.drop(1), args)
+        }
+    }
+
+    private fun execute(
+        arguments: List<Execution.Argument>,
+    ) {
+        val execution = Execution(arguments)
+        execution.block()
+    }
+
+    private fun parseArguments(
+        args: List<String>,
+    ): List<Execution.Argument> {
+        val result = mutableListOf<Execution.Argument>()
+
+        for (arg in args) {
+            val match = ARGUMENT.matchEntire(arg)
+                ?: throw InvalidArgumentException(arg)
+
+            val name = match.groups["name"]!!.value
+            val value = match.groups["value"]?.value
+
+            if (arguments.none { it.name == name })
+                throw UnknownArgumentException(name)
+
+            result += Execution.Argument(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(
+        private val name: String = "",
+    ) {
+        private val commands = mutableListOf<Command>()
+        private val arguments = mutableListOf<Argument<*>>()
+        private lateinit var block: Execution.() -> Unit
+
+        fun command(
+            name: String,
+            block: Builder.() -> Unit,
+        ) {
+            if (!COMMAND_NAME.matches(name))
+                throw IllegalCommandNameException(name)
+
+            if (commands.any { it.name == name })
+                throw DuplicateCommandException(name)
+
+            val builder = Builder(name)
+            builder.block()
+            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(name, commands, arguments, block)
+        }
+    }
+}
+
+fun cli(
+    block: Command.Builder.() -> Unit,
+): Command {
+    val builder = Command.Builder()
+    builder.block()
+    return builder.build()
+}

src/commonMain/kotlin/com/infendro/cli/Execution.kt

@@ -0,0 +1,52 @@
+package com.infendro.cli
+
+import com.infendro.cli.argument.Argument.*
+import kotlin.reflect.KProperty
+
+class Execution(
+    val arguments: List<Argument>,
+) {
+    class Argument(
+        val name: String,
+        val value: String?,
+    )
+
+    operator fun <T> Single<T>.getValue(
+        thisRef: Any?,
+        property: KProperty<*>,
+    ): T {
+        return parser.parse(
+            arguments
+                .find { it.name == name }!!
+                .value
+        )
+    }
+
+    operator fun <T> SingleOrElse<T>.getValue(
+        thisRef: Any?,
+        property: KProperty<*>,
+    ): T {
+        return arguments
+            .find { it.name == name }
+            ?.let { parser.parse(it.value) }
+            ?: other
+    }
+
+    operator fun <T> SingleOrNull<T>.getValue(
+        thisRef: Any?,
+        property: KProperty<*>,
+    ): T? {
+        return arguments
+            .find { it.name == name }
+            ?.let { parser.parse(it.value) }
+    }
+
+    operator fun <T> Multiple<T>.getValue(
+        thisRef: Any?,
+        property: KProperty<*>,
+    ): List<T> {
+        return arguments
+            .filter { it.name == name }
+            .map { parser.parse(it.value) }
+    }
+}

src/commonMain/kotlin/com/infendro/cli/Main.kt

@@ -0,0 +1,45 @@
+package com.infendro.cli
+
+import com.infendro.cli.ARG.NAME
+import com.infendro.cli.ARG.B
+import com.infendro.cli.ARG.C
+import com.infendro.cli.ARG.D
+import com.infendro.cli.ARG.E
+import com.infendro.cli.ARG.F
+import com.infendro.cli.argument.*
+
+object ARG {
+    val NAME = stringOrNull("a")
+    val B = stringOrElse("b", "x")
+    val C = ints("c", min = 2, max = 3)
+    val D = strings("d")
+    val E = booleanOrElse("e", true)
+    val F = booleanOrNull("f")
+}
+
+fun main(args: Array<String>) {
+    cli {
+        val G = boolean("g")
+        arguments(NAME, B, C, D, E, F)
+
+        execute {
+            val name by NAME
+            val b by B
+            val c by C
+            val d by D
+            val e by E
+            val f by F
+            val g by G
+
+            println(g)
+        }
+    }.run(
+        arrayOf(
+            "--a=woah",
+            "--c=0",
+            "--c=0",
+//        "--f=false",
+            "--g",
+        )
+    )
+}

src/commonMain/kotlin/com/infendro/cli/Regex.kt

@@ -0,0 +1,7 @@
+package com.infendro.cli
+
+internal object Regex {
+    val COMMAND_NAME = """[a-z]+(?:-[a-z]+)*""".toRegex()
+    val ARGUMENT_NAME = """[a-z]+(?:[\-.][a-z]+)*""".toRegex()
+    val ARGUMENT = """--(?<name>[a-z]+(?:[\-.][a-z]+)*)(?:=(?<value>.*))?""".toRegex()
+}

src/commonMain/kotlin/com/infendro/cli/argument/Argument.kt

@@ -0,0 +1,45 @@
+package com.infendro.cli.argument
+
+sealed class Argument<T> {
+    abstract val name: String
+    abstract val min: Int
+    abstract val max: Int
+
+    abstract class Single<T> : Argument<T>() {
+        final override val min: Int
+            get() = 1
+        final override val max: Int
+            get() = 1
+
+        abstract val parser: Parser<T>
+    }
+
+    abstract class SingleOrElse<T> : Argument<T>() {
+        abstract val other: T
+
+        final override val min: Int
+            get() = 0
+        final override val max: Int
+            get() = 1
+
+        abstract val parser: Parser<T>
+    }
+
+    abstract class SingleOrNull<T> : Argument<T>() {
+        final override val min: Int
+            get() = 0
+        final override val max: Int
+            get() = 1
+
+        abstract val parser: Parser<T>
+    }
+
+    abstract class Multiple<T> : Argument<List<T>>() {
+        override val min: Int
+            get() = 0
+        override val max: Int
+            get() = Int.MAX_VALUE
+
+        abstract val parser: Parser<T>
+    }
+}

src/commonMain/kotlin/com/infendro/cli/argument/Boolean.kt

@@ -0,0 +1,84 @@
+package com.infendro.cli.argument
+
+import com.infendro.cli.Command
+
+private object BooleanParser : Parser<Boolean> {
+    override fun parse(
+        text: String?,
+    ): Boolean {
+        return text == null || text.toBooleanStrict()
+    }
+}
+
+class BooleanArgument(
+    override val name: String,
+) : Argument.Single<Boolean>() {
+    override val parser: Parser<Boolean>
+        get() = BooleanParser
+}
+
+fun boolean(
+    name: String,
+) = BooleanArgument(name)
+
+fun Command.Builder.boolean(
+    name: String,
+) = BooleanArgument(name)
+    .also { argument(it) }
+
+class BooleanOrElseArgument(
+    override val name: String,
+    override val other: Boolean,
+) : Argument.SingleOrElse<Boolean>() {
+    override val parser: Parser<Boolean>
+        get() = BooleanParser
+}
+
+fun booleanOrElse(
+    name: String,
+    other: Boolean,
+) = BooleanOrElseArgument(name, other)
+
+fun Command.Builder.booleanOrElse(
+    name: String,
+    other: Boolean,
+) = BooleanOrElseArgument(name, other)
+    .also { argument(it) }
+
+class BooleanOrNullArgument(
+    override val name: String,
+) : Argument.SingleOrNull<Boolean>() {
+    override val parser: Parser<Boolean>
+        get() = BooleanParser
+}
+
+fun booleanOrNull(
+    name: String,
+) = BooleanOrNullArgument(name)
+
+fun Command.Builder.booleanOrNull(
+    name: String,
+) = BooleanOrNullArgument(name)
+    .also { argument(it) }
+
+class BooleansArgument(
+    override val name: String,
+    override val min: Int = 0,
+    override val max: Int = Int.MAX_VALUE,
+) : Argument.Multiple<Boolean>() {
+    override val parser: Parser<Boolean>
+        get() = BooleanParser
+}
+
+fun booleans(
+    name: String,
+    min: Int = 0,
+    max: Int = Int.MAX_VALUE,
+) = BooleansArgument(name, min, max)
+
+fun Command.Builder.booleans(
+    name: String,
+    min: Int = 0,
+    max: Int = Int.MAX_VALUE,
+) = BooleansArgument(name, min, max)
+    .also { argument(it) }

src/commonMain/kotlin/com/infendro/cli/argument/Int.kt

@@ -0,0 +1,84 @@
+package com.infendro.cli.argument
+
+import com.infendro.cli.Command
+
+private object IntParser : Parser<Int> {
+    override fun parse(
+        text: String?,
+    ): Int {
+        return text!!.toInt()
+    }
+}
+
+class IntArgument(
+    override val name: String,
+) : Argument.Single<Int>() {
+    override val parser: Parser<Int>
+        get() = IntParser
+}
+
+fun int(
+    name: String,
+) = IntArgument(name)
+
+fun Command.Builder.int(
+    name: String,
+) = IntArgument(name)
+    .also { argument(it) }
+
+class IntOrElseArgument(
+    override val name: String,
+    override val other: Int,
+) : Argument.SingleOrElse<Int>() {
+    override val parser: Parser<Int>
+        get() = IntParser
+}
+
+fun intOrElse(
+    name: String,
+    other: Int,
+) = IntOrElseArgument(name, other)
+
+fun Command.Builder.intOrElse(
+    name: String,
+    other: Int,
+) = IntOrElseArgument(name, other)
+    .also { argument(it) }
+
+class IntOrNullArgument(
+    override val name: String,
+) : Argument.SingleOrNull<Int>() {
+    override val parser: Parser<Int>
+        get() = IntParser
+}
+
+fun intOrNull(
+    name: String,
+) = IntOrNullArgument(name)
+
+fun Command.Builder.intOrNull(
+    name: String,
+) = IntOrNullArgument(name)
+    .also { argument(it) }
+
+class IntsArgument(
+    override val name: String,
+    override val min: Int = 0,
+    override val max: Int = Int.MAX_VALUE,
+) : Argument.Multiple<Int>() {
+    override val parser: Parser<Int>
+        get() = IntParser
+}
+
+fun ints(
+    name: String,
+    min: Int = 0,
+    max: Int = Int.MAX_VALUE,
+) = IntsArgument(name, min, max)
+
+fun Command.Builder.ints(
+    name: String,
+    min: Int = 0,
+    max: Int = Int.MAX_VALUE,
+) = IntsArgument(name, min, max)
+    .also { argument(it) }

src/commonMain/kotlin/com/infendro/cli/argument/Parser.kt

@@ -0,0 +1,7 @@
+package com.infendro.cli.argument
+
+interface Parser<T> {
+    fun parse(
+        text: String?,
+    ): T
+}

src/commonMain/kotlin/com/infendro/cli/argument/String.kt

@@ -0,0 +1,84 @@
+package com.infendro.cli.argument
+
+import com.infendro.cli.Command
+
+private object StringParser : Parser<String> {
+    override fun parse(
+        text: String?,
+    ): String {
+        return text!!
+    }
+}
+
+class StringArgument(
+    override val name: String,
+) : Argument.Single<String>() {
+    override val parser: Parser<String>
+        get() = StringParser
+}
+
+fun string(
+    name: String,
+) = StringArgument(name)
+
+fun Command.Builder.string(
+    name: String,
+) = StringArgument(name)
+    .also { argument(it) }
+
+class StringOrElseArgument(
+    override val name: String,
+    override val other: String,
+) : Argument.SingleOrElse<String>() {
+    override val parser: Parser<String>
+        get() = StringParser
+}
+
+fun stringOrElse(
+    name: String,
+    other: String,
+) = StringOrElseArgument(name, other)
+
+fun Command.Builder.stringOrElse(
+    name: String,
+    other: String,
+) = StringOrElseArgument(name, other)
+    .also { argument(it) }
+
+class StringOrNullArgument(
+    override val name: String,
+) : Argument.SingleOrNull<String>() {
+    override val parser: Parser<String>
+        get() = StringParser
+}
+
+fun stringOrNull(
+    name: String,
+) = StringOrNullArgument(name)
+
+fun Command.Builder.stringOrNull(
+    name: String,
+) = StringOrNullArgument(name)
+    .also { argument(it) }
+
+class StringsArgument(
+    override val name: String,
+    override val min: Int = 0,
+    override val max: Int = Int.MAX_VALUE,
+) : Argument.Multiple<String>() {
+    override val parser: Parser<String>
+        get() = StringParser
+}
+
+fun strings(
+    name: String,
+    min: Int = 0,
+    max: Int = Int.MAX_VALUE,
+) = StringsArgument(name, min, max)
+
+fun Command.Builder.strings(
+    name: String,
+    min: Int = 0,
+    max: Int = Int.MAX_VALUE,
+) = StringsArgument(name, min, max)
+    .also { argument(it) }

src/commonMain/kotlin/com/infendro/cli/exception/build/DuplicateArgumentException.kt

@@ -0,0 +1,5 @@
+package com.infendro.cli.exception.build
+
+class DuplicateArgumentException(
+    val argument: String,
+) : Exception()

src/commonMain/kotlin/com/infendro/cli/exception/build/DuplicateCommandException.kt

@@ -0,0 +1,5 @@
+package com.infendro.cli.exception.build
+
+class DuplicateCommandException(
+    val command: String,
+) : Exception()

src/commonMain/kotlin/com/infendro/cli/exception/build/DuplicateExecuteException.kt

@@ -0,0 +1,3 @@
+package com.infendro.cli.exception.build
+
+class DuplicateExecuteException : Exception()

src/commonMain/kotlin/com/infendro/cli/exception/build/IllegalArgumentNameException.kt

@@ -0,0 +1,5 @@
+package com.infendro.cli.exception.build
+
+class IllegalArgumentNameException(
+    val name: String,
+) : Exception()

src/commonMain/kotlin/com/infendro/cli/exception/build/IllegalCommandNameException.kt

@@ -0,0 +1,5 @@
+package com.infendro.cli.exception.build
+
+class IllegalCommandNameException(
+    val name: String,
+) : Exception()

src/commonMain/kotlin/com/infendro/cli/exception/build/NoExecuteException.kt

@@ -0,0 +1,3 @@
+package com.infendro.cli.exception.build
+
+class NoExecuteException : Exception()

src/commonMain/kotlin/com/infendro/cli/exception/run/ArgumentCountException.kt

@@ -0,0 +1,7 @@
+package com.infendro.cli.exception.run
+
+class ArgumentCountException(
+    val argument: String,
+    val min: Int,
+    val max: Int,
+) : Exception()

src/commonMain/kotlin/com/infendro/cli/exception/run/InvalidArgumentException.kt

@@ -0,0 +1,5 @@
+package com.infendro.cli.exception.run
+
+class InvalidArgumentException(
+    val argument: String,
+) : Exception()

src/commonMain/kotlin/com/infendro/cli/exception/run/UnknownArgumentException.kt

@@ -0,0 +1,5 @@
+package com.infendro.cli.exception.run
+
+class UnknownArgumentException(
+    val argument: String,
+) : Exception()

src/commonMain/kotlin/com/infendro/cli/exception/run/UnknownCommandException.kt

@@ -0,0 +1,5 @@
+package com.infendro.cli.exception.run
+
+class UnknownCommandException(
+    val command: String,
+) : Exception()