Introduced ignore attribute to JsonKey. When set to true the generato…

json_annotation/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.2.3
+
+* Added `ignore` field to `JsonKey` class annotation
+
 ## 0.2.2
 
 * Added a helper class – `$JsonMapWrapper` – and helper functions – `$wrapMap`, 

json_annotation/lib/src/json_serializable.dart

@@ -65,10 +65,16 @@ class JsonKey {
   /// enclosing class.
   final bool includeIfNull;
 
+  /// `true` if the generator should ignore this field completely.
+  ///
+  /// If `null` (the default) or `false`, the field will be considered for
+  /// serialization.
+  final bool ignore;
+
   /// Creates a new [JsonKey].
   ///
   /// Only required when the default behavior is not desired.
-  const JsonKey({this.name, this.nullable, this.includeIfNull});
+  const JsonKey({this.name, this.nullable, this.includeIfNull, this.ignore});
 }
 
 // TODO(kevmoo): Add documentation

json_annotation/pubspec.yaml

@@ -1,5 +1,5 @@
 name: json_annotation
-version: 0.2.2
+version: 0.2.3-dev
 description: Annotations for the json_serializable package
 homepage: https://github.com/dart-lang/json_serializable
 author: Dart Team <misc@dartlang.org>

json_serializable/CHANGELOG.md

@@ -6,6 +6,10 @@
   `DeserializeContext` is now readonly. This would potentially break code that
   extends these classes – which is not expected. 
 
+* Private and ignored fields are now excluded when generating serialization and deserialization code.
+
+* Throw an exception if a private field, or an ignored field is referenced by a required constructor argument.
+
 ## 0.4.0
 
 * **Potentially Breaking** Inherited fields are now processed and used

json_serializable/lib/src/json_serializable_generator.dart

@@ -7,6 +7,7 @@ import 'dart:collection';
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
+
 // ignore: implementation_imports
 import 'package:analyzer/src/dart/resolver/inheritance_manager.dart'
     show InheritanceManager;
@@ -81,7 +82,10 @@ class JsonSerializableGenerator
 
     // Get all of the fields that need to be assigned
     // TODO: support overriding the field set with an annotation option
-    var fieldsList = _listFields(classElement);
+    var fieldList = _listFields(classElement);
+    var fieldsList = fieldList
+        .where((field) => field.isPublic && _jsonKeyFor(field).ignore != true)
+        .toList();
 
     var undefinedFields =
         fieldsList.where((fe) => fe.type.isUndefined).toList();
@@ -112,14 +116,17 @@ class JsonSerializableGenerator
     final classAnnotation = _valueForAnnotation(annotation);
 
     if (classAnnotation.createFactory) {
-      var toSkip = _writeFactory(
-          buffer, classElement, fields, prefix, classAnnotation.nullable);
+      var ignoredFields = new Map<String, FieldElement>.fromIterable(
+          fieldList.where(
+              (field) => !field.isPublic || _jsonKeyFor(field).ignore == true),
+          key: (f) => (f as FieldElement).name);
+
+      var fieldsSetByFactory = _writeFactory(buffer, classElement, fields,
+          ignoredFields, prefix, classAnnotation.nullable);
 
       // If there are fields that are final – that are not set via the generated
       // constructor, then don't output them when generating the `toJson` call.
-      for (var field in toSkip) {
-        fields.remove(field.name);
-      }
+      fields.removeWhere((key, field) => !fieldsSetByFactory.contains(field));
     }
 
     // Now we check for duplicate JSON keys due to colliding annotations.
@@ -231,7 +238,8 @@ class JsonSerializableGenerator
     for (var field in fields.values) {
       var valueAccess = '_v.${field.name}';
       buffer.write('''case ${_safeNameAccess(field)}:
-        return ${_serializeField(field, classAnnotation.nullable, accessOverride:  valueAccess)};''');
+        return ${_serializeField(
+          field, classAnnotation.nullable, accessOverride: valueAccess)};''');
     }
 
     buffer.writeln('''
@@ -306,23 +314,26 @@ void $toJsonMapHelperName(String key, dynamic value) {
 
     var pairs = <String>[];
     for (var field in fields) {
-      pairs.add(
-          '${_safeNameAccess(field)}: ${_serializeField(field, classSupportNullable )}');
+      pairs.add('${_safeNameAccess(field)}: ${_serializeField(
+              field, classSupportNullable)}');
     }
     buffer.writeAll(pairs, ',\n');
 
     buffer.writeln('  };');
   }
 
