Merge pull request #147 from blast-hardcheese/fix-issue-145

Fix emptyToNull not working correctly with snake-cased parameters

Author: blast-hardcheese

modules/codegen/src/main/scala/com/twilio/guardrail/ProtocolGenerator.scala

@@ -21,12 +21,15 @@ case class ProtocolDefinitions[L <: LA](elems: List[StrictProtocolElems[L]],
                                         protocolImports: List[L#Import],
                                         packageObjectImports: List[L#Import],
                                         packageObjectContents: List[L#ValueDefinition])
+sealed trait EmptyToNullBehaviour
+case object EmptyIsNull extends EmptyToNullBehaviour
+case object EmptyIsEmpty extends EmptyToNullBehaviour
 
 case class ProtocolParameter[L <: LA](term: L#MethodParameter,
                                       name: String,
                                       dep: Option[L#TermName],
                                       readOnlyKey: Option[String],
-                                      emptyToNullKey: Option[String])
+                                      emptyToNull: EmptyToNullBehaviour)
 
 case class SuperClass[L <: LA](
     clsName: String,

modules/codegen/src/main/scala/com/twilio/guardrail/extract/Extractable.scala

@@ -1,4 +1,5 @@
 package com.twilio.guardrail.extract
+import com.twilio.guardrail.{ EmptyIsEmpty, EmptyIsNull, EmptyToNullBehaviour }
 
 import scala.util.Try
 
@@ -28,4 +29,9 @@ object Extractable {
   implicit val defaultExtractableString: Extractable[String] = build[String]({
     case x: String => x
   })
+  implicit val defaultExtractableEmptyToNullBehaviour: Extractable[EmptyToNullBehaviour] =
+    build[EmptyToNullBehaviour]({
+      case x: Boolean if x => EmptyIsNull
+      case x: Boolean if ! x => EmptyIsEmpty
+    })
 }

modules/codegen/src/main/scala/com/twilio/guardrail/extract/package.scala

@@ -9,8 +9,8 @@ package object extract {
     VendorExtension(v).extract[String]("x-scala-type")
   def ServerRawResponse[F: VendorExtension.VendorExtensible](v: F): Option[Boolean] =
     VendorExtension(v).extract[Boolean]("x-server-raw-response")
-  def ScalaEmptyIsNull[F: VendorExtension.VendorExtensible](v: F): Option[Boolean] =
-    VendorExtension(v).extract[Boolean]("x-scala-empty-is-null")
+  def ScalaEmptyIsNull[F: VendorExtension.VendorExtensible](v: F): Option[EmptyToNullBehaviour] =
+    VendorExtension(v).extract[EmptyToNullBehaviour]("x-scala-empty-is-null")
   def ScalaFileHashAlgorithm[F: VendorExtension.VendorExtensible](v: F): Option[String] =
     VendorExtension(v).extract[String]("x-scala-file-hash")
 }

modules/codegen/src/main/scala/com/twilio/guardrail/generators/CirceProtocolGenerator.scala

@@ -132,13 +132,12 @@ object CirceProtocolGenerator {
           }
 
           readOnlyKey = Option(name).filter(_ => Option(property.getReadOnly).contains(true))
-          needsEmptyToNull = property match {
+          emptyToNull = (property match {
             case d: DateProperty      => ScalaEmptyIsNull(d)
             case dt: DateTimeProperty => ScalaEmptyIsNull(dt)
             case s: StringProperty    => ScalaEmptyIsNull(s)
             case _                    => None
-          }
-          emptyToNullKey = needsEmptyToNull.filter(_ == true).map(_ => argName)
+          }).getOrElse(EmptyIsEmpty)
 
           (tpe, classDep) = meta match {
             case SwaggerUtil.Resolved(declType, classDep, _) =>
@@ -162,7 +161,7 @@ object CirceProtocolGenerator {
             )(Function.const((tpe, defaultValue)) _)
           term = param"${Term.Name(argName)}: ${finalDeclType}".copy(default = finalDefaultValue)
           dep  = classDep.filterNot(_.value == clsName) // Filter out our own class name
-        } yield ProtocolParameter[ScalaLanguage](term, name, dep, readOnlyKey, emptyToNullKey)
+        } yield ProtocolParameter[ScalaLanguage](term, name, dep, readOnlyKey, emptyToNull)
 
       case RenderDTOClass(clsName, selfTerms, parents) =>
         val discriminators = parents.flatMap(_.discriminators)
@@ -238,9 +237,9 @@ object CirceProtocolGenerator {
         val params = (parents.reverse.flatMap(_.params) ++ selfParams).filterNot(
           param => discriminators.contains(param.name)
         )
-        val emptyToNullKeys: List[String] = params.flatMap(_.emptyToNullKey).toList
+        val needsEmptyToNull: Boolean = params.exists(_.emptyToNull == EmptyIsNull)
         val paramCount                    = params.length
-        val decVal = if (paramCount <= 22 && emptyToNullKeys.isEmpty) {
+        val decVal = if (paramCount <= 22 && !needsEmptyToNull) {
           val names: List[Lit] = params.map(_.name).map(Lit.String(_)).to[List]
           q"""
             Decoder.${Term.Name(s"forProduct${paramCount}")}(..${names})(${Term
@@ -258,7 +257,7 @@ object CirceProtocolGenerator {
                 })
                 .get
               val term = Term.Name(param.term.name.value)
-              val enum = if (emptyToNullKeys contains param.name) {
+              val enum = if (param.emptyToNull == EmptyIsNull) {
                 enumerator"""
                 ${Pat.Var(term)} <- c.downField(${Lit
                   .String(param.name)}).withFocus(j => j.asString.fold(j)(s => if(s.isEmpty) Json.Null else j)).as[${tpe}]

modules/codegen/src/test/scala/core/issues/Issue145.scala

@@ -0,0 +1,67 @@
+package core.issues
+
+import com.twilio.guardrail._
+import com.twilio.guardrail.generators.AkkaHttp
+import org.scalatest.{ FunSpec, Matchers }
+import support.SwaggerSpecRunner
+
+import scala.meta._
+
+class Issue145 extends FunSpec with Matchers with SwaggerSpecRunner {
+
+  describe("Generate hierarchical classes") {
+
+    val swagger: String = """
+      | swagger: '2.0'
+      | info:
+      |   title: Parsing Error Sample
+      |   version: 1.0.0
+      | definitions:
+      |   Pet:
+      |     type: object
+      |     properties:
+      |       name:
+      |         type: string
+      |         x-scala-empty-is-null: true
+      |         x-scala-type: CustomThing
+      |       underscore_name:
+      |         type: string
+      |         x-scala-empty-is-null: true
+      |         x-scala-type: CustomThing
+      |       dash-name:
+      |         type: string
+      |         x-scala-empty-is-null: true
+      |         x-scala-type: CustomThing
+      |""".stripMargin
+
+    val (
+      ProtocolDefinitions(
+        ClassDefinition(namePet, tpePet, clsPet, companionPet, catParents) :: Nil,
+        _,
+        _,
+        _
+      ),
+      _,
+      _
+    ) = runSwaggerSpec(swagger)(Context.empty, AkkaHttp)
+
+    it("should generate right companion object") {
+      companionPet.toString() shouldBe q"""
+        object Pet {
+          implicit val encodePet = {
+            val readOnlyKeys = Set[String]()
+            Encoder.forProduct3("name", "underscore_name", "dash-name")((o: Pet) => (o.name, o.underscoreName, o.`dash-name`)).mapJsonObject(_.filterKeys(key => !(readOnlyKeys contains key)))
+          }
+          implicit val decodePet = new Decoder[Pet] {
+            final def apply(c: HCursor): Decoder.Result[Pet] =
+              for (
+                name <- c.downField("name").withFocus(j => j.asString.fold(j)(s => if (s.isEmpty) Json.Null else j)).as[Option[CustomThing]];
+                underscoreName <- c.downField("underscore_name").withFocus(j => j.asString.fold(j)(s => if (s.isEmpty) Json.Null else j)).as[Option[CustomThing]];
+                `dash-name` <- c.downField("dash-name").withFocus(j => j.asString.fold(j)(s => if (s.isEmpty) Json.Null else j)).as[Option[CustomThing]]
+              ) yield Pet(name, underscoreName, `dash-name`)
+          }
+        }""".toString()
+    }
+
+  }
+}