Added annotation to ignore None values in Case Classes

SCALA-300

Author: rozza

bson/src/main/scala/org/mongodb/scala/bson/codecs/Macros.scala

@@ -52,7 +52,7 @@ object Macros {
    * @return the CodecProvider for the case class
    */
   @compileTimeOnly("Creating a CodecProvider utilises Macros and must be run at compile time.")
-  def createCodecProvider[T](): CodecProvider = macro CaseClassProvider.createCaseClassProvider[T]
+  def createCodecProvider[T](): CodecProvider = macro CaseClassProvider.createCodecProviderEncodeNone[T]
 
   /**
    * Creates a CodecProvider for a case class using the given class to represent the case class
@@ -62,25 +62,67 @@ object Macros {
    * @return the CodecProvider for the case class
    */
   @compileTimeOnly("Creating a CodecProvider utilises Macros and must be run at compile time.")
-  implicit def createCodecProvider[T](clazz: Class[T]): CodecProvider = macro CaseClassProvider.createCaseClassProviderWithClass[T]
+  implicit def createCodecProvider[T](clazz: Class[T]): CodecProvider = macro CaseClassProvider.createCodecProviderWithClassEncodeNone[T]
+
+  /**
+   * Creates a CodecProvider for a case class that ignores any `None` values
+   *
+   * @tparam T the case class to create a Codec from
+   * @return the CodecProvider for the case class
+   * @since 2.1
+   */
+  @compileTimeOnly("Creating a CodecProvider utilises Macros and must be run at compile time.")
+  def createCodecProviderIgnoreNone[T](): CodecProvider = macro CaseClassProvider.createCodecProviderIgnoreNone[T]
+
+  /**
+   * Creates a CodecProvider for a case class that ignores any `None` values, using the given class to represent the case class
+   *
+   * @param clazz the clazz that is the case class
+   * @tparam T the case class to create a Codec from
+   * @return the CodecProvider for the case class
+   * @since 2.1
+   */
+  @compileTimeOnly("Creating a CodecProvider utilises Macros and must be run at compile time.")
+  def createCodecProviderIgnoreNone[T](clazz: Class[T]): CodecProvider = macro CaseClassProvider.createCodecProviderWithClassIgnoreNone[T]
+
+  /**
+   * Creates a Codec for a case class
+   *
+   * @tparam T the case class to create a Codec from
+   * @return the Codec for the case class
+   */
+  @compileTimeOnly("Creating a Codec utilises Macros and must be run at compile time.")
+  def createCodec[T](): Codec[T] = macro CaseClassCodec.createCodecDefaultCodecRegistryEncodeNone[T]
+
+  /**
+   * Creates a Codec for a case class
+   *
+   * @param codecRegistry the Codec Registry to use
+   * @tparam T the case class to create a codec from
+   * @return the Codec for the case class
+   */
+  @compileTimeOnly("Creating a Codec utilises Macros and must be run at compile time.")
+  def createCodec[T](codecRegistry: CodecRegistry): Codec[T] = macro CaseClassCodec.createCodecEncodeNone[T]
 
   /**
    * Creates a Codec for a case class
    *
    * @tparam T the case class to create a Codec from
    * @return the Codec for the case class
+   * @since 2.1
    */
   @compileTimeOnly("Creating a Codec utilises Macros and must be run at compile time.")
-  def createCodec[T](): Codec[T] = macro CaseClassCodec.createCodecNoArgs[T]
+  def createCodecIgnoreNone[T](): Codec[T] = macro CaseClassCodec.createCodecDefaultCodecRegistryIgnoreNone[T]
 
   /**
    * Creates a Codec for a case class
    *
    * @param codecRegistry the Codec Registry to use
    * @tparam T the case class to create a codec from
    * @return the Codec for the case class
+   * @since 2.1
    */
   @compileTimeOnly("Creating a Codec utilises Macros and must be run at compile time.")
-  def createCodec[T](codecRegistry: CodecRegistry): Codec[T] = macro CaseClassCodec.createCodec[T]
+  def createCodecIgnoreNone[T](codecRegistry: CodecRegistry): Codec[T] = macro CaseClassCodec.createCodecIgnoreNone[T]
 
 }

bson/src/main/scala/org/mongodb/scala/bson/codecs/macrocodecs/CaseClassCodec.scala

