Add includeIfNull to JsonSerialiazable annotation

Author: kevmoo

lib/src/json_serializable.dart

@@ -6,9 +6,17 @@ class JsonSerializable {
   final bool createFactory;
   final bool createToJson;
 
-  const JsonSerializable({bool createFactory: true, bool createToJson: true})
-      : this.createFactory = createFactory,
-        this.createToJson = createToJson;
+  /// Whether the generator should include the this field in the serialized
+  /// output, even if the value is `null`.
+  final bool includeIfNull;
+
+  const JsonSerializable(
+      {bool createFactory: true,
+      bool createToJson: true,
+      bool includeIfNull: true})
+      : this.createFactory = createFactory ?? true,
+        this.createToJson = createToJson ?? true,
+        this.includeIfNull = includeIfNull ?? true;
 }
 
 /// An annotation used to specify how a field is serialized.
@@ -29,12 +37,16 @@ class JsonKey {
 
   /// [true] if the generator should include the this field in the serialized
   /// output, even if the value is `null`.
+  ///
+  /// The default value, `null`, indicates that the behavior should be
+  /// acquired from the [JsonSerializable.includeIfNull] annotation on the
+  /// enclosing class.
   final bool includeIfNull;
 
   /// Creates a new [JsonKey].
   ///
   /// Only required when the default behavior is not desired.
-  const JsonKey({this.name, bool nullable: true, bool includeIfNull: true})
+  const JsonKey({this.name, bool nullable: true, bool includeIfNull})
       : this.nullable = nullable ?? true,
-        this.includeIfNull = includeIfNull ?? true;
+        this.includeIfNull = includeIfNull;
 }

lib/src/json_serializable_generator.dart

@@ -128,12 +128,13 @@ class JsonSerializableGenerator
       });
 
       buffer.writeln('  Map<String, dynamic> toJson() ');
-      if (fieldsList.every((fe) => _jsonKeyFor(fe).includeIfNull)) {
+      if (fieldsList
+          .every((e) => _includeIfNull(e, annotation.includeIfNull))) {
         // write simple `toJson` method that includes all keys...
         _writeToJsonSimple(buffer, fields);
       } else {
         // At least one field should be excluded if null
-        _writeToJsonWithNullChecks(buffer, fields);
+        _writeToJsonWithNullChecks(buffer, fields, annotation.includeIfNull);
       }
 
       // end of the mixin class
@@ -143,8 +144,8 @@ class JsonSerializableGenerator
     return buffer.toString();
   }
 