-  /// Returns the set of fields that are not written to via constructors.
+  /// Returns the set of fields that are written to via factory.
+  /// Includes final fields that are written to in the constructor parameter list
+  /// Excludes remaining final fields, as they can't be set in the factory body
+  /// and shoudn't generated with toJson
   Set<FieldElement> _writeFactory(
       StringBuffer buffer,
       ClassElement classElement,
       Map<String, FieldElement> fields,
+      Map<String, FieldElement> ignoredFields,
       String prefix,
       bool classSupportNullable) {
-    // creating a copy so it can be mutated
-    var fieldsToSet = new Map<String, FieldElement>.from(fields);
+    var fieldsSetByFactory = new Set<FieldElement>();
     var className = classElement.displayName;
     // Create the factory method
 
@@ -342,9 +353,20 @@ void $toJsonMapHelperName(String key, dynamic value) {
 
       if (field == null) {
         if (arg.parameterKind == ParameterKind.REQUIRED) {
+          var additionalInfo = '';
+          var ignoredField = ignoredFields[arg.name];
+          if (ignoredField != null) {
+            if (_jsonKeyFor(ignoredField).ignore == true) {
+              additionalInfo = ' It it assigns to an ignored field.';
+            } else if (!ignoredField.isPublic) {
+              additionalInfo = ' It it assigns to a non public field.';
+            }
+          }
+
           throw new UnsupportedError('Cannot populate the required constructor '
-              'argument: ${arg.displayName}.');
+              'argument: ${arg.displayName}.$additionalInfo');
         }
+
         continue;
       }
 
@@ -354,7 +376,7 @@ void $toJsonMapHelperName(String key, dynamic value) {
       } else {
         ctorArguments.add(arg);
       }
-      fieldsToSet.remove(arg.name);
+      fieldsSetByFactory.add(field);
     }
 
     var undefinedArgs = [ctorArguments, ctorNamedArguments]
@@ -370,14 +392,11 @@ void $toJsonMapHelperName(String key, dynamic value) {
           todo: 'Check names and imports.');
     }
 
-    // these are fields to skip – now to find them
-    var finalFields =
-        fieldsToSet.values.where((field) => field.isFinal).toSet();
-
-    for (var finalField in finalFields) {
-      var value = fieldsToSet.remove(finalField.name);
-      assert(value == finalField);
-    }
+    // find fields that aren't already set by the constructor and that aren't final
+    var remainingFieldsForFactoryBody = fields.values
+        .where((field) => !field.isFinal)
+        .toSet()
+        .difference(fieldsSetByFactory);
 
     //
     // Generate the static factory method
@@ -402,19 +421,20 @@ void $toJsonMapHelperName(String key, dynamic value) {
     }), ', ');
 
     buffer.write(')');
-    if (fieldsToSet.isEmpty) {
+    if (remainingFieldsForFactoryBody.isEmpty) {
       buffer.writeln(';');
     } else {
-      for (var field in fieldsToSet.values) {
+      for (var field in remainingFieldsForFactoryBody) {
         buffer.writeln();
         buffer.write('      ..${field.name} = ');
         buffer.write(_deserializeForField(field, classSupportNullable));
+        fieldsSetByFactory.add(field);
       }
       buffer.writeln(';');
     }
     buffer.writeln();
 
-    return finalFields;
+    return fieldsSetByFactory;
   }
 
   Iterable<TypeHelper> get _allHelpers =>
@@ -519,7 +539,8 @@ JsonKey _jsonKeyFor(FieldElement element) {
         : new JsonKey(
             name: obj.getField('name').toStringValue(),
             nullable: obj.getField('nullable').toBoolValue(),
-            includeIfNull: obj.getField('includeIfNull').toBoolValue());
+            includeIfNull: obj.getField('includeIfNull').toBoolValue(),
+            ignore: obj.getField('ignore').toBoolValue());
   }
 
   return key;

json_serializable/pubspec.yaml

@@ -13,7 +13,7 @@ dependencies:
 
   # Use a tight version constraint to ensure that a constraint on
   # `json_annotation`. Properly constrains all features it provides.
-  json_annotation: '>=0.2.2 <0.2.3'
+  json_annotation: '>=0.2.3 <0.2.4'
   path: ^1.3.2
   source_gen: ^0.7.5
 dev_dependencies:
@@ -22,3 +22,7 @@ dev_dependencies:
   collection: ^1.14.0
   dart_style: ^1.0.0
   test: ^0.12.3
+
+dependency_overrides:
+  json_annotation:
+    path: ../json_annotation

json_serializable/test/json_serializable_test.dart

@@ -125,6 +125,23 @@ void _registerTests(JsonSerializableGenerator generator) {
     expect(generateResult, contains('Map<String, dynamic> toJson()'));
   });
 
