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

implement optional variable argument/option ranges, refactor exception handling

Browse Source 
adapt required/optional argument handling
implement bounded/unbounded variable argument handling
This commit is contained in:
Infendro
2026-01-06 22:47:21 +01:00
parent 8e491751f5
commit 4e9b358ef8
49 changed files with 315 additions and 231 deletions
Download Patch File Download Diff File Expand all files Collapse all files

73
src/commonMain/kotlin/com/infendro/cli/command/Argument.kt
View File

@@ -1,56 +1,71 @@
package com.infendro.cli.command
import com.infendro.cli.exception.build.InvalidRange
import com.infendro.cli.parser.*
sealed class Argument<T : Any>(
val parser: Parser<T>,
val name: String,
val min: Int,
val max: Int?,
) {
abstract val required: Boolean
init {
when {
min !in 0..count -> throw InvalidRange()
}
}
val required: Boolean
get() = min > 0
val optional: Boolean
get() = !required
val bounded: Boolean
get() = max != null
val unbounded: Boolean
get() = !bounded
val count: Int
get() = max ?: Int.MAX_VALUE
class Required<T : Any>(
parser: Parser<T>,
) : Argument<T>(parser) {
override val required: Boolean
get() = true
fun orElse(other: T) = OrElse(parser, other)
fun orNull() = OrNull(parser)
fun variable() = Variable(parser)
name: String,
) : Argument<T>(parser, name, min = 1, max = 1) {
fun orElse(other: T) = OrElse(parser, name, other)
fun orNull() = OrNull(parser, name)
fun variable(min: Int = 0, max: Int? = null) = Variable(parser, name, min, max)
}
class OrElse<T : Any>(
parser: Parser<T>,
name: String,
val other: T,
) : Argument<T>(parser) {
override val required: Boolean
get() = false
}
) : Argument<T>(parser, name, min = 0, max = 1)
class OrNull<T : Any>(
parser: Parser<T>,
) : Argument<T>(parser) {
override val required: Boolean
get() = false
}
name: String,
) : Argument<T>(parser, name, min = 0, max = 1)
class Variable<T : Any>(
parser: Parser<T>,
) : Argument<T>(parser) {
override val required: Boolean
get() = false
}
name: String,
min: Int,
max: Int?,
) : Argument<T>(parser, name, min, max)
companion object {
fun string() = argument(StringParser)
fun int() = argument(IntParser)
fun long() = argument(LongParser)
fun float() = argument(FloatParser)
fun double() = argument(DoubleParser)
fun boolean() = argument(BooleanParser)
fun string(name: String) = argument(StringParser, name)
fun int(name: String) = argument(IntParser, name)
fun long(name: String) = argument(LongParser, name)
fun float(name: String) = argument(FloatParser, name)
fun double(name: String) = argument(DoubleParser, name)
fun boolean(name: String) = argument(BooleanParser, name)
inline fun <reified T : Enum<T>> enum() = argument(enumParser<T>())
inline fun <reified T : Enum<T>> enum(name: String) = argument(enumParser<T>(), name)
}
}
fun <T : Any> argument(parser: Parser<T>) =
Argument.Required(parser)
fun <T : Any> argument(parser: Parser<T>, name: String) =
Argument.Required(parser, name)

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