-  void _writeToJsonWithNullChecks(
-      StringBuffer buffer, Map<String, FieldElement> fields) {
+  void _writeToJsonWithNullChecks(StringBuffer buffer,
+      Map<String, FieldElement> fields, bool includeIfNull) {
     buffer.writeln('{');
 
     // TODO(kevmoo) We could write all values up to the null-excluded value
@@ -159,21 +160,21 @@ class JsonSerializableGenerator
 
     fields.forEach((fieldName, field) {
       try {
-        var jsonKey = _jsonKeyFor(field);
-        var safeJsonKeyString = _safeNameAccess(jsonKey.name ?? fieldName);
+        var safeJsonKeyString =
+            _safeNameAccess(_fieldToJsonMapKey(field, fieldName));
 
         // If `fieldName` collides with one of the local helpers, prefix
         // access with `this.`.
         if (fieldName == toJsonMapVarName || fieldName == toJsonMapHelperName) {
           fieldName = 'this.$fieldName';
         }
 
-        if (jsonKey.includeIfNull) {
+        if (_includeIfNull(field, includeIfNull)) {
           buffer.writeln("$toJsonMapVarName[$safeJsonKeyString] = "
-              "${_serialize(field.type, fieldName, jsonKey.nullable)};");
+              "${_serialize(field.type, fieldName,  _nullable(field))};");
         } else {
-          buffer.writeln("$toJsonMapHelperName($safeJsonKeyString,"
-              "${_serialize(field.type, fieldName, jsonKey.nullable)});");
+          buffer.writeln("$toJsonMapHelperName($safeJsonKeyString, "
+              "${_serialize(field.type, fieldName, _nullable(field))});");
         }
       } on UnsupportedTypeError {
         throw new InvalidGenerationSourceError(
@@ -195,7 +196,7 @@ class JsonSerializableGenerator
     var pairs = <String>[];
     fields.forEach((fieldName, field) {
       try {
-        pairs.add("'${_fieldToJsonMapKey(field) ?? fieldName}': "
+        pairs.add("'${_fieldToJsonMapKey(field, fieldName)}': "
             "${_serialize(field.type, fieldName, _nullable(field))}");
       } on UnsupportedTypeError {
         throw new InvalidGenerationSourceError(
@@ -321,7 +322,7 @@ class JsonSerializableGenerator
 
   String _deserializeForField(String name, FieldElement field,
       {ParameterElement ctorParam}) {
-    name = _fieldToJsonMapKey(field) ?? name;
+    name = _fieldToJsonMapKey(field, name);
 
     var targetType = ctorParam?.type ?? field.type;
 
@@ -350,13 +351,17 @@ String _safeNameAccess(String name) =>
 /// Returns the JSON map `key` to be used when (de)serializing [field], if any.
 ///
 /// Otherwise, `null`;
-String _fieldToJsonMapKey(FieldElement field) => _jsonKeyFor(field).name;
+String _fieldToJsonMapKey(FieldElement field, String ifNull) =>
+    _jsonKeyFor(field).name ?? ifNull;
 
 /// Returns `true` if the field should be treated as potentially nullable.
 ///
 /// If no [JsonKey] annotation is present on the field, `true` is returned.
 bool _nullable(FieldElement field) => _jsonKeyFor(field).nullable;
 
+bool _includeIfNull(FieldElement element, bool parentValue) =>
+    _jsonKeyFor(element).includeIfNull ?? parentValue;
+
 JsonKey _jsonKeyFor(FieldElement element) {
   var key = _jsonKeyExpando[element];
 

test/json_serializable_test.dart

@@ -10,6 +10,7 @@ import 'dart:async';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/src/string_source.dart';
 import 'package:json_serializable/generators.dart';
+import 'package:json_serializable/src/utils.dart';
 import 'package:path/path.dart' as p;
 import 'package:test/test.dart';
 
@@ -153,11 +154,25 @@ void main() {
     expect(output, contains("'h': height,"));
     expect(output, contains("..height = json['h']"));
   });
+
+  group("includeIfNull", () {
+    test("some", () async {
+      var output = await _runForElementNamed('IncludeIfNullAll');
+      expect(output, isNot(contains(toJsonMapVarName)));
+      expect(output, isNot(contains(toJsonMapHelperName)));
+    });
+
+    test("all", () async {
+      var output = await _runForElementNamed('IncludeIfNullOverride');
+      expect(output, contains("$toJsonMapVarName[\'number\'] = number;"));
+      expect(output, contains("$toJsonMapHelperName('str', str);"));
+    });
+  });
 }
 
 const _generator = const JsonSerializableGenerator();
 
-Future<String> _runForElementNamed(String name) async {
+Future<String> _runForElementNamed(String name) {
   var library = _compUnit.element.library;
   var element =
       getElementsFromLibraryElement(library).singleWhere((e) => e.name == name);
@@ -278,4 +293,18 @@ class NoSerializeBadKey {
 class NoDeserializeBadKey {
   Map<int, DateTime> intDateTimeMap;
 }
+
+@JsonSerializable(createFactory: false)
+class IncludeIfNullAll {
+  @JsonKey(includeIfNull: true)
+  int number;
+  String str;
+}
+
+@JsonSerializable(createFactory: false, includeIfNull: false)
+class IncludeIfNullOverride {
+  @JsonKey(includeIfNull: true)
+  int number;
+  String str;
+}
 ''';