Fix github issue #14

Change `identifierToOptionName` so that it converts "fooBarBaz" into
"--foo-bar-baz".

Author: xenomachina

CHANGELOG.md

@@ -7,12 +7,22 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+
 ### Changed
 
-- Fixed [Issue #15](https://github.com/xenomachina/kotlin-argparser/issues/15)
+- [Issue #14](https://github.com/xenomachina/kotlin-argparser/issues/14) —
+  previously, automatic option naming would turn "camelCase" into
+  "--camelCase". Now it is converted to "--camel-case".
 
 - Improve help formatting w/long program names
 
+### Fixed
+
+- [Issue #15](https://github.com/xenomachina/kotlin-argparser/issues/15)
+  — make it possible to specify 'argName' on all variants of 'storing' and
+  `adding`
+
+
 ## 2.0.0 - 2017-04-21
 
 ### Added

README.md

@@ -21,25 +21,28 @@ which are in turn each represented by properties that delegate to an
 
 ```kotlin
 class MyArgs(parser: ArgParser) {
-    val verbose by parser.flagging(help = "enable verbose mode")
+    val v by parser.flagging(help = "enable verbose mode")
 
-    val name by parser.storing(help = "name of the widget")
+    val widgetName by parser.storing("name of the widget")
 
-    val size by parser.storing(help = "size of the plumbus") { toInt() }
+    val size by parser.storing("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):
+The name of an option is inferred from the name of the property it is bound to.
+The options above are named "-v", "--widget-name" and "--size",
+respectively.
+
+Direct control over an option's name is also possible, and for most types of
+options it is also possible to have multiple names (typically used to have both
+a short and long name):
 
 ```kotlin
 class MyArgs(parser: ArgParser) {
     val verbose by parser.flagging("-v", "--verbose",
-                                   help="enable verbose mode")
+                                   help = "enable verbose mode")
 
-    val name by parser.storing("-N", "--name",
+    val name by parser.storing("-w", "--widget-name",
                                help = "name of the widget")
 
     val size by parser.storing("-s", "--size",
@@ -153,7 +156,7 @@ For a single positional argument:
 
 ```kotlin
 val destination by parser.positional("DEST",
-                                     help="destination filename")
+                                     help = "destination filename")
 ```
 
 The name ("DEST", here) is used in error handling and help text.
@@ -162,7 +165,7 @@ For a list of positional arguments:
 
 ```kotlin
 val sources by parser.positionalList("SOURCE", 1..Int.MAX_VALUE,
-                                     help="source filename")
+                                     help = "source filename")
 ```
 
 The range indicates how many arguments should be collected, and actually
@@ -174,10 +177,10 @@ arguments from `String` to whatever type is actually desired:
 
 ```kotlin
 val destination by parser.positional("DEST",
-                                     help="...") { File(this) }
+                                     help = "...") { File(this) }
 
 val sources by parser.positionalList("SOURCE", 1..Int.MAX_VALUE,
-                                     help="...") { File(this) }
+                                     help = "...") { File(this) }
 ```
 
 
@@ -191,13 +194,13 @@ optional attributes:
   value is provided. This is done with the `default` method:
 
   ```kotlin
-  val name by parser.storing("-N", "--name", help="...").default("John Doe")
+  val name by parser.storing("-N", "--name", help = "...").default("John Doe")
   ```
 
   Note that it *is* possible to use `null` for the default:
 
   ```kotlin
-  val name by parser.storing("-N", "--name", help="...").default(null)
+  val name by parser.storing("-N", "--name", help = "...").default(null)
   ```
 
   The resulting value will be nullable (a `String?` in this case).
@@ -206,7 +209,7 @@ optional attributes:
   case the `addValidator` method can be used.
 
   ```kotlin
-  val percentages by parser.adding("--percentages", help="...") { toInt() }
+  val percentages by parser.adding("--percentages", help = "...") { toInt() }
           .addValidator {
                 if (sum() != 100)
                     throw InvalidArgumentException(

src/main/kotlin/ArgParser.kt

@@ -429,7 +429,13 @@ class ArgParser(args: Array<out String>,
 
         companion object {
             fun identifierToOptionName(identifier: String): String {
-                return if (identifier.length == 1) ("-" + identifier) else ("--" + identifier.replace('_', '-'))
+                return when (identifier.length) {
+                    1 -> "-" + identifier
+                    else -> "--" + identifier.replace('_', '-')
+                            .replace(Regex("(\\p{javaLowerCase})(\\p{javaUpperCase})")) { m ->
+                                m.groups[1]!!.value + "-" + m.groups[2]!!.value.toLowerCase()
+                            }
+                }
             }
 
             fun identifierToArgName(identifier: String): String {

src/test/kotlin/ArgParserTest.kt

@@ -1171,16 +1171,16 @@ class AutoNamedFlaggingTest : Test({
         val autoFlag by parser.flagging(TEST_HELP)
     }
     Args(parserOf()).autoFlag shouldBe false
-    Args(parserOf("--autoFlag")).autoFlag shouldBe true
+    Args(parserOf("--auto-flag")).autoFlag shouldBe true
 })
 
 class AutoNamedCountingTest : Test({
     class Args(parser: ArgParser) {
         val autoCount by parser.counting(TEST_HELP)
     }
     Args(parserOf()).autoCount shouldBe 0
-    Args(parserOf("--autoCount")).autoCount shouldBe 1
-    Args(parserOf("--autoCount", "--autoCount")).autoCount shouldBe 2
+    Args(parserOf("--auto-count")).autoCount shouldBe 1
+    Args(parserOf("--auto-count", "--auto-count")).autoCount shouldBe 2
 })
 
 class AutoNamedStoringTest : Test({
@@ -1191,11 +1191,11 @@ class AutoNamedStoringTest : Test({
     shouldThrow<MissingValueException> {
         Args(parserOf()).autoStore
     }.run {
-        message shouldBe "missing AUTOSTORE"
+        message shouldBe "missing AUTO_STORE"
     }
 
-    Args(parserOf("--autoStore=foo")).autoStore shouldBe "foo"
-    Args(parserOf("--autoStore", "bar", "--autoStore", "baz")).autoStore shouldBe "baz"
+    Args(parserOf("--auto-store=foo")).autoStore shouldBe "foo"
+    Args(parserOf("--auto-store", "bar", "--auto-store", "baz")).autoStore shouldBe "baz"
 })
 
 class AutoNamedStoringWithTransformTest : Test({
@@ -1206,11 +1206,11 @@ class AutoNamedStoringWithTransformTest : Test({
     shouldThrow<MissingValueException> {
         Args(parserOf()).autoStore
     }.run {
-        message shouldBe "missing AUTOSTORE"
+        message shouldBe "missing AUTO_STORE"
     }
 
-    Args(parserOf("--autoStore=5")).autoStore shouldBe 5
-    Args(parserOf("--autoStore", "11", "--autoStore", "42")).autoStore shouldBe 42
+    Args(parserOf("--auto-store=5")).autoStore shouldBe 5
+    Args(parserOf("--auto-store", "11", "--auto-store", "42")).autoStore shouldBe 42
 })
 
 class AutoNamedAddingTest : Test({
@@ -1219,8 +1219,8 @@ class AutoNamedAddingTest : Test({
     }
 
     Args(parserOf()).autoAccumulator shouldBe emptyList<String>()
-    Args(parserOf("--autoAccumulator=foo")).autoAccumulator shouldBe listOf("foo")
-    Args(parserOf("--autoAccumulator", "bar", "--autoAccumulator", "baz")).autoAccumulator shouldBe listOf("bar", "baz")
+    Args(parserOf("--auto-accumulator=foo")).autoAccumulator shouldBe listOf("foo")
+    Args(parserOf("--auto-accumulator", "bar", "--auto-accumulator", "baz")).autoAccumulator shouldBe listOf("bar", "baz")
 })
 
 class AutoNamedAddingWithTransformTest : Test({
@@ -1229,8 +1229,8 @@ class AutoNamedAddingWithTransformTest : Test({
     }
 
     Args(parserOf()).autoAccumulator shouldBe emptyList<Int>()
-    Args(parserOf("--autoAccumulator=5")).autoAccumulator shouldBe listOf(5)
-    Args(parserOf("--autoAccumulator", "11", "--autoAccumulator", "42")).autoAccumulator shouldBe listOf(11, 42)
+    Args(parserOf("--auto-accumulator=5")).autoAccumulator shouldBe listOf(5)
+    Args(parserOf("--auto-accumulator", "11", "--auto-accumulator", "42")).autoAccumulator shouldBe listOf(11, 42)
 })
 
 class AutoNamedAddingWithTransformAndInitialTest : Test({
@@ -1239,8 +1239,8 @@ class AutoNamedAddingWithTransformAndInitialTest : Test({
     }
 
     Args(parserOf()).autoAccumulator shouldBe emptySet<Int>()
-    Args(parserOf("--autoAccumulator=5")).autoAccumulator shouldBe setOf(5)
-    Args(parserOf("--autoAccumulator", "11", "--autoAccumulator", "42")).autoAccumulator shouldBe setOf(42, 11)
+    Args(parserOf("--auto-accumulator=5")).autoAccumulator shouldBe setOf(5)
+    Args(parserOf("--auto-accumulator", "11", "--auto-accumulator", "42")).autoAccumulator shouldBe setOf(42, 11)
 })
 
 class AutoNamedPositionalTest : Test({