Merge pull request #42 from openapi-processor/#41

resolves #41

Author: hauner

build.gradle

@@ -5,10 +5,10 @@ plugins {
     id 'java-library'
     id 'maven-publish'
     id "org.sonarqube" version "3.0"
-    id 'org.jetbrains.dokka' version '1.4.10'
-    id 'org.jetbrains.kotlin.jvm' version '1.4.10'
+    id 'org.jetbrains.dokka' version '1.4.10.2'
+    id 'org.jetbrains.kotlin.jvm' version '1.4.20'
     id 'org.unbroken-dome.test-sets' version '3.0.1'
-    id "com.github.ben-manes.versions" version "0.33.0"
+    id "com.github.ben-manes.versions" version "0.36.0"
 }
 
 group projectGroupId

src/main/kotlin/io/openapiprocessor/core/writer/java/Identifier.kt

@@ -39,7 +39,7 @@ import java.lang.Character.isJavaIdentifierStart
  * @author Martin Hauner
  */
 fun toCamelCase(src: String): String {
-    return joinCamelCase(joinSingleCharWords(splitAtWordBreaks(src)))
+    return joinCamelCase(splitAtWordBreaks(src))
 }
 
 /**
@@ -81,10 +81,9 @@ fun toClass(src: String): String {
  * @author Martin Hauner
  */
 fun toEnum(src: String): String {
-    return joinEnum(joinSingleCharWords(splitAtWordBreaks(src)))
+    return joinEnum(splitAtWordBreaks(src))
 }
 
-
 /**
  * joins the given words to a single camel case string.
  *
@@ -95,7 +94,7 @@ fun toEnum(src: String): String {
  *
  * @author Martin Hauner
  */
-private fun joinCamelCase(words: ArrayList<String>): String {
+private fun joinCamelCase(words: List<String>): String {
     val sb = StringBuilder()
 
     words.forEachIndexed { idx, p ->
@@ -121,7 +120,7 @@ private fun joinCamelCase(words: ArrayList<String>): String {
  *
  * @author Martin Hauner
  */
-private fun joinEnum(words: ArrayList<String>): String {
+private fun joinEnum(words: List<String>): String {
     val result = words.joinToString("_") { it.toUpperCase() }
 
     if (result.isEmpty()) {
@@ -131,42 +130,6 @@ private fun joinEnum(words: ArrayList<String>): String {
     return result
 }
 
-/**
- * joins two words if at least one has only a single character.
- *
- * this tries to avoid identifiers with multiple uppercase characters in a row.
- *
- * @param words a list of words
- * @return a list of words
- *
- * @author Martin Hauner
- */
-private fun joinSingleCharWords(words: List<String>): ArrayList<String> {
-    val merged = ArrayList<String>()
-    val current = StringBuilder()
-
-    words.forEachIndexed { idx, p ->
-        if (idx == 0) {
-            current.append(p)
-        } else {
-            if (current.last().isUpperCase() && (current.length == 1 || p.length == 1)) {
-                current.append(p)
-            } else {
-                merged.add(current.toString())
-                current.clear()
-                current.append(p)
-            }
-        }
-    }
-
-
-    if (current.isNotEmpty()) {
-        merged.add(current.toString())
-    }
-
-    return merged
-}
-
 /**
  * splits the given string at the word breaks.
  *
@@ -182,7 +145,7 @@ private fun splitAtWordBreaks(src: String): List<String> {
     val trimmed = src.trimInvalidStart()
     trimmed.forEachIndexed { idx, c ->
 
-        if (idx == 0 || c.isNoWordBreak()) {
+        if (idx == 0 || !trimmed.isWordBreak(idx)) {
             current.append(c)
             return@forEachIndexed
         }
@@ -219,13 +182,33 @@ private fun StringBuilder.appendValid(c: Char): StringBuilder {
     return this
 }
 
+private fun String.isWordBreak(idx: Int): Boolean {
+    return this.isForcedBreak(idx)
+        || this.isCaseBreak(idx)
+}
+
+private fun String.isForcedBreak(idx: Int): Boolean {
+    return this[idx].isWordBreak()
+}
+
+// detect existing camel case word breaks
+private fun String.isCaseBreak(idx: Int): Boolean {
+    if (idx == 0)
+        return false
+
+    val prev = this[idx - 1]
+    val curr = this[idx]
+
+    return prev.isLowerCase()
+        && curr.isUpperCase()
+}
+
 private fun Char.isNoWordBreak(): Boolean {
     return !isWordBreak()
 }
 
 private fun Char.isWordBreak(): Boolean {
     return isWordBreakChar(this)
-        || this.isUpperCase()
         || !isJavaIdentifierPart(this)
 }
 

src/test/groovy/io/openapiprocessor/core/writer/java/IdentifierSpec.groovy

@@ -34,10 +34,7 @@ class IdentifierSpec extends Specification {
         // first char should be lowercase
         "a"              | "a"            | "A"            | "A"
         "A"              | "a"            | "A"            | "A"
-
-        //
         "AA"             | "aa"           | "Aa"           | "AA"
-        "AAFoo"          | "aaFoo"        | "AaFoo"        | "AA_FOO"
 
         // invalid chars are stripped
         "1a"             | "a"            | "A"            | "A"
@@ -46,30 +43,29 @@ class IdentifierSpec extends Specification {
         // word break at invalid characters
         "a foo"          | "aFoo"         | "AFoo"         | "A_FOO"
         "a-foo"          | "aFoo"         | "AFoo"         | "A_FOO"
+        "FOO-bar"        | "fooBar"       | "FooBar"       | "FOO_BAR"
         "a foo bar"      | "aFooBar"      | "AFooBar"      | "A_FOO_BAR"
         "a-foo-bar"      | "aFooBar"      | "AFooBar"      | "A_FOO_BAR"
         "a foo-bar"      | "aFooBar"      | "AFooBar"      | "A_FOO_BAR"
         'api/some/thing' | 'apiSomeThing' | "ApiSomeThing" | "API_SOME_THING"
+        "_fo-o"          | 'foO'          | 'FoO'          | "FO_O"
 
-        // word break at underscore, it is valid but unwanted
+        // word break at underscore, it is valid but unwanted except for enums
         "_ab"            | "ab"           | "Ab"           | "AB"
         "a_b"            | "aB"           | "AB"           | "A_B"
         "a_foo"          | "aFoo"         | "AFoo"         | "A_FOO"
+        "A_A"            | "aA"           | "AA"           | "A_A"
+        "FOO_FOO"        | "fooFoo"       | "FooFoo"       | "FOO_FOO"
+
+        // word break at case change: lower to upper, preserve camel case
+        "fooBar"         | "fooBar"       | "FooBar"       | "FOO_BAR"
+        "fooBAr"         | "fooBar"       | "FooBar"       | "FOO_BAR"
+        "fooBAR"         | "fooBar"       | "FooBar"       | "FOO_BAR"
 
         // final result is empty
         " "              | "invalid"      | "Invalid"      | "INVALID"
         "_"              | "invalid"      | "Invalid"      | "INVALID"
         "-"              | "invalid"      | "Invalid"      | "INVALID"
-
-        // word break at uppercase
-        "fooBar"         | "fooBar"       | "FooBar"       | "FOO_BAR"
-
-        // upper case only at word break
-        "fooBAr"         | "fooBar"       | "FooBar"       | "FOO_BAR"
-        "fooBAR"         | "fooBar"       | "FooBar"       | "FOO_BAR"
-        "FOO-bar"        | "fooBar"       | "FooBar"       | "FOO_BAR"
-        "FOOBar"         | "fooBar"       | "FooBar"       | "FOO_BAR"
-        "FOObar"         | "foObar"       | "FoObar"       | "FO_OBAR"
     }
 
 }