+  if (!generator.useWrappers) {
+    test('includes final field in toJson when set in ctor', () async {
+      var generateResult = await runForElementNamed('FinalFields');
+      expect(generateResult, contains('new FinalFields(json[\'a\'] as int);'));
+      expect(
+          generateResult, contains('toJson() => <String, dynamic>{\'a\': a};'));
+    });
+
+    test('excludes final field in toJson when not set in ctor', () async {
+      var generateResult = await runForElementNamed('FinalFieldsNotSetInCtor');
+      expect(generateResult,
+          isNot(contains('new FinalFields(json[\'a\'] as int);')));
+      expect(generateResult,
+          isNot(contains('toJson() => <String, dynamic>{\'a\': a};')));
+    });
+  }
+
   group('valid inputs', () {
     if (!generator.useWrappers) {
       test('class with no ctor params', () async {
@@ -233,6 +250,39 @@ abstract class _$OrderSerializerMixin {
       });
     }
 
+    if (!generator.useWrappers) {
+      test('works to ignore a field', () async {
+        var output = await runForElementNamed('IgnoredFieldClass');
+
+        expect(output, contains("'ignoredFalseField': ignoredFalseField,"));
+        expect(output, contains("'ignoredNullField': ignoredNullField"));
+        expect(output, isNot(contains("'ignoredTrueField': ignoredTrueField")));
+      });
+    }
+
+    if (!generator.useWrappers) {
+      test('fails if ignored field is referenced by ctor', () async {
+        expect(
+            () => runForElementNamed('IgnoredFieldCtorClass'),
+            throwsA(new FeatureMatcher<UnsupportedError>(
+                'message',
+                (e) => e.message,
+                'Cannot populate the required constructor argument: '
+                'ignoredTrueField. It it assigns to an ignored field.')));
+      });
+    }
+    if (!generator.useWrappers) {
+      test('fails if private field is referenced by ctor', () async {
+        expect(
+            () => runForElementNamed('PrivateFieldCtorClass'),
+            throwsA(new FeatureMatcher<UnsupportedError>(
+                'message',
+                (e) => e.message,
+                'Cannot populate the required constructor argument: '
+                '_privateField. It it assigns to a non public field.')));
+      });
+    }
+
     test('fails if name duplicates existing field', () async {
       expect(
           () => runForElementNamed('KeyDupesField'),

json_serializable/test/src/json_serializable_test_input.dart

@@ -41,6 +41,13 @@ class FinalFields {
   FinalFields(this.a);
 }
 
+@JsonSerializable()
+class FinalFieldsNotSetInCtor {
+  final int a = 1;
+
+  FinalFieldsNotSetInCtor();
+}
+
 @JsonSerializable()
 class FromJsonOptionalParameters {
   final ChildWithFromJson child;
@@ -154,6 +161,31 @@ class DupeKeys {
   String str;
 }
 
+@JsonSerializable(createFactory: false)
+class IgnoredFieldClass {
+  @JsonKey(ignore: true)
+  int ignoredTrueField;
+
+  @JsonKey(ignore: false)
+  int ignoredFalseField;
+
+  int ignoredNullField;
+}
+
+@JsonSerializable()
+class IgnoredFieldCtorClass {
+  @JsonKey(ignore: true)
+  int ignoredTrueField;
+  IgnoredFieldCtorClass(this.ignoredTrueField);
+}
+
+@JsonSerializable()
+class PrivateFieldCtorClass {
+  // ignore: unused_field
+  int _privateField;
+  PrivateFieldCtorClass(this._privateField);
+}
+
 @JsonSerializable()
 class SubType extends SuperType {
   final int subTypeViaCtor;

json_serializable/test/test_files/json_test_example.dart

@@ -49,6 +49,13 @@ class Order extends Object with _$OrderSerializerMixin {
   Platform platform;
   Map<String, Platform> altPlatforms;
 
+  @JsonKey(ignore: true)
+  String get platformValue => platform?.description;
+
+  set platformValue(String value) {
+    throw new UnimplementedError('not impld');
+  }
+
   int get price => items.fold(0, (total, item) => item.price + total);
 
   Order(this.category, [Iterable<Item> items])

json_serializable/test/test_files/json_test_example.non_nullable.dart

@@ -55,6 +55,13 @@ class Order extends Object with _$OrderSerializerMixin {
   Platform platform;
   Map<String, Platform> altPlatforms;
 
+  @JsonKey(ignore: true)
+  String get platformValue => platform?.description;
+
+  set platformValue(String value) {
+    throw new UnimplementedError('not impld');
+  }
+
   int get price => items.fold(0, (total, item) => item.price + total);
 
   Order(this.category, [Iterable<Item> items])

json_serializable/test/test_files/json_test_example.non_nullable.wrapped.dart

@@ -61,6 +61,13 @@ class Order extends Object with _$OrderSerializerMixin {
   Platform platform;
   Map<String, Platform> altPlatforms;
 
+  @JsonKey(ignore: true)
+  String get platformValue => platform?.description;
+
+  set platformValue(String value) {
+    throw new UnimplementedError('not impld');
+  }
+
   int get price => items.fold(0, (total, item) => item.price + total);
 
   Order(this.category, [Iterable<Item> items])

json_serializable/test/test_files/json_test_example.wrapped.dart

@@ -55,6 +55,13 @@ class Order extends Object with _$OrderSerializerMixin {
   Platform platform;
   Map<String, Platform> altPlatforms;
 
+  @JsonKey(ignore: true)
+  String get platformValue => platform?.description;
+
+  set platformValue(String value) {
+    throw new UnimplementedError('not impld');
+  }
+
   int get price => items.fold(0, (total, item) => item.price + total);
 
   Order(this.category, [Iterable<Item> items])