eu.project.ttc.engines.variant.VariantRuleYamlIO.java Source code

Introduction

Here is the source code for eu.project.ttc.engines.variant.VariantRuleYamlIO.java

Source

/*******************************************************************************
 * Copyright 2015-2016 - CNRS (Centre National de Recherche Scientifique)
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *******************************************************************************/
package eu.project.ttc.engines.variant;

import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.lang3.StringUtils;
import org.yaml.snakeyaml.Yaml;

import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;

import eu.project.ttc.utils.TermSuiteUtils;

public class VariantRuleYamlIO {
    public static final String P_SOURCE = "source";
    public static final String P_TARGET = "target";
    public static final String P_RULE = "rule";
    public static final String OPT_COMPOUND = "compound";
    public static final String COMPOUND_REGEX = "\\[\\s*(\\w+)\\s*\\]";

    private static final List<String> ALLOWED_PROPS = ImmutableList.of(P_SOURCE, P_TARGET, P_RULE);

    private List<VariantRule> variantRules;

    private String yaml;

    private VariantRuleYamlIO(String yamlString) {
        this.yaml = yamlString;
    }

    public static VariantRuleYamlIO fromYaml(String yamlString) {
        return new VariantRuleYamlIO(yamlString);
    }

    private void fromYaml() {
        this.variantRules = Lists.newArrayList();
        Object yaml = new Yaml().load(this.yaml);
        Preconditions.checkArgument(yaml instanceof LinkedHashMap,
                "Bad format for yaml rules file. Expected key-values, got: " + yaml.getClass());

        Map<?, ?> map = (Map<?, ?>) yaml;
        for (Map.Entry<?, ?> entry : map.entrySet()) {
            String ruleName = (String) entry.getKey();
            VariantRuleBuilder builder = VariantRuleBuilder.start(ruleName);
            Preconditions.checkArgument(entry.getValue() instanceof LinkedHashMap, String.format(
                    "Bad format for rule %s. Expected key-values, got: %s", entry.getKey(), entry.getClass()));
            Map<?, ?> props = (Map<?, ?>) entry.getValue();
            Preconditions.checkArgument(ALLOWED_PROPS.containsAll(props.keySet()), String.format(
                    "Unexcpected property in rule %s. Allowed rule properties: %s", ruleName, ALLOWED_PROPS));
            if (props.get(P_SOURCE) != null)
                parseSourceTarget(builder, ruleName, P_SOURCE, props.get(P_SOURCE));
            if (props.get(P_TARGET) != null)
                parseSourceTarget(builder, ruleName, P_TARGET, props.get(P_TARGET));
            if (props.get(P_RULE) != null) {
                parseRule(builder, ruleName, props.get(P_RULE));
            }
            this.variantRules.add(builder.create());
        }
    }

    private void parseRule(VariantRuleBuilder builder, String ruleName, Object valueStr) {
        Preconditions.checkArgument(valueStr instanceof CharSequence,
                String.format("Bad format for property rule (in rule %s). String expected. Got %s", ruleName,
                        valueStr.getClass().getName()));
        builder.rule(StringUtils.chomp((String) valueStr));
    }

    private void parseSourceTarget(VariantRuleBuilder builder, String ruleName, String prop, Object valueStr) {
        Preconditions.checkArgument(valueStr instanceof CharSequence,
                String.format("Bad format for property %s (rule %s). String expected. Got %s", prop, ruleName,
                        valueStr.getClass().getName()));

        String value = (String) valueStr;
        Matcher compoundMatcher = Pattern.compile(COMPOUND_REGEX).matcher(value);
        boolean isCompound = false;
        int cnt = 0;
        while (compoundMatcher.find()) {
            if (++cnt > 1)
                // do not allow to have multiple option
                throw new IllegalArgumentException(
                        String.format("Only one option bracket allowed (rule %s). Got: %s", ruleName, value));
            if (compoundMatcher.group(1).equals(OPT_COMPOUND))
                isCompound = true;
            else
                throw new IllegalArgumentException(
                        String.format("Illegal options for rule %s: %s", ruleName, compoundMatcher.group(1)));
        }
        String withoutOptions = value.replaceAll(COMPOUND_REGEX, "").trim();
        Iterable<String> occPatterns = Splitter.on(',').split(withoutOptions);
        if (P_SOURCE.equals(prop)) {
            if (isCompound)
                builder.sourceCompound();
            for (String p : occPatterns)
                if (!p.trim().isEmpty())
                    builder.addSourcePattern(TermSuiteUtils.trimInside(p));
        } else if (P_TARGET.equals(prop)) {
            if (isCompound)
                builder.targetCompound();
            for (String p : occPatterns)
                if (!p.trim().isEmpty())
                    builder.addTargetPattern(TermSuiteUtils.trimInside(p));
        }
    }

    public List<VariantRule> getVariantRules() {
        if (this.variantRules == null)
            fromYaml();
        return variantRules;
    }

}