Make option's erroName nullable, add argName param

Author: xenomachina

CHANGELOG.md

@@ -22,11 +22,13 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Changed
 
-- The `adding` and `positionalList` methods of `ArgParser` have had their
-  parameters slightly reordered to be consistent with the other methods. This
-  is an incompatible change. The name(s) come first, if any, followed by
+- The `storing`, `adding` and `positionalList` methods of `ArgParser` have had
+  their parameters slightly reordered to be consistent with the other methods.
+  This is an incompatible change. The name(s) come first, if any, followed by
   `help`. Other parameters appear after `help`, with the `transform` function,
-  if any, last.
+  if any, last. It is recommended that clients either pass the transform as a
+  block (ie: with braces) or as a named parameter, as any future new parameters
+  will necessarily change its position in the list.
 
 - Delegate and DelegateProvider are now abstract classes with internal
   constructors. This makes it much easier for me to separate internal and

src/main/kotlin/ArgParser.kt

@@ -56,7 +56,6 @@ class ArgParser(args: Array<out String>,
     fun flagging(vararg names: String, help: String): Delegate<Boolean> =
             option<Boolean>(
                     *names,
-                    errorName = optionNamesToErrorName(names),
                     help = help) { true }.default(false)
 
     /**
@@ -71,7 +70,6 @@ class ArgParser(args: Array<out String>,
     fun counting(vararg names: String, help: String): Delegate<Int> =
             option<Int>(
                     *names,
-                    errorName = optionNamesToErrorName(names),
                     isRepeating = true,
                     help = help) { value.orElse { 0 } + 1 }.default(0)
 
@@ -86,13 +84,14 @@ class ArgParser(args: Array<out String>,
     fun <T> storing(
             vararg names: String,
             help: String,
+            argName: String? = null,
             transform: String.() -> T
     ): Delegate<T> {
-        val errorName = optionNamesToErrorName(names)
+        val nonNullArgName = argName ?: optionNameToArgName(selectRepresentativeOptionName(names))
         return option(
                 *names,
-                errorName = errorName,
-                argNames = listOf(errorName),
+                errorName = nonNullArgName,
+                argNames = listOf(nonNullArgName),
                 help = help) { transform(arguments.first()) }
     }
 
@@ -101,8 +100,9 @@ class ArgParser(args: Array<out String>,
      */
     fun <T> storing(
             help: String,
+            argName: String? = null,
             transform: String.() -> T
-    ) = DelegateProvider { identifier -> storing(identifierToOptionName(identifier), help = help, transform = transform) }
+    ) = DelegateProvider { identifier -> storing(identifierToOptionName(identifier), help = help, argName = argName, transform = transform) }
 
     /**
      * Creates a Delegate for a single-argument option that stores and returns the option's argument.
@@ -122,15 +122,15 @@ class ArgParser(args: Array<out String>,
     fun <E, T : MutableCollection<E>> adding(
             vararg names: String,
             help: String,
+            argName: String? = null,
             initialValue: T,
             transform: String.() -> E
     ): Delegate<T> {
-        val errorName = optionNamesToErrorName(names)
+        val nonNullArgName = argName ?: optionNameToArgName(selectRepresentativeOptionName(names))
         return option<T>(
                 *names,
-                errorName = errorName,
                 help = help,
-                argNames = listOf(errorName),
+                argNames = listOf(nonNullArgName),
                 isRepeating = true) {
             val result = value.orElse { initialValue }
             result.add(transform(arguments.first()))
@@ -144,10 +144,11 @@ class ArgParser(args: Array<out String>,
      */
     fun <E, T : MutableCollection<E>> adding(
             help: String,
+            argName: String? = null,
             initialValue: T,
             transform: String.() -> E
     ) = DelegateProvider { identifier ->
-                adding(identifierToOptionName(identifier), initialValue = initialValue, help = help, transform = transform) }
+                adding(identifierToOptionName(identifier), help = help, argName = argName, initialValue = initialValue, transform = transform) }
 
     /**
      * Creates a Delegate for a single-argument option that adds the option's (transformed) argument to a
@@ -156,8 +157,9 @@ class ArgParser(args: Array<out String>,
     fun <T> adding(
             vararg names: String,
             help: String,
+            argName: String? = null,
             transform: String.() -> T
-    ) = adding(*names, initialValue = mutableListOf(), help = help, transform = transform)
+    ) = adding(*names, help = help, argName = argName, initialValue = mutableListOf(), transform = transform)
 
     /**
      * Creates a DelegateProvider for a single-argument option that adds the option's (transformed) argument to a
@@ -208,7 +210,8 @@ class ArgParser(args: Array<out String>,
     /**
      * Creates a Delegate for an option with the specified names.
      * @param names names of options, with leading "-" or "--"
-     * @param errorName name to use when talking about this option in error messages
+     * @param errorName name to use when talking about this option in error messages, or null to base it upon the
+     * option names
      * @param help the help text for this option
      * @param argNames names of this option's arguments
      * @param isRepeating whether or not it make sense to repeat this option -- usually used for options where
@@ -219,15 +222,14 @@ class ArgParser(args: Array<out String>,
             // TODO: add optionalArg: Boolean
             vararg names: String,
             help: String,
-            // TODO: make errorName nullable, and choose name from option names if null
-            errorName: String,
+            errorName: String? = null,
             argNames: List<String> = emptyList(),
             isRepeating: Boolean = false,
             handler: OptionInvocation<T>.() -> T
     ): Delegate<T> {
         val delegate = OptionDelegate<T>(
                 parser = this,
-                errorName = errorName,
+                errorName = errorName ?: optionNameToArgName(selectRepresentativeOptionName(names)),
                 help = help,
                 optionNames = listOf(*names),
                 argNames = argNames.toList(),
@@ -760,10 +762,6 @@ class ArgParser(args: Array<out String>,
             return names[0]
         }
 
-        internal fun optionNamesToErrorName(names: Array<out String>): String {
-            return optionNameToArgName(selectRepresentativeOptionName(names))
-        }
-
         private fun optionNameToArgName(name: String) =
                 LEADING_HYPHENS.replace(name, "").toUpperCase().replace('-', '_')
 

src/test/kotlin/ArgParserTest.kt

@@ -1092,7 +1092,7 @@ fun nullableString() : String? = null
 
 class NullableOptionalTest : Test({
     class Args(parser: ArgParser) {
-        val path by parser.storing("The path", ::File)
+        val path by parser.storing("The path", transform = ::File)
                 .default(nullableString()?.let(::File))
 
     }
@@ -1113,9 +1113,9 @@ class NullableOptional_withoutTransformTest : Test({
 
 class DefaultGeneralizationTest : Test({
     class Args(parser: ArgParser) {
-        val shape by parser.storing("The path", ::Rectangle)
+        val shape by parser.storing("The path", transform = ::Rectangle)
                 .default(Circle())
-        val rect by parser.storing("The path", ::Rectangle)
+        val rect by parser.storing("The path", transform = ::Rectangle)
     }
     val args = Args(parserOf("--rect=foo"))
     staticType(args.shape) shouldBe Shape::class