Umstellung auf Kotlin Multiplatform
This commit is contained in:
Hartmut Bauer committed
1 parent
1ee8dd356f
commit
4a73301eb3
35 files changed
+246
-47
No files matched your search
@@ -0,0 +1,669 @@
|
||||
package net.keinekekse.args.v1
|
||||
|
||||
import net.keinekekse.args.v1.AbstractCommandLineParser.Companion.NAME_PATTERN
|
||||
import net.keinekekse.args.v1.AbstractCommandLineParser.Companion.SHORT_NAME_PATTERN
|
||||
import net.keinekekse.util.ValueDelegate
|
||||
import kotlin.system.exitProcess
|
||||
|
||||
class ArgumentParserException(message: String) : RuntimeException(message) {
|
||||
companion object {
|
||||
const val ERROR_MSG = "\n*** ERROR parsing arguments: %s\n"
|
||||
fun optionExists(name: String) = ArgumentParserException("Option '$name' already exists.")
|
||||
fun commandExists(name: String) =
|
||||
ArgumentParserException("Command or alias '$name' already exists.")
|
||||
|
||||
fun unknownOption(name: String) = ArgumentParserException("Unknown option '$name'.")
|
||||
fun unknownCommand(name: String) = ArgumentParserException("Unknown command '$name'.")
|
||||
fun optionRequiresValue(name: String) =
|
||||
ArgumentParserException("Option '$name' requires a value.")
|
||||
|
||||
fun optionNoValue(name: String) =
|
||||
ArgumentParserException("Option '$name' does not accept a value.")
|
||||
|
||||
fun optionRequired(name: String) = ArgumentParserException("Option '$name' is required.")
|
||||
fun commandRequired() = ArgumentParserException("At least on command is required.")
|
||||
fun invalidLongValue(value: String) =
|
||||
ArgumentParserException("Value '$value' is not a long integer.")
|
||||
|
||||
fun invalidShortName(name: String) =
|
||||
ArgumentParserException("Option short name '$name' is invalid.")
|
||||
|
||||
fun invalidName(name: String) = ArgumentParserException("Option name '$name' is invalid.")
|
||||
fun invalidCommand(name: String) =
|
||||
ArgumentParserException("Command name '$name' is invalid.")
|
||||
|
||||
fun noMoreOptions() = ArgumentParserException("Options can't be added after parsing.")
|
||||
fun noMoreParsing() = ArgumentParserException("Arguments have already been parsed.")
|
||||
}
|
||||
}
|
||||
|
||||
class ParameterValue : ValueDelegate<List<String>> {
|
||||
override var value: List<String>? = null
|
||||
}
|
||||
|
||||
class OptionValue<T> : ValueDelegate<T> {
|
||||
override var value: T? = null
|
||||
fun isEmpty() = value == null
|
||||
}
|
||||
|
||||
data class OptionConfig(
|
||||
val name: String,
|
||||
val shortName: Char? = null,
|
||||
val description: String,
|
||||
val required: Boolean = false,
|
||||
)
|
||||
|
||||
interface OptionConverter<T> {
|
||||
fun convert(value: String): T
|
||||
}
|
||||
|
||||
sealed class OptionType<T>(
|
||||
val converter: OptionConverter<T>,
|
||||
val hasParameter: Boolean = true,
|
||||
) {
|
||||
companion object {
|
||||
private class StringConverter : OptionConverter<String> {
|
||||
override fun convert(value: String) = value
|
||||
}
|
||||
|
||||
private class LongConverter : OptionConverter<Long> {
|
||||
override fun convert(value: String) = value.toLongOrNull()
|
||||
?: throw ArgumentParserException.invalidLongValue(value)
|
||||
}
|
||||
|
||||
private class BooleanConverter : OptionConverter<Boolean> {
|
||||
override fun convert(value: String) = value == "true"
|
||||
}
|
||||
}
|
||||
|
||||
open fun createOption(config: OptionConfig): Option<T> = Option(config, this)
|
||||
fun convertAndSet(value: String, opt: Option<T>) {
|
||||
opt.setValue(converter.convert(value))
|
||||
}
|
||||
|
||||
object STRING : OptionType<String>(StringConverter())
|
||||
object LONG : OptionType<Long>(LongConverter())
|
||||
object BOOLEAN : OptionType<Boolean>(BooleanConverter(), hasParameter = false) {
|
||||
override fun createOption(config: OptionConfig): Option<Boolean> {
|
||||
return super.createOption(config).apply { setValue(false) }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
data class Option<T>(
|
||||
val config: OptionConfig,
|
||||
val type: OptionType<T>,
|
||||
) {
|
||||
val optionValue = OptionValue<T>()
|
||||
|
||||
fun setValue(value: T) {
|
||||
optionValue.value = value
|
||||
}
|
||||
|
||||
fun isEmpty() = optionValue.isEmpty()
|
||||
}
|
||||
|
||||
interface AddOptions {
|
||||
val options: List<Option<Any>>
|
||||
fun stringOption(config: OptionConfig): OptionValue<String>
|
||||
fun longOption(config: OptionConfig): OptionValue<Long>
|
||||
fun boolOption(config: OptionConfig): OptionValue<Boolean>
|
||||
fun <T> createOption(config: OptionConfig, type: OptionType<T>): OptionValue<T>
|
||||
}
|
||||
|
||||
/**
|
||||
* Represents a command in a command-line interface that can have options and aliases.
|
||||
*
|
||||
* A `Command` is identified by its name and can optionally have a description and alternative names (aliases).
|
||||
* It also supports adding and managing options that customize its behavior.
|
||||
*
|
||||
* @property name The unique name of the command.
|
||||
* @property description A brief description explaining the purpose of the command.
|
||||
* @property aliases A list of alternative names (aliases) that can also invoke the command.
|
||||
*
|
||||
* @constructor Creates a new `Command` instance with the specified name, description, and optional aliases.
|
||||
*/
|
||||
class Command(
|
||||
val name: String,
|
||||
val description: String,
|
||||
val aliases: List<String> = emptyList<String>(),
|
||||
) : AddOptions {
|
||||
override val options = mutableListOf<Option<Any>>()
|
||||
var isSet = false
|
||||
internal set
|
||||
|
||||
/**
|
||||
* Adds a string-based option to the command configuration.
|
||||
*
|
||||
* This method creates a command-line option that accepts a string value, based on the provided
|
||||
* configuration. The configuration includes details such as the option's name, description,
|
||||
* and whether it is required.
|
||||
*
|
||||
* @param config the configuration object containing details about the string option to be created
|
||||
* @return an `OptionValue` instance representing the value of the string option
|
||||
*/
|
||||
override fun stringOption(config: OptionConfig): OptionValue<String> =
|
||||
createOption(config, OptionType.STRING)
|
||||
|
||||
/**
|
||||
* Creates a command-line option that accepts a `Long` value based on the provided configuration.
|
||||
*
|
||||
* This method utilizes the specified configuration to define details such as the option's name,
|
||||
* description, and whether it is required. It then generates an option that expects a `Long` value.
|
||||
*
|
||||
* @param config the configuration object containing details about the long option to be created
|
||||
* @return an `OptionValue<Long>` instance representing the value of the long option
|
||||
*/
|
||||
override fun longOption(config: OptionConfig): OptionValue<Long> =
|
||||
createOption(config, OptionType.LONG)
|
||||
|
||||
/**
|
||||
* Creates a command-line option that accepts a Boolean value based on the provided configuration.
|
||||
*
|
||||
* This method uses the specified configuration to define details such as the option's name,
|
||||
* description, and whether it is required. The resulting option accepts a Boolean value, with
|
||||
* `false` being the default if the option is not explicitly provided in the command-line arguments.
|
||||
*
|
||||
* @param config the configuration object containing details about the Boolean option to be created
|
||||
* @return an `OptionValue<Boolean>` instance representing the value of the Boolean option
|
||||
*/
|
||||
override fun boolOption(config: OptionConfig): OptionValue<Boolean> =
|
||||
createOption(
|
||||
config.copy(required = false),
|
||||
OptionType.BOOLEAN
|
||||
)
|
||||
|
||||
override fun <T> createOption(
|
||||
config: OptionConfig,
|
||||
type: OptionType<T>,
|
||||
): OptionValue<T> {
|
||||
DefaultOptionValidator.validateOption(config, options)
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
return type.createOption(config).also { options.add(it as Option<Any>) }.optionValue
|
||||
}
|
||||
|
||||
override operator fun equals(other: Any?): Boolean {
|
||||
if (other is String) {
|
||||
return name == other || aliases.contains(other)
|
||||
}
|
||||
return super.equals(other)
|
||||
}
|
||||
|
||||
override fun hashCode(): Int {
|
||||
var result = isSet.hashCode()
|
||||
result = 31 * result + name.hashCode()
|
||||
result = 31 * result + description.hashCode()
|
||||
result = 31 * result + aliases.hashCode()
|
||||
result = 31 * result + options.hashCode()
|
||||
return result
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
class CommandList(commands: MutableList<Command> = mutableListOf<Command>()) :
|
||||
MutableList<Command> by commands {
|
||||
operator fun contains(name: String) = this.any { it.equals(name) }
|
||||
operator fun get(name: String) =
|
||||
this.find { it.equals(name) } ?: throw ArgumentParserException.unknownCommand(name)
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses and handles command-line arguments for commands and their associated options.
|
||||
*
|
||||
* The `CommandCommandLineParser` is a specialized parser designed to handle top-level commands,
|
||||
* each potentially with its own set of options and arguments. It extends `AbstractCommandLineParser`
|
||||
* to incorporate functionality for parsing commands alongside their arguments and options.
|
||||
*
|
||||
* Example:
|
||||
* ```
|
||||
* val arguments = CommandCommandLineParser("some info text")
|
||||
*
|
||||
* val cmdImport = arguments.addCommand("import", "description", listOf("imp", "in"))
|
||||
* val auto by cmdImport.boolOption(OptionConfig("auto",'a',"description",false))
|
||||
*
|
||||
* // more option & commands ...
|
||||
*
|
||||
* val files by arguments.parametersList()
|
||||
* arguments.parse(args)
|
||||
*
|
||||
* when {
|
||||
* cmdImport.isSet -> {
|
||||
*
|
||||
* ```
|
||||
*
|
||||
* @constructor accepts a help string that is used to display usage instructions, adding context
|
||||
* for the users of the command-line tool.
|
||||
* @param helpString A message string to display as guidance for the tool usage.
|
||||
*/
|
||||
class CommandCommandLineParser(private val helpString: String) :
|
||||
AbstractCommandLineParser(helpString) {
|
||||
private val commands = CommandList()
|
||||
|
||||
/**
|
||||
* Holds the currently active command after the command-line arguments are parsed.
|
||||
*
|
||||
* This variable is updated when a valid command is identified and processed by the parser.
|
||||
* If no valid command is found during parsing, it remains null.
|
||||
* This property is read-only externally and can only be set internally by the parser.
|
||||
*/
|
||||
var command: Command? = null
|
||||
private set
|
||||
|
||||
override val helpFormatter = CommandHelpFormatter(commands, helpString)
|
||||
|
||||
init {
|
||||
addCommand("help", "Display this help message.")
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds a new command with the specified name, description, and optional aliases.
|
||||
*
|
||||
* This method registers a command to the parser, allowing it to be identified by its name or aliases.
|
||||
* Throws an exception if commands cannot be added or if the name or aliases conflict with existing commands.
|
||||
*
|
||||
* @param name The unique name of the command to be added.
|
||||
* @param description A brief description of the command.
|
||||
* @param aliases An optional list of alternative names (aliases) for the command. Defaults to an empty list.
|
||||
* @return A `Command` instance that can be used to add option for this command.
|
||||
*/
|
||||
fun addCommand(name: String, description: String, aliases: List<String> = emptyList()) =
|
||||
try {
|
||||
if (isParsed) throw ArgumentParserException.noMoreOptions()
|
||||
if (commands.contains(name) || aliases.any { commands.contains(it) })
|
||||
throw ArgumentParserException.commandExists(name)
|
||||
Command(name, description, aliases).also { commands.add(it) }
|
||||
} catch (e: ArgumentParserException) {
|
||||
handleParsingError(e)
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses an array of command-line arguments and validates the command and its options.
|
||||
*
|
||||
* The method processes the first argument as the command and checks whether it is valid.
|
||||
* If the command is recognized and exists within the predefined set of allowed commands,
|
||||
* its associated options are then parsed. If an error occurs during parsing, appropriate
|
||||
* error handling is invoked.
|
||||
*
|
||||
* @param args The array of command-line arguments to be parsed. The first element is treated
|
||||
* as the primary command, and the rest are interpreted as its options.
|
||||
*/
|
||||
override fun parse(args: Array<String>) {
|
||||
if (args.isEmpty()) {
|
||||
handleParsingError(ArgumentParserException.commandRequired())
|
||||
}
|
||||
val cmd = args[0]
|
||||
if (!argumentParser.parseCommand(cmd)) {
|
||||
handleParsingError(ArgumentParserException.invalidCommand(cmd))
|
||||
}
|
||||
if (cmd !in commands) {
|
||||
handleParsingError(ArgumentParserException.unknownCommand(cmd))
|
||||
} else {
|
||||
parseArguments(args.drop(1).toTypedArray(), commands[cmd].options)
|
||||
commands[cmd].isSet = true
|
||||
command = commands[cmd]
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* A command-line parser specifically designed to parse and manage options provided
|
||||
* via command-line arguments. It extends the `AbstractCommandLineParser` and implements
|
||||
* the `AddOptions` interface.
|
||||
*
|
||||
* This parser supports different types of options including string, long, and boolean,
|
||||
* and ensures validation during the parsing process. It also auto-registers a help option
|
||||
* to display the usage of the parser.
|
||||
*
|
||||
* Example:
|
||||
* ```
|
||||
* val arguments = OptionCommandLineParser("some info text")
|
||||
* val author by arguments.stringOption(OptionConfig("author", 'a', "some author", true))
|
||||
*
|
||||
* // more options ...
|
||||
*
|
||||
* val files by arguments.parametersList()
|
||||
* arguments.parse(args)
|
||||
*
|
||||
* if (author != null) {
|
||||
*```
|
||||
*
|
||||
* @constructor Creates an `OptionCommandLineParser` with a custom help string.
|
||||
* @param helpString Descriptive text that is displayed when the help option is invoked.
|
||||
*/
|
||||
class OptionCommandLineParser(private val helpString: String) :
|
||||
AbstractCommandLineParser(helpString), AddOptions {
|
||||
override val options = mutableListOf<Option<Any>>()
|
||||
|
||||
override val helpFormatter = OptionHelpFormatter(options, helpString)
|
||||
|
||||
init {
|
||||
boolOption(OptionConfig("help", 'h', "Display this help message"))
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates and registers a string-based command-line option based on the provided configuration.
|
||||
*
|
||||
* @param config The configuration object containing the name, short name, description,
|
||||
* and requirements for the string option.
|
||||
* @return An instance of OptionValue that delegates access to the parsed value of the option.
|
||||
*/
|
||||
override fun stringOption(config: OptionConfig): OptionValue<String> =
|
||||
createOption(config, OptionType.STRING)
|
||||
|
||||
/**
|
||||
* Creates and registers a command-line option that parses and returns a `Long` value.
|
||||
*
|
||||
* @param config The configuration object containing the name, short name, description,
|
||||
* and requirements for the long option.
|
||||
* @return An instance of `OptionValue<Long>` that provides access to the parsed value
|
||||
* of the long option.
|
||||
*/
|
||||
override fun longOption(config: OptionConfig): OptionValue<Long> =
|
||||
createOption(config, OptionType.LONG)
|
||||
|
||||
/**
|
||||
* Creates and registers a command-line option that parses and returns a `Boolean` value.
|
||||
*
|
||||
* @param config The configuration object containing the name, short name, description,
|
||||
* and requirements for the boolean option.
|
||||
* @return An instance of `OptionValue<Boolean>` that provides access to the parsed value
|
||||
* of the boolean option.
|
||||
*/
|
||||
override fun boolOption(config: OptionConfig): OptionValue<Boolean> =
|
||||
createOption(
|
||||
config.copy(required = false),
|
||||
OptionType.BOOLEAN
|
||||
)
|
||||
|
||||
override fun <T> createOption(
|
||||
config: OptionConfig,
|
||||
type: OptionType<T>,
|
||||
): OptionValue<T> {
|
||||
try {
|
||||
if (isParsed) throw ArgumentParserException.noMoreOptions()
|
||||
DefaultOptionValidator.validateOption(config, options)
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
return type.createOption(config).also { options.add(it as Option<Any>) }.optionValue
|
||||
} catch (e: ArgumentParserException) {
|
||||
handleParsingError(e)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses the provided array of command-line arguments.
|
||||
*
|
||||
* This method processes the input arguments, identifies the options and parameters
|
||||
* based on the argument parser's configuration, and validates the required options.
|
||||
* If the arguments have already been parsed, it raises an exception.
|
||||
* In case of errors during parsing or validation, an error message is displayed
|
||||
* and the help information is shown.
|
||||
*
|
||||
* @param args The array of command-line arguments to be parsed.
|
||||
*/
|
||||
override fun parse(args: Array<String>) {
|
||||
parseArguments(args, options)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
abstract class AbstractCommandLineParser(private val helpString: String) {
|
||||
|
||||
private val parameters = ParameterValue()
|
||||
protected var isParsed = false
|
||||
protected val argumentParser: ArgumentParser = DefaultArgumentParser()
|
||||
protected abstract val helpFormatter: HelpFormatter
|
||||
|
||||
companion object {
|
||||
const val NAME = """[a-zA-Z][\w-]+"""
|
||||
const val SHORT_NAME = """[a-zA-Z]"""
|
||||
val ARGUMENT_PATTERN = """^(?:-(${SHORT_NAME})|--(${NAME}))(?:=(.+)|$)$""".toRegex()
|
||||
val NAME_PATTERN = """^${NAME}$""".toRegex()
|
||||
val SHORT_NAME_PATTERN = """^${SHORT_NAME}$""".toRegex()
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the list of parameters provided to the argument parser.
|
||||
*
|
||||
* The parameters are parsed from the command-line input following the provided argument options.
|
||||
* This method allows accessing any additional parameters that are not directly associated with
|
||||
* the defined options.
|
||||
*
|
||||
* @return A list of strings representing the positional parameters passed after all options.
|
||||
*/
|
||||
fun parametersList() = parameters
|
||||
|
||||
abstract fun parse(args: Array<String>)
|
||||
|
||||
protected fun parseArguments(args: Array<String>, options: MutableList<Option<Any>>) {
|
||||
if (isParsed) throw ArgumentParserException.noMoreParsing()
|
||||
try {
|
||||
argumentParser.parseArguments(args, options, parameters)
|
||||
isParsed = true
|
||||
DefaultOptionValidator.validateRequiredOptions(options)
|
||||
handleHelpOption(options)
|
||||
} catch (e: ArgumentParserException) {
|
||||
handleParsingError(e)
|
||||
}
|
||||
}
|
||||
|
||||
fun showHelp(errorMessage: String = ""): Nothing {
|
||||
helpFormatter.show()
|
||||
if (errorMessage.isNotEmpty()) {
|
||||
println()
|
||||
println(errorMessage)
|
||||
println()
|
||||
}
|
||||
exitProcess(0)
|
||||
}
|
||||
|
||||
private fun handleHelpOption(options: MutableList<Option<Any>>) {
|
||||
if (findOption("help", options)?.optionValue?.value == true) {
|
||||
showHelp()
|
||||
}
|
||||
}
|
||||
|
||||
private fun findOption(name: String, options: MutableList<Option<Any>>): Option<Any>? =
|
||||
if (name.length > 1) options.find { it.config.name == name }
|
||||
else options.find { it.config.shortName == name[0] }
|
||||
|
||||
protected fun handleParsingError(e: ArgumentParserException): Nothing {
|
||||
showHelp(ArgumentParserException.ERROR_MSG.format(e.message))
|
||||
}
|
||||
|
||||
// argument parsing
|
||||
|
||||
interface ArgumentParser {
|
||||
fun parseArguments(
|
||||
args: Array<String>,
|
||||
options: List<Option<Any>>,
|
||||
parameters: ParameterValue,
|
||||
)
|
||||
|
||||
fun parseCommand(cmd: String): Boolean
|
||||
}
|
||||
|
||||
private class DefaultArgumentParser : ArgumentParser {
|
||||
override fun parseArguments(
|
||||
args: Array<String>,
|
||||
options: List<Option<Any>>,
|
||||
parameters: ParameterValue,
|
||||
) {
|
||||
var index = 0
|
||||
parameters.value = emptyList()
|
||||
while (index < args.size) {
|
||||
val parseResult = parseArgument(args[index])
|
||||
if (parseResult != null) {
|
||||
val (key, value) = parseResult
|
||||
index += handleOption(key, value, args, index, options)
|
||||
index++
|
||||
} else {
|
||||
parameters.value = args.drop(index)
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
override fun parseCommand(cmd: String) =
|
||||
NAME_PATTERN.matches(cmd)
|
||||
|
||||
private fun parseArgument(arg: String): Pair<String, String>? =
|
||||
ARGUMENT_PATTERN.matchEntire(arg)?.groupValues?.let { Pair(it[1] + it[2], it[3]) }
|
||||
|
||||
private fun handleOption(
|
||||
key: String,
|
||||
value: String,
|
||||
args: Array<String>,
|
||||
index: Int,
|
||||
options: List<Option<Any>>,
|
||||
): Int {
|
||||
val option = options.find {
|
||||
it.config.name == key || it.config.shortName?.toString() == key
|
||||
} ?: throw ArgumentParserException.unknownOption(key)
|
||||
|
||||
return when {
|
||||
option.type.hasParameter -> handleParameterOption(option, value, args, index)
|
||||
else -> handleFlagOption(option, value)
|
||||
}
|
||||
}
|
||||
|
||||
private fun handleParameterOption(
|
||||
option: Option<Any>,
|
||||
value: String,
|
||||
args: Array<String>,
|
||||
index: Int,
|
||||
): Int = when {
|
||||
value.isNotBlank() -> {
|
||||
option.type.convertAndSet(value, option)
|
||||
0
|
||||
}
|
||||
|
||||
index < args.size - 1 && !ARGUMENT_PATTERN.matches(args[index + 1]) -> {
|
||||
option.type.convertAndSet(args[index + 1], option)
|
||||
1
|
||||
}
|
||||
|
||||
else -> throw ArgumentParserException.optionRequiresValue(option.config.name)
|
||||
}
|
||||
|
||||
private fun handleFlagOption(option: Option<Any>, value: String): Int {
|
||||
if (value.isNotBlank()) {
|
||||
throw ArgumentParserException.optionNoValue(option.config.name)
|
||||
}
|
||||
option.type.convertAndSet("true", option)
|
||||
return 0
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// help output
|
||||
|
||||
protected interface HelpFormatter {
|
||||
fun show(indent: String = "")
|
||||
}
|
||||
|
||||
protected class CommandHelpFormatter(
|
||||
protected val commands: CommandList,
|
||||
private val infoMessage: String,
|
||||
) : HelpFormatter {
|
||||
override fun show(indent: String) {
|
||||
println()
|
||||
println(infoMessage)
|
||||
for (cmd in commands) {
|
||||
val aliases = buildString {
|
||||
if (cmd.aliases.isNotEmpty()) append(
|
||||
"|'${
|
||||
cmd.aliases.joinToString("'|'")
|
||||
}'"
|
||||
)
|
||||
}
|
||||
OptionHelpFormatter(
|
||||
cmd.options,
|
||||
"Command '${cmd.name}'${aliases}: ${cmd.description}"
|
||||
).show(" ")
|
||||
println()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
protected class OptionHelpFormatter(
|
||||
private val options: List<Option<Any>>,
|
||||
private val infoMessage: String,
|
||||
) : HelpFormatter {
|
||||
override fun show(indent: String) {
|
||||
println(infoMessage)
|
||||
if (options.isNotEmpty()) {
|
||||
if (indent.isEmpty()) println("Options:")
|
||||
printOptions(indent)
|
||||
}
|
||||
}
|
||||
|
||||
private fun printOptions(indent: String) {
|
||||
val maxNameLength = calculateMaxNameLength() + 4 + indent.length
|
||||
options.forEach { printOption(it, maxNameLength, indent) }
|
||||
}
|
||||
|
||||
private fun calculateMaxNameLength(): Int =
|
||||
options.maxOfOrNull { opt ->
|
||||
opt.config.name.length + 2 + (opt.config.shortName?.let { 4 } ?: 0)
|
||||
} ?: 0
|
||||
|
||||
private fun printOption(option: Option<Any>, maxNameLength: Int, indent: String) {
|
||||
val shortName = option.config.shortName?.let { "-$it, " } ?: ""
|
||||
val optionText = StringBuilder()
|
||||
.append(indent)
|
||||
.append(shortName)
|
||||
.append("--")
|
||||
.append(option.config.name)
|
||||
.padEnd(maxNameLength)
|
||||
println("$optionText ${option.config.description}")
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
// option validation
|
||||
|
||||
private interface OptionValidator {
|
||||
fun validateOption(config: OptionConfig, existingOptions: List<Option<Any>>)
|
||||
fun validateRequiredOptions(options: List<Option<Any>>)
|
||||
}
|
||||
|
||||
private object DefaultOptionValidator : OptionValidator {
|
||||
override fun validateOption(config: OptionConfig, existingOptions: List<Option<Any>>) {
|
||||
validateOptionName(config.name)
|
||||
validateShortName(config.shortName)
|
||||
validateOptionUniqueness(config, existingOptions)
|
||||
}
|
||||
|
||||
override fun validateRequiredOptions(options: List<Option<Any>>) {
|
||||
val emptyNames = options.filter { it.config.required && it.isEmpty() }
|
||||
.joinToString(", ") { it.config.name }
|
||||
if (emptyNames.isNotEmpty()) throw ArgumentParserException.optionRequired(emptyNames)
|
||||
}
|
||||
|
||||
private fun validateOptionName(name: String) {
|
||||
if (!name.matches(NAME_PATTERN)) {
|
||||
throw ArgumentParserException.invalidName(name)
|
||||
}
|
||||
}
|
||||
|
||||
private fun validateShortName(shortName: Char?) {
|
||||
if (shortName != null && !shortName.toString().matches(SHORT_NAME_PATTERN)) {
|
||||
throw ArgumentParserException.invalidShortName(shortName.toString())
|
||||
}
|
||||
}
|
||||
|
||||
private fun validateOptionUniqueness(
|
||||
config: OptionConfig,
|
||||
existingOptions: List<Option<Any>>,
|
||||
) {
|
||||
val nameExists = existingOptions.any { it.config.name == config.name }
|
||||
val shortNameExists = config.shortName?.let { shortName ->
|
||||
existingOptions.any { it.config.shortName == shortName }
|
||||
} ?: false
|
||||
|
||||
if (nameExists || shortNameExists) {
|
||||
throw ArgumentParserException.optionExists(config.name)
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user