@@ -24,18 +24,38 @@ import org.bson.codecs.configuration.CodecRegistry
 
 private[codecs] object CaseClassCodec {
 
-  def createCodecNoArgs[T: c.WeakTypeTag](c: whitebox.Context)(): c.Expr[Codec[T]] = {
+  def createCodecDefaultCodecRegistryEncodeNone[T: c.WeakTypeTag](c: whitebox.Context)(): c.Expr[Codec[T]] = {
+    import c.universe._
+    createCodecDefaultCodecRegistry[T](c)(c.Expr[Boolean](q"true"))
+  }
+
+  def createCodecEncodeNone[T: c.WeakTypeTag](c: whitebox.Context)(codecRegistry: c.Expr[CodecRegistry]): c.Expr[Codec[T]] = {
+    import c.universe._
+    createCodec[T](c)(codecRegistry, c.Expr[Boolean](q"true"))
+  }
+
+  def createCodecDefaultCodecRegistryIgnoreNone[T: c.WeakTypeTag](c: whitebox.Context)(): c.Expr[Codec[T]] = {
+    import c.universe._
+    createCodecDefaultCodecRegistry[T](c)(c.Expr[Boolean](q"false"))
+  }
+
+  def createCodecIgnoreNone[T: c.WeakTypeTag](c: whitebox.Context)(codecRegistry: c.Expr[CodecRegistry]): c.Expr[Codec[T]] = {
+    import c.universe._
+    createCodec[T](c)(codecRegistry, c.Expr[Boolean](q"false"))
+  }
+
+  def createCodecDefaultCodecRegistry[T: c.WeakTypeTag](c: whitebox.Context)(encodeNone: c.Expr[Boolean]): c.Expr[Codec[T]] = {
     import c.universe._
     createCodec[T](c)(c.Expr[CodecRegistry](
       q"""
          import org.mongodb.scala.bson.codecs.DEFAULT_CODEC_REGISTRY
          DEFAULT_CODEC_REGISTRY
       """
-    )).asInstanceOf[c.Expr[Codec[T]]]
+    ), encodeNone)
   }
 
   // scalastyle:off method.length
