Add fromJsonFunction and toJsonFunction fields to JsonKey class

Closes #137

Author: kevmoo

json_annotation/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.2.4
+
+* Added `fromJsonFunction` and `toJsonFunction` fields to `JsonKey` class.
+
 ## 0.2.3
 
 * Added `ignore` field to `JsonKey` class annotation

json_annotation/lib/src/json_serializable.dart

@@ -72,10 +72,24 @@ class JsonKey {
   /// serialization.
   final bool ignore;
 
+  /// A top-level [Function] to use when deserializing the associated JSON
+  /// value to the annotated field.
+  final Function fromJsonFunction;
+
+  /// A top-level [Function] to use when serializing the annotated field to
+  /// JSON.
+  final Function toJsonFunction;
+
   /// Creates a new [JsonKey].
   ///
   /// Only required when the default behavior is not desired.
-  const JsonKey({this.name, this.nullable, this.includeIfNull, this.ignore});
+  const JsonKey(
+      {this.name,
+      this.nullable,
+      this.includeIfNull,
+      this.ignore,
+      this.fromJsonFunction,
+      this.toJsonFunction});
 }
 
 /// Helper classes used in generated code when

json_annotation/pubspec.yaml

@@ -1,5 +1,5 @@
 name: json_annotation
-version: 0.2.3
+version: 0.2.4-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

@@ -1,7 +1,10 @@
 ## 0.5.1
 
+* Support new `fromJsonFunction` and `toJsonFunction` fields on `JsonKey`.
+
 * Use `log` exposed by `package:build`. This requires end-users to have at least
   `package:build_runner` `^0.8.2`.
+
 * Updated minimum `package:source_gen` dependency to `0.8.1` which includes
   improved error messages.
 

json_serializable/lib/src/generator_helper.dart

@@ -301,7 +301,8 @@ void $toJsonMapHelperName(String key, dynamic value) {
   }
 
   TypeHelperContext _getHelperContext(FieldElement field) =>
-      new TypeHelperContext(_generator, field.metadata, _nullable(field));
+      new TypeHelperContext(
+          _generator, field.metadata, _nullable(field), jsonKeyFor(field));
 
   /// Returns `true` if the field can be written to JSON 'naively' – meaning
   /// we can avoid checking for `null`.

json_serializable/lib/src/json_key_helpers.dart

@@ -2,16 +2,27 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/dart/constant/value.dart';
 
 import 'package:json_annotation/json_annotation.dart';
+import 'package:meta/meta.dart';
 import 'package:source_gen/source_gen.dart';
 
-final _jsonKeyExpando = new Expando<JsonKey>();
+@alwaysThrows
+T _throwUnsupported<T>(FieldElement element, String message, {String todo}) =>
+    throw new InvalidGenerationSourceError(
+        'Error with `@JsonKey` on `${element.displayName}`. $message',
+        element: element,
+        todo: todo);
+
+final _jsonKeyExpando = new Expando<JsonKeyImpl>();
 
 final _jsonKeyChecker = const TypeChecker.fromRuntime(JsonKey);
 