@@ -4,31 +4,31 @@ import com.infendro.cli.Dsl
import com.infendro.cli.command.context.Context
import com.infendro.cli.command.context.Parser
import com.infendro.cli.exception.build.*
import com.infendro.cli.exception.run.CliException
import com.infendro.cli.exception.run.RunException
import com.infendro.cli.util.Regex.ARGUMENT
import com.infendro.cli.util.Regex.COMMAND
import com.infendro.cli.util.Regex.OPTION
import kotlin.reflect.KProperty
class Command private constructor(
val name: String?,
val name: String,
val fallback: Boolean,
val commands: List<Command>,
val arguments: List<Argument<*>>,
val options: List<Option<*>>,
internal val execute: Context.() -> Unit,
) {
val fallback: Boolean
get() = name == null
fun run(args: Array<String>) = try {
Parser.parse(this, args).execute()
} catch (e: CliException) {
} catch (e: RunException) {
println(e.message)
}
@Dsl
class Builder internal constructor(
private val level: Int,
private val name: String?,
private val name: String,
private val fallback: Boolean,
) {
private val commands = mutableListOf<Command>()
private val arguments = mutableListOf<Argument<*>>()
@@ -39,35 +39,17 @@ class Command private constructor(
get() = Key(level)
fun command(name: String, block: Builder.() -> Unit) {
// validate
val last = commands.lastOrNull()
when {
last != null && last.fallback -> throw CommandOrderException()
!name.matches(COMMAND) -> throw IllegalCommandNameException(name)
commands.any { it.name == name } -> throw DuplicateCommandException(name)
}
commands += Builder(level + 1, name).also(block).build()
validateCommand(name)
commands += Builder(level + 1, name, fallback = false).apply(block).build()
}
fun fallback(block: Builder.(Key) -> Unit) {
// validate
val last = commands.lastOrNull()
when {
last != null && last.fallback -> throw CommandOrderException()
}
commands += Builder(level + 1, null).also { it.block(it.key) }.build()
fun fallback(name: String, block: Builder.(Key) -> Unit) {
validateCommand(name)
commands += Builder(level + 1, name, fallback = true).apply { block(key) }.build()
}
fun argument(argument: Argument<*>) {
// validate
val last = arguments.lastOrNull()
when {
last is Argument.Variable -> throw ArgumentOrderException()
argument.required && last != null && !last.required -> throw ArgumentOrderException()
}
validateArgument(argument)
arguments += argument
}
@@ -77,14 +59,7 @@ class Command private constructor(
operator fun <T : Argument<*>> T.getValue(thisRef: Nothing?, property: KProperty<*>) = this
fun option(option: Option<*>) {
// validate
for (name in option.names) {
when {
!name.matches(OPTION) -> throw IllegalOptionNameException(name)
options.any { name in it.names } -> throw DuplicateOptionException(name)
}
}
validateOption(option)
options += option
}
@@ -94,23 +69,62 @@ class Command private constructor(
operator fun <T : Option<*>> T.getValue(thisRef: Nothing?, property: KProperty<*>) = this
fun execute(block: Context.() -> Unit) {
if (::_execute.isInitialized)
throw DuplicateExecuteException()
validateExecute()
_execute = block
}
fun build(): Command {
// validate
val last = commands.lastOrNull()
when {
last != null && last.fallback && arguments.isNotEmpty() -> throw InvalidFallbackException()
}
if (!::_execute.isInitialized)
_execute = {}
return Command(name, commands, arguments, options, _execute)
validate()
return Command(name, fallback, commands, arguments, options, _execute)
}
private fun validateCommand(name: String) {
if (commands.isNotEmpty()) {
val last = commands.last()
when {
last.fallback -> throw InvalidCommandOrder()
}
}
when {
!name.matches(COMMAND) -> throw InvalidCommand(name)
commands.any { it.name == name } -> throw DuplicateCommand(name)
}
}
private fun validateArgument(argument: Argument<*>) {
if (arguments.isNotEmpty()) {
val last = arguments.last()
when {
last.unbounded -> throw InvalidArgumentOrder()
argument.required && last.optional -> throw InvalidArgumentOrder()
}
}
when {
!argument.name.matches(ARGUMENT) -> throw InvalidArgument(argument.name)
}
}
private fun validateOption(option: Option<*>) {
for (name in option.names) {
when {
!name.matches(OPTION) -> throw InvalidOption(name)
options.any { name in it.names } -> throw DuplicateOption(name)
}
}
}
private fun validateExecute() {
if (::_execute.isInitialized)
throw DuplicateExecute()
}
private fun validate() {
if (commands.any { it.fallback } && arguments.isNotEmpty()) {
throw InvalidFallback()
}
}
}
@@ -119,5 +133,5 @@ class Command private constructor(
)
}
fun cli(block: Command.Builder.() -> Unit) =
Command.Builder(-1, null).also(block).build()
fun cli(name: String, block: Command.Builder.() -> Unit) =
Command.Builder(-1, name, fallback = false).apply(block).build()

56
src/commonMain/kotlin/com/infendro/cli/command/Option.kt
View File

@@ -1,42 +1,55 @@
package com.infendro.cli.command
import com.infendro.cli.exception.build.MissingOptionNameException
import com.infendro.cli.exception.build.InvalidRange
import com.infendro.cli.exception.build.MissingOptionName
import com.infendro.cli.parser.*
sealed class Option<T : Any>(
val parser: Parser<T>,
val fallback: T?,
val names: List<String>,
val min: Int,
val max: Int?,
) {
val name: String
get() = names.maxBy { it.length }
val flag: Boolean
get() = fallback != null
val name: String
get() = names[0]
val required: Boolean
get() = min > 0
val optional: Boolean
get() = !required
abstract val required: Boolean
val bounded: Boolean
get() = max != null
val unbounded: Boolean
get() = !bounded
val count: Int
get() = max ?: Int.MAX_VALUE
init {
if (names.isEmpty())
throw MissingOptionNameException()
when {
names.isEmpty() -> throw MissingOptionName()
min !in 0..count -> throw InvalidRange()
}
}
class Required<T : Any>(
parser: Parser<T>,
fallback: T?,
names: List<String>,
) : Option<T>(parser, fallback, names) {
) : Option<T>(parser, fallback, names, min = 1, max = 1) {
constructor(
parser: Parser<T>,
names: List<String>,
) : this(parser, null, names)
override val required: Boolean
get() = true
fun orElse(other: T) = OrElse(parser, fallback, names, other)
fun orNull() = OrNull(parser, fallback, names)
fun variable() = Variable(parser, fallback, names)
fun variable(min: Int = 0, max: Int? = null) = Variable(parser, fallback, names, min, max)
}
class OrElse<T : Any>(
@@ -44,43 +57,38 @@ sealed class Option<T : Any>(
fallback: T?,
names: List<String>,
val other: T,
) : Option<T>(parser, fallback, names) {
) : Option<T>(parser, fallback, names, min = 0, max = 1) {
constructor(
parser: Parser<T>,
names: List<String>,
other: T,
) : this(parser, null, names, other)
override val required: Boolean
get() = false
}
class OrNull<T : Any>(
parser: Parser<T>,
fallback: T?,
names: List<String>,
) : Option<T>(parser, fallback, names) {
) : Option<T>(parser, fallback, names, min = 0, max = 1) {
constructor(
parser: Parser<T>,
names: List<String>,
) : this(parser, null, names)
override val required: Boolean
get() = false
}
class Variable<T : Any>(
parser: Parser<T>,
fallback: T?,
names: List<String>,
) : Option<T>(parser, fallback, names) {
min: Int,
max: Int?,
) : Option<T>(parser, fallback, names, min, max) {
constructor(
parser: Parser<T>,
names: List<String>,
) : this(parser, null, names)
override val required: Boolean
get() = false
min: Int,
max: Int?,
) : this(parser, null, names, min, max)
}
companion object {

4
src/commonMain/kotlin/com/infendro/cli/command/context/Context.kt
View File

@@ -31,7 +31,7 @@ class Context internal constructor(
operator fun Command.Key.getValue(thisRef: Any?, property: KProperty<*>): String = commands[index].name
private val <T : Any> Argument<T>.index: Int
get() = command.arguments.indexOf(this)
get() = command.arguments.takeWhile { it != this }.sumOf { it.count }
@Suppress("UNCHECKED_CAST")
private val <T : Any> Argument<T>.value: T?
@@ -39,7 +39,7 @@ class Context internal constructor(
@Suppress("UNCHECKED_CAST")
private val <T : Any> Argument.Variable<T>.values: List<T>
get() = arguments.drop(index).map { it.value as T }
get() = arguments.drop(index).take(count).map { it.value as T }
operator fun <T : Any> Argument.Required<T>.getValue(thisRef: Any?, property: KProperty<*>): T = value!!
operator fun <T : Any> Argument.OrElse<T>.getValue(thisRef: Any?, property: KProperty<*>): T = value ?: other

57
src/commonMain/kotlin/com/infendro/cli/command/context/Parser.kt
View File

@@ -1,8 +1,6 @@
package com.infendro.cli.command.context
import com.infendro.cli.command.Argument
import com.infendro.cli.command.Command
import com.infendro.cli.command.Option
import com.infendro.cli.command.context.Context.*
import com.infendro.cli.exception.run.*
@@ -25,7 +23,7 @@ internal object Parser {
val c = command.commands.firstOrNull { it.name == current || it.fallback }
if (c == null) {
when {
command.arguments.isEmpty() -> throw UnknownCommandException(current)
command.arguments.isEmpty() -> throw UnknownCommand(current)
else -> break
}
}
@@ -39,6 +37,7 @@ internal object Parser {
// arguments and options
var endOfOptions = false
var argumentIndex = 0
var argumentCount = 0
while (i < args.size) {
val dashes = args[i].takeWhile { it == '-' }.count()
val current = args[i].drop(dashes)
@@ -47,13 +46,16 @@ internal object Parser {
// argument
endOfOptions || dashes == 0 -> {
val argument = command.arguments.getOrNull(argumentIndex)
?: throw TooManyArgumentsException()
?: throw UnexpectedArgument()
if (argument !is Argument.Variable)
argumentIndex++
val value = argument.parser.parse(current) as Any
val value = argument.parser.parse(current)
arg += Arg(value)
argumentCount++
if (argumentCount == argument.count) {
argumentCount = 0
argumentIndex++
}
}
// option
@@ -88,12 +90,12 @@ internal object Parser {
for (name in names) {
val option = command.options.firstOrNull { name in it.names }
?: throw UnknownOptionException(name)
?: throw UnknownOption(name)
val value = when {
text != null -> option.parser.parse(text)
option.flag -> option.fallback!!
else -> throw MissingOptionValueException(name)
else -> throw MissingOptionValue(option)
}
opt += Opt(name, value)
}
@@ -104,9 +106,9 @@ internal object Parser {
when {
args[i].contains('=') -> {
val (option) = args[i].split('=', limit = 2)
throw MalformedOptionException(option)
throw MalformedOption(option)
}
else -> throw MalformedOptionException(args[i])
else -> throw MalformedOption(args[i])
}
}
}
@@ -114,17 +116,28 @@ internal object Parser {
i++
}
if (arg.size < command.arguments.count { it is Argument.Required })
throw MissingArgumentException()
for (option in command.options) {
val count = opt.count { it.name in option.names }
when {
option is Option.Required && count == 0 -> throw MissingOptionException(option.name)
option !is Option.Variable && count > 1 -> throw DuplicateOptionException(option.name)
}
}
validateArguments(command, arg)
validateOptions(command, opt)
return Context(command, cmd, opt, arg)
}
private fun validateArguments(command: Command, arg: List<Arg>) {
val required = command.arguments.filter { it.required }
var consumed = 0
for (argument in required) {
val needed = if (argument === required.last()) argument.min else argument.count
val delta = arg.size - consumed
if (delta < needed) throw InvalidArgumentCount(argument, delta)
consumed += needed
}
}
private fun validateOptions(command: Command, opt: List<Opt>) {
for (option in command.options) {
val count = opt.count { it.name in option.names }
if (count !in option.min..option.count) throw InvalidOptionCount(option, count)
}
}
}