refactor argument system
- arguments can have multiple names simultaneously - argument values can be passed using spaces (e.g., --arg value) - single-character arguments can be passed using a single dash (e.g., --a -> -a) - multiple single-character arguments can be combined (e.g., -a -b -> -ab) - simplify custom arguments using generic classes
This commit is contained in:
@@ -1,99 +1,37 @@
|
||||
package com.infendro.cli.command
|
||||
|
||||
import com.infendro.cli.argument.Argument
|
||||
import com.infendro.cli.exception.CliException
|
||||
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<*>>,
|
||||
val name: String?,
|
||||
val commands: List<Command>,
|
||||
val arguments: List<Argument<*>>,
|
||||
private val block: Execution.() -> Unit,
|
||||
) {
|
||||
private val nextIndex: Int
|
||||
get() = index + 1
|
||||
|
||||
fun run(
|
||||
args: Array<String>,
|
||||
) {
|
||||
fun run(args: Array<String>) = try {
|
||||
val index = args.withIndex()
|
||||
.find { (_, value) -> value.startsWith("--") }
|
||||
.firstOrNull { (_, 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)
|
||||
var command = this
|
||||
for (c in cmd) {
|
||||
command = command.commands.firstOrNull { it.name == c || it.name == null }
|
||||
?: throw UnknownCommandException(c)
|
||||
}
|
||||
|
||||
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
|
||||
val execution = Execution.from(command, cmd, arg)
|
||||
val execute = command.block
|
||||
execution.execute()
|
||||
} catch (e: CliException) {
|
||||
println(e.message)
|
||||
}
|
||||
|
||||
class Builder internal constructor(
|
||||
@@ -107,46 +45,37 @@ class Command private constructor(
|
||||
private val nextIndex: Int
|
||||
get() = index + 1
|
||||
|
||||
fun command(
|
||||
name: String? = null,
|
||||
block: Builder.(Key) -> Unit,
|
||||
) {
|
||||
if (name != null && !COMMAND_NAME.matches(name))
|
||||
fun command(name: String? = null, block: Builder.(Key) -> Unit) {
|
||||
if (name != null && !name.matches(COMMAND_NAME))
|
||||
throw IllegalCommandNameException(name)
|
||||
|
||||
if (commands.any { it.name == name })
|
||||
throw DuplicateCommandException(name)
|
||||
|
||||
val builder = Builder(nextIndex, name)
|
||||
builder.block(Key(nextIndex))
|
||||
val key = Key(nextIndex)
|
||||
builder.block(key)
|
||||
val command = builder.build()
|
||||
|
||||
commands.add(command)
|
||||
}
|
||||
|
||||
fun argument(
|
||||
argument: Argument<*>,
|
||||
) {
|
||||
if (!ARGUMENT_NAME.matches(argument.name))
|
||||
throw IllegalArgumentNameException(argument.name)
|
||||
fun argument(argument: Argument<*>) {
|
||||
for (name in argument.names) {
|
||||
if (!name.matches(ARGUMENT_NAME))
|
||||
throw IllegalArgumentNameException(name)
|
||||
|
||||
if (arguments.any { it.name == argument.name })
|
||||
throw DuplicateArgumentException(argument.name)
|
||||
if (arguments.any { name in it.names })
|
||||
throw DuplicateArgumentException(name)
|
||||
}
|
||||
|
||||
arguments.add(argument)
|
||||
}
|
||||
|
||||
fun arguments(
|
||||
vararg arguments: Argument<*>,
|
||||
) {
|
||||
for (argument in arguments) {
|
||||
argument(argument)
|
||||
}
|
||||
}
|
||||
fun arguments(vararg arguments: Argument<*>) =
|
||||
arguments.forEach(::argument)
|
||||
|
||||
fun execute(
|
||||
block: Execution.() -> Unit,
|
||||
) {
|
||||
fun execute(block: Execution.() -> Unit) {
|
||||
if (this::block.isInitialized)
|
||||
throw DuplicateExecuteException()
|
||||
|
||||
@@ -157,7 +86,7 @@ class Command private constructor(
|
||||
if (!this::block.isInitialized)
|
||||
throw NoExecuteException()
|
||||
|
||||
return Command(index, name, commands, arguments, block)
|
||||
return Command(name, commands, arguments, block)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,20 +1,92 @@
|
||||
package com.infendro.cli.command
|
||||
|
||||
import com.infendro.cli.argument.Argument
|
||||
import com.infendro.cli.exception.run.DuplicateArgumentException
|
||||
import com.infendro.cli.exception.run.MalformedArgumentException
|
||||
import com.infendro.cli.exception.run.MissingArgumentException
|
||||
import com.infendro.cli.exception.run.UnknownArgumentException
|
||||
import kotlin.reflect.KProperty
|
||||
|
||||
class Execution(
|
||||
class Execution private constructor(
|
||||
val commands: List<Cmd>,
|
||||
val arguments: List<Arg>,
|
||||
) {
|
||||
companion object {
|
||||
fun from(
|
||||
command: Command,
|
||||
cmd: List<String>,
|
||||
arg: List<String>,
|
||||
): Execution {
|
||||
val commands = Cmd.from(cmd)
|
||||
val arguments = Arg.from(command, arg)
|
||||
return Execution(commands, arguments)
|
||||
}
|
||||
}
|
||||
|
||||
class Cmd(
|
||||
val name: String,
|
||||
)
|
||||
) {
|
||||
companion object {
|
||||
fun from(cmd: List<String>): List<Cmd> = cmd.map { Cmd(it) }
|
||||
}
|
||||
}
|
||||
|
||||
class Arg(
|
||||
val name: String,
|
||||
val value: String?,
|
||||
)
|
||||
) {
|
||||
companion object {
|
||||
fun from(command: Command, arg: List<String>): List<Arg> = buildList {
|
||||
var i = 0
|
||||
while (i < arg.size) {
|
||||
val dashes = arg[i].takeWhile { it == '-' }.count()
|
||||
val trimmed = arg[i].substring(dashes)
|
||||
|
||||
if (dashes !in 1..2 || trimmed.isEmpty())
|
||||
throw MalformedArgumentException(arg[i])
|
||||
|
||||
val (name, value) = when {
|
||||
trimmed.contains('=') -> {
|
||||
val (name, value) = trimmed.split('=', limit = 2)
|
||||
name to value
|
||||
}
|
||||
|
||||
else -> {
|
||||
val next = arg.getOrNull(i + 1)
|
||||
if (next != null && !next.startsWith('-')) {
|
||||
i++
|
||||
trimmed to next
|
||||
} else {
|
||||
trimmed to null
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
val names = when {
|
||||
dashes == 1 -> name.map { "$it" }
|
||||
else -> listOf(name)
|
||||
}
|
||||
|
||||
for (name in names) {
|
||||
if (command.arguments.none { name in it.names })
|
||||
throw UnknownArgumentException(name)
|
||||
|
||||
//TODO parse early
|
||||
add(Arg(name, value))
|
||||
}
|
||||
i++
|
||||
}
|
||||
|
||||
for (argument in command.arguments) {
|
||||
val count = count { it.name in argument.names }
|
||||
when {
|
||||
argument.required && count == 0 -> throw MissingArgumentException(argument.name)
|
||||
count > 1 -> throw DuplicateArgumentException(argument.name)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
operator fun Command.Key.getValue(
|
||||
thisRef: Any?,
|
||||
@@ -24,24 +96,18 @@ class Execution(
|
||||
operator fun <T> Argument.Single<T>.getValue(
|
||||
thisRef: Any?,
|
||||
property: KProperty<*>,
|
||||
): T = arguments.single { it.name == name }
|
||||
): T = arguments.single { it.name in names }
|
||||
.let { parser.parse(it.value) }
|
||||
|
||||
operator fun <T> Argument.SingleOrElse<T>.getValue(
|
||||
thisRef: Any?,
|
||||
property: KProperty<*>,
|
||||
): T = arguments.singleOrNull { it.name == name }
|
||||
): T = arguments.singleOrNull { it.name in names }
|
||||
?.let { parser.parse(it.value) } ?: other
|
||||
|
||||
operator fun <T> Argument.SingleOrNull<T>.getValue(
|
||||
thisRef: Any?,
|
||||
property: KProperty<*>,
|
||||
): T? = arguments.singleOrNull { it.name == name }
|
||||
): T? = arguments.singleOrNull { it.name in names }
|
||||
?.let { parser.parse(it.value) }
|
||||
|
||||
operator fun <T> Argument.Multiple<T>.getValue(
|
||||
thisRef: Any?,
|
||||
property: KProperty<*>,
|
||||
): List<T> = arguments.filter { it.name == name }
|
||||
.map { parser.parse(it.value) }
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user