Add serializer plugin that does renames

[vadimtsushko]

That is one of requirements, that probably appears only when one works with external API.
In my case models have many String fields that can have values only from some predefined list:
For example, the field chartType can have values

• table
• barchart
• linechart
• pivot-table

and so on. Ideally, I would like to use Enums for such fields, but some of the possible values (pivot-table in above example) are not valid dart identifiers.

It would be great If we could change serialized value of Enum by some annotation.

For example, given enum

class SecondTestEnum extends EnumClass {
  static const SecondTestEnum yes = _$ys;
  static const SecondTestEnum no = _$n;
  static const SecondTestEnum definitely = _$definitely;
  @SerializedAs('no-thanks')
  static const SecondTestEnum noThanks = _$noThanks;
  const SecondTestEnum._(String name) : super(name);
  static Serializer<SecondTestEnum> get serializer => _$secondTestEnumSerializer;
  static BuiltSet<SecondTestEnum> get values => _$vls;
  static SecondTestEnum valueOf(String name) => _$vlOf(name);
}

Its implementation would be:

const SecondTestEnum _$ys = const SecondTestEnum._('yes');
const SecondTestEnum _$n = const SecondTestEnum._('no');
const SecondTestEnum _$definitely = const SecondTestEnum._('definitely');
const SecondTestEnum _$noThanks = const SecondTestEnum._('no-thanks');

SecondTestEnum _$vlOf(String name) {
  switch (name) {
    case 'yes':
      return _$ys;
    case 'no':
      return _$n;
    case 'definitely':
      return _$definitely;
    case 'no-thanks':
      return _$noThanks;
    default:
      throw new ArgumentError(name);
  }
}

...

[vadimtsushko]

I've made some naive implementation and added related snipped in example project - it works as required in that scenario. I've not managed to add tests though.

[vadimtsushko]

Ups, I've omitted some file in commit

[davidmorgan]

Thanks! It definitely makes sense to support this somehow.

There's one alternative path I'd like to explore: using a serializer plugin. These run before/after each serialization/deserialization and can modify values, e.g.:

https://github.com/google/built_value.dart/blob/master/built_value/lib/standard_json_plugin.dart

So for example I can see writing something like

final mySerializers = (serializers.toBuilder()..addPlugin(
    (new EnumRenamerPlugin()
        ..add(SecondTestEnum, {'no-thanks': 'noThanks'})).build(), 
  ).build();

This makes the serialization format separate from the class definition -- you could have different plugins for different ways you want to serialize. And, it's more general -- we can add plugins for various tweaks that you might need to make serialization compatible.

But, perhaps it's less convenient. What do you think?

[vadimtsushko]

I just added skipped file to commits in my repo.

I think plugins would be OK for renaming enum values, but annotations seem to be slightly more convenient in that case

[vadimtsushko]

With regard to plugins I think it makes sense to consider another scenario - renaming field name in serialization. Say we want to use Built_value for CSS models. Field in our models would be camelCased (as fontWidth) and in serialized form they should look like font-width

[vadimtsushko]

Hm, probably in that scenario both approaches would work too. Plugins would be slightly slower in runtime, I guess?

[vadimtsushko]

And some errors that could be checked in generation time with the annotiation approach, would be checked in the runtime with plugins. For example duplication of enum values or field names

[vadimtsushko]

Well, plugin approach has a big plus - it can be easily integrated into a working system.
I created a simple plugin, that suits my immediately needs well, so I may try it and get a feeling - how it works

import 'package:built_collection/built_collection.dart';
import 'package:built_value/serializer.dart';

class EnumRenamerPlugin implements SerializerPlugin {
  final FullType fullType;
  final Map<String, String> mappings;
  final Map<String, String> reverseMappings = {};
  EnumRenamerPlugin(this.fullType, this.mappings) {
    for (var key in mappings.keys) {
      reverseMappings[mappings[key]] = key;
    }
  }

  @override
  Object beforeSerialize(Object object, FullType specifiedType) {
    return object;
  }

  @override
  Object afterSerialize(Object object, FullType specifiedType) {
    if (specifiedType == fullType) {
      if (mappings.containsKey(object)) {
        return mappings[object];
      }
    }
    return object;
  }

  @override
  Object beforeDeserialize(Object object, FullType specifiedType) {
    if (specifiedType == fullType) {
      if (reverseMappings.containsKey(object)) {
        return reverseMappings[object];
      }
    }
    return object;
  }

  @override
  Object afterDeserialize(Object object, FullType specifiedType) {
    return object;
  }
}

[dave26199]

Great, I look forward to hearing how it works out. Thanks!

[zoechi]

Is there a smart way to find whether the current object is an enum?

[davidmorgan]

I'm not quite sure what you're asking -- do you mean in the context of a serializer plugin?

[zoechi]

Exactly, I want to do some replacements only for enum values but not for normal built_value instances.

[zoechi]

there doesn't seem to be a way to check if specifiedType is EnumClass