Upgrade Option Serialization support to use ReferenceType.

nbauernfeind · nbauernfeind · commit 5b3e78ffdf48 · 2016-04-18T23:07:27.000-04:00
diff --git a/build.sbt b/build.sbt
@@ -7,7 +7,7 @@ organization := "com.fasterxml.jackson.module"
 
 scalaVersion := "2.11.8"
 
-crossScalaVersions := Seq("2.10.6", "2.11.8", "2.12.0-M4")
+crossScalaVersions := Seq("2.10.6", "2.11.8", "2.12.0-M4)
 
 scalacOptions ++= Seq("-deprecation", "-unchecked", "-feature")
 
diff --git a/src/main/scala/com/fasterxml/jackson/module/scala/modifiers/OptionTypeModifierModule.scala b/src/main/scala/com/fasterxml/jackson/module/scala/modifiers/OptionTypeModifierModule.scala
@@ -1,11 +1,23 @@
 package com.fasterxml.jackson.module.scala.modifiers
 
+import java.lang.reflect.Type
+
+import com.fasterxml.jackson.databind.JavaType
+import com.fasterxml.jackson.databind.`type`.{ReferenceType, TypeBindings, TypeFactory, TypeModifier}
 import com.fasterxml.jackson.module.scala.JacksonModule
 
-private object OptionTypeModifier extends CollectionLikeTypeModifier {
-  def BASE = classOf[Option[Any]]
+private object OptionTypeModifier extends TypeModifier with GenTypeModifier {
+  def OPTION = classOf[Option[AnyRef]]
+
+  override def modifyType(typ: JavaType, jdkType: Type, context: TypeBindings, typeFactory: TypeFactory): JavaType = {
+    if (typ.isReferenceType || typ.isContainerType) return typ
+
+    if (classObjectFor(jdkType).exists(OPTION.isAssignableFrom)) {
+      ReferenceType.upgradeFrom(typ, typ.containedTypeOrUnknown(0))
+    } else typ
+  }
 }
 
 trait OptionTypeModifierModule extends JacksonModule {
   this += OptionTypeModifier
-}
+}
diff --git a/src/main/scala/com/fasterxml/jackson/module/scala/ser/OptionSerializerModule.scala b/src/main/scala/com/fasterxml/jackson/module/scala/ser/OptionSerializerModule.scala
@@ -2,178 +2,214 @@ package com.fasterxml.jackson
 package module.scala
 package ser
 
-import util.Implicits._
-import modifiers.OptionTypeModifierModule
-
-import core.JsonGenerator
-import databind._
-import jsontype.TypeSerializer
-import jsonschema.{JsonSchema, SchemaAware}
-import ser.{ContextualSerializer, BeanPropertyWriter, BeanSerializerModifier, Serializers}
-import ser.impl.UnknownSerializer
-import ser.std.StdSerializer
-import com.fasterxml.jackson.databind.`type`.CollectionLikeType
-import jsonFormatVisitors.JsonFormatVisitorWrapper
-
 import java.lang.reflect.Type
-import java.{util => ju}
+import com.fasterxml.jackson.annotation.JsonInclude
+import com.fasterxml.jackson.core.JsonGenerator
+import com.fasterxml.jackson.databind._
+import com.fasterxml.jackson.databind.`type`.ReferenceType
+import com.fasterxml.jackson.databind.annotation.JsonSerialize
+import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper
+import com.fasterxml.jackson.databind.jsonschema.{JsonSchema, SchemaAware}
+import com.fasterxml.jackson.databind.jsontype.TypeSerializer
+import com.fasterxml.jackson.databind.ser.impl.{PropertySerializerMap, UnknownSerializer}
+import com.fasterxml.jackson.databind.ser.std.StdSerializer
+import com.fasterxml.jackson.databind.ser.{ContextualSerializer, Serializers}
+import com.fasterxml.jackson.databind.util.NameTransformer
+import com.fasterxml.jackson.module.scala.modifiers.OptionTypeModifierModule
+import com.fasterxml.jackson.module.scala.util.Implicits._
+
+private object OptionSerializer {
+  def useStatic(provider: SerializerProvider, property: Option[BeanProperty], referredType: JavaType): Boolean = {
+    // First: no serializer for `Object.class`, must be dynamic
+    if (referredType.isJavaLangObject) return false
+    // but if type is final, might as well fetch
+    if (referredType.isFinal) return true
+    // also: if indicated by typing, should be considered static
+    if (referredType.useStaticType()) return true
+    // if neither, maybe explicit annotation?
+    for (
+      ann <- property.flatMap(p => Option(p.getMember));
+      intr <- Option(provider.getAnnotationIntrospector)
+    ) {
+      val typing = intr.findSerializationTyping(ann)
+      if (typing == JsonSerialize.Typing.STATIC) return true
+      if (typing == JsonSerialize.Typing.DYNAMIC) return false
+    }
+    // and finally, may be forced by global static typing (unlikely...)
+    provider.isEnabled(MapperFeature.USE_STATIC_TYPING)
+  }
+
+  def findSerializer(provider: SerializerProvider, typ: Class[_], prop: Option[BeanProperty]): JsonSerializer[AnyRef] = {
+    // Important: ask for TYPED serializer, in case polymorphic handling is needed!
+    provider.findTypedValueSerializer(typ, true, prop.orNull)
+  }
+
+  def findSerializer(provider: SerializerProvider, typ: JavaType, prop: Option[BeanProperty]): JsonSerializer[AnyRef] = {
+    // Important: ask for TYPED serializer, in case polymorphic handling is needed!
+    provider.findTypedValueSerializer(typ, true, prop.orNull)
+  }
+
+  def hasContentTypeAnnotation(provider: SerializerProvider, property: BeanProperty): Boolean = {
+    val intr = provider.getAnnotationIntrospector
+    if (property == null || intr == null) return false
+    intr.refineSerializationType(provider.getConfig, property.getMember, property.getType) != null
+  }
+}
 
-private class OptionSerializer(elementType: Option[JavaType],
+private class OptionSerializer(referredType: JavaType,
+                               property: Option[BeanProperty],
                                valueTypeSerializer: Option[TypeSerializer],
-                               beanProperty: Option[BeanProperty],
-                               elementSerializer: Option[JsonSerializer[AnyRef]])
-  extends StdSerializer[Option[AnyRef]](classOf[Option[AnyRef]])
-  with ContextualSerializer
-  with SchemaAware
-{
-  override def serialize(value: Option[AnyRef], jgen: JsonGenerator, provider: SerializerProvider) {
-    def doSerialize(v: AnyRef) = {
-      val cls = v.getClass
-      val ser = elementType.filter(_.hasGenericTypes) match {
-        case Some(et) => provider.findValueSerializer(provider.constructSpecializedType(et, cls), beanProperty.orNull)
-        case None => provider.findValueSerializer(cls, beanProperty.orNull)
-      }
-      ser.serialize(v, jgen, provider)
-    }
+                               valueSerializer: Option[JsonSerializer[AnyRef]],
+                               contentInclusion: Option[JsonInclude.Include],
+                               unwrapper: Option[NameTransformer],
+                               var dynamicSerializers: PropertySerializerMap = PropertySerializerMap.emptyForProperties())
+  extends StdSerializer[Option[AnyRef]](referredType)
+    with ContextualSerializer
+    with SchemaAware {
+
+  import OptionSerializer._
+
+  override def unwrappingSerializer(transformer: NameTransformer): JsonSerializer[Option[AnyRef]] = {
+    val ser = valueSerializer.map(_.unwrappingSerializer(transformer))
+    val unt = unwrapper.map(NameTransformer.chainedTransformer(transformer, _)).getOrElse(transformer)
+    withResolved(property, valueTypeSerializer, ser, Option(unt), contentInclusion)
+  }
 
-    valueTypeSerializer match {
-      case Some(vt) => serializeWithType(value, jgen, provider, vt)
-      case None =>
-        (value, elementSerializer) match {
-          case (Some(v), Some(vs: UnknownSerializer)) => doSerialize(v)
-          case (Some(v), None) => doSerialize(v)
-          case (Some(v), Some(vs)) => vs.serialize(v, jgen, provider)
-          case (None, _) => provider.defaultSerializeNull(jgen)
-        }
-    }
+  protected[this] def withResolved(prop: Option[BeanProperty], vts: Option[TypeSerializer],
+                                   valueSer: Option[JsonSerializer[AnyRef]], unt: Option[NameTransformer],
+                                   contentIncl: Option[JsonInclude.Include]): OptionSerializer = {
+    if (prop == property && vts == valueTypeSerializer && valueSer == valueSerializer &&
+      contentIncl == contentInclusion && unt == unwrapper) this
+    else new OptionSerializer(referredType, prop, vts, valueSer, contentIncl, unt, dynamicSerializers)
   }
 
-  override def serializeWithType(value: Option[AnyRef], jgen: JsonGenerator, provider: SerializerProvider, typeSer: TypeSerializer) {
-    def doSerialize(v: AnyRef) = {
-      val cls = v.getClass
-      val ser = elementType.filter(_.hasGenericTypes) match {
-        case Some(et) => provider.findTypedValueSerializer(provider.constructSpecializedType(et, cls), true, beanProperty.orNull)
-        case None => provider.findTypedValueSerializer(cls, true, beanProperty.orNull)
-      }
-      ser.serializeWithType(v, jgen, provider, typeSer)
+  override def createContextual(prov: SerializerProvider, prop: BeanProperty): JsonSerializer[_] = {
+    val propOpt = Option(prop)
+
+    val vts = valueTypeSerializer.optMap(_.forProperty(prop))
+    var ser = for (
+      prop <- propOpt;
+      member <- Option(prop.getMember);
+      serDef <- Option(prov.getAnnotationIntrospector.findContentSerializer(member))
+    ) yield prov.serializerInstance(member, serDef)
+    ser = ser.orElse(valueSerializer).map(prov.handlePrimaryContextualization(_, prop)).asInstanceOf[Option[JsonSerializer[AnyRef]]]
+    ser = Option(findConvertingContentSerializer(prov, prop, ser.orNull).asInstanceOf[JsonSerializer[AnyRef]])
+    ser = ser match {
+      case None => if (hasContentTypeAnnotation(prov, prop)) {
+        Option(prov.findValueSerializer(referredType, prop)).filterNot(_.isInstanceOf[UnknownSerializer])
+      } else None
+        // Why secondary why not primary?
+      case Some(s) => Option(prov.handleSecondaryContextualization(s, prop).asInstanceOf[JsonSerializer[AnyRef]])
     }
 
-    (value, elementSerializer) match {
-      case (Some(v), Some(vs: UnknownSerializer)) => doSerialize(v)
-      case (Some(v), None) => doSerialize(v)
-      case (Some(v), Some(vs)) => vs.serializeWithType(v, jgen, provider, typeSer)
-      case (None, _) => provider.defaultSerializeNull(jgen)
+    // A few conditions needed to be able to fetch serializer here:
+    if (ser.isEmpty && useStatic(prov, propOpt, referredType)) {
+      ser = Option(findSerializer(prov, referredType, propOpt))
     }
+    // Also: may want to have more refined exclusion based on referenced value
+    val newIncl = propOpt match {
+      case None => contentInclusion
+      case Some(p) =>
+        val pinc = p.findPropertyInclusion(prov.getConfig, classOf[Option[AnyRef]])
+        val incl = pinc.getContentInclusion
+        if (incl != JsonInclude.Include.USE_DEFAULTS) {
+          Some(incl)
+        } else contentInclusion
+    }
+    withResolved(propOpt, vts, ser, unwrapper, newIncl)
+  }
+
+  override def isEmpty(provider: SerializerProvider, value: Option[AnyRef]): Boolean = {
+    if (value == null || value.isEmpty) return true
+    if (contentInclusion.isEmpty) return false
+    val contents = value.get
+    valueSerializer
+      .getOrElse(findCachedSerializer(provider, contents.getClass))
+      .isEmpty(provider, contents)
   }
 
-  override def createContextual(prov: SerializerProvider, property: BeanProperty): JsonSerializer[_] = {
-    // Based on the version in AsArraySerializerBase
-    val typeSer = valueTypeSerializer.optMap(_.forProperty(property))
-    var ser: Option[JsonSerializer[_]] =
-      Option(property).flatMap { p =>
-        Option(p.getMember).flatMap { m =>
-          Option(prov.getAnnotationIntrospector.findContentSerializer(m)).map { serDef =>
-            prov.serializerInstance(m, serDef)
-          }
-        }
-      } orElse elementSerializer
-    ser = Option(findConvertingContentSerializer(prov, property, ser.orNull))
-    if (ser.isEmpty) {
-      if (elementType.isDefined) {
-        if (hasContentTypeAnnotation(prov, property)) {
-          ser = Option(prov.findValueSerializer(elementType.get, property))
-        }
+  override def isUnwrappingSerializer: Boolean = unwrapper.isDefined
+
+  override def serialize(opt: Option[AnyRef], gen: JsonGenerator, provider: SerializerProvider): Unit = {
+    if (opt.isEmpty) {
+      if (unwrapper.isEmpty) {
+        provider.defaultSerializeNull(gen)
       }
+      return
     }
-    else {
-      ser = Option(prov.handleSecondaryContextualization(ser.get, property))
+
+    val value = opt.get
+    val ser = valueSerializer.getOrElse(findCachedSerializer(provider, value.getClass))
+    valueTypeSerializer match {
+      case Some(vts) => ser.serializeWithType(value, gen, provider, vts)
+      case None => ser.serialize(value, gen, provider)
     }
-    if ((ser != elementSerializer) || (property != beanProperty.orNull) || (valueTypeSerializer != typeSer))
-      new OptionSerializer(elementType, typeSer, Option(property), ser.asInstanceOf[Option[JsonSerializer[AnyRef]]])
-    else this
   }
 
-  def hasContentTypeAnnotation(provider: SerializerProvider, property: BeanProperty) = {
-    Option(property).exists { p =>
-      Option(provider.getAnnotationIntrospector).exists { intr =>
-        Option(intr.refineSerializationType(provider.getConfig, p.getMember, p.getType)).isDefined
+  override def serializeWithType(opt: Option[AnyRef], gen: JsonGenerator, provider: SerializerProvider, typeSer: TypeSerializer): Unit = {
+    if (opt.isEmpty) {
+      if (unwrapper.isEmpty) {
+        provider.defaultSerializeNull(gen)
       }
+      return
     }
+    // Otherwise apply type-prefix/suffix, then std serialize:
+    typeSer.writeTypePrefixForScalar(opt, gen, classOf[Option[_]])
+    serialize(opt, gen, provider)
+    typeSer.writeTypeSuffixForScalar(opt, gen)
   }
 
-  override def isEmpty(value: Option[AnyRef]): Boolean = value.isEmpty
-
   override def getSchema(provider: SerializerProvider, typeHint: Type): JsonNode =
     getSchema(provider, typeHint, isOptional = true)
 
   override def getSchema(provider: SerializerProvider, typeHint: Type, isOptional: Boolean): JsonNode = {
-    val contentSerializer = elementSerializer.getOrElse {
+    val contentSerializer = valueSerializer.getOrElse {
       val javaType = provider.constructType(typeHint)
       val componentType = javaType.getContentType
-      provider.findTypedValueSerializer(componentType, true, beanProperty.orNull)
+      provider.findTypedValueSerializer(componentType, true, property.orNull)
     }
     contentSerializer match {
       case cs: SchemaAware => cs.getSchema(provider, contentSerializer.handledType(), isOptional)
       case _ => JsonSchema.getDefaultSchemaNode
     }
   }
 
-  override def acceptJsonFormatVisitor(wrapper: JsonFormatVisitorWrapper, javaType: JavaType) {
-    val containedType = javaType.getContentType
-    val ser = elementSerializer.getOrElse(wrapper.getProvider.findTypedValueSerializer(containedType, true, beanProperty.orNull))
-    ser.acceptJsonFormatVisitor(wrapper, containedType)
+  override def acceptJsonFormatVisitor(visitor: JsonFormatVisitorWrapper, typeHint: JavaType): Unit = {
+    var ser = valueSerializer.getOrElse(findSerializer(visitor.getProvider, referredType, property))
+    ser = unwrapper.map(ser.unwrappingSerializer).getOrElse(ser)
+    ser.acceptJsonFormatVisitor(visitor, referredType)
   }
-}
 
-private class OptionPropertyWriter(delegate: BeanPropertyWriter) extends BeanPropertyWriter(delegate)
-{
-  override def serializeAsField(bean: AnyRef, jgen: JsonGenerator, prov: SerializerProvider) {
-    (get(bean), _nullSerializer) match {
-      // value is None, which we'll serialize as null, but there's no
-      // null-serializer, which means it should be suppressed
-      case (None, null) => return
-      case _ => super.serializeAsField(bean, jgen, prov)
+  protected[this] def findCachedSerializer(prov: SerializerProvider, typ: Class[_]): JsonSerializer[AnyRef] = {
+    var ser = dynamicSerializers.serializerFor(typ)
+    if (ser == null) {
+      ser = findSerializer(prov, typ, property)
+      ser = unwrapper.map(ser.unwrappingSerializer).getOrElse(ser)
+      dynamicSerializers = dynamicSerializers.newWith(typ, ser)
     }
-  }
-}
-
-private object OptionBeanSerializerModifier extends BeanSerializerModifier {
-
-  override def changeProperties(config: SerializationConfig,
-                                beanDesc: BeanDescription,
-                                beanProperties: ju.List[BeanPropertyWriter]): ju.List[BeanPropertyWriter] = {
-    import scala.collection.JavaConversions._
-    beanProperties.transform(w => if (isOption(w)) new OptionPropertyWriter(w) else w)
-  }
-
-  private[this] def isOption(writer: BeanPropertyWriter): Boolean = {
-    classOf[Option[_]].isAssignableFrom(writer.getPropertyType)
+    ser
   }
 }
 
 private object OptionSerializerResolver extends Serializers.Base {
 
   private val OPTION = classOf[Option[_]]
 
-  override def findCollectionLikeSerializer(config: SerializationConfig,
-                                            `type`: CollectionLikeType,
-                                            beanDesc: BeanDescription,
-                                            elementTypeSerializer: TypeSerializer ,
-                                            elementValueSerializer: JsonSerializer[AnyRef]
-                                           ): JsonSerializer[_] =
-
-    if (!OPTION.isAssignableFrom(`type`.getRawClass)) null
-    else {
-      val elementType = `type`.getContentType
-      val typeSer = Option(elementTypeSerializer).orElse(Option(elementType.getTypeHandler.asInstanceOf[TypeSerializer]))
-      val valSer = Option(elementValueSerializer).orElse(Option(elementType.getValueHandler.asInstanceOf[JsonSerializer[AnyRef]]))
-      new OptionSerializer(Option(`type`.getContentType), typeSer, None, valSer)
-    }
+  override def findReferenceSerializer(config: SerializationConfig,
+                                       refType: ReferenceType,
+                                       beanDesc: BeanDescription,
+                                       contentTypeSerializer: TypeSerializer,
+                                       contentValueSerializer: JsonSerializer[AnyRef]): JsonSerializer[_] = {
+    if (!OPTION.isAssignableFrom(refType.getRawClass)) return null
+    new OptionSerializer(refType.getReferencedType, property = None,
+      valueTypeSerializer = Option(contentTypeSerializer).orElse(Option(refType.getTypeHandler[TypeSerializer])),
+      valueSerializer = Option(contentValueSerializer).orElse(Option(refType.getValueHandler[JsonSerializer[AnyRef]])),
+      contentInclusion = None, unwrapper = None)
+  }
 }
 
 trait OptionSerializerModule extends OptionTypeModifierModule {
   this += { ctx =>
     ctx addSerializers OptionSerializerResolver
-    ctx addBeanSerializerModifier OptionBeanSerializerModifier
   }
 }
diff --git a/src/test/scala/com/fasterxml/jackson/module/scala/JacksonTest.scala b/src/test/scala/com/fasterxml/jackson/module/scala/JacksonTest.scala
@@ -3,13 +3,11 @@ package com.fasterxml.jackson.module.scala
 import com.fasterxml.jackson.databind.{Module, ObjectMapper}
 
 abstract class JacksonTest extends BaseSpec {
-
   def module: Module
 
   def newMapper = {
     val result = new ObjectMapper
     result.registerModule(module)
     result
   }
-
 }
diff --git a/src/test/scala/com/fasterxml/jackson/module/scala/ser/OptionSerializerTest.scala b/src/test/scala/com/fasterxml/jackson/module/scala/ser/OptionSerializerTest.scala
diff --git a/src/test/scala/com/fasterxml/jackson/module/scala/ser/SerializerTest.scala b/src/test/scala/com/fasterxml/jackson/module/scala/ser/SerializerTest.scala

Original file line number	Diff line number	Diff line change
`@@ -3,13 +3,11 @@ package com.fasterxml.jackson.module.scala`
`3`	`3`	`import com.fasterxml.jackson.databind.{Module, ObjectMapper}`
`4`	`4`
`5`	`5`	`abstract class JacksonTest extends BaseSpec {`
`6`		`-`
`7`	`6`	`def module: Module`
`8`	`7`
`9`	`8`	`def newMapper = {`
`10`	`9`	`val result = new ObjectMapper`
`11`	`10`	`result.registerModule(module)`
`12`	`11`	`result`
`13`	`12`	`}`
`14`		`-`
`15`	`13`	`}`