Add support for ignoring nulls in JsonDataEncoder

Author: mrwillis21

encoders/firebase-encoders-json/src/json/java/com/google/firebase/encoders/json/JsonDataEncoderBuilder.java

@@ -35,7 +35,7 @@
 
 public final class JsonDataEncoderBuilder implements EncoderConfig<JsonDataEncoderBuilder> {
 
-  private final ObjectEncoder<Object> DEFAULT_FALLBACK_ENCODER =
+  private static final ObjectEncoder<Object> DEFAULT_FALLBACK_ENCODER =
       (o, ctx) -> {
         throw new EncodingException(
             "Couldn't find encoder for type " + o.getClass().getCanonicalName());
@@ -44,6 +44,7 @@ public final class JsonDataEncoderBuilder implements EncoderConfig<JsonDataEncod
   private final Map<Class<?>, ObjectEncoder<?>> objectEncoders = new HashMap<>();
   private final Map<Class<?>, ValueEncoder<?>> valueEncoders = new HashMap<>();
   private ObjectEncoder<Object> fallbackEncoder = DEFAULT_FALLBACK_ENCODER;
+  private boolean ignoreNulls = false;
 
   private static final class TimestampEncoder implements ValueEncoder<Date> {
     private static final DateFormat rfc339;
@@ -104,6 +105,12 @@ public JsonDataEncoderBuilder configureWith(@NonNull Configurator config) {
     return this;
   }
 
+  @NonNull
+  public JsonDataEncoderBuilder ignoreNulls(boolean ignore) {
+    this.ignoreNulls = ignore;
+    return this;
+  }
+
   @NonNull
   public DataEncoder build() {
     return new DataEncoder() {
@@ -112,7 +119,7 @@ public void encode(@NonNull Object o, @NonNull Writer writer)
           throws IOException, EncodingException {
         JsonValueObjectEncoderContext encoderContext =
             new JsonValueObjectEncoderContext(
-                writer, objectEncoders, valueEncoders, fallbackEncoder);
+                writer, objectEncoders, valueEncoders, fallbackEncoder, ignoreNulls);
         encoderContext.add(o, false);
         encoderContext.close();
       }

encoders/firebase-encoders-json/src/json/java/com/google/firebase/encoders/json/JsonValueObjectEncoderContext.java

@@ -31,42 +31,45 @@
 
 final class JsonValueObjectEncoderContext implements ObjectEncoderContext, ValueEncoderContext {
 
+  private interface AddMethod {
+    JsonValueObjectEncoderContext invoke(@NonNull String name, @Nullable Object o)
+        throws IOException, EncodingException;
+  }
+
   private JsonValueObjectEncoderContext childContext = null;
   private boolean active = true;
   private final JsonWriter jsonWriter;
   private final Map<Class<?>, ObjectEncoder<?>> objectEncoders;
   private final Map<Class<?>, ValueEncoder<?>> valueEncoders;
   private final ObjectEncoder<Object> fallbackEncoder;
+  private final AddMethod addMethod;
 
   JsonValueObjectEncoderContext(
       @NonNull Writer writer,
       @NonNull Map<Class<?>, ObjectEncoder<?>> objectEncoders,
       @NonNull Map<Class<?>, ValueEncoder<?>> valueEncoders,
-      ObjectEncoder<Object> fallbackEncoder) {
+      ObjectEncoder<Object> fallbackEncoder,
+      boolean ignoreNulls) {
     this.jsonWriter = new JsonWriter(writer);
     this.objectEncoders = objectEncoders;
     this.valueEncoders = valueEncoders;
     this.fallbackEncoder = fallbackEncoder;
+    this.addMethod = ignoreNulls ? this::internalAddIgnoreNulls : this::internalAdd;
   }
 
   private JsonValueObjectEncoderContext(JsonValueObjectEncoderContext anotherContext) {
     this.jsonWriter = anotherContext.jsonWriter;
     this.objectEncoders = anotherContext.objectEncoders;
     this.valueEncoders = anotherContext.valueEncoders;
     this.fallbackEncoder = anotherContext.fallbackEncoder;
+    this.addMethod = anotherContext.addMethod;
   }
 
   @NonNull
   @Override
   public JsonValueObjectEncoderContext add(@NonNull String name, @Nullable Object o)
       throws IOException, EncodingException {
-    maybeUnNest();
-    jsonWriter.name(name);
-    if (o == null) {
-      jsonWriter.nullValue();
-      return this;
-    }
-    return add(o, false);
+    return addMethod.invoke(name, o);
   }
 
   @NonNull
@@ -311,4 +314,25 @@ private void maybeUnNest() throws IOException {
       jsonWriter.endObject();
     }
   }
+
+  private JsonValueObjectEncoderContext internalAdd(@NonNull String name, @Nullable Object o)
+      throws IOException, EncodingException {
+    maybeUnNest();
+    jsonWriter.name(name);
+    if (o == null) {
+      jsonWriter.nullValue();
+      return this;
+    }
+    return add(o, false);
+  }
+
+  private JsonValueObjectEncoderContext internalAddIgnoreNulls(
+      @NonNull String name, @Nullable Object o) throws IOException, EncodingException {
+    if (o == null) {
+      return this;
+    }
+    maybeUnNest();
+    jsonWriter.name(name);
+    return add(o, false);
+  }
 }

encoders/firebase-encoders-json/src/test/java/com/google/firebase/encoders/json/JsonDataEncoderBuilderTests.java

@@ -22,6 +22,7 @@
 import com.google.firebase.encoders.ObjectEncoderContext;
 import com.google.firebase.encoders.ValueEncoderContext;
 import java.util.Collections;
+import java.util.HashMap;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
@@ -61,4 +62,43 @@ public void configureWith_shouldCorrectlyRegisterValueEncoder() throws EncodingE
     assertThat(encoder.encode(Collections.singletonMap("foo", new Foo())))
         .isEqualTo("{\"foo\":\"value\"}");
   }
+
+  @Test
+  public void ignoreNulls_shouldCorrectlyEncodeObjectIgnoringNullObjects()
+      throws EncodingException {
+    DataEncoder encoder =
+        new JsonDataEncoderBuilder()
+            .configureWith(
+                cfg ->
+                    cfg.registerEncoder(
+                        Foo.class,
+                        (Foo s, ObjectEncoderContext ctx) -> {
+                          ctx.add("foo", "value");
+                          ctx.add("bar", null);
+                        }))
+            .ignoreNulls(true)
+            .build();
+
+    assertThat(encoder.encode(new Foo())).isEqualTo("{\"foo\":\"value\"}");
+  }
+
+  @Test
+  public void ignoreNulls_shouldCorrectlyEncodeValueIgnoringNullObjects() throws EncodingException {
+    DataEncoder encoder =
+        new JsonDataEncoderBuilder()
+            .configureWith(
+                cfg ->
+                    cfg.registerEncoder(
+                        Foo.class,
+                        (Foo s, ValueEncoderContext ctx) -> {
+                          ctx.add("value");
+                        }))
+            .ignoreNulls(true)
+            .build();
+
+    HashMap<String, Foo> fooMap = new HashMap<>();
+    fooMap.put("foo", new Foo());
+    fooMap.put("bar", null);
+    assertThat(encoder.encode(fooMap)).isEqualTo("{\"foo\":\"value\"}");
+  }
 }