Print case classes from a nested structure

CaseClassPrinting.scala

object Printing extends App {

  trait Test {
    val name: String
  }
  case class TestSingle(name: String, t: String, isOptional: Boolean) extends Test
  case class NestedTest(name: String, fields: List[Test], isOptional: Boolean) extends Test

  val testData = NestedTest("main", List(
    TestSingle("field1", "Boolean", false),
    TestSingle("field2", "String", true),
    NestedTest("nestedField", List(
      TestSingle("field3", "Boolean", false),
      NestedTest("nestedFieldDeeper", List(
        TestSingle("field4", "Awesome", true)
      ), true)
    ), false)
  ), true)

  case class PrintField(name: String, typeName: String, isOptional: Boolean)
  case class PrintClass(name: String, fields: List[PrintField])

  def toPrintClasses(nested: NestedTest): List[PrintClass] = {

    val result: List[(PrintField, List[PrintClass])] = nested.fields.map({
      case TestSingle(name, value, isOptional) => (PrintField(name, value, isOptional), List())
      case nested@NestedTest(name, _, isOptional) => {
        (PrintField(name, name.capitalize, isOptional), toPrintClasses(nested))
      }
    })

    val fieldsToPrint: List[PrintField] = result.map(_._1)
    val classesToPrint = result.flatMap(_._2)
    PrintClass(nested.name.capitalize, fieldsToPrint) :: classesToPrint
  }


  def printClass(toPrint: PrintClass): String = {

    val fields = toPrint.fields.map(f => {
      if (f.isOptional)
        s"${f.name}: Option[${f.typeName}]"
      else
        s"${f.name}: ${f.typeName}"
    }).mkString(",\n  ")

    s"""
       |case class ${toPrint.name}(
       |  $fields
       |)
     """.stripMargin
  }

  def printClasses(toPrint: List[PrintClass]): String = {
    toPrint.reverse.map(printClass).mkString("")
  }

  println(printClasses(toPrintClasses(testData)))
}