Add MutuallyExclusiveGroup.single

Author: ajalt

clikt/src/main/kotlin/com/github/ajalt/clikt/parameters/groups/MutuallyExclusiveOption.kt

@@ -7,11 +7,11 @@ import com.github.ajalt.clikt.parsers.OptionParser
 import kotlin.properties.ReadOnlyProperty
 import kotlin.reflect.KProperty
 
-class MutuallyExclusiveOptions<OptT, OutT>(
+class MutuallyExclusiveOptions<OptT : Any, OutT>(
         internal val options: List<OptionDelegate<OptT?>>,
         override val groupName: String?,
         override val groupHelp: String?,
-        private val transform: (OptT?) -> OutT
+        internal val transformAll: (List<OptT>) -> OutT
 ) : ParameterGroupDelegate<OutT> {
     init {
         require(options.size > 1) { "must provide at least two options to a mutually exclusive group" }
@@ -22,17 +22,13 @@ class MutuallyExclusiveOptions<OptT, OutT>(
     override fun getValue(thisRef: CliktCommand, property: KProperty<*>): OutT = value
 
     override fun finalize(context: Context, invocationsByOption: Map<Option, List<OptionParser.Invocation>>) {
-        if (invocationsByOption.size > 1) {
-            throw MutuallyExclusiveGroupException(options.map { o -> o.names.maxBy { it.length }!! })
-        }
-
         for ((option, invocations) in invocationsByOption) {
             check(option in options) { "Internal Clikt Error: finalizing unregistered option [${option.names}]" }
             option.finalize(context, invocations)
         }
 
-        val values = options.filter { it.value != null }.map { it.value }
-        value = transform(values.firstOrNull())
+        val values = options.mapNotNull { it.value }
+        value = transformAll(values)
     }
 
     override operator fun provideDelegate(thisRef: CliktCommand, prop: KProperty<*>): ReadOnlyProperty<CliktCommand, OutT> {
@@ -47,15 +43,15 @@ class MutuallyExclusiveOptions<OptT, OutT>(
         return this
     }
 
-    fun <T> copy(transform: (OptT?) -> T) = MutuallyExclusiveOptions(options, groupName, groupHelp, transform)
+    fun <T> copy(transformAll: (List<OptT>) -> T) = MutuallyExclusiveOptions(options, groupName, groupHelp, transformAll)
 }
 
 /**
  * Declare a set of two or more mutually exclusive options.
  *
  * If none of the options are given on the command line, the value of this delegate will be null.
  * If one option is given, the value will be that option's value.
- * If more than one option is given, a [UsageError] is thrown.
+ * If more than one option is given, the value of the last one is used.
  *
  * All options in the group must have a name specified. All options must be nullable (they cannot
  * use [flag], [required] etc.). If you want flags, you should use [switch] instead.
@@ -80,20 +76,33 @@ fun <T : Any> ParameterHolder.mutuallyExclusiveOptions(
         name: String? = null,
         help: String? = null
 ): MutuallyExclusiveOptions<T, T?> {
-    return MutuallyExclusiveOptions(listOf(option1, option2) + options, name, help) { it }
+    return MutuallyExclusiveOptions(listOf(option1, option2) + options, name, help) { it.lastOrNull() }
+}
+
+/**
+ * If more than one of the group's options are given on the command line, throw a [MutuallyExclusiveGroupException]
+ */
+fun <T : Any> MutuallyExclusiveOptions<T, T?>.single(): MutuallyExclusiveOptions<T, T?> = copy {
+    if (it.size > 1) {
+        throw MutuallyExclusiveGroupException(options.map { o -> o.longestName()!! })
+    }
+    it.lastOrNull()
 }
 
 /**
  * Make a [mutuallyExclusiveOptions] group required. If none of the options in the group are given,
  * a [UsageError] is thrown.
  */
-fun <T : Any> MutuallyExclusiveOptions<T, T?>.required(): MutuallyExclusiveOptions<T, T> = copy {
-    it ?: throw UsageError("Must provide one of ${options.joinToString { it.names.maxBy { it.length }!! }}")
+fun <T : Any> MutuallyExclusiveOptions<T, T?>.required(): MutuallyExclusiveOptions<T, T> {
+    return copy {
+        transformAll(it)
+                ?: throw UsageError("Must provide one of ${options.joinToString { it.longestName()!! }}")
+    }
 }
 
 /**
  * If none of the options in a [mutuallyExclusiveOptions] group are given on the command line, us [value] for the group.
  */
-fun <T : Any> MutuallyExclusiveOptions<T, T?>.default(value: T): MutuallyExclusiveOptions<T, T> = copy {
-    it ?: value
+fun <T : Any> MutuallyExclusiveOptions<T, T?>.default(value: T): MutuallyExclusiveOptions<T, T> {
+    return copy { transformAll(it) ?: value }
 }

clikt/src/main/kotlin/com/github/ajalt/clikt/parameters/options/Option.kt

@@ -121,3 +121,5 @@ internal fun <EachT, AllT> deprecationTransformer(
     }
     transformAll(it)
 }
+
+internal fun Option.longestName(): String? = names.maxBy { it.length }

clikt/src/main/kotlin/com/github/ajalt/clikt/parameters/options/OptionWithValues.kt

@@ -562,7 +562,7 @@ fun <T : Any> NullableOption<T, T>.prompt(
         confirmationPrompt: String = "Repeat for confirmation: ",
         promptSuffix: String = ": ",
         showDefault: Boolean = true): OptionWithValues<T, T, T> = transformAll {
-    val promptText = text ?: names.maxBy { it.length }?.let { splitOptionPrefix(it).second }
+    val promptText = text ?: longestName()?.let { splitOptionPrefix(it).second }
             ?.replace(Regex("\\W"), " ")?.capitalize() ?: "Value"
 
     when (val provided = it.lastOrNull()) {

clikt/src/test/kotlin/com/github/ajalt/clikt/parameters/groups/OptionGroupsTest.kt

@@ -12,6 +12,7 @@ import com.github.ajalt.clikt.parameters.options.required
 import com.github.ajalt.clikt.testing.NeverCalledCliktCommand
 import com.github.ajalt.clikt.testing.splitArgv
 import io.kotlintest.data.forall
+import io.kotlintest.fail
 import io.kotlintest.shouldBe
 import io.kotlintest.shouldThrow
 import io.kotlintest.tables.row
@@ -88,7 +89,7 @@ class OptionGroupsTest {
     fun `mutually exclusive group`() = forall(
             row("", null, "d"),
             row("--x=1", "1", "d"),
-            row("--x=1 --x=2", "2", "d"),
+            row("--x=1 --y=2", "2", "d"),
             row("--y=3", "3", "d"),
             row("--x=4 --o=5", "4", "5")
     ) { argv, eg, eo ->
@@ -105,14 +106,21 @@ class OptionGroupsTest {
     }
 
     @Test
-    fun `mutually exclusive group collision`() {
-        class C : NeverCalledCliktCommand() {
-            val g by mutuallyExclusiveOptions(option("--x"), option("--y"), option("--z"))
+    fun `mutually exclusive group single`() {
+        class C(val runAllowed: Boolean) : CliktCommand() {
+            val g by mutuallyExclusiveOptions(option("--x"), option("--y"), option("--z")).single()
+            override fun run() {
+                if (!runAllowed) fail("run should not be called")
+            }
         }
-        shouldThrow<MutuallyExclusiveGroupException> { C().parse(splitArgv("--x=1 --y=2")) }
+
+        C(true).apply { parse(splitArgv("--x=1")) }.g shouldBe "1"
+        C(true).apply { parse(splitArgv("--y=1 --y=2")) }.g shouldBe "2"
+
+        shouldThrow<MutuallyExclusiveGroupException> { C(false).parse(splitArgv("--x=1 --y=2")) }
                 .message shouldBe "option --x cannot be used with --y or --z"
 
-        shouldThrow<MutuallyExclusiveGroupException> { C().parse(splitArgv("--y=1 --z=2")) }
+        shouldThrow<MutuallyExclusiveGroupException> { C(false).parse(splitArgv("--y=1 --z=2")) }
                 .message shouldBe "option --x cannot be used with --y or --z"
     }
 

docs/options.md

@@ -402,7 +402,7 @@ If [`choice`](#choice-options) or [`switch`](#feature-switch-flags) options aren
 you can use
 [`mutuallyExclusiveOptions`](api/clikt/com.github.ajalt.clikt.parameters.groups/mutually-exclusive-options.html)
 to group any nullable options into a mutually exclusive group. If more than one of the options in
-the group is given on the command line, an error is reported. 
+the group is given on the command line, the last value is used.
 
 If you want different types for each option, you can wrap them in a sealed class.
 
@@ -428,14 +428,26 @@ Apples(count=10)
 $ ./order --oranges=small
 Oranges(size=small)
 
+$ ./order --apples=10 --oranges=large
+Oranges(size=large)
+
+Usage: order [OPTIONS]
+
+Error: option --apples cannot be used with --oranges
+```
+
+You can enforce that only one of the options is given with
+[`single`](api/clikt/com.github.ajalt.clikt.parameters.groups/single.html):
+
+```
 $ ./order --apples=10 --oranges=small
 Usage: order [OPTIONS]
 
 Error: option --apples cannot be used with --oranges
 ```
 
 Like regular options, you can make the entire group
-[`required`](api/clikt/com.github.ajalt.clikt.parameters.groups/required.html) or give it a
+[`required`](api/clikt/com.github.ajalt.clikt.parameters.groups/required.html), or give it a
 [`default`](api/clikt/com.github.ajalt.clikt.parameters.groups/required.html) value.
 
 Like [other option groups](documenting/#grouping-options-in-help), you can specify a `name` and