[maven-release-plugin] prepare for next development iteration

Bump log4j-core from 2.17.0 to 2.17.1

.classpath

@@ -1,37 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" output="target/classes" path="src/main/java">
-		<attributes>
-			<attribute name="optional" value="true"/>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources">
-		<attributes>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry kind="src" output="target/test-classes" path="src/test/java">
-		<attributes>
-			<attribute name="test" value="true"/>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry excluding="**" kind="src" output="target/test-classes" path="src/test/resources">
-		<attributes>
-			<attribute name="test" value="true"/>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry exported="true" kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
-		<attributes>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-11">
-		<attributes>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry kind="output" path="target/classes"/>
-</classpath>

.github/workflows/maven.yml

@@ -0,0 +1,24 @@
+# This workflow will build a Java project with Maven
+# For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-maven
+
+name: PropertyToJavaGenerator Library and console programm
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up JDK 1.8
+      uses: actions/setup-java@v1
+      with:
+        java-version: 11
+    - name: Build with Maven
+      run: mvn -B package --file pom.xml

.gitignore

@@ -1,3 +1,5 @@
-
+.classpath
-\.settings/
+.project
+.factorypath
+.settings
 target

.project

@@ -1,23 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>PropertyToJavaGenerator</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.jdt.core.javabuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.m2e.core.maven2Builder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.jdt.core.javanature</nature>
-		<nature>org.eclipse.m2e.core.maven2Nature</nature>
-	</natures>
-</projectDescription>

META-INF/services/javax.annotation.processing.Processor

@@ -0,0 +1 @@
+de.kreth.property2java.processor.Property2JavaGenerator

pom.xml

@@ -4,7 +4,7 @@
 	<modelVersion>4.0.0</modelVersion>
 	<groupId>de.kreth.property2java</groupId>
 	<artifactId>PropertyToJavaGenerator</artifactId>
-	<version>1.0.0</version>
+	<version>2.0.3-SNAPSHOT</version>
 
 	<properties>
 
@@ -12,20 +12,12 @@
 		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
 		<java.version>11</java.version>
 		<org.junit.jupiter>5.3.0-M1</org.junit.jupiter>
-		<org.slf4j>1.7.21</org.slf4j>
+		<org.slf4j>1.7.36</org.slf4j>
-		<org.apache.logging.log4j>2.11.0</org.apache.logging.log4j>
+		<org.apache.logging.log4j>2.17.2</org.apache.logging.log4j>
 
 		<timestamp>${maven.build.timestamp}</timestamp>
 		<maven.build.timestamp.format>yyyy-MM-dd HH:mm:ss</maven.build.timestamp.format>
-
+		<project.scm.id>github</project.scm.id>
-		<sonar.login>3f3a1fa86ea83226b564895f3a8503f67e855440</sonar.login>
-		<sonar.jacoco.reportPaths>target/surefire-reports</sonar.jacoco.reportPaths>
-		<sonar.java.coveragePlugin>jacoco</sonar.java.coveragePlugin>
-		<sonar.core.codeCoveragePlugin>jacoco</sonar.core.codeCoveragePlugin>
-		<sonar.dynamicAnalysis>reuseReports</sonar.dynamicAnalysis>
-		<sonar.jacoco.reportPath>${project.basedir}/target/jacoco.exec</sonar.jacoco.reportPath>
-		<sonar.exclusions>**/src/main/webapp/VAADIN/**/*</sonar.exclusions>
-
 	</properties>
 
 	<dependencies>
@@ -126,6 +118,18 @@
 		</dependency>
 	</dependencies>
 
+	<distributionManagement>
+		<snapshotRepository>
+			<id>kreth.snapshots</id>
+			<url>https://nexus.kreth-development.de/repository/maven-snapshots/</url>
+		</snapshotRepository>
+		<repository>
+			<id>kreth.releases</id>
+			<url>https://nexus.kreth-development.de/repository/maven-releases/</url>
+		</repository>
+	</distributionManagement>
+
+
 	<build>
 		<plugins>
 			<plugin>
@@ -134,35 +138,14 @@
 				<version>3.8.0</version>
 				<configuration>
 					<release>${java.version}</release>
+					<compilerArgs>-proc:none</compilerArgs>
 				</configuration>
 			</plugin>
-			<plugin>
-				<groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-surefire-plugin</artifactId>
-				<version>3.0.0-M3</version>
-			</plugin>
-
-			<plugin>
-				<groupId>org.jacoco</groupId>
-				<artifactId>jacoco-maven-plugin</artifactId>
-				<version>0.8.2</version>
-				<executions>
-					<execution>
-						<id>default-jacoco-prepare-agent</id>
-						<goals>
-							<goal>prepare-agent</goal>
-						</goals>
-					</execution>
-					<execution>
-						<id>default-jacoco-report</id>
-						<phase>prepare-package</phase>
-						<goals>
-							<goal>report</goal>
-						</goals>
-					</execution>
-				</executions>
-			</plugin>
 		</plugins>
 	</build>
-
+	<scm>
-</project>
+		<developerConnection>scm:git:https://gitea.kreth-development.de/markus/PropertyToJavaGenerator_migration.git</developerConnection>
+		<connection>scm:git:https://gitea.kreth-development.de/markus/PropertyToJavaGenerator_migration.git</connection>
+    <tag>HEAD</tag>
+  </scm>
+</project>

src/main/java/de/kreth/property2java/Configuration.java

@@ -12,41 +12,54 @@ import java.util.Map;
 import org.apache.commons.text.WordUtils;
 
 import de.kreth.property2java.config.Regex;
+import de.kreth.property2java.processor.Format;
 
 public interface Configuration {
 
-	/**
+    /**
-	 * Package for generated Java Classes eg. "de.kreth.property2java". If null - no package line is generated.
+     * Package for generated Java Classes eg. "de.kreth.property2java". If null - no
-	 * @return
+     * package line is generated.
-	 */
+     *
-	String getPackage();
+     * @return
-
+     */
-	/**
+    String getPackage();
-	 * Filename to InputReader Entries
+
-	 * @return
+    default Format getFormat() {
-	 */
+	return Format.WithUnaryOperatorParameter;
-	Map<String, Reader> getInput();
+    }
-
+
-	/**
+    /**
-	 * Path of java source folder.
+     * Filename to InputReader Entries
-	 * @return
+     *
-	 */
+     * @return
-	Path getRootPath();
+     */
-
+    Map<String, Reader> getInput();
-	default Writer outWriter(String fileName) throws IOException {
+
-		return new FileWriter(new File(getRootPath().toFile(), mapFilenameToClassName(fileName) + ".java"),
+    /**
-				outputCharset());
+     * Path of java source folder.
-	}
+     *
-
+     * @return
-	default Charset outputCharset() {
+     */
-		return Charset.defaultCharset();
+    Path getRootPath();
-	}
+
-
+    default Writer outWriter(String fileName) throws IOException {
-	default String mapFilenameToClassName(String fileName) {
+	return new FileWriter(new File(getRootPath().toFile(), mapFilenameToClassName(fileName) + ".java"),
-
+		outputCharset());
-		String path = Regex.PATTERN.matcher(fileName).replaceAll(".").replaceAll("\\.", "_").replaceAll(" ", "_");
+    }
-		path = WordUtils.capitalize(path, '_');
+
-		return path;
+    default Charset outputCharset() {
-	}
+	return Charset.defaultCharset();
+    }
+
+    default String mapFilenameToClassName(String fileName) {
+
+	String path = Regex.PATTERN.matcher(fileName)
+		.replaceAll(".")
+		.replaceAll("\\.", "_")
+		.replaceAll(" ", "_")
+		.replaceAll("/", "_");
+	path = WordUtils.capitalize(path, '_');
+	return path;
+    }
 
 }

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

@@ -1,8 +1,10 @@
 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;
@@ -20,114 +22,143 @@ import freemarker.template.TemplateException;
 
 public class Generator {
 
-	private static final DateFormat dateTimeInstance = DateFormat.getDateTimeInstance();
+    private static final DateFormat dateTimeInstance = DateFormat.getDateTimeInstance();
 
-	private final Configuration config;
+    private final Configuration config;
 
-	private final Template template;
+    private final Template template;
 
-	public Generator(Configuration config) {
+    public Generator(Configuration config) {
-		this.config = config;
+	this.config = config;
-		try {
+	try {
-			template = FreemarkerConfig.INSTANCE.getTemplate();
+	    template = FreemarkerConfig.INSTANCE.getTemplate(config.getFormat());
-		}
+	} catch (IOException e) {
-		catch (IOException e) {
+	    throw new IllegalStateException("Unable to load freemarker template", e);
-			throw new IllegalStateException("Unable to load freemarker template", e);
-		}
 	}
+    }
+
+    public void start() throws IOException, GeneratorException {
 
-	public void start() throws IOException, GeneratorException {
+	for (Map.Entry<String, Reader> entry : config.getInput().entrySet()) {
-
+	    String fileName = entry.getKey();
-		for (Map.Entry<String, Reader> entry : config.getInput().entrySet()) {
+	    try (Writer out = config.outWriter(fileName)) {
-			String fileName = entry.getKey();
+
-			try (Writer out = config.outWriter(fileName)) {
+		Properties properties = new Properties();
-
+		properties.load(entry.getValue());
-				Properties properties = new Properties();
+		try {
-				properties.load(entry.getValue());
+		    generate(properties, out, fileName, config);
-				try {
+		} catch (TemplateException e) {
-					generate(properties, out, fileName, config);
+		    throw new GeneratorException("Error configuring Engine", e);
-				}
-				catch (TemplateException e) {
-					throw new GeneratorException("Error configuring Engine", e);
-				}
-			}
 		}
+	    }
 	}
+    }
 
-	void generate(Properties properties, Writer out, String fileName, Configuration config)
+    void generate(Properties properties, Writer out, String fileName, Configuration config)
-			throws IOException, TemplateException {
+	    throws IOException, TemplateException {
 
-		Map<String, Object> root = new HashMap<>();
+	Map<String, Object> root = new HashMap<>();
-		root.put("generator_name", getClass().getName());
+	root.put("generator_name", getClass().getName());
-		root.put("generation_date", dateTimeInstance.format(new Date()));
+	root.put("generation_date", dateTimeInstance.format(new Date()));
-		root.put("package", config.getPackage());
+	root.put("package", config.getPackage());
-		root.put("fileName", fileName);
+	root.put("fileName", fileName);
-		root.put("classname", config.mapFilenameToClassName(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<>();
+	List<Entry> entries = new ArrayList<>();
 
-		root.put("entries", entries);
+	root.put("entries", entries);
 
-		@SuppressWarnings("unchecked")
+	@SuppressWarnings("unchecked")
-		List<String> propertyNames = Collections.list((Enumeration<String>) properties.propertyNames());
+	List<String> propertyNames = Collections.list((Enumeration<String>) properties.propertyNames());
-		Collections.sort(propertyNames);
+	Collections.sort(propertyNames);
 
-		for (String propertyKeyString : propertyNames) {
+	for (String propertyKeyString : propertyNames) {
-			final String propertyValue = properties.getProperty(propertyKeyString);
+	    final String propertyValue = properties.getProperty(propertyKeyString);
 
-			entries.add(new Entry(propertyKeyString.toUpperCase().replaceAll("[\\.-]", "_"), propertyKeyString,
+	    entries.add(new Entry(propertyKeyString.toUpperCase().replaceAll("[\\.-]", "_"), propertyKeyString,
-					propertyValue));
+		    propertyValue));
-		}
-		template.process(root, out);
 	}
+	template.process(root, out);
+    }
 
-	public static void main(String[] args) throws IOException, GeneratorException {
+    int min(int a, int b) {
-		Generator generator = new Generator(ArgumentConfiguration.parse(args));
+	int result = Math.min(a, b);
-		generator.start();
+	if (result < 0) {
+	    result = Math.max(a, b);
 	}
+	return result;
+    }
 
-	/**
+    public static void main(String[] args) throws IOException, GeneratorException {
-	 * Represents an Property Entry for the generated java class.
+	Generator generator = new Generator(ArgumentConfiguration.parse(args));
-	 * @author markus
+	generator.start();
-	 *
+    }
-	 */
-	public class Entry {
 
-		public final String constant;
+    public static void generateFor(Class<?> locationClass, List<URL> rescources, String relativeTargetDir)
+	    throws IOException, GeneratorException {
 
-		public final String key;
+	ArgumentConfiguration.Builder config = new ArgumentConfiguration.Builder();
 
-		public final String value;
+	rescources
+		.stream()
+		.map(URL::getFile)
+		.map(File::new)
+		.map(File::getAbsolutePath)
+		.forEach(config::addPropFile);
 
-		/**
+	config.setPackageName(locationClass.getPackageName())
-		 * Creates Property Entry data for the generated java class.
+		.setTarget(relativeTargetDir);
-		 * @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() {
+	Generator g = new Generator(config.build());
-			return constant;
+	g.start();
-		}
+    }
 
-		public String getKey() {
+    /**
-			return key;
+     * Represents an Property Entry for the generated java class.
-		}
+     *
+     * @author markus
+     *
+     */
+    public class Entry {
 
-		public String getValue() {
+	public final String constant;
-			return value;
-		}
 
-		@Override
+	public final String key;
-		public String toString() {
-			return "Entry [constant=" + constant + ", key=" + key + ", value=" + value + "]";
-		}
 
+	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 + "]";
+	}
+
+    }
+
 }

src/main/java/de/kreth/property2java/cli/ArgumentConfiguration.java

@@ -16,82 +16,81 @@ import de.kreth.property2java.Configuration;
 
 public class ArgumentConfiguration implements Configuration {
 
-	private final String packageName;
+    private final String packageName;
 
-	private final Map<String, Reader> files;
+    private final Map<String, Reader> files;
 
-	private final Path rootPath;
+    private final Path rootPath;
 
-	private ArgumentConfiguration(Builder builder) throws IOException {
+    private ArgumentConfiguration(Builder builder) throws IOException {
-		this.packageName = builder.packageName;
+	this.packageName = builder.packageName;
-		rootPath = new File(builder.target).toPath();
+	rootPath = new File(builder.target).toPath();
-		files = new HashMap<>();
+	files = new HashMap<>();
-		for (String filePath : builder.propFiles) {
+	for (String filePath : builder.propFiles) {
-			File f = new File(filePath);
+	    File f = new File(filePath);
-			files.put(f.getName(), new FileReader(f));
+	    files.put(f.getName(), new FileReader(f));
-		}
-
-	}
-
-	@Override
-	public String getPackage() {
-		return packageName;
 	}
 
-	@Override
+    }
-	public Map<String, Reader> getInput() {
+
-		return files;
+    @Override
+    public String getPackage() {
+	return packageName;
+    }
+
+    @Override
+    public Map<String, Reader> getInput() {
+	return files;
+    }
+
+    @Override
+    public Path getRootPath() {
+	return rootPath;
+    }
+
+    @Override
+    public Writer outWriter(String fileName) throws IOException {
+	File dir;
+	if (packageName != null && packageName.isBlank() == false) {
+	    dir = new File(rootPath.toFile(), packageName.replace('.', File.separatorChar));
+	} else {
+	    dir = rootPath.toFile();
 	}
+	return new FileWriter(new File(dir, mapFilenameToClassName(fileName) + ".java"), false);
+    }
 
-	@Override
+    public static Configuration parse(String[] args) throws IOException {
-	public Path getRootPath() {
+	CliConfig cliConfig = new CliConfig();
-		return rootPath;
-	}
 
-	@Override
+	Builder builder = new Builder();
-	public Writer outWriter(String fileName) throws IOException {
+	cliConfig.fill(builder, args);
-		File dir;
+	return builder.build();
-		if (packageName != null && packageName.isBlank() == false) {
+    }
-			dir = new File(rootPath.toFile(), packageName.replace('.', File.separatorChar));
-		}
-		else {
-			dir = rootPath.toFile();
-		}
-		return new FileWriter(new File(dir, mapFilenameToClassName(fileName) + ".java"), false);
-	}
 
-	public static Configuration parse(String[] args) throws IOException {
+    public static class Builder {
-		CliConfig cliConfig = new CliConfig();
+	String target;
 
-		Builder builder = new Builder();
+	List<String> propFiles = new ArrayList<>();
-		cliConfig.fill(builder, args);
-		return builder.build();
-	}
 
-	static class Builder {
+	String packageName;
-		String target;
 
-		List<String> propFiles = new ArrayList<>();
+	public Builder setTarget(String target) {
-
+	    this.target = target;
-		String packageName;
+	    return this;
-
+	}
-		public Builder setTarget(String target) {
-			this.target = target;
-			return this;
-		}
 
-		public Builder addPropFile(String propFile) {
+	public Builder addPropFile(String propFile) {
-			this.propFiles.add(propFile);
+	    this.propFiles.add(propFile);
-			return this;
+	    return this;
-		}
+	}
 
-		public Builder setPackageName(String packageName) {
+	public Builder setPackageName(String packageName) {
-			this.packageName = packageName;
+	    this.packageName = packageName;
-			return this;
+	    return this;
-		}
+	}
 
-		public Configuration build() throws IOException {
+	public Configuration build() throws IOException {
-			return new ArgumentConfiguration(this);
+	    return new ArgumentConfiguration(this);
-		}
 	}
+    }
 }

src/main/java/de/kreth/property2java/config/FreemarkerConfig.java

@@ -2,23 +2,36 @@ package de.kreth.property2java.config;
 
 import java.io.IOException;
 
+import de.kreth.property2java.processor.Format;
 import freemarker.template.Configuration;
 import freemarker.template.Template;
 
 public enum FreemarkerConfig {
 
-	INSTANCE;
+    INSTANCE;
-
+
-	private final Configuration cfg;
+    private final Configuration cfg;
-
+
-	public Template getTemplate() throws IOException {
+    public Template getTemplate(Format format) throws IOException {
-		return cfg.getTemplate("enum_template.tpl");
+	switch (format) {
+	case WithInitializer:
+	    return cfg.getTemplate("enum_template_with_initializer.tpl");
+	case WithInnerPropertyLoader:
+	    return cfg.getTemplate("enum_template_with_inner_properties.tpl");
+	case WithInnerPropertyResourceBundle:
+	    return cfg.getTemplate("enum_template_with_inner_propertyresourcebundle.tpl");
+	case WithUnaryOperatorParameter:
+	    return cfg.getTemplate("enum_template.tpl");
+	default:
+	    throw new IllegalArgumentException("Format " + format + " is not supported.");
 	}
 
-	private FreemarkerConfig() {
+    }
-		cfg = new Configuration(Configuration.VERSION_2_3_28);
+
-		cfg.setClassForTemplateLoading(this.getClass(), "/template/");
+    private FreemarkerConfig() {
-		cfg.setDefaultEncoding("UTF-8");
+	cfg = new Configuration(Configuration.VERSION_2_3_28);
-	}
+	cfg.setClassForTemplateLoading(this.getClass(), "/template/");
+	cfg.setDefaultEncoding("UTF-8");
+    }
 
 }

src/main/java/de/kreth/property2java/processor/Format.java

@@ -0,0 +1,27 @@
+package de.kreth.property2java.processor;
+
+import java.util.PropertyResourceBundle;
+
+public enum Format {
+
+    /**
+     * Offers a getString(UnaryOperator<String> resourceFunction) method to access
+     * the String value
+     */
+    WithUnaryOperatorParameter,
+    /**
+     * Generates {@link PropertyResourceBundle} to offer a getText() method without
+     * parameters.
+     */
+    WithInnerPropertyResourceBundle,
+    /**
+     * Offers a generated {@link PropertyResourceBundle} to offer a getText() method
+     * without parameters.
+     */
+    WithInnerPropertyLoader,
+    /**
+     * Offers a static init(UnaryOperator<String> resourceFunction) method to offer
+     * a getText() method. The init method must be called before any getText() call.
+     */
+    WithInitializer
+}

src/main/java/de/kreth/property2java/processor/GenerateProperty2Java.java

@@ -0,0 +1,42 @@
+package de.kreth.property2java.processor;
+
+import static java.lang.annotation.ElementType.TYPE;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target(TYPE)
+@Retention(RetentionPolicy.SOURCE)
+/**
+ * Für die konfigurierten Resourcen wird jeweils eine Java Klasse erzeugt. Es
+ * muss nur die Abhängigkeit eingebunden werden und die Annotation in einer
+ * Klasse verwendet werden, in deren Package die neuen Klassen generiert werden.
+ *
+ * Für die Ausgabe der Prozessornachrichten muss folgendes im maven compiler
+ * konfiguriert werden:
+ *
+ * <pre>
+&lt;build&gt;
+	&lt;plugins&gt;
+		&lt;plugin&gt;
+			&lt;groupId&gt;org.apache.maven.plugins&lt;/groupId&gt;
+			&lt;artifactId&gt;maven-compiler-plugin&lt;/artifactId&gt;
+			&lt;version&gt;3.8.0&lt;/version&gt;
+			&lt;configuration&gt;
+				&lt;release&gt;${java.version}&lt;/release&gt;
+				<b>&lt;showWarnings&gt;true&lt;/showWarnings&gt;</b>
+			&lt;/configuration&gt;
+		&lt;/plugin&gt;
+	&lt;/plugins&gt;
+&lt;/build&gt;
+ * </pre>
+ *
+ * @author Markus
+ *
+ */
+public @interface GenerateProperty2Java {
+    String[] resources();
+
+    Format format() default Format.WithUnaryOperatorParameter;
+}

src/main/java/de/kreth/property2java/processor/GenerateResourceBundleProperty2Java.java

@@ -0,0 +1,46 @@
+package de.kreth.property2java.processor;
+
+import static java.lang.annotation.ElementType.TYPE;
+
+import java.lang.annotation.Repeatable;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target(TYPE)
+@Retention(RetentionPolicy.SOURCE)
+@Repeatable(value = GenerateResourceBundleProperty2Javas.class)
+/**
+ * Für die konfigurierten Resourcen wird jeweils eine Java Klasse erzeugt. Es
+ * muss nur die Abhängigkeit eingebunden werden und die Annotation in einer
+ * Klasse verwendet werden, in deren Package die neuen Klassen generiert werden.
+ * Wenn mehrere Resourcen verarbeitet werden sollen, kann diese Annotation
+ * mehrfach parallel angegeben werden.
+ *
+ * Für die Ausgabe der Prozessornachrichten muss folgendes im maven compiler
+ * konfiguriert werden:
+ *
+ * <pre>
+&lt;build&gt;
+	&lt;plugins&gt;
+		&lt;plugin&gt;
+			&lt;groupId&gt;org.apache.maven.plugins&lt;/groupId&gt;
+			&lt;artifactId&gt;maven-compiler-plugin&lt;/artifactId&gt;
+			&lt;version&gt;3.8.0&lt;/version&gt;
+			&lt;configuration&gt;
+				&lt;release&gt;${java.version}&lt;/release&gt;
+				<b>&lt;showWarnings&gt;true&lt;/showWarnings&gt;</b>
+			&lt;/configuration&gt;
+		&lt;/plugin&gt;
+	&lt;/plugins&gt;
+&lt;/build&gt;
+ * </pre>
+ *
+ * @author Markus
+ *
+ */
+public @interface GenerateResourceBundleProperty2Java {
+    String resource();
+
+    Format format();
+}

src/main/java/de/kreth/property2java/processor/GenerateResourceBundleProperty2Javas.java

@@ -0,0 +1,21 @@
+package de.kreth.property2java.processor;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Diese Annotation sollte nicht verwendet werden. Sie sammelt nur
+ * {@link GenerateResourceBundleProperty2Java} wenn diese mehrfach verwendet
+ * wird.
+ *
+ * @author Markus
+ *
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface GenerateResourceBundleProperty2Javas {
+
+    GenerateResourceBundleProperty2Java[] value();
+}

src/main/java/de/kreth/property2java/processor/ProcessorConfiguration.java

@@ -0,0 +1,116 @@
+package de.kreth.property2java.processor;
+
+import java.io.IOException;
+import java.io.Reader;
+import java.io.Writer;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+import javax.annotation.processing.Filer;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.PackageElement;
+import javax.lang.model.element.TypeElement;
+import javax.tools.FileObject;
+import javax.tools.StandardLocation;
+
+import de.kreth.property2java.Configuration;
+import de.kreth.property2java.Generator;
+import de.kreth.property2java.GeneratorException;
+
+public class ProcessorConfiguration implements Configuration {
+
+    private final Filer filer;
+    private final Element element;
+    private final Map<String, Reader> input;
+    private final Format format;
+
+    ProcessorConfiguration(Builder builder) throws IOException {
+	this.filer = builder.filer;
+	this.element = builder.element;
+	this.format = Objects.requireNonNullElse(builder.format, Format.WithUnaryOperatorParameter);
+	this.input = new HashMap<>();
+	for (String resource : builder.resourcenames) {
+	    FileObject ressource = filer.getResource(StandardLocation.CLASS_PATH, "", resource);
+	    input.put(resource, ressource.openReader(false));
+	}
+    }
+
+    @Override
+    public String getPackage() {
+
+	String packageName = "";
+	if (element instanceof TypeElement) {
+	    TypeElement typeElement = (TypeElement) element;
+	    PackageElement packageElement = (PackageElement) typeElement.getEnclosingElement();
+	    packageName = packageElement.getQualifiedName().toString();
+	}
+	return packageName;
+    }
+
+    @Override
+    public Format getFormat() {
+	return format;
+    }
+
+    @Override
+    public Map<String, Reader> getInput() {
+	return input;
+    }
+
+    @Override
+    public Path getRootPath() {
+	throw new UnsupportedOperationException(
+		"For Annotation Processor this is not supported as outWriter is overwritten.");
+    }
+
+    @Override
+    public Writer outWriter(String fileName) throws IOException {
+	String packageName = getPackage();
+	if (packageName != null && !packageName.isBlank()) {
+	    fileName = packageName + "." + mapFilenameToClassName(fileName);
+	}
+	return filer.createSourceFile(fileName, element).openWriter();
+    }
+
+    static Builder builder(Filer filer, Element element) {
+	return new Builder(filer, element);
+    }
+
+    static class Builder {
+	private final Filer filer;
+	private final Element element;
+	private final List<String> resourcenames;
+	private Format format = Format.WithUnaryOperatorParameter;
+
+	private Builder(Filer filer, Element element) {
+	    this.filer = filer;
+	    this.element = element;
+	    this.resourcenames = new ArrayList<>();
+	}
+
+	public Builder withFormat(Format format) {
+	    this.format = format;
+	    return this;
+	}
+
+	public Builder addAll(String[] resourceNames) {
+	    this.resourcenames.addAll(Arrays.asList(resourceNames));
+	    return this;
+	}
+
+	public Builder addAll(List<String> resourceNames) {
+	    this.resourcenames.addAll(resourceNames);
+	    return this;
+	}
+
+	public void startGeneration() throws IOException, GeneratorException {
+	    Generator g = new Generator(new ProcessorConfiguration(this));
+	    g.start();
+	}
+    }
+}

src/main/java/de/kreth/property2java/processor/Property2JavaGenerator.java

@@ -0,0 +1,91 @@
+package de.kreth.property2java.processor;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Set;
+
+import javax.annotation.processing.AbstractProcessor;
+import javax.annotation.processing.RoundEnvironment;
+import javax.annotation.processing.SupportedAnnotationTypes;
+import javax.annotation.processing.SupportedSourceVersion;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+import javax.tools.Diagnostic.Kind;
+
+import de.kreth.property2java.GeneratorException;
+
+@SupportedAnnotationTypes({ "de.kreth.property2java.processor.GenerateProperty2Java",
+	"de.kreth.property2java.processor.GenerateResourceBundleProperty2Javas",
+	"de.kreth.property2java.processor.GenerateResourceBundleProperty2Java" })
+@SupportedSourceVersion(SourceVersion.RELEASE_8)
+public class Property2JavaGenerator extends AbstractProcessor {
+
+    @Override
+    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
+
+	if (!roundEnv.processingOver()) {
+	    processGenerateProperty2Java(roundEnv);
+	    processGenerateResourceBundleProperty2Javas(roundEnv);
+	} else {
+	    processingEnv.getMessager().printMessage(Kind.NOTE,
+		    "finished working on annotation " + annotations);
+	}
+	return true;
+    }
+
+    private void processGenerateProperty2Java(RoundEnvironment roundEnv) {
+	processingEnv.getMessager().printMessage(Kind.NOTE,
+		"Processing annotation " + GenerateProperty2Java.class);
+
+	Set<? extends Element> elementsAnnotatedWith = roundEnv
+		.getElementsAnnotatedWith(GenerateProperty2Java.class);
+
+	for (Element element : elementsAnnotatedWith) {
+	    GenerateProperty2Java generateAnnotation = element.getAnnotation(GenerateProperty2Java.class);
+	    String[] resources = generateAnnotation.resources();
+	    Format format = generateAnnotation.format();
+	    generateElementProperties(element, Arrays.asList(resources), format);
+	}
+    }
+
+    private void processGenerateResourceBundleProperty2Javas(RoundEnvironment roundEnv) {
+
+	processingEnv.getMessager().printMessage(Kind.NOTE,
+		"Processing annotation " + GenerateResourceBundleProperty2Javas.class);
+
+	Set<? extends Element> elementsAnnotatedWith = roundEnv
+		.getElementsAnnotatedWith(GenerateResourceBundleProperty2Javas.class);
+
+	for (Element element : elementsAnnotatedWith) {
+	    GenerateResourceBundleProperty2Java[] value = element
+		    .getAnnotation(GenerateResourceBundleProperty2Javas.class).value();
+	    for (GenerateResourceBundleProperty2Java generateResourceBundleProperty2Java : value) {
+		List<String> resources = Arrays.asList(generateResourceBundleProperty2Java.resource());
+		generateElementProperties(element, resources, generateResourceBundleProperty2Java.format());
+	    }
+	}
+    }
+
+    private void generateElementProperties(Element element, List<String> resources, Format format) {
+	processingEnv.getMessager().printMessage(Kind.NOTE,
+		"Generating Java for " + Arrays.asList(resources));
+	try {
+	    ProcessorConfiguration
+		    .builder(processingEnv.getFiler(), element)
+		    .addAll(resources)
+		    .withFormat(format)
+		    .startGeneration();
+	} catch (IOException | GeneratorException e) {
+	    StringWriter out = new StringWriter();
+	    e.printStackTrace(new PrintWriter(out));
+	    out.flush();
+	    processingEnv.getMessager().printMessage(Kind.ERROR, "Exception " + e + "\n" + out.toString(),
+		    element);
+	}
+    }
+
+}

src/main/resources/META-INF/services/javax.annotation.processing.Processor

@@ -0,0 +1 @@
+de.kreth.property2java.processor.Property2JavaGenerator

src/main/resources/template/enum_template.tpl

@@ -8,6 +8,8 @@ import javax.annotation.processing.Generated;
 
 /**
  * Property keys from ${fileName}
+ * {@link #getValue()} gives the key for the entry, with {@link #getString(UnaryOperator<String>)}
+ * the value is given directly.
  */
 @Generated(date = "${generation_date}", value = "${generator_name}")
 public enum ${classname} {

src/main/resources/template/enum_template_with_initializer.tpl

@@ -0,0 +1,62 @@
+<#if package??>package ${package};
+
+</#if>import java.util.Properties;
+import java.util.ResourceBundle;
+import java.util.function.UnaryOperator;
+
+import javax.annotation.processing.Generated;
+
+/**
+ * Property keys from ${fileName}
+ * {@link #getValue()} gives the key for the entry, with {@link #getText()} the value for the key is given directly.
+ * This enum needs to be initialized before any use by {@link #init(UnaryOperator)}.
+ */
+@Generated(date = "${generation_date}", value = "${generator_name}")
+public enum ${classname} {
+
+<#list entries as e>
+	/**
+	 * ${e.key} = "${e.value}"
+	 */
+	${e.constant} ("${e.key}")<#sep>,
+</#sep>
+</#list>;
+
+	private static UnaryOperator<String> function;
+	private final String value;
+
+	private ${classname} (String value) {
+		this.value = value;
+	}
+	
+	public static void init(UnaryOperator<String> resourceFunction) {
+		function = resourceFunction;
+	}
+	
+	/**
+	 * Represented Key in property File.
+	 * @return key
+	 */
+	public String getValue() {
+		return value;
+	}
+
+	/**
+	* Resolves the value for this key. 
+	* {@link #init(UnaryOperator<String>)} must be called before.
+	*/
+	public String getText() {
+		return function.apply(value);
+	}
+	
+	/**
+	 * Resolves the value for this key from the parameter function.
+	 * <p>
+	 * e.g. <code>${classname}.getString(resBundle::getString)</code>
+	 * @param resourceFunction {@link Properties#getProperty(String)} or {@link ResourceBundle#getString(String)}
+	 * @return
+	 */
+	public String getString(UnaryOperator<String> resourceFunction) {
+		return resourceFunction.apply(value);
+	}
+}

src/main/resources/template/enum_template_with_inner_properties.tpl

@@ -0,0 +1,48 @@
+<#if package??>package ${package};
+
+</#if>import java.util.Properties;
+import java.util.PropertyResourceBundle;
+import java.util.ResourceBundle;
+import java.util.function.UnaryOperator;
+
+import javax.annotation.processing.Generated;
+
+/**
+ * Property keys from ${fileName}
+ */
+@Generated(date = "${generation_date}", value = "${generator_name}")
+public enum ${classname} {
+
+<#list entries as e>
+	/**
+	 * ${e.key} = "${e.value}"
+	 */
+	${e.constant} ("${e.key}")<#sep>,
+</#sep>
+</#list>;
+
+	private final String value;
+
+	private ${classname} (String value) {
+		this.value = value;
+	}
+
+	/**
+	 * Represented Key in property File.
+	 * @return key
+	 */
+	public String getValue() {
+		return value;
+	}
+
+    private static ResourceBundle bundle = PropertyResourceBundle.getBundle("${bundle_base_name}");
+
+	/**
+	 * The Text for this Key from PropertyResourceBundle
+	 * @return human readable text
+	 */
+    public String getText() {
+		return bundle.getString(value);
+    }
+
+}

src/main/resources/template/enum_template_with_inner_propertyresourcebundle.tpl

@@ -0,0 +1,50 @@
+<#if package??>package ${package};
+
+</#if>import java.util.Properties;
+import java.util.PropertyResourceBundle;
+import java.util.ResourceBundle;
+import java.util.function.UnaryOperator;
+
+import javax.annotation.processing.Generated;
+
+/**
+ * Property keys from ${fileName}
+ * {@link #getValue()} gives the key for the entry, with {@link #getText()} the value for the key is given directly.
+ * Initializationis generated also.
+ */
+@Generated(date = "${generation_date}", value = "${generator_name}")
+public enum ${classname} {
+
+<#list entries as e>
+	/**
+	 * ${e.key} = "${e.value}"
+	 */
+	${e.constant} ("${e.key}")<#sep>,
+</#sep>
+</#list>;
+
+	private final String value;
+
+	private ${classname} (String value) {
+		this.value = value;
+	}
+
+	/**
+	 * Represented Key in property File.
+	 * @return key
+	 */
+	public String getValue() {
+		return value;
+	}
+
+    private static ResourceBundle bundle = PropertyResourceBundle.getBundle("${bundle_base_name}");
+
+	/**
+	 * The Text for this Key from PropertyResourceBundle
+	 * @return human readable text
+	 */
+    public String getText() {
+		return bundle.getString(value);
+    }
+
+}

src/test/java/de/kreth/property2java/GeneratorTests.java

@@ -29,149 +29,149 @@ import org.junit.jupiter.api.Test;
 
 class GeneratorTests {
 
-	private String path = "application.properties";
+    private String path = "application.properties";
-
+
-	private Configuration config;
+    private Configuration config;
-
+
-	private Generator generator;
+    private Generator generator;
-
+
-	@BeforeEach
+    @BeforeEach
-	void setUp() throws Exception {
+    void setUp() throws Exception {
-		Map<String, Reader> input = new HashMap<>();
+	Map<String, Reader> input = new HashMap<>();
-		input.put(path, testProperties());
+	input.put(path, testProperties());
-
+
-		config = mock(Configuration.class);
+	config = mock(Configuration.class);
-		when(config.getInput()).thenReturn(input);
+	when(config.getInput()).thenReturn(input);
-		when(config.mapFilenameToClassName(anyString())).thenCallRealMethod();
+	when(config.mapFilenameToClassName(anyString())).thenCallRealMethod();
-		when(config.outputCharset()).thenCallRealMethod();
+	when(config.outputCharset()).thenCallRealMethod();
-
+
-		generator = new Generator(config);
+	generator = new Generator(config);
+    }
+
+    @Test
+    void testClassDefinition() throws IOException, GeneratorException {
+
+	when(config.getPackage()).thenReturn("de.kreth.property2java");
+	when(config.mapFilenameToClassName(anyString())).thenCallRealMethod();
+
+	StringWriter out = new StringWriter();
+	when(config.outWriter(anyString())).thenReturn(out);
+
+	generator.start();
+
+	String sourceCode = out.toString().trim();
+	StringTokenizer sourceTokenizer = new StringTokenizer(sourceCode, "\n");
+	String linePackage = null;
+	String lineClass = null;
+	int countOpenBaces = 0;
+	int countCloseBaces = 0;
+	while (sourceTokenizer.hasMoreTokens()) {
+	    String line = sourceTokenizer.nextToken();
+	    if (line.trim().startsWith("package")) {
+		linePackage = line;
+	    } else if (line.trim().startsWith("public enum")) {
+		lineClass = line;
+	    }
+	    if (line.contains("{")) {
+		countOpenBaces++;
+	    }
+	    if (line.contains("}")) {
+		countCloseBaces++;
+	    }
 	}
 
-	@Test
+	assertEquals(countCloseBaces, countOpenBaces,
-	void testClassDefinition() throws IOException, GeneratorException {
+		"Count of Braces doesn't match. Open = " + countOpenBaces + ", Close = " + countCloseBaces);
-
+
-		when(config.getPackage()).thenReturn("de.kreth.property2java");
+	assertNotNull(linePackage);
-		when(config.mapFilenameToClassName(anyString())).thenCallRealMethod();
+	assertNotNull(lineClass);
-
+
-		StringWriter out = new StringWriter();
+	assertThat(linePackage,
-		when(config.outWriter(anyString())).thenReturn(out);
+		Matchers.stringContainsInOrder(Arrays.asList("package", "de.kreth.property2java", ";")));
-
+
-		generator.start();
+	assertThat(lineClass,
-
+		Matchers.stringContainsInOrder(Arrays.asList("public", "enum", "Application_Properties")));
-		String sourceCode = out.toString().trim();
+
-		StringTokenizer sourceTokenizer = new StringTokenizer(sourceCode, "\n");
+    }
-		String linePackage = null;
+
-		String lineClass = null;
+    @Test
-		int countOpenBaces = 0;
+    void testOneInputGeneratesOneOutput() throws IOException, GeneratorException {
-		int countCloseBaces = 0;
+
-		while (sourceTokenizer.hasMoreTokens()) {
+	Writer out = mock(Writer.class);
-			String line = sourceTokenizer.nextToken();
+	Writer nonOut = mock(Writer.class);
-			if (line.trim().startsWith("package")) {
+	when(config.outWriter(anyString())).thenReturn(out, nonOut);
-				linePackage = line;
+	generator.start();
-			}
+	verify(out).close();
-			else if (line.trim().startsWith("public enum")) {
+	verify(nonOut, never()).close();
-				lineClass = line;
+	verify(nonOut, never()).flush();
-			}
+    }
-			if (line.contains("{")) {
+
-				countOpenBaces++;
+    @Test
-			}
+    void testKeys() throws IOException, GeneratorException {
-			if (line.contains("}")) {
+
-				countCloseBaces++;
+	StringWriter out = new StringWriter();
-			}
+	when(config.outWriter(anyString())).thenReturn(out);
-		}
+	generator.start();
-
+
-		assertEquals(countCloseBaces, countOpenBaces,
+	List<String> lines = out.toString().lines().filter(line -> line.contains(" (\""))
-				"Count of Braces doesn't match. Open = " + countOpenBaces + ", Close = " + countCloseBaces);
+		.collect(Collectors.toList());
-
+
-		assertNotNull(linePackage);
+	assertEquals(21, lines.size());
-		assertNotNull(lineClass);
+	assertLineMatch(lines, "label", "label");
-
+	assertLineMatch(lines, "label_addarticle", "label.addarticle");
-		assertThat(linePackage,
+	assertLineMatch(lines, "label_user_register", "label.user.register");
-				Matchers.stringContainsInOrder(Arrays.asList("package", "de.kreth.property2java", ";")));
+	assertLineMatch(lines, "message_article_priceerror", "message.article.priceerror");
-
+	assertLineMatch(lines, "message_invoiceitem_startbeforeend",
-		assertThat(lineClass,
+		"message.invoiceitem.startbeforeend");
-				Matchers.stringContainsInOrder(Arrays.asList("public", "enum", "Application_Properties")));
+	assertLineMatch(lines, "message_invoiceitem_allfieldsmustbeset",
-
+		"message.invoiceitem.allfieldsmustbeset");
-	}
+    }
-
+
-	@Test
+    private void assertLineMatch(List<String> lines, String key, String expected) {
-	void testOneInputGeneratesOneOutput() throws IOException, GeneratorException {
+	Optional<String> found = lines.stream().filter(line -> keyMatches(line, key))
-
+		.findFirst();
-		Writer out = mock(Writer.class);
+
-		Writer nonOut = mock(Writer.class);
+	assertTrue(found.isPresent(), "No line found with key = " + key);
-		when(config.outWriter(anyString())).thenReturn(out, nonOut);
+	final String line = found.get().trim();
-		generator.start();
+	int indexEquals = line.indexOf('(');
-		verify(out).close();
+	String value = line.substring(indexEquals + 1).trim().substring(1);
-		verify(nonOut, never()).close();
+	value = value.substring(0, value.length() - 3);
-		verify(nonOut, never()).flush();
+	assertEquals(expected, value, "Line \"" + line + "\" don't match expected Value \"" + expected + "\"");
-	}
+
-
+    }
-	@Test
+
-	void testKeys() throws IOException, GeneratorException {
+    private boolean keyMatches(String line, String key) {
-
+	line = line.toLowerCase();
-		StringWriter out = new StringWriter();
+	key = key.toLowerCase();
-		when(config.outWriter(anyString())).thenReturn(out);
+	return line.contains("\t" + key + " ");
-		generator.start();
+    }
-
+
-		List<String> lines = out.toString().lines().filter(line -> line.contains(" (\""))
+    private StringReader testProperties() {
-				.collect(Collectors.toList());
+	return new StringReader("\r\n" +
-
+		"label = \r\n" +
-		assertEquals(21, lines.size());
+		"\r\n" +
-		assertLineMatch(lines, "label", "label");
+		"label.addarticle    = Add Article\r\n" +
-		assertLineMatch(lines, "label_addarticle", "label.addarticle");
+		"label.cancel        = Cancel\r\n" +
-		assertLineMatch(lines, "label_user_register", "label.user.register");
+		"label.close         = Close\r\n" +
-		assertLineMatch(lines, "message_article_priceerror", "message.article.priceerror");
+		"label.delete        = Delete\r\n" +
-		assertLineMatch(lines, "message_invoiceitem_startbeforeend",
+		"label.discart       = Discart\r\n" +
-				"message.invoiceitem.startbeforeend");
+		"label.loggedin      = Logged in:\r\n" +
-		assertLineMatch(lines, "message_invoiceitem_allfieldsmustbeset",
+		"label.logout        = Logout\r\n" +
-				"message.invoiceitem.allfieldsmustbeset");
+		"label.ok            = OK\r\n" +
-	}
+		"label.store         = Store\r\n" +
-
+		"label.preview       = Preview\r\n" +
-	private void assertLineMatch(List<String> lines, String key, String expected) {
+		"label.open          = Open\r\n" +
-		Optional<String> found = lines.stream().filter(line -> keyMatches(line, key))
+		"label.user.register = Register\r\n" +
-				.findFirst();
+		"\r\n" +
-		assertTrue(found.isPresent(), "No line found with key = " + key);
+		"message.article.priceerror             = Please set the price.\r\n" +
-		final String line = found.get().trim();
+		"message.delete.text                    = Delete {0}?\r\n" +
-		int indexEquals = line.indexOf('(');
+		"message.delete.title                   = Really delete?\r\n" +
-		String value = line.substring(indexEquals + 1).trim().substring(1);
+		"message.invoiceitem.allfieldsmustbeset = Start, end and article must not be \\r\\n" +
-		value = value.substring(0, value.length() - 3);
+		"                                         empty!\r\n" +
-		assertEquals(expected, value, "Line \"" + line + "\" don't match expected Value \"" + expected + "\"");
+		"message.invoiceitem.startbeforeend     = End must be later than start.\r\n" +
-
+		"message.user.create.success            = Thanks {0} created!\r\n" +
-	}
+		"message.user.loginfailure              = Login Error! Wrong user or password?\r\n" +
-
+		"message.user.passwordmissmatch         = Passwords don't match.\r\n" +
-	private boolean keyMatches(String line, String key) {
+		"");
-		line = line.toLowerCase();
+    }
-		key = key.toLowerCase();
-		return line.contains("\t" + key + " ");
-	}
-
-	private StringReader testProperties() {
-		return new StringReader("\r\n" +
-				"label = \r\n" +
-				"\r\n" +
-				"label.addarticle    = Add Article\r\n" +
-				"label.cancel        = Cancel\r\n" +
-				"label.close         = Close\r\n" +
-				"label.delete        = Delete\r\n" +
-				"label.discart       = Discart\r\n" +
-				"label.loggedin      = Logged in:\r\n" +
-				"label.logout        = Logout\r\n" +
-				"label.ok            = OK\r\n" +
-				"label.store         = Store\r\n" +
-				"label.preview       = Preview\r\n" +
-				"label.open          = Open\r\n" +
-				"label.user.register = Register\r\n" +
-				"\r\n" +
-				"message.article.priceerror             = Please set the price.\r\n" +
-				"message.delete.text                    = Delete {0}?\r\n" +
-				"message.delete.title                   = Really delete?\r\n" +
-				"message.invoiceitem.allfieldsmustbeset = Start, end and article must not be \\r\\n" +
-				"                                         empty!\r\n" +
-				"message.invoiceitem.startbeforeend     = End must be later than start.\r\n" +
-				"message.user.create.success            = Thanks {0} created!\r\n" +
-				"message.user.loginfailure              = Login Error! Wrong user or password?\r\n" +
-				"message.user.passwordmissmatch         = Passwords don't match.\r\n" +
-				"");
-	}
 }

src/test/java/de/kreth/property2java/processor/Property2JavaGeneratorTest.java

@@ -0,0 +1,46 @@
+package de.kreth.property2java.processor;
+
+import static org.mockito.Mockito.when;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import javax.annotation.processing.Messager;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.annotation.processing.RoundEnvironment;
+import javax.lang.model.element.TypeElement;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentMatchers;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+public class Property2JavaGeneratorTest {
+
+    private Property2JavaGenerator processor;
+    @Mock
+    private ProcessingEnvironment processingEnv;
+    @Mock
+    private RoundEnvironment roundEnv;
+    private Set<TypeElement> annotations;
+    @Mock
+    private Messager messanger;
+
+    @BeforeEach
+    void initProcesor() {
+	MockitoAnnotations.initMocks(this);
+	annotations = new HashSet<>();
+
+	processor = new Property2JavaGenerator();
+	processor.init(processingEnv);
+	when(processingEnv.getMessager()).thenReturn(messanger);
+    }
+
+    @Test
+    void testGeneratorInitializedCorrectly() {
+	when(roundEnv.getElementsAnnotatedWith(ArgumentMatchers.any(Class.class)))
+		.thenReturn(annotations);
+	processor.process(annotations, roundEnv);
+    }
+}