Implemenation for camel to snake case conversion

Author: yadavan88

scala-core-modules/scala-strings-2/src/main/scala/com/baeldung/scala/strings/cameltosnake/CamelToSnakeConversion.scala

@@ -0,0 +1,65 @@
+package com.baeldung.scala.strings.cameltosnake
+
+import scala.annotation.tailrec
+
+object CamelToSnakeConversion {
+
+  def usingRegex(camelCaseString: String): String = {
+    val regex = "([A-Z])".r
+    regex.replaceAllIn(
+      camelCaseString,
+      m => s"_${m.group(1).toLowerCase}"
+    )
+  }
+
+  def usingFoldLeft(camelCaseString: String): String = {
+    camelCaseString.foldLeft("") { (acc, char) =>
+      if (char.isUpper) {
+        if (acc.isEmpty) char.toLower.toString
+        else acc + "_" + char.toLower
+      } else {
+        acc + char
+      }
+    }
+  }
+
+  def handleAcronymsWithRegex(camelCaseString: String): String = {
+    camelCaseString
+      .replaceAll("([A-Z]+)([A-Z][a-z])", "$1_$2")
+      .replaceAll("([a-z\\d])([A-Z])", "$1_$2")
+      .toLowerCase
+  }
+
+  def usingFlatMap(camelCase: String): String = {
+    camelCase
+      .flatMap { c =>
+        if (c.isUpper) List('_', c) else List(c)
+      }
+      .mkString
+      .toLowerCase
+  }
+
+  def usingPatternMatching(camelCase: String): String = {
+    @tailrec
+    def rec(chars: List[Char], acc: List[Char]): List[Char] = {
+      chars match {
+        case Nil                    => acc
+        case a :: tail if a.isUpper => rec(tail, acc ++ Seq('_', a))
+        case a :: tail              => rec(tail, acc ++ Seq(a))
+      }
+    }
+    rec(camelCase.toList, Nil).mkString.toLowerCase
+  }
+
+  def usingCollect(camelCase: String): String = {
+    camelCase
+      .collect {
+        case c if c.isUpper => Seq('_', c)
+        case c              => Seq(c)
+      }
+      .flatten
+      .mkString
+      .toLowerCase
+  }
+
+}

scala-core-modules/scala-strings-2/src/test/scala/com/baeldung/scala/strings/cameltosnake/CamelToSnakeConversionUnitTest.scala

@@ -0,0 +1,59 @@
+package com.baeldung.scala.strings.cameltosnake
+
+import org.scalatest.flatspec.AnyFlatSpec
+import org.scalatest.matchers.should.Matchers
+import org.scalatest.prop.TableDrivenPropertyChecks
+
+class CamelToSnakeConversionUnitTest
+  extends AnyFlatSpec
+  with Matchers
+  with TableDrivenPropertyChecks {
+
+  private val table = Table(
+    ("input", "expected"),
+    ("thisIsCamelCase", "this_is_camel_case"),
+    ("isThisCamel?", "is_this_camel?"),
+    ("alllower", "alllower"),
+    ("thisIsUSA", "this_is_u_s_a"),
+    ("xmlHttpRequest", "xml_http_request"),
+    ("convertXMLToJSON", "convert_x_m_l_to_j_s_o_n"),
+    ("parseHTML", "parse_h_t_m_l"),
+    ("classOfT", "class_of_t")
+  )
+  private val fns = Seq(
+    ("usingRegex", CamelToSnakeConversion.usingRegex),
+    ("usingFoldLeft", CamelToSnakeConversion.usingFoldLeft),
+    ("usingFlatMap", CamelToSnakeConversion.usingFlatMap),
+    ("usingPatterMatching", CamelToSnakeConversion.usingPatternMatching),
+    ("usingCollect", CamelToSnakeConversion.usingCollect)
+  )
+
+  it should "convert camel to snake case" in {
+    forAll(table) { (camel, expectedSnake) =>
+      fns.map { (name, fn) =>
+        withClue("function name: " + name) {
+          fn(camel) shouldBe expectedSnake
+        }
+      }
+    }
+  }
+
+  it should "handle camel case starting with upper case character" in {
+    val output = CamelToSnakeConversion.usingRegex("HelloWorld")
+    output.stripPrefix("_") shouldBe "hello_world"
+  }
+
+  it should "handle special case" in {
+    Seq(
+      ("HelloWorld", "hello_world"),
+      ("thisIsUSA", "this_is_usa"),
+      ("convertXMLToJSON", "convert_xml_to_json"),
+      ("xmlToHTTPRequest", "xml_to_http_request")
+    ).map { (in, out) =>
+      val output = CamelToSnakeConversion.handleAcronymsWithRegex(in)
+      output shouldBe out
+    }
+
+  }
+
+}