Merge branch '2.19' into 3.x

Author: cowtowncoder

javax-money/MonetaryAmountSerializerTest.java

@@ -0,0 +1,16 @@
+package com.fasterxml.jackson.datatype.javax.money;
+
+import org.apiguardian.api.API;
+
+import javax.money.MonetaryAmount;
+
+import static org.apiguardian.api.API.Status.EXPERIMENTAL;
+
+@API(status = EXPERIMENTAL)
+public interface AmountWriter<T> {
+
+    Class<T> getType();
+
+    T write(MonetaryAmount amount);
+
+}

javax-money/delombok.tgz

@@ -0,0 +1,17 @@
+package com.fasterxml.jackson.datatype.javax.money;
+
+import org.apiguardian.api.API;
+
+import java.math.BigDecimal;
+
+import static org.apiguardian.api.API.Status.EXPERIMENTAL;
+
+@API(status = EXPERIMENTAL)
+public interface BigDecimalAmountWriter extends AmountWriter<BigDecimal> {
+
+    @Override
+    default Class<BigDecimal> getType() {
+        return BigDecimal.class;
+    }
+
+}

javax-money/delombok/src/main/java/com/fasterxml/jackson/datatype/javax/money/AmountWriter.java

@@ -0,0 +1,37 @@
+package com.fasterxml.jackson.datatype.javax.money;
+
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.deser.std.StdScalarDeserializer;
+import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
+import org.apiguardian.api.API;
+
+import javax.money.CurrencyUnit;
+import javax.money.Monetary;
+import java.io.IOException;
+
+import static org.apiguardian.api.API.Status.MAINTAINED;
+
+@API(status = MAINTAINED)
+public final class CurrencyUnitDeserializer extends StdScalarDeserializer<CurrencyUnit>
+{
+    private static final long serialVersionUID = 1L;
+
+    public CurrencyUnitDeserializer() {
+        super(CurrencyUnit.class);
+    }
+
+    @Override
+    public Object deserializeWithType(final JsonParser parser, final DeserializationContext context,
+            final TypeDeserializer deserializer) throws IOException {
+
+        // effectively assuming no type information at all
+        return deserialize(parser, context);
+    }
+
+    @Override
+    public CurrencyUnit deserialize(final JsonParser parser, final DeserializationContext context) throws IOException {
+        final String currencyCode = parser.getValueAsString();
+        return Monetary.getCurrency(currencyCode);
+    }
+}

javax-money/delombok/src/main/java/com/fasterxml/jackson/datatype/javax/money/BigDecimalAmountWriter.java

@@ -0,0 +1,36 @@
+package com.fasterxml.jackson.datatype.javax.money;
+
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.databind.JavaType;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.SerializerProvider;
+import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper;
+import com.fasterxml.jackson.databind.ser.std.StdScalarSerializer;
+import com.fasterxml.jackson.databind.ser.std.StdSerializer;
+import org.apiguardian.api.API;
+
+import javax.money.CurrencyUnit;
+import java.io.IOException;
+
+import static org.apiguardian.api.API.Status.MAINTAINED;
+
+@API(status = MAINTAINED)
+public final class CurrencyUnitSerializer extends StdScalarSerializer<CurrencyUnit> {
+
+    CurrencyUnitSerializer() {
+        super(CurrencyUnit.class);
+    }
+
+    @Override
+    public void serialize(final CurrencyUnit value, final JsonGenerator generator, final SerializerProvider serializers)
+            throws IOException {
+        generator.writeString(value.getCurrencyCode());
+    }
+
+    @Override
+    public void acceptJsonFormatVisitor(final JsonFormatVisitorWrapper visitor, final JavaType hint)
+            throws JsonMappingException {
+        visitor.expectStringFormat(hint);
+    }
+
+}

javax-money/delombok/src/main/java/com/fasterxml/jackson/datatype/javax/money/CurrencyUnitDeserializer.java

@@ -0,0 +1,19 @@
+package com.fasterxml.jackson.datatype.javax.money;
+
+import javax.annotation.Nonnull;
+import javax.money.MonetaryAmount;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+
+final class DecimalAmountWriter implements BigDecimalAmountWriter {
+
+    @Override
+    public BigDecimal write(@Nonnull final MonetaryAmount amount) {
+        final BigDecimal decimal = amount.getNumber().numberValueExact(BigDecimal.class);
+        final int defaultFractionDigits = amount.getCurrency().getDefaultFractionDigits();
+        final int scale = Math.max(decimal.scale(), defaultFractionDigits);
+
+        return decimal.setScale(scale, RoundingMode.UNNECESSARY);
+    }
+
+}

javax-money/delombok/src/main/java/com/fasterxml/jackson/datatype/javax/money/CurrencyUnitSerializer.java

@@ -0,0 +1,26 @@
+package com.fasterxml.jackson.datatype.javax.money;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.With;
+
+@AllArgsConstructor(staticName = "valueOf")
+@Getter
+public final class FieldNames
+{
+    static final FieldNames DEFAULT = FieldNames.valueOf("amount", "currency", "formatted");
+
+    @With
+    private final String amount;
+
+    @With
+    private final String currency;
+
+    @With
+    private final String formatted;
+
+    public static FieldNames defaults() {
+        return DEFAULT;
+    }
+
+}

javax-money/delombok/src/main/java/com/fasterxml/jackson/datatype/javax/money/DecimalAmountWriter.java

@@ -0,0 +1,110 @@
+package com.fasterxml.jackson.datatype.javax.money;
+
+import javax.money.CurrencyUnit;
+import javax.money.Monetary;
+import javax.money.MonetaryAmount;
+import javax.money.format.MonetaryFormats;
+
+import org.apiguardian.api.API;
+
+import com.fasterxml.jackson.core.Version;
+import com.fasterxml.jackson.databind.Module;
+import com.fasterxml.jackson.databind.module.SimpleDeserializers;
+import com.fasterxml.jackson.databind.module.SimpleSerializers;
+
+import static org.apiguardian.api.API.Status.EXPERIMENTAL;
+import static org.apiguardian.api.API.Status.STABLE;
+
+@API(status = STABLE)
+public final class JavaxMoneyModule extends Module
+{
+    private final AmountWriter<?> writer;
+    private final FieldNames names;
+    private final MonetaryAmountFormatFactory formatFactory;
+    private final MonetaryAmountFactory<? extends MonetaryAmount> amountFactory;
+
+    public JavaxMoneyModule() {
+        //When No AmountFactory is provided, use the default MonetaryAmountFactory from Monetary
+        this(new DecimalAmountWriter(), FieldNames.defaults(), MonetaryAmountFormatFactory.NONE, (amount, currency) -> Monetary.getDefaultAmountFactory().setNumber(amount).setCurrency(currency).create());
+    }
+
+    private <T extends MonetaryAmount> JavaxMoneyModule(final AmountWriter<?> writer, final FieldNames names, final MonetaryAmountFormatFactory formatFactory, final MonetaryAmountFactory<T> amountFactory) {
+
+        this.writer = writer;
+        this.names = names;
+        this.formatFactory = formatFactory;
+        this.amountFactory = amountFactory;
+    }
+
+    @Override
+    public String getModuleName() {
+        return JavaxMoneyModule.class.getSimpleName();
+    }
+
+    @Override
+    public Version version() {
+        return PackageVersion.VERSION;
+    }
+
+    @Override
+    public void setupModule(final SetupContext context) {
+        final SimpleSerializers serializers = new SimpleSerializers();
+        serializers.addSerializer(CurrencyUnit.class, new CurrencyUnitSerializer());
+        serializers.addSerializer(MonetaryAmount.class, new MonetaryAmountSerializer(names, writer, formatFactory));
+        context.addSerializers(serializers);
+
+        final SimpleDeserializers deserializers = new SimpleDeserializers();
+        deserializers.addDeserializer(CurrencyUnit.class, new CurrencyUnitDeserializer());
+
+        //Use provided amountFactory to deserialize a MonetaryAmount
+        deserializers.addDeserializer(MonetaryAmount.class, new MonetaryAmountDeserializer<>(amountFactory, names));
+
+        context.addDeserializers(deserializers);
+    }
+
+    public JavaxMoneyModule withDecimalNumbers() {
+        return withNumbers(new DecimalAmountWriter());
+    }
+
+    public JavaxMoneyModule withQuotedDecimalNumbers() {
+        return withNumbers(new QuotedDecimalAmountWriter());
+    }
+
+    @API(status = EXPERIMENTAL)
+    public JavaxMoneyModule withNumbers(final AmountWriter<?> writer) {
+        return new JavaxMoneyModule(writer, names, formatFactory, amountFactory);
+    }
+
+    public <T extends MonetaryAmount> JavaxMoneyModule withMonetaryAmountFactory(final MonetaryAmountFactory<T> amountFactory) {
+        return new JavaxMoneyModule(writer, names, formatFactory, amountFactory);
+    }
+
+    public JavaxMoneyModule withoutFormatting() {
+        return withFormatting(MonetaryAmountFormatFactory.NONE);
+    }
+
+    public JavaxMoneyModule withDefaultFormatting() {
+        return withFormatting(MonetaryFormats::getAmountFormat);
+    }
+
+    public JavaxMoneyModule withFormatting(final MonetaryAmountFormatFactory formatFactory) {
+        return new JavaxMoneyModule(writer, names, formatFactory, amountFactory);
+    }
+
+    public JavaxMoneyModule withAmountFieldName(final String name) {
+        return withFieldNames(names.withAmount(name));
+    }
+
+    public JavaxMoneyModule withCurrencyFieldName(final String name) {
+        return withFieldNames(names.withCurrency(name));
+    }
+
+    public JavaxMoneyModule withFormattedFieldName(final String name) {
+        return withFieldNames(names.withFormatted(name));
+    }
+
+    private JavaxMoneyModule withFieldNames(final FieldNames names) {
+        return new JavaxMoneyModule(writer, names, formatFactory, amountFactory);
+    }
+
+}

javax-money/delombok/src/main/java/com/fasterxml/jackson/datatype/javax/money/FieldNames.java

@@ -0,0 +1,75 @@
+package com.fasterxml.jackson.datatype.javax.money;
+
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonToken;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.JsonDeserializer;
+import com.fasterxml.jackson.databind.exc.UnrecognizedPropertyException;
+import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
+
+import javax.money.CurrencyUnit;
+import javax.money.MonetaryAmount;
+import java.io.IOException;
+import java.math.BigDecimal;
+import java.util.Arrays;
+import java.util.Objects;
+
+import static com.fasterxml.jackson.databind.DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES;
+import static java.lang.String.format;
+
+public final class MonetaryAmountDeserializer<M extends MonetaryAmount> extends JsonDeserializer<M> {
+
+    private final MonetaryAmountFactory<M> factory;
+    private final FieldNames names;
+
+    public MonetaryAmountDeserializer(final MonetaryAmountFactory<M> factory, final FieldNames names) {
+        this.factory = factory;
+        this.names = names;
+    }
+
+    @Override
+    public Object deserializeWithType(final JsonParser parser, final DeserializationContext context,
+                                      final TypeDeserializer deserializer) throws IOException {
+
+        // effectively assuming no type information at all
+        return deserialize(parser, context);
+    }
+
+    @Override
+    public M deserialize(final JsonParser parser, final DeserializationContext context) throws IOException {
+        BigDecimal amount = null;
+        CurrencyUnit currency = null;
+
+        while (parser.nextToken() != JsonToken.END_OBJECT) {
+            final String field = parser.currentName();
+
+            parser.nextToken();
+
+            if (field.equals(names.getAmount())) {
+                amount = context.readValue(parser, BigDecimal.class);
+            } else if (field.equals(names.getCurrency())) {
+                currency = context.readValue(parser, CurrencyUnit.class);
+            } else if (field.equals(names.getFormatted())) {
+                //noinspection UnnecessaryContinue
+                continue;
+            } else if (context.isEnabled(FAIL_ON_UNKNOWN_PROPERTIES)) {
+                throw UnrecognizedPropertyException.from(parser, MonetaryAmount.class, field,
+                        Arrays.asList(names.getAmount(), names.getCurrency(), names.getFormatted()));
+            } else {
+                parser.skipChildren();
+            }
+        }
+
+        String missingName;
+
+        if (Objects.isNull(currency)) {
+            missingName = names.getCurrency();
+        } else if (Objects.isNull(amount)) {
+            missingName = names.getAmount();
+        } else {
+            return factory.create(amount, currency);
+        }
+
+        return context.reportPropertyInputMismatch(MonetaryAmount.class, missingName, format("Missing property: '%s'", missingName));
+    }
+}