-JsonKey jsonKeyFor(FieldElement element) {
+JsonKeyImpl jsonKeyFor(FieldElement element) {
   var key = _jsonKeyExpando[element];
 
   if (key == null) {
@@ -21,14 +32,108 @@ JsonKey jsonKeyFor(FieldElement element) {
     var obj = _jsonKeyChecker.firstAnnotationOfExact(element) ??
         _jsonKeyChecker.firstAnnotationOfExact(element.getter);
 
-    _jsonKeyExpando[element] = key = obj == null
-        ? const JsonKey()
-        : new JsonKey(
-            name: obj.getField('name').toStringValue(),
-            nullable: obj.getField('nullable').toBoolValue(),
-            includeIfNull: obj.getField('includeIfNull').toBoolValue(),
-            ignore: obj.getField('ignore').toBoolValue());
+    if (obj == null) {
+      key = const JsonKeyImpl.empty();
+    } else {
+      key = _from(element, obj);
+    }
+    _jsonKeyExpando[element] = key;
   }
 
   return key;
 }
+
+JsonKeyImpl _from(FieldElement element, DartObject obj) {
+  var fromJsonName = _getFunctionName(obj, element, true);
+  var toJsonName = _getFunctionName(obj, element, false);
+
+  return new JsonKeyImpl(
+      obj.getField('name').toStringValue(),
+      obj.getField('nullable').toBoolValue(),
+      obj.getField('includeIfNull').toBoolValue(),
+      obj.getField('ignore').toBoolValue(),
+      fromJsonName,
+      toJsonName);
+}
+
+class ConvertDataImpl {
+  final String name;
+  final DartType paramType;
+
+  ConvertDataImpl(this.name, this.paramType);
+}
+
+class JsonKeyImpl extends JsonKey {
+  final ConvertDataImpl fromJsonData;
+  final ConvertDataImpl toJsonData;
+
+  const JsonKeyImpl.empty()
+      : fromJsonData = null,
+        toJsonData = null,
+        super();
+
+  JsonKeyImpl(String name, bool nullable, bool includeIfNull, bool ignore,
+      this.fromJsonData, this.toJsonData)
+      : super(
+            name: name,
+            nullable: nullable,
+            includeIfNull: includeIfNull,
+            ignore: ignore);
+}
+
+ConvertDataImpl _getFunctionName(
+    DartObject obj, FieldElement element, bool isFrom) {
+  DartObject objectValue;
+  if (isFrom) {
+    objectValue = obj.getField('fromJsonFunction');
+  } else {
+    objectValue = obj.getField('toJsonFunction');
+  }
+
+  if (objectValue.isNull) {
+    return null;
+  }
+
+  var type = objectValue.type as FunctionType;
+
+  if (type.element is MethodElement) {
+    _throwUnsupported(
+        element,
+        'The function provided for `convert` must be top-level. '
+        'Static class methods (`${type.element.name}`) are not supported.');
+  }
+  var functionElement = type.element as FunctionElement;
+
+  var positionalParams = functionElement.parameters
+      .where((pe) => pe.parameterKind == ParameterKind.REQUIRED)
+      .toList();
+
+  if (positionalParams.length != 1) {
+    _throwUnsupported(
+        element,
+        'The convert function `${functionElement.name}` must have one '
+        'positional paramater.');
+  }
+
+  if (isFrom) {
+    if (!functionElement.returnType.isAssignableTo(element.type)) {
+      _throwUnsupported(
+          element,
+          'The convert function `${functionElement.name}` return type '
+          '`${functionElement
+              .returnType}` is not compatible with field type'
+          ' `${element.type}`.');
+    }
+  } else {
+    var argType = positionalParams.single.type;
+    if (!element.type.isAssignableTo(argType)) {
+      _throwUnsupported(
+          element,
+          'The convert function `${functionElement.name}` argument type '
+          '`$argType` is not compatible with field type'
+          ' `${element.type}`.');
+    }
+  }
+  return new ConvertDataImpl(
+      functionElement.name, positionalParams.single.type);
+}

json_serializable/lib/src/json_serializable_generator.dart

@@ -11,6 +11,7 @@ import 'package:source_gen/source_gen.dart';
 
 import 'generator_helper.dart';
 import 'type_helper.dart';
+import 'type_helpers/convert_helper.dart';
 import 'type_helpers/date_time_helper.dart';
 import 'type_helpers/enum_helper.dart';
 import 'type_helpers/iterable_helper.dart';
@@ -24,6 +25,7 @@ Iterable<TypeHelper> allHelpersImpl(JsonSerializableGenerator generator) =>
 class JsonSerializableGenerator
     extends GeneratorForAnnotation<JsonSerializable> {
   static const _coreHelpers = const [
+    const ConvertHelper(),
     const IterableHelper(),
     const MapHelper(),
     const EnumHelper(),

json_serializable/lib/src/type_helper_context.dart

@@ -5,6 +5,7 @@
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 
+import 'json_key_helpers.dart';
 import 'json_serializable_generator.dart';
 import 'type_helper.dart';
 
@@ -20,7 +21,10 @@ class TypeHelperContext implements SerializeContext, DeserializeContext {
   @override
   final bool nullable;
 
-  TypeHelperContext(this._generator, this.metadata, this.nullable);
+  final JsonKeyImpl jsonKey;
+
+  TypeHelperContext(
+      this._generator, this.metadata, this.nullable, this.jsonKey);
 
   @override
   String serialize(DartType targetType, String expression) => _run(

json_serializable/lib/src/type_helpers/convert_helper.dart

@@ -0,0 +1,42 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:analyzer/dart/element/type.dart';
+
+import '../type_helper.dart';
+import '../type_helper_context.dart';
+import '../utils.dart';
+
+class ConvertHelper extends TypeHelper {
+  const ConvertHelper();
+
+  @override
+  String serialize(
+      DartType targetType, String expression, SerializeContext context) {
+    var jsonKey = (context as TypeHelperContext).jsonKey;
+    if (jsonKey.toJsonData != null) {
+      assert(targetType.isAssignableTo(jsonKey.toJsonData.paramType));
+
+      var result = '${jsonKey.toJsonData.name}($expression)';
+      return commonNullPrefix(context.nullable, expression, result);
+    }
+    return null;
+  }
+
+  @override
+  String deserialize(
+      DartType targetType, String expression, DeserializeContext context) {
+    var jsonKey = (context as TypeHelperContext).jsonKey;
+    if (jsonKey.fromJsonData != null) {
+      var asContent = '';
+      var paramType = jsonKey.fromJsonData.paramType;
+      if (!(paramType.isDynamic || paramType.isObject)) {
+        asContent = ' as $paramType';
+      }
+      var result = '${jsonKey.fromJsonData.name}($expression$asContent)';
+      return commonNullPrefix(context.nullable, expression, result);
+    }
+    return null;
+  }
+}

json_serializable/pubspec.yaml

@@ -12,7 +12,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.3 <0.2.4'
+  json_annotation: '>=0.2.4 <0.2.5'
   path: ^1.3.2
   source_gen: '>=0.8.1 <0.9.0'
 dev_dependencies:
@@ -21,3 +21,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_integration_test.dart

@@ -128,7 +128,8 @@ void main() {
         ..nums = [0, 0.0]
         ..doubles = [0.0]
         ..nnDoubles = [0.0]
-        ..ints = [0]);
+        ..ints = [0]
+        ..duration = const Duration(seconds: 1));
     });
 
     test('support ints as doubles', () {

json_serializable/test/json_serializable_test.dart

@@ -309,6 +309,67 @@ abstract class _$OrderSerializerMixin {
     }
   });
 
+  group('functions', () {
+    group('fromJsonFunction', () {
+      test('with bad fromJson return type', () {
+        expectThrows(
+            'BadFromFuncReturnType',
+            'Error with `@JsonKey` on `field`. The convert function `_toInt` '
+            'return type `int` is not compatible with field type `String`.');
+      });
+      test('with 2 arg fromJson function', () {
+        expectThrows(
+            'InvalidFromFunc2Args',
+            'Error with `@JsonKey` on `field`. The convert function '
+            '`_twoArgFunction` must have one positional paramater.');
+      });
+      test('with class static function', () {
+        expectThrows(
+            'InvalidFromFuncClassStatic',
+            'Error with `@JsonKey` on `field`. '
+            'The function provided for `convert` must be top-level. '
+            'Static class methods (`_staticFunc`) are not supported.');
+      });
+    });
+
+    group('toJsonFunction', () {
+      test('with bad fromJson return type', () {
+        expectThrows(
+            'BadToFuncReturnType',
+            'Error with `@JsonKey` on `field`. The convert function `_toInt` '
+            'argument type `bool` is not compatible with field type `String`.');
+      });
+      test('with 2 arg fromJson function', () {
+        expectThrows(
+            'InvalidToFunc2Args',
+            'Error with `@JsonKey` on `field`. The convert function '
+            '`_twoArgFunction` must have one positional paramater.');
+      });
+      test('with class static function', () {
+        expectThrows(
+            'InvalidToFuncClassStatic',
+            'Error with `@JsonKey` on `field`. '
+            'The function provided for `convert` must be top-level. '
+            'Static class methods (`_staticFunc`) are not supported.');
+      });
+    });
+
+    if (!generator.useWrappers) {
+      test('object', () async {
+        var output = await runForElementNamed('ObjectConvertMethods');
+        expect(output, contains("_toObject(json['field'])"));
+      });
+      test('dynamic', () async {
+        var output = await runForElementNamed('DynamicConvertMethods');
+        expect(output, contains("_toDynamic(json['field'])"));
+      });
+      test('typed', () async {
+        var output = await runForElementNamed('TypedConvertMethods');
+        expect(output, contains("_toString(json['field'] as String)"));
+      });
+    }
+  });
+
   test('missing default ctor with a factory', () async {
     expect(
         () => runForElementNamed('NoCtorClass'),