ValidatorFunction.java

package io.monokkel.core.utils;

import io.monokkel.exceptions.ValidationError;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.xml.bind.ValidationException;
import java.util.ArrayList;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import static io.monokkel.core.utils.ParserUtils.isAValidJsonBaseType;

/**
 * Created by tarjei on 20/09/14.
 */
public class ValidatorFunction implements MapTransformationFunction<String,Object> {

    private Logger log = LoggerFactory.getLogger(ValidatorFunction.class);

    private class MatchAllExpression {}

    @Override
    public Object transform(String key, Object value, Map<String, Object> validationMap) {

        final Object validationObject = validationMap.getOrDefault(key,MatchAllExpression.class);

        if (validationObject instanceof String){
            String validateExpression = (String)validationObject;
            Pattern pattern = Pattern.compile(validateExpression);
            final Matcher matcher = pattern.matcher(value.toString());
            final boolean patternMatches = matcher.matches();
            if(!patternMatches){
                log.debug("Pattern {} do no match value {}",validateExpression,value);
                throw new ValidationError(key, value.toString(), validateExpression);
            } else {
                log.debug("Pattern {} match value {}",validateExpression,value);
                return patternMatches;
            }
        } else if(validationObject instanceof ArrayList){
            log.warn("Your configuration seem to have a list in its validator configuration. This functionality is not supported yet", validationObject);
            return true;
        } else {
            // No legal expression for the field is available in the validation map, the
            // default is to return valid element.
            return true;
        }
    }




}