PropertyToJavaGenerator/src/main/java/de/kreth/property2java/Generator.java

package de.kreth.property2java;

import java.io.File;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
import java.net.URL;
import java.text.DateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import de.kreth.property2java.cli.ArgumentConfiguration;
import de.kreth.property2java.config.FreemarkerConfig;
import freemarker.template.Template;
import freemarker.template.TemplateException;

public class Generator {

    private static final DateFormat dateTimeInstance = DateFormat.getDateTimeInstance();

    private final Configuration config;

    private final Template template;

    public Generator(Configuration config) {
	this.config = config;
	try {
	    template = FreemarkerConfig.INSTANCE.getTemplate(config.getFormat());
	} catch (IOException e) {
	    throw new IllegalStateException("Unable to load freemarker template", e);
	}
    }

    public void start() throws IOException, GeneratorException {

	for (Map.Entry<String, Reader> entry : config.getInput().entrySet()) {
	    String fileName = entry.getKey();
	    try (Writer out = config.outWriter(fileName)) {

		Properties properties = new Properties();
		properties.load(entry.getValue());
		try {
		    generate(properties, out, fileName, config);
		} catch (TemplateException e) {
		    throw new GeneratorException("Error configuring Engine", e);
		}
	    }
	}
    }

    void generate(Properties properties, Writer out, String fileName, Configuration config)
	    throws IOException, TemplateException {

	Map<String, Object> root = new HashMap<>();
	root.put("generator_name", getClass().getName());
	root.put("generation_date", dateTimeInstance.format(new Date()));
	root.put("package", config.getPackage());
	root.put("fileName", fileName);
	root.put("bundle_base_name", fileName.substring(0, min(fileName.length(), fileName.lastIndexOf('.'))));
	root.put("classname", config.mapFilenameToClassName(fileName));

	List<Entry> entries = new ArrayList<>();

	root.put("entries", entries);

	@SuppressWarnings("unchecked")
	List<String> propertyNames = Collections.list((Enumeration<String>) properties.propertyNames());
	Collections.sort(propertyNames);

	for (String propertyKeyString : propertyNames) {
	    final String propertyValue = properties.getProperty(propertyKeyString);

	    entries.add(new Entry(propertyKeyString.toUpperCase().replaceAll("[\\.-]", "_"), propertyKeyString,
		    propertyValue));
	}
	template.process(root, out);
    }

    int min(int a, int b) {
	int result = Math.min(a, b);
	if (result < 0) {
	    result = Math.max(a, b);
	}
	return result;
    }

    public static void main(String[] args) throws IOException, GeneratorException {
	Generator generator = new Generator(ArgumentConfiguration.parse(args));
	generator.start();
    }

    public static void generateFor(Class<?> locationClass, List<URL> rescources, String relativeTargetDir)
	    throws IOException, GeneratorException {

	ArgumentConfiguration.Builder config = new ArgumentConfiguration.Builder();

	rescources
		.stream()
		.map(URL::getFile)
		.map(File::new)
		.map(File::getAbsolutePath)
		.forEach(config::addPropFile);

	config.setPackageName(locationClass.getPackageName())
		.setTarget(relativeTargetDir);

	Generator g = new Generator(config.build());
	g.start();
    }

    /**
     * Represents an Property Entry for the generated java class.
     *
     * @author markus
     *
     */
    public class Entry {

	public final String constant;

	public final String key;

	public final String value;

	/**
	 * Creates Property Entry data for the generated java class.
	 *
	 * @param constant name for the created constant.
	 * @param key      property key
	 * @param value    property value
	 */
	public Entry(String constant, String key, String value) {
	    super();
	    this.constant = constant;
	    this.key = key;
	    this.value = value;
	}

	public String getConstant() {
	    return constant;
	}

	public String getKey() {
	    return key;
	}

	public String getValue() {
	    return value;
	}

	@Override
	public String toString() {
	    return "Entry [constant=" + constant + ", key=" + key + ", value=" + value + "]";
	}

    }

}