implement optional variable argument/option ranges, refactor exception handling

adapt required/optional argument handling
implement bounded/unbounded variable argument handling

README.md

@@ -28,19 +28,20 @@ dependencies {
 ## Usage
 
 ```kotlin
-fun main(args: Array<String>) = cli {
+fun main(args: Array<String>) = cli("application") {
     execute {
         // define execution of command (e.g., display help)
+        println("Usage: application <command> [arguments] [options]")
     }
 
     // declare command "greet"
     command("greet") {
         // declare arguments
-        val speakersArg = Argument.string().variable().register()
+        val speakersArg by Argument.string("speakers").variable(min = 1)
 
         // declare options
-        val greetingOpt = Option.string("greeting", "greet", "g").orElse("Hello").register()
+        val greetingOpt by Option.string("greeting", "greet", "g").orElse("Hello")
-        val nameOpt = Option.string("name", "n").orNull().register()
+        val nameOpt by Option.string("name", "n").orNull()
 
         execute {
             // retrieve the arguments and options
@@ -55,7 +56,7 @@ fun main(args: Array<String>) = cli {
     }
 
     // declare fallback command
-    fallback { valueArg ->
+    fallback("value") { valueArg ->
         execute {
             // retrieve the value used for the fallback command
             val value by valueArg

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

@@ -1,4 +1,4 @@
 package com.infendro.cli
 
 @DslMarker
-internal annotation class Dsl()
+internal annotation class Dsl

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

@@ -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) {
+        name: String,
-        override val required: Boolean
+    ) : Argument<T>(parser, name, min = 1, max = 1) {
-            get() = true
+        fun orElse(other: T) = OrElse(parser, name, other)
-
+        fun orNull() = OrNull(parser, name)
-        fun orElse(other: T) = OrElse(parser, other)
+        fun variable(min: Int = 0, max: Int? = null) = Variable(parser, name, min, max)
-        fun orNull() = OrNull(parser)
-        fun variable() = Variable(parser)
     }
 
     class OrElse<T : Any>(
         parser: Parser<T>,
+        name: String,
         val other: T,
-    ) : Argument<T>(parser) {
+    ) : Argument<T>(parser, name, min = 0, max = 1)
-        override val required: Boolean
-            get() = false
-    }
 
     class OrNull<T : Any>(
         parser: Parser<T>,
-    ) : Argument<T>(parser) {
+        name: String,
-        override val required: Boolean
+    ) : Argument<T>(parser, name, min = 0, max = 1)
-            get() = false
-    }
 
     class Variable<T : Any>(
         parser: Parser<T>,
-    ) : Argument<T>(parser) {
+        name: String,
-        override val required: Boolean
+        min: Int,
-            get() = false
+        max: Int?,
-    }
+    ) : Argument<T>(parser, name, min, max)
 
     companion object {
-        fun string() = argument(StringParser)
+        fun string(name: String) = argument(StringParser, name)
-        fun int() = argument(IntParser)
+        fun int(name: String) = argument(IntParser, name)
-        fun long() = argument(LongParser)
+        fun long(name: String) = argument(LongParser, name)
-        fun float() = argument(FloatParser)
+        fun float(name: String) = argument(FloatParser, name)
-        fun double() = argument(DoubleParser)
+        fun double(name: String) = argument(DoubleParser, name)
-        fun boolean() = argument(BooleanParser)
+        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>) =
+fun <T : Any> argument(parser: Parser<T>, name: String) =
-    Argument.Required(parser)
+    Argument.Required(parser, name)

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

@@ -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
+            validateCommand(name)
-            val last = commands.lastOrNull()
+            commands += Builder(level + 1, name, fallback = false).apply(block).build()
-            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()
+        fun fallback(name: String, block: Builder.(Key) -> Unit) {
-        }
+            validateCommand(name)
-
+            commands += Builder(level + 1, name, fallback = true).apply { block(key) }.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 argument(argument: Argument<*>) {
-            // validate
+            validateArgument(argument)
-            val last = arguments.lastOrNull()
-            when {
-                last is Argument.Variable -> throw ArgumentOrderException()
-                argument.required && last != null && !last.required -> throw ArgumentOrderException()
-            }
-
             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
+            validateOption(option)
-            for (name in option.names) {
-                when {
-                    !name.matches(OPTION) -> throw IllegalOptionNameException(name)
-                    options.any { name in it.names } -> throw DuplicateOptionException(name)
-                }
-            }
-
             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)
+            validateExecute()
-                throw DuplicateExecuteException()
-
             _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) =
+fun cli(name: String, block: Command.Builder.() -> Unit) =
-    Command.Builder(-1, null).also(block).build()
+    Command.Builder(-1, name, fallback = false).apply(block).build()

src/commonMain/kotlin/com/infendro/cli/command/Option.kt

@@ -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
+    val required: Boolean
-        get() = names[0]
+        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())
+        when {
-            throw MissingOptionNameException()
+            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)
+            min: Int,
-
+            max: Int?,
-        override val required: Boolean
+        ) : this(parser, null, names, min, max)
-            get() = false
     }
 
     companion object {

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

@@ -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

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

@@ -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)
+                    val value = argument.parser.parse(current)
-                        argumentIndex++
-
-                    val value = argument.parser.parse(current) as Any
                     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 })
+        validateArguments(command, arg)
-            throw MissingArgumentException()
+        validateOptions(command, opt)
-
-        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)
-            }
-        }
 
         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)
+        }
+    }
 }

src/commonMain/kotlin/com/infendro/cli/exception/CliException.kt

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

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

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

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

@@ -0,0 +1,5 @@
+package com.infendro.cli.exception.build
+
+import com.infendro.cli.exception.CliException
+
+abstract class BuildException : CliException()

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

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

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

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

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

@@ -1,3 +1,3 @@
 package com.infendro.cli.exception.build
 
-class CommandOrderException : Exception()
+class DuplicateExecute : BuildException()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,3 +0,0 @@
-package com.infendro.cli.exception.run
-
-abstract class CliException : Exception()

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

@@ -1,8 +0,0 @@
-package com.infendro.cli.exception.run
-
-class DuplicateOptionException(
-    val option: String,
-) : CliException() {
-    override val message: String
-        get() = """duplicate option "$option""""
-}

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

@@ -1,5 +0,0 @@
-package com.infendro.cli.exception.run
-
-class ExecuteException(
-    override val message: String,
-) : CliException()

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

@@ -0,0 +1,18 @@
+package com.infendro.cli.exception.run
+
+import com.infendro.cli.command.Argument
+
+class InvalidArgumentCount(
+    val argument: Argument<*>,
+    val count: Int,
+) : RunException() {
+    override val message: String
+        get() {
+            val expected = when {
+                argument.min == argument.max -> "${argument.min}"
+                argument.unbounded -> "at least ${argument.min}"
+                else -> "${argument.min} to ${argument.max}"
+            }
+            return """invalid number of values for argument "${argument.name}": expected $expected but found $count"""
+        }
+}

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

@@ -0,0 +1,18 @@
+package com.infendro.cli.exception.run
+
+import com.infendro.cli.command.Option
+
+class InvalidOptionCount(
+    val option: Option<*>,
+    val count: Int,
+) : RunException() {
+    override val message: String
+        get() {
+            val expected = when {
+                option.min == option.max -> "${option.min}"
+                option.unbounded -> "at least ${option.min}"
+                else -> "${option.min} to ${option.max}"
+            }
+            return """invalid number of values passed for option "${option.name}": expected $expected but found $count"""
+        }
+}

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

@@ -0,0 +1,11 @@
+package com.infendro.cli.exception.run
+
+import kotlin.reflect.KClass
+
+class InvalidValue(
+    val value: String,
+    val type: KClass<*>,
+) : RunException() {
+    override val message: String
+        get() = """"$value" cannot be converted to ${type.simpleName}"""
+}

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

@@ -1,8 +1,8 @@
 package com.infendro.cli.exception.run
 
-class MalformedOptionException(
+class MalformedOption(
     val option: String,
-) : CliException() {
+) : RunException() {
     override val message: String
         get() = """malformed option "$option""""
 }

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

@@ -1,6 +0,0 @@
-package com.infendro.cli.exception.run
-
-class MissingArgumentException : CliException() {
-    override val message: String
-        get() = """missing argument"""
-}

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

@@ -1,8 +0,0 @@
-package com.infendro.cli.exception.run
-
-class MissingOptionException(
-    val option: String,
-) : CliException() {
-    override val message: String
-        get() = """missing option "$option""""
-}

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

@@ -0,0 +1,10 @@
+package com.infendro.cli.exception.run
+
+import com.infendro.cli.command.Option
+
+class MissingOptionValue(
+    val option: Option<*>,
+) : RunException() {
+    override val message: String
+        get() = """no value provided for option "${option.name}""""
+}

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

@@ -1,8 +0,0 @@
-package com.infendro.cli.exception.run
-
-class MissingOptionValueException(
-    val option: String,
-) : CliException() {
-    override val message: String
-        get() = """no value provided for option "$option""""
-}

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

@@ -1,9 +0,0 @@
-package com.infendro.cli.exception.run
-
-class ParseException(
-    val text: String?,
-    val type: String,
-) : CliException() {
-    override val message: String
-        get() = """"$text" cannot be converted to $type"""
-}

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

@@ -0,0 +1,5 @@
+package com.infendro.cli.exception.run
+
+import com.infendro.cli.exception.CliException
+
+abstract class RunException : CliException()

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

@@ -1,6 +0,0 @@
-package com.infendro.cli.exception.run
-
-class TooManyArgumentsException : CliException() {
-    override val message: String
-        get() = """too many arguments"""
-}

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

@@ -0,0 +1,6 @@
+package com.infendro.cli.exception.run
+
+class UnexpectedArgument : RunException() {
+    override val message: String
+        get() = """unexpected argument"""
+}

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

@@ -1,8 +1,8 @@
 package com.infendro.cli.exception.run
 
-class UnknownCommandException(
+class UnknownCommand(
     val command: String,
-) : CliException() {
+) : RunException() {
     override val message: String
         get() = """unknown command "$command""""
 }

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

@@ -1,8 +1,8 @@
 package com.infendro.cli.exception.run
 
-class UnknownOptionException(
+class UnknownOption(
     val option: String,
-) : CliException() {
+) : RunException() {
     override val message: String
         get() = """unknown option "$option""""
 }

src/commonMain/kotlin/com/infendro/cli/parser/BooleanParser.kt

@@ -1,11 +1,11 @@
 package com.infendro.cli.parser
 
-import com.infendro.cli.exception.run.ParseException
+import com.infendro.cli.exception.run.InvalidValue
 
 object BooleanParser : Parser<Boolean> {
     override fun parse(text: String): Boolean = when (text) {
         "true", "t" -> true
         "false", "f" -> false
-        else -> throw ParseException(text, "Boolean")
+        else -> throw InvalidValue(text, Boolean::class)
     }
 }

src/commonMain/kotlin/com/infendro/cli/parser/DoubleParser.kt

@@ -1,8 +1,8 @@
 package com.infendro.cli.parser
 
-import com.infendro.cli.exception.run.ParseException
+import com.infendro.cli.exception.run.InvalidValue
 
 object DoubleParser : Parser<Double> {
     override fun parse(text: String): Double = text.toDoubleOrNull()
-        ?: throw ParseException(text, "Double")
+        ?: throw InvalidValue(text, Double::class)
 }

src/commonMain/kotlin/com/infendro/cli/parser/EnumParser.kt

@@ -1,14 +1,15 @@
 package com.infendro.cli.parser
 
-import com.infendro.cli.exception.run.ParseException
+import com.infendro.cli.exception.run.InvalidValue
 import kotlin.enums.enumEntries
+import kotlin.reflect.KClass
 
 class EnumParser<T : Enum<T>>(
-    private val name: String,
+    private val type: KClass<T>,
     private val values: List<T>,
 ) : Parser<T> {
     override fun parse(text: String): T = values.firstOrNull { it.name == text }
-        ?: throw ParseException(text, name)
+        ?: throw InvalidValue(text, type)
 }
 
-inline fun <reified T : Enum<T>> enumParser() = EnumParser(T::class.simpleName!!, enumEntries<T>())
+inline fun <reified T : Enum<T>> enumParser() = EnumParser(T::class, enumEntries<T>())

src/commonMain/kotlin/com/infendro/cli/parser/FloatParser.kt

@@ -1,8 +1,8 @@
 package com.infendro.cli.parser
 
-import com.infendro.cli.exception.run.ParseException
+import com.infendro.cli.exception.run.InvalidValue
 
 object FloatParser : Parser<Float> {
     override fun parse(text: String): Float = text.toFloatOrNull()
-        ?: throw ParseException(text, "Float")
+        ?: throw InvalidValue(text, Float::class)
 }

src/commonMain/kotlin/com/infendro/cli/parser/IntParser.kt

@@ -1,8 +1,8 @@
 package com.infendro.cli.parser
 
-import com.infendro.cli.exception.run.ParseException
+import com.infendro.cli.exception.run.InvalidValue
 
 object IntParser : Parser<Int> {
     override fun parse(text: String): Int = text.toIntOrNull()
-        ?: throw ParseException(text, "Int")
+        ?: throw InvalidValue(text, Int::class)
 }

src/commonMain/kotlin/com/infendro/cli/parser/LongParser.kt

@@ -1,8 +1,8 @@
 package com.infendro.cli.parser
 
-import com.infendro.cli.exception.run.ParseException
+import com.infendro.cli.exception.run.InvalidValue
 
 object LongParser : Parser<Long> {
     override fun parse(text: String): Long = text.toLongOrNull()
-        ?: throw ParseException(text, "Long")
+        ?: throw InvalidValue(text, Long::class)
 }

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

@@ -2,5 +2,6 @@ package com.infendro.cli.util
 
 internal object Regex {
     val COMMAND = Regex("""[a-zA-Z][a-zA-Z0-9]*(?:-[a-zA-Z0-9]+)*""")
+    val ARGUMENT = Regex("""[a-zA-Z][a-zA-Z0-9]*(?:[\-.][a-zA-Z0-9]+)*""")
     val OPTION = Regex("""[a-zA-Z][a-zA-Z0-9]*(?:[\-.][a-zA-Z0-9]+)*""")
 }