improve parsing and flag Options

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

@@ -1,13 +1,16 @@
 package com.infendro.cli.command
 
-import com.infendro.cli.exception.build.NoOptionNameException
+import com.infendro.cli.exception.build.MissingOptionNameException
 import com.infendro.cli.parser.*
-import com.infendro.cli.parser.Parser
 
-sealed class Option<T>(
-    val names: List<String>,
+sealed class Option<T : Any>(
     val parser: Parser<T>,
+    val fallback: T?,
+    val names: List<String>,
 ) {
+    val flag: Boolean
+        get() = fallback != null
+
     val name: String
         get() = names[0]
 
@@ -15,89 +18,114 @@ sealed class Option<T>(
 
     init {
         if (names.isEmpty())
-            throw NoOptionNameException()
+            throw MissingOptionNameException()
     }
 
-    class Required<T>(
-        names: List<String>,
+    class Required<T : Any>(
         parser: Parser<T>,
-    ) : Option<T>(names, parser) {
+        fallback: T?,
+        names: List<String>,
+    ) : Option<T>(parser, fallback, names) {
+        constructor(
+            parser: Parser<T>,
+            names: List<String>,
+        ) : this(parser, null, names)
+
         override val required: Boolean
             get() = true
     }
 
-    class OrElse<T>(
+    class OrElse<T : Any>(
+        parser: Parser<T>,
+        fallback: T?,
         names: List<String>,
         val other: T,
-        parser: Parser<T>,
-    ) : Option<T>(names, parser) {
+    ) : Option<T>(parser, fallback, names) {
+        constructor(
+            parser: Parser<T>,
+            names: List<String>,
+            other: T,
+        ) : this(parser, null, names, other)
+
         override val required: Boolean
             get() = false
     }
 
-    class OrNull<T>(
-        names: List<String>,
+    class OrNull<T : Any>(
         parser: Parser<T>,
-    ) : Option<T>(names, parser) {
+        fallback: T?,
+        names: List<String>,
+    ) : Option<T>(parser, fallback, names) {
+        constructor(
+            parser: Parser<T>,
+            names: List<String>,
+        ) : this(parser, null, names)
+
         override val required: Boolean
             get() = false
     }
 
-    class Variable<T>(
-        names: List<String>,
+    class Variable<T : Any>(
         parser: Parser<T>,
-    ) : Option<T>(names, parser) {
+        fallback: T?,
+        names: List<String>,
+    ) : Option<T>(parser, fallback, names) {
+        constructor(
+            parser: Parser<T>,
+            names: List<String>,
+        ) : this(parser, null, names)
+
         override val required: Boolean
             get() = false
     }
 
     companion object {
         fun string(vararg names: String) =
-            Required(names.asList(), StringParser)
+            Required(StringParser, names.asList())
 
         fun stringOrElse(vararg names: String, other: String) =
-            OrElse(names.asList(), other, StringParser)
+            OrElse(StringParser, names.asList(), other)
 
         fun stringOrNull(vararg names: String) =
-            OrNull(names.asList(), StringParser)
+            OrNull(StringParser, names.asList())
 
         fun strings(vararg names: String) =
-            Variable(names.asList(), StringParser)
+            Variable(StringParser, names.asList())
 
         fun int(vararg names: String) =
-            Required(names.asList(), IntParser)
+            Required(IntParser, names.asList())
 
         fun intOrElse(vararg names: String, other: Int) =
-            OrElse(names.asList(), other, IntParser)
+            OrElse(IntParser, names.asList(), other)
 
         fun intOrNull(vararg names: String) =
-            OrNull(names.asList(), IntParser)
+            OrNull(IntParser, names.asList())
 
         fun ints(vararg names: String) =
-            Variable(names.asList(), IntParser)
+            Variable(IntParser, names.asList())
 
         fun boolean(vararg names: String) =
-            Required(names.asList(), BooleanParser)
+            Required(BooleanParser, true, names.asList())
 
         fun booleanOrElse(vararg names: String, other: Boolean) =
-            OrElse(names.asList(), other, BooleanParser)
+            OrElse(BooleanParser, true, names.asList(), other)
 
         fun booleanOrNull(vararg names: String) =
-            OrNull(names.asList(), BooleanParser)
+            OrNull(BooleanParser, true, names.asList())
 
         fun booleans(vararg names: String) =
-            Variable(names.asList(), BooleanParser)
+            Variable(BooleanParser, true, names.asList())
 
         inline fun <reified T : Enum<T>> enum(vararg names: String) =
-            Required(names.asList(), enumParser<T>())
+            Required(enumParser<T>(), names.asList())
 
         inline fun <reified T : Enum<T>> enumOrElse(vararg names: String, other: T) =
-            OrElse(names.asList(), other, enumParser<T>())
+            OrElse(enumParser<T>(), names.asList(), other)
 
         inline fun <reified T : Enum<T>> enumOrNull(vararg names: String) =
-            OrNull(names.asList(), enumParser<T>())
+            OrNull(enumParser<T>(), names.asList())
 
         inline fun <reified T : Enum<T>> enums(vararg names: String) =
-            Variable(names.asList(), enumParser<T>())
+            Variable(enumParser<T>(), names.asList())
     }
 }