-  def createCodec[T: c.WeakTypeTag](c: whitebox.Context)(codecRegistry: c.Expr[CodecRegistry]): c.Expr[Codec[T]] = {
+  def createCodec[T: c.WeakTypeTag](c: whitebox.Context)(codecRegistry: c.Expr[CodecRegistry], encodeNone: c.Expr[Boolean]): c.Expr[Codec[T]] = {
     import c.universe._
 
     // Declared types
@@ -195,10 +215,11 @@ private[codecs] object CaseClassCodec {
           f match {
             case optional if isOption(optional) => q"""
               val localVal = instanceValue.$name
-              writer.writeName($key)
               if (localVal.isDefined) {
+                writer.writeName($key)
                 this.writeFieldValue($key, writer, localVal.get, encoderContext)
-              } else {
+              } else if ($encodeNone) {
+                writer.writeName($key)
                 this.writeFieldValue($key, writer, this.bsonNull, encoderContext)
               }"""
             case _ => q"""

bson/src/main/scala/org/mongodb/scala/bson/codecs/macrocodecs/CaseClassProvider.scala

@@ -22,10 +22,27 @@ import org.bson.codecs.configuration.{ CodecProvider, CodecRegistry }
 
 private[codecs] object CaseClassProvider {
 
-  def createCaseClassProviderWithClass[T: c.WeakTypeTag](c: whitebox.Context)(clazz: c.Expr[Class[T]]): c.Expr[CodecProvider] =
-    createCaseClassProvider[T](c)().asInstanceOf[c.Expr[CodecProvider]]
+  def createCodecProviderEncodeNone[T: c.WeakTypeTag](c: whitebox.Context)(): c.Expr[CodecProvider] = {
+    import c.universe._
+    createCodecProvider[T](c)(c.Expr[Boolean](q"true"))
+  }
+
+  def createCodecProviderWithClassEncodeNone[T: c.WeakTypeTag](c: whitebox.Context)(clazz: c.Expr[Class[T]]): c.Expr[CodecProvider] = {
+    import c.universe._
+    createCodecProvider[T](c)(c.Expr[Boolean](q"true"))
+  }
+
+  def createCodecProviderWithClassIgnoreNone[T: c.WeakTypeTag](c: whitebox.Context)(clazz: c.Expr[Class[T]]): c.Expr[CodecProvider] = {
+    import c.universe._
+    createCodecProvider[T](c)(c.Expr[Boolean](q"false"))
+  }
+
+  def createCodecProviderIgnoreNone[T: c.WeakTypeTag](c: whitebox.Context)(): c.Expr[CodecProvider] = {
+    import c.universe._
+    createCodecProvider[T](c)(c.Expr[Boolean](q"false"))
+  }
 
-  def createCaseClassProvider[T: c.WeakTypeTag](c: whitebox.Context)(): c.Expr[CodecProvider] = {
+  def createCodecProvider[T: c.WeakTypeTag](c: whitebox.Context)(encodeNone: c.Expr[Boolean]): c.Expr[CodecProvider] = {
     import c.universe._
 
     // Declared type
@@ -34,7 +51,7 @@ private[codecs] object CaseClassProvider {
 
     // Names
     def exprCodecRegistry = c.Expr[CodecRegistry](q"codecRegistry")
-    def codec = CaseClassCodec.createCodec[T](c)(exprCodecRegistry)
+    def codec = CaseClassCodec.createCodec[T](c)(exprCodecRegistry, encodeNone)
 
     c.Expr[CodecProvider](
       q"""

bson/src/test/scala/org/mongodb/scala/bson/codecs/MacrosSpec.scala

@@ -21,14 +21,15 @@ import java.util
 import java.util.Date
 
 import scala.collection.JavaConverters._
+import scala.language.implicitConversions
 import scala.reflect.ClassTag
 
 import org.bson._
 import org.bson.codecs.configuration.{ CodecConfigurationException, CodecProvider, CodecRegistries }
 import org.bson.codecs.{ Codec, DecoderContext, EncoderContext }
 import org.bson.io.{ BasicOutputBuffer, ByteBufferBsonInput, OutputBuffer }
 
-import org.mongodb.scala.bson.codecs.Macros.createCodecProvider
+import org.mongodb.scala.bson.codecs.Macros.{ createCodecProvider, createCodecProviderIgnoreNone }
 import org.mongodb.scala.bson.collection.immutable.Document
 import org.scalatest.{ FlatSpec, Matchers }
 
@@ -141,6 +142,23 @@ class MacrosSpec extends FlatSpec with Matchers {
     decode(registry.get(classOf[OptionalValue]), buffer) should equal(OptionalValue("Bob", None))
   }
 
+  it should "be able to round trip optional values, when None is ignored" in {
+    roundTrip(OptionalValue("Bob", None), """{name: "Bob"}""", createCodecProviderIgnoreNone[OptionalValue]())
+    roundTrip(OptionalValue("Bob", Some("value")), """{name: "Bob", value: "value"}""", createCodecProviderIgnoreNone[OptionalValue]())
+    roundTrip(OptionalCaseClass("Bob", None), """{name: "Bob"}""", createCodecProviderIgnoreNone[OptionalCaseClass]())
+    roundTrip(
+      OptionalCaseClass("Bob", Some(Person("Charlie", "Jones"))),
+      """{name: "Bob", value: {firstName: "Charlie", lastName: "Jones"}}""",
+      createCodecProviderIgnoreNone[OptionalCaseClass](), createCodecProviderIgnoreNone[Person]()
+    )
+
+    roundTrip(OptionalRecursive("Bob", None), """{name: "Bob"}""", createCodecProviderIgnoreNone[OptionalRecursive]())
+    roundTrip(
+      OptionalRecursive("Bob", Some(OptionalRecursive("Charlie", None))),
+      """{name: "Bob", value: {name: "Charlie"}}""", createCodecProviderIgnoreNone[OptionalRecursive]()
+    )
+  }
+
   it should "roundtrip all the supported bson types" in {
     val value =
       roundTrip(
@@ -258,6 +276,6 @@ class MacrosSpec extends FlatSpec with Matchers {
     codec.decode(reader, DecoderContext.builder().build())
   }
 
-  val documentCodec = DEFAULT_CODEC_REGISTRY.get(classOf[Document])
+  val documentCodec: Codec[Document] = DEFAULT_CODEC_REGISTRY.get(classOf[Document])
 
 }

docs/reference/content/bson/macros.md

@@ -84,3 +84,17 @@ case class Leaf(value: Int) extends Tree
 
 val codecRegistry = fromRegistries( fromProviders(classOf[Tree]), DEFAULT_CODEC_REGISTRY )
 ```
+
+
+## Options and None values.
+
+By default `Option` values are always stored. In 2.1.0 a new macro helpers were added so that `None` values would not be stored in the 
+database. In the following example only if an address is present will it be stored in the database:
+
+```scala
+import org.mongodb.scala.bson.codecs.Macros
+
+case class Person(firstName: String, secondName: String, address: Option[Address])
+
+val personCodecProvider = Macros.createCodecProviderIgnoreNone[Person]()
+```