Add methods to modify an existing binding

[heruan]

Given an existing binding, it's currently not possible to modify its properties; for example, given

var binding = binder.forField(field).bind(getter, setter);

I might need to add additional validation, like:

• binding.setRequired(true)
• binding.addValidator(validator)

depending on user actions or status of other fields.

[berndklb]

Hi @heruan
is this change https://github.com/vaadin/flow/compare/master...berndklb:feature/5030_change_existing_binding?expand=1 something you would expect? At the moment I implemented only the setRequired and addValidator methods.

[heruan]

@berndklb I have to test it yet, but it seems like it!

[heruan]

Any update on this?

[heruan]

@berndklb Can't find your branch anymore, is it still available?

[berndklb]

I cleaned up a while ago, but I repushed the branch.
But I did not investigate further into this so far.

[heruan]

Thank you @berndklb for pushing that again. In the meanwhile, I've crafted a custom Binder as a workaround:

public class CustomBinder<T> extends Binder<T> {

    public interface CustomBinding<T, V> extends Binding<T, V> {

        default void setRequired(boolean required) {
            if (required) {
                this.setRequired(context -> "");
            } else {
                this.setRequired(Validator.alwaysPass());
            }
            this.getField().setRequiredIndicatorVisible(required);
            this.validate(false);
        }

        void setRequired(ErrorMessageProvider errorMessageProvider);

        void setRequired(Validator<V> validator);

    }

    public interface CustomBindingBuilder<T, V> extends BindingBuilder<T, V> {

        @Override
        default CustomBindingBuilder<T, V> asRequired() {
            return this.asRequired(context -> "");
        }

        @Override
        default CustomBindingBuilder<T, V> asRequired(String errorMessage) {
            return this.asRequired(context -> errorMessage);
        }

        @Override
        CustomBindingBuilder<T, V> asRequired(ErrorMessageProvider errorMessageProvider);

        @Override
        CustomBindingBuilder<T, V> asRequired(Validator<V> customRequiredValidator);

        @Override
        CustomBinding<T, V> bind(ValueProvider<T, V> getter, Setter<T, V> setter);

    }

    protected static class CustomValidatorImpl<T> implements Validator<T> {

        private Validator<T> upstream;

        public CustomValidatorImpl(Validator<T> upstream) {
            this.upstream = upstream;
        }

        @Override
        public ValidationResult apply(T value, ValueContext context) {
            return this.upstream.apply(value, context);
        }

    }

    protected static class CustomBindingBuilderImpl<T, U, V> extends BindingBuilderImpl<T, U, V>
            implements CustomBindingBuilder<T, V> {

        private final HasValue<?, U> field;

        private final Converter<U, V> converterValidatorChain;

        private CustomValidatorImpl<V> requiredValidator;

        protected CustomBindingBuilderImpl(Binder<T> binder, HasValue<?, U> field,
                Converter<U, V> converterValidatorChain,
                BindingValidationStatusHandler statusHandler) {
            super(binder, field, converterValidatorChain, statusHandler);
            this.field = field;
            this.converterValidatorChain = converterValidatorChain;
        }

        @Override
        public CustomBindingBuilder<T, V> withValidator(Validator<? super V> validator) {
            super.withValidator(validator);
            return this;
        }

        @Override
        public CustomBindingBuilder<T, V> asRequired(ErrorMessageProvider errorMessageProvider) {
            return this.asRequired((v, c) -> Validator.<V>from(value -> {
                var emptyValue = this.field.getEmptyValue();
                var convertedValue = this.converterValidatorChain.convertToPresentation(value, c);
                return !Objects.equals(convertedValue, emptyValue);
            }, errorMessageProvider).apply(v, c));
        }

        @Override
        public CustomBindingBuilder<T, V> asRequired(Validator<V> customRequiredValidator) {
            this.requiredValidator = new CustomValidatorImpl<>(customRequiredValidator);
            this.checkUnbound();
            this.field.setRequiredIndicatorVisible(true);
            return this.withValidator(this.requiredValidator);
        }

        @Override
        public CustomBinding<T, V> bind(ValueProvider<T, V> getter, Setter<T, V> setter) {
            var upstream = super.bind(getter, setter);
            return new CustomBindingImpl<>(upstream, this);
        }

    }

    protected static class CustomBindingImpl<T, U, V> implements CustomBinding<T, V> {

        private final Binding<T, V> upstream;

        private final HasValue<?, U> field;

        private final Converter<U, V> converterValidatorChain;

        private final CustomValidatorImpl<V> requiredValidator;

        public CustomBindingImpl(Binding<T, V> upstream,
                CustomBindingBuilderImpl<T, U, V> builder) {
            this.upstream = upstream;
            this.field = builder.field;
            this.converterValidatorChain = builder.converterValidatorChain;
            this.requiredValidator = builder.requiredValidator;
        }

        @Override
        public void setRequired(ErrorMessageProvider errorMessageProvider) {
            this.setRequired((v, c) -> Validator.<V>from(value -> {
                var emptyValue = this.field.getEmptyValue();
                var convertedValue = this.converterValidatorChain.convertToPresentation(value, c);
                return !Objects.equals(convertedValue, emptyValue);
            }, errorMessageProvider).apply(v, c));
        }

        @Override
        public void setRequired(Validator<V> validator) {
            this.requiredValidator.upstream = validator;
        }

        @Override
        public HasValue<?, ?> getField() {
            return this.upstream.getField();
        }

        @Override
        public BindingValidationStatus<V> validate(boolean fireEvent) {
            return this.upstream.validate(fireEvent);
        }

        @Override
        public BindingValidationStatusHandler getValidationStatusHandler() {
            return this.upstream.getValidationStatusHandler();
        }

        @Override
        public void unbind() {
            this.upstream.unbind();
        }

        @Override
        public void read(T bean) {
            this.upstream.read(bean);
        }

        @Override
        public void setReadOnly(boolean readOnly) {
            this.upstream.setReadOnly(readOnly);
        }

        @Override
        public boolean isReadOnly() {
            return this.upstream.isReadOnly();
        }

        @Override
        public ValueProvider<T, V> getGetter() {
            return this.upstream.getGetter();
        }

        @Override
        public Setter<T, V> getSetter() {
            return this.upstream.getSetter();
        }

    }

    @Override
    public <U> CustomBindingBuilder<T, U> forField(HasValue<?, U> field) {
        return (CustomBindingBuilder<T, U>) super.forField(field);
    }

    @Override
    protected <U, V> BindingBuilder<T, V> doCreateBinding(HasValue<?, U> field,
            Converter<U, V> converter, BindingValidationStatusHandler handler) {
        return new CustomBindingBuilderImpl<>(this, field, converter, handler);
    }

}

But I still think the feature should be on core, so I hope to get rid of this soon 🙂

[pleku]

Acceptance Criteria

• Inclusion of the API as suggested in couple comments above
• Unit tests that verify that the API does what it should (no ITs should be required)

This feature is up for grabs for contributing, please read the contribution guidelines https://github.com/vaadin/flow/blob/master/CONTRIBUTING.md and ask any questions in here or eg. https://gitter.im/vaadin/flow if necessary.