Infendro/cli.kt
1
0
Fork 0
Code Issues Pull Requests Actions Packages Wiki Activity

improve command handling, change argument/option registration

Browse Source
This commit is contained in:
Infendro
2026-01-08 18:53:54 +01:00
parent 2a9f086c9d
commit 6aa6c1b3c8
9 changed files with 123 additions and 117 deletions
Download Patch File Download Diff File Expand all files Collapse all files

112
src/commonMain/kotlin/com/infendro/cli/command/Command.kt
View File

@@ -8,12 +8,10 @@ import com.infendro.cli.command.help.DefaultHelpRenderer
import com.infendro.cli.command.help.HelpRenderer
import com.infendro.cli.command.option.Option
import com.infendro.cli.error.build.*
import com.infendro.cli.parser.*
import com.infendro.cli.parser.Parser
import com.infendro.cli.util.Regex
import kotlin.reflect.KProperty
sealed class Command private constructor(
val parent: Command?,
val name: String,
val commands: List<Command>,
val arguments: List<Argument<*>>,
@@ -21,22 +19,21 @@ sealed class Command private constructor(
internal val execute: Context.() -> Unit,
internal val renderer: HelpRenderer,
) {
val path: List<Command>
get() = when {
parent == null -> listOf(this)
else -> parent.path + this
}
val help: String?
get() = renderer.render(this)
init {
if (!name.matches(Regex.COMMAND)) throw InvalidCommand(name)
}
fun run(args: Array<String>) {
when (val result = ContextParser(this, args).parse()) {
is ContextParser.Result.Success -> result.context.execute()
is ContextParser.Result.Help -> result.command.help?.let { print(it) }
is ContextParser.Result.Help -> {
val command = result.path.last()
command.renderer.render(result.path)?.let { print(it) }
}
is ContextParser.Result.Failure -> {
println("error: ${result.error.message}")
result.command.help?.let {
val command = result.path.last()
command.renderer.render(result.path)?.let {
println()
print(it)
}
@@ -45,24 +42,22 @@ sealed class Command private constructor(
}
class Named(
parent: Command?,
name: String,
commands: List<Command>,
arguments: List<Argument<*>>,
options: List<Option<*>>,
execute: Context.() -> Unit,
renderer: HelpRenderer,
) : Command(parent, name, commands, arguments, options, execute, renderer) {
) : Command(name, commands, arguments, options, execute, renderer) {
class Builder(
name: String,
) : Command.Builder<Named>(name) {
override fun create() =
Named(parent, name, commands, arguments, options, execute, renderer)
Named(name, commands, arguments, options, execute, renderer)
}
}
class Fallback<T : Any>(
parent: Command?,
val key: Key<T>,
val parser: Parser<T>,
name: String,
@@ -71,7 +66,7 @@ sealed class Command private constructor(
options: List<Option<*>>,
execute: Context.() -> Unit,
renderer: HelpRenderer,
) : Command(parent, name, commands, arguments, options, execute, renderer) {
) : Command(name, commands, arguments, options, execute, renderer) {
class Builder<T : Any>(
val parser: Parser<T>,
name: String,
@@ -79,7 +74,7 @@ sealed class Command private constructor(
internal val key = Key<T>()
override fun create() =
Fallback(parent, key, parser, name, commands, arguments, options, execute, renderer)
Fallback(key, parser, name, commands, arguments, options, execute, renderer)
}
class Key<T>
@@ -89,8 +84,6 @@ sealed class Command private constructor(
sealed class Builder<COMMAND : Command>(
protected val name: String,
) {
protected var parent: Command? = null
private val builders = mutableListOf<Builder<*>>()
protected val commands = mutableListOf<Command>()
protected val arguments = mutableListOf<Argument<*>>()
protected val options = mutableListOf<Option<*>>()
@@ -102,40 +95,13 @@ sealed class Command private constructor(
protected val renderer: HelpRenderer
get() = _renderer!!
fun command(name: String, block: Builder<*>.() -> Unit) {
validateCommand(name)
builders += Named.Builder(name).apply(block)
fun register(command: Command) {
validateCommand(command)
commands += command
}
inner class FallbackFactory {
fun string(name: String, block: Builder<*>.(Fallback.Key<String>) -> Unit) =
fallback(StringParser, name, block)
fun int(name: String, block: Builder<*>.(Fallback.Key<Int>) -> Unit) =
fallback(IntParser, name, block)
fun long(name: String, block: Builder<*>.(Fallback.Key<Long>) -> Unit) =
fallback(LongParser, name, block)
fun float(name: String, block: Builder<*>.(Fallback.Key<Float>) -> Unit) =
fallback(FloatParser, name, block)
fun double(name: String, block: Builder<*>.(Fallback.Key<Double>) -> Unit) =
fallback(DoubleParser, name, block)
fun boolean(name: String, block: Builder<*>.(Fallback.Key<Boolean>) -> Unit) =
fallback(BooleanParser, name, block)
inline fun <reified T : Enum<T>> enum(name: String, noinline block: Builder<*>.(Fallback.Key<T>) -> Unit) =
fallback(enumParser<T>(), name, block)
}
val fallback = FallbackFactory()
fun <T : Any> fallback(parser: Parser<T>, name: String, block: Fallback.Builder<T>.(Fallback.Key<T>) -> Unit) {
validateCommand(name)
builders += Fallback.Builder(parser, name).apply { block(key) }
}
fun register(vararg commands: Command) = commands.forEach(::register)
operator fun <T : Command> T.unaryPlus() = also(::register)
fun register(argument: Argument<*>) {
validateArgument(argument)
@@ -143,9 +109,7 @@ sealed class Command private constructor(
}
fun register(vararg arguments: Argument<*>) = arguments.forEach(::register)
operator fun <T : Argument<*>> T.provideDelegate(thisRef: Nothing?, property: KProperty<*>) = also(::register)
operator fun <T : Argument<*>> T.getValue(thisRef: Nothing?, property: KProperty<*>) = this
operator fun <T : Argument<*>> T.unaryPlus() = also(::register)
fun register(option: Option<*>) {
validateOption(option)
@@ -153,9 +117,7 @@ sealed class Command private constructor(
}
fun register(vararg options: Option<*>) = options.forEach(::register)
operator fun <T : Option<*>> T.provideDelegate(thisRef: Nothing?, property: KProperty<*>) = also(::register)
operator fun <T : Option<*>> T.getValue(thisRef: Nothing?, property: KProperty<*>) = this
operator fun <T : Option<*>> T.unaryPlus() = also(::register)
fun execute(block: Context.() -> Unit) {
validateExecute()
@@ -167,32 +129,22 @@ sealed class Command private constructor(
_renderer = renderer
}
internal abstract fun create(): COMMAND
internal fun build(): Command {
if (_execute == null) _execute = {}
if (_renderer == null) _renderer = DefaultHelpRenderer
validate()
val command = create()
for (builder in builders) {
builder.parent = command
commands += builder.build()
}
return command
return create()
}
internal abstract fun create(): COMMAND
private fun validateCommand(name: String) {
if (builders.isNotEmpty()) {
val last = builders.last()
if (last is Fallback.Builder<*>) throw InvalidCommandOrder()
}
when {
!name.matches(Regex.COMMAND) -> throw InvalidCommand(name)
builders.any { it.name == name } -> throw DuplicateCommand(name)
private fun validateCommand(command: Command) {
if (commands.isNotEmpty()) {
val last = commands.last()
if (last is Fallback<*>) throw InvalidCommandOrder()
}
if (commands.any { it.name == command.name }) throw DuplicateCommand(command.name)
}
private fun validateArgument(argument: Argument<*>) {
@@ -203,6 +155,7 @@ sealed class Command private constructor(
argument.required && last.optional -> throw InvalidArgumentOrder()
}
}
if (arguments.any { it.name == argument.name }) throw DuplicateArgument(argument.name)
}
private fun validateOption(option: Option<*>) {
@@ -220,10 +173,7 @@ sealed class Command private constructor(
}
private fun validate() {
if (builders.any { it is Fallback.Builder<*> } && arguments.isNotEmpty()) throw InvalidFallback()
if (commands.any { it is Fallback<*> } && arguments.isNotEmpty()) throw InvalidFallback()
}
}
}
fun cli(name: String, block: Command.Builder<*>.() -> Unit) =
Command.Named.Builder(name).apply(block).build()