Implement auto-naming of options and positionals

xenomachina · xenomachina · commit c5b10bf038d0 · 2017-03-09T15:16:53.000-08:00
- Each of the ArgParser methods that takes names and returns a Delegate&lt;T&gt; has
  an overload that takes no name, but returns a DelegateProvider&lt;T&gt;.

- A DelegateProvider&lt;T&gt; has an `operator fun provideDelegate` that returns a
  Delegate&lt;T&gt;, using a name derived from the name of the property the
  DelegateProvider is being bound to.

Also removed option from README.md, as it is internal, and fixed spelling of
addValidator.
diff --git a/README.md b/README.md
@@ -19,6 +19,21 @@ Typical usage is to create a class to represent the set of parsed arguments,
 which are in turn each represented by properties that delegate to an
 `ArgParser`:
 
+```kotlin
+class MyArgs(parser: ArgParser) {
+    val verbose by parser.flagging(help = "enable verbose mode")
+
+    val name by parser.storing(help = "name of the widget")
+
+    val size by parser.storing(help = "size of the plumbus") { toInt() }
+}
+```
+
+The names of an option is inferred from the name of the property it's bound to.
+Direct control over the option name is also possible, and for most types of
+options it's also possible to have multiple names (typically used for a short
+and long name):
+
 ```kotlin
 class MyArgs(parser: ArgParser) {
     val verbose by parser.flagging("-v", "--verbose",
@@ -94,25 +109,10 @@ Various types of options can be parsed from the command line arguments:
   Here the `mode` property will be set to the corresponding `Mode` value depending
   on which of `--fast`, `--small`, and `--quiet` appears (last) in the arguments.
 
-- For the times when none of the above do what you need, the much more powerful
-  `option` method can be used.  (The methods described above are convenience
-  methods built on top of `option`.)
+  `mapping` is one of the few cases where it is not possible to infer the option
+  name from the property name.
 
-  ```kotlin
-  val zaphod by parser.option(
-          "--fibonacci",
-          help = "collects fibonnaci sequence, remembers length") {
-      var prev = 0
-      var current = 1
-      var result = 0
-      while (peek() == current) {
-          result++
-          prev, current = current, current+prev
-          next()
-      }
-      return result
-  }
-  ```
+## Modifying Delegates
 
 The delegates returned by any of these methods also have a few methods for setting
 optional attributes:
@@ -184,7 +184,7 @@ recommended that transform functions (given to `storing`, `positionalList`, etc.
 throw a `SystemExitException` when parsing fails.
 
 Additional post-parsing validation can be performed on a delegate using
-`addValidtator`.
+`addValidator`.
 
 As a convenience, these exceptions can be handled by using the `runMain`
 extension function:
diff --git a/src/main/kotlin/ArgParser.kt b/src/main/kotlin/ArgParser.kt
@@ -57,6 +57,12 @@ class ArgParser(args: Array<out String>,
                     isRepeating = false,
                     help = help) { true }.default(false)
 
+    /**
+     * Creates a DelegateProvider for a zero-argument option that returns true if and only the option is present in args.
+     */
+    fun flagging(help: String) =
+            DelegateProvider { name -> flagging(identifierToOptionName(name), help = help) }
+
     /**
      * Creates a Delegate for a zero-argument option that returns the count of how many times the option appears in args.
      */
@@ -68,6 +74,11 @@ class ArgParser(args: Array<out String>,
                     isRepeating = true,
                     help = help) { value.orElse { 0 } + 1 }.default(0)
 
+    /**
+     * Creates a DelegateProvider for a zero-argument option that returns the count of how many times the option appears in args.
+     */
+    fun counting(help: String) = DelegateProvider { name -> counting(identifierToOptionName(name), help = help) }
+
     /**
      * Creates a Delegate for a single-argument option that stores and returns the option's (transformed) argument.
      */
@@ -85,12 +96,25 @@ class ArgParser(args: Array<out String>,
                 help = help) { transform(this.next()) }
     }
 
+    /**
+     * Creates a DelegateProvider for a single-argument option that stores and returns the option's (transformed) argument.
+     */
+    fun <T> storing(
+            help: String,
+            transform: String.() -> T
+    ) = DelegateProvider { name -> storing(identifierToOptionName(name), help = help, transform = transform) }
+
     /**
      * Creates a Delegate for a single-argument option that stores and returns the option's argument.
      */
     fun storing(vararg names: String, help: String): Delegate<String> =
             storing(*names, help = help) { this }
 
+    /**
+     * Creates a DelegateProvider for a single-argument option that stores and returns the option's argument.
+     */
+    fun storing(help: String) = DelegateProvider { name -> storing(identifierToOptionName(name), help = help) }
+
     /**
      * Creates a Delegate for a single-argument option that adds the option's (transformed) argument to a
      * MutableCollection each time the option appears in args, and returns said MutableCollection.
@@ -114,6 +138,17 @@ class ArgParser(args: Array<out String>,
         }.default(initialValue)
     }
 
+    /**
+     * Creates a DelegateProvider for a single-argument option that adds the option's (transformed) argument to a
+     * MutableCollection each time the option appears in args, and returns said MutableCollection.
+     */
+    fun <E, T : MutableCollection<E>> adding(
+            initialValue: T,
+            help: String,
+            transform: String.() -> E
+    ) = DelegateProvider { name ->
+                adding(identifierToOptionName(name), initialValue = initialValue, help = help, transform = transform) }
+
     /**
      * Creates a Delegate for a single-argument option that adds the option's (transformed) argument to a
      * MutableList each time the option appears in args, and returns said MutableCollection.
@@ -124,13 +159,30 @@ class ArgParser(args: Array<out String>,
             transform: String.() -> T
     ) = adding(*names, initialValue = mutableListOf(), help = help, transform = transform)
 
+    /**
+     * Creates a DelegateProvider for a single-argument option that adds the option's (transformed) argument to a
+     * MutableList each time the option appears in args, and returns said MutableCollection.
+     */
+    fun <T> adding(
+            help: String,
+            transform: String.() -> T
+    ) = DelegateProvider { name ->
+        adding(identifierToOptionName(name), help = help, transform = transform) }
+
     /**
      * Creates a Delegate for a single-argument option that adds the option's argument to a MutableList each time the
      * option appears in args, and returns said MutableCollection.
      */
     fun adding(vararg names: String, help: String): Delegate<MutableList<String>> =
             adding(*names, help = help) { this }
 
+    /**
+     * Creates a DelegateProvider for a single-argument option that adds the option's argument to a MutableList each time the
+     * option appears in args, and returns said MutableCollection.
+     */
+    fun adding(help: String) = DelegateProvider { name ->
+        adding(identifierToOptionName(name), help = help) }
+
     /**
      * Creates a Delegate for a zero-argument option that maps from the option's name as it appears in args to one of a
      * fixed set of values.
@@ -189,6 +241,12 @@ class ArgParser(args: Array<out String>,
      */
     fun positional(name: String, help: String) = positional(name, help = help) { this }
 
+    /**
+     * Creates a DelegateProvider for a single positional argument which returns the argument's value.
+     */
+    fun positional(help: String) =
+            DelegateProvider { ident -> positional(identifierToArgName(ident), help = help) }
+
     /**
      * Creates a Delegate for a single positional argument which returns the argument's transformed value.
      */
@@ -204,6 +262,14 @@ class ArgParser(args: Array<out String>,
         }
     }
 
+    /**
+     * Creates a DelegateProvider for a single positional argument which returns the argument's transformed value.
+     */
+    fun <T> positional(
+            help: String,
+            transform: String.() -> T
+    ) = DelegateProvider { ident -> positional(identifierToArgName(ident), help = help, transform = transform) }
+
     /**
      * Creates a Delegate for a sequence of positional arguments which returns a List containing the arguments.
      */
@@ -213,6 +279,14 @@ class ArgParser(args: Array<out String>,
             help: String
     ) = positionalList(name, sizeRange, help = help) { this }
 
+    /**
+     * Creates a DelegateProvider for a sequence of positional arguments which returns a List containing the arguments.
+     */
+    fun positionalList(
+            sizeRange: IntRange = 1..Int.MAX_VALUE,
+            help: String
+    ) = DelegateProvider { ident -> positionalList(identifierToArgName(ident), sizeRange, help = help) }
+
     /**
      * Creates a Delegate for a sequence of positional arguments which returns a List containing the transformed
      * arguments.
@@ -241,6 +315,16 @@ class ArgParser(args: Array<out String>,
         }
     }
 
+    /**
+     * Creates a DelegateProvider for a sequence of positional arguments which returns a List containing the transformed
+     * arguments.
+     */
+    fun <T> positionalList(
+            sizeRange: IntRange = 1..Int.MAX_VALUE,
+            help: String,
+            transform: String.() -> T
+    ) = DelegateProvider { ident -> positionalList(identifierToArgName(ident), sizeRange, help, transform) }
+
     internal abstract class WrappingDelegate<U, W>(private val inner: Delegate<U>) : Delegate<W> {
 
         abstract fun wrap(u: U): W
@@ -258,7 +342,7 @@ class ArgParser(args: Array<out String>,
         override fun default(value: W): Delegate<W> =
                 apply { inner.default(unwrap(value)) }
 
-        override fun addValidtator(validator: Delegate<W>.() -> Unit): Delegate<W> =
+        override fun addValidator(validator: Delegate<W>.() -> Unit): Delegate<W> =
                 apply { validator(this) }
     }
 
@@ -281,7 +365,31 @@ class ArgParser(args: Array<out String>,
         fun default(value: T): Delegate<T>
 
         /** Add validation logic. Validator should throw a [SystemExitException] on failure. */
-        fun addValidtator(validator: Delegate<T>.() -> Unit): Delegate<T>
+        fun addValidator(validator: Delegate<T>.() -> Unit): Delegate<T>
+
+        @Deprecated("Use addValidator instead")
+        fun addValidtator(validator: Delegate<T>.() -> Unit) = addValidator(validator)
+    }
+
+    /**
+     * Provides a [Delegate] when given a name. This makes it possible to infer
+     * a name for the `Delegate` based on the name it is bound to, rather than
+     * specifying a name explicitly.
+     */
+    class DelegateProvider<T>(private val ctor: (ident: String) -> Delegate<T>) {
+        operator fun provideDelegate(thisRef: Any?, prop: KProperty<*>): Delegate<T> {
+            return ctor(prop.name).apply {
+                defaultValue?.let {
+                    default(it.value)
+                }
+            }
+        }
+
+        fun default(t: T): DelegateProvider<T> = apply {
+            defaultValue = Holder(t)
+        }
+
+        private var defaultValue : Holder<T>? = null
     }
 
     internal abstract class ParsingDelegate<T>(
@@ -305,7 +413,7 @@ class ArgParser(args: Array<out String>,
             return this
         }
 
-        override fun addValidtator(validator: Delegate<T>.() -> Unit): Delegate<T> = apply {
+        override fun addValidator(validator: Delegate<T>.() -> Unit): Delegate<T> = apply {
             validators.add(validator)
         }
 
@@ -621,6 +729,14 @@ class ArgParser(args: Array<out String>,
 
         private fun optionNameToArgName(name: String) =
                 LEADING_HYPHENS.replace(name, "").toUpperCase().replace('-', '_')
+
+        internal fun identifierToOptionName(ident: String) : String {
+            return if (ident.length == 1) ("-" + ident) else ("--" + ident.replace('_', '-'))
+        }
+
+        internal fun identifierToArgName(ident: String) : String {
+            return ident.toUpperCase()
+        }
     }
 
     init {
diff --git a/src/test/kotlin/ArgParserTest.kt b/src/test/kotlin/ArgParserTest.kt
@@ -20,8 +20,8 @@ package com.xenomachina.argparser
 
 import com.xenomachina.common.orElse
 import org.junit.Assert.assertEquals
-import org.junit.Assert.assertTrue
 import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
 import org.junit.Rule
 import org.junit.Test
 import org.junit.rules.TestName
@@ -267,6 +267,32 @@ class ArgParserTest {
                 8,
                 Args(parserOf("-x9", "-x8")).x)
     }
+    @Test
+    fun testDefaultWithProvider() {
+        class Args(parser: ArgParser) {
+            val x by parser.storing(help = TEST_HELP) { toInt() }.default(5)
+        }
+
+        // Test with no value
+        assertEquals(
+                5,
+                Args(parserOf()).x)
+
+        // Test with value
+        assertEquals(
+                6,
+                Args(parserOf("-x6")).x)
+
+        // Test with value as separate arg
+        assertEquals(
+                7,
+                Args(parserOf("-x", "7")).x)
+
+        // Test with multiple values
+        assertEquals(
+                8,
+                Args(parserOf("-x9", "-x8")).x)
+    }
 
     @Test
     fun testFlag() {
@@ -587,7 +613,7 @@ class ArgParserTest {
 
             val xDelegate = parser.storing("-x",
                     help = TEST_HELP) { toInt() }
-                    .addValidtator {
+                    .addValidator {
                         if (value.rem(2) != 0)
                             throw InvalidArgumentException("$errorName must be even, $value is odd")
                     }
@@ -904,6 +930,56 @@ ultrices tempus lectus fermentum vestibulum. Phasellus.
         }
     }
 
+    @Test
+    fun testImplicitLongFlagName() {
+        class Args(parser: ArgParser) {
+            val flag1 by parser.flagging(help = TEST_HELP)
+            val flag2 by parser.flagging(help = TEST_HELP)
+            val count by parser.counting(help = TEST_HELP)
+            val store by parser.storing(help = TEST_HELP)
+            val store_int by parser.storing(help = TEST_HELP) { toInt() }
+            val adder by parser.adding(help = TEST_HELP)
+            val int_adder by parser.adding(help = TEST_HELP) { toInt() }
+            val int_set_adder by parser.adding(initialValue = mutableSetOf<Int>(), help = TEST_HELP) { toInt() }
+            val positional by parser.positional(help = TEST_HELP)
+            val positional_int by parser.positional(help = TEST_HELP) { toInt() }
+            val positionalList by parser.positionalList(sizeRange = 2..2, help = TEST_HELP)
+            val positionalList_int by parser.positionalList(sizeRange = 2..2, help = TEST_HELP) { toInt() }
+        }
+
+        Args(parserOf(
+                "--flag1", "--count", "--count", "--store=hello", "--store-int=42",
+                "--adder=foo", "--adder=bar",
+                "--int-adder=2", "--int-adder=4", "--int-adder=6",
+                "--int-set-adder=64", "--int-set-adder=128", "--int-set-adder=20",
+                "1", "1", "2", "3", "5", "8"
+                )).run {
+            assertTrue(flag1)
+            assertFalse(flag2)
+            assertEquals(2, count)
+            assertEquals("hello", store)
+            assertEquals(42, store_int)
+            assertEquals(listOf("foo", "bar"), adder)
+            assertEquals(listOf(2, 4, 6), int_adder)
+            assertEquals(setOf(20, 64, 128), int_set_adder)
+            assertEquals("1", positional)
+            assertEquals(1, positional_int)
+            assertEquals(listOf("2", "3"), positionalList)
+            assertEquals(listOf(5, 8), positionalList_int)
+        }
+
+        shouldThrow<MissingRequiredPositionalArgumentException> {
+            Args(parserOf(
+                    "13", "21", "34", "55", "89"
+            )).run {
+                assertFalse(flag1)
+            }
+        }.run {
+            assertEquals("missing POSITIONALLIST_INT operand", message)
+        }
+    }
+
+    // TODO: test auto-naming on positional args
     // TODO: test default on argument
     // TODO: test default on argumentList
     // TODO: test addValidator on argument
