[#95] Added possibility to add resource files via fluent api (acts as alias for resources, shadows existing files)

Author: tobiasstamann

cute/src/main/java/io/toolisticon/cute/CompileTest.java

@@ -246,7 +246,7 @@ public static CompilationResult compile(CuteApi.CompilerTestBB compileTestConfig
 
 
         // Configure java compilation task
-        CompileTestFileManager javaFileManager = new CompileTestFileManager(stdJavaFileManager);
+        CompileTestFileManager javaFileManager = new CompileTestFileManager(stdJavaFileManager, compileTestConfiguration.resourceFiles());
 
         JavaCompiler.CompilationTask compilationTask = compiler.getTask(
                 null,

cute/src/main/java/io/toolisticon/cute/CompileTestFileManager.java

@@ -1,11 +1,5 @@
 package io.toolisticon.cute;
 
-import javax.tools.FileObject;
-import javax.tools.ForwardingJavaFileManager;
-import javax.tools.JavaFileManager;
-import javax.tools.JavaFileObject;
-import javax.tools.SimpleJavaFileObject;
-import javax.tools.StandardJavaFileManager;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
@@ -22,12 +16,26 @@
 import java.util.List;
 import java.util.Map;
 
+import javax.tools.FileObject;
+import javax.tools.ForwardingJavaFileManager;
+import javax.tools.JavaFileManager;
+import javax.tools.JavaFileObject;
+import javax.tools.SimpleJavaFileObject;
+import javax.tools.StandardJavaFileManager;
+import javax.tools.StandardLocation;
+
+import io.toolisticon.cute.CuteApi.ResourceFileBB;
+
 /**
  * Forwarding file manager to be able to test for generated sources and resources
  */
 class CompileTestFileManager extends ForwardingJavaFileManager<StandardJavaFileManager> {
 
 
+	/**
+	 * The file object cache that is used to store generated classes and resources.
+	 * @param <T> The type of cached file objects, must be either FileObject or JavaFileObject
+	 */
     public static class FileObjectCache<T extends FileObject> {
 
         final Map<URI, T> fileObjectCache = new HashMap<>();
@@ -54,15 +62,46 @@ public boolean isEmpty() {
         }
 
 
+    }
+   
+    /**
+     * This internal class is used to provide resources from class path via a custom package.
+     * Internally this works like an alias.
+     * It hides any pre-existing resources with uri.
+     */
+    public static class ProvidedResourceFilesCache{
+    	
+    	
+    	final Map<URI, FileObject> resourcesMap = new HashMap<>();
+    	
+    	ProvidedResourceFilesCache (List<ResourceFileBB> resourceFiles) {
+    		
+    		if (resourceFiles != null) {
+    			resourceFiles.stream().filter(e -> e.getRelativeName() != null).forEach( e -> resourcesMap.put(uriForFileObject(StandardLocation.CLASS_PATH, e.targetPackageName(), e.getRelativeName()), FileObjectUtils.forPassedInResource(e)));
+    		}
+    		
+    	}
+    	
+    	FileObject get(String packageName, String relativeName) {
+    		URI uri = uriForFileObject(StandardLocation.CLASS_PATH, packageName,relativeName);
+    		return this.resourcesMap.get(uri);
+    	}
+    	
+    	
+    	
     }
 
 
     private final FileObjectCache<InMemoryOutputJavaFileObject> generatedJavaFileObjectCache = new FileObjectCache<>();
     private final FileObjectCache<InMemoryOutputFileObject> generatedFileObjectCache = new FileObjectCache<>();
+    private final ProvidedResourceFilesCache providedResourceFilesCache;
 
 
-    public CompileTestFileManager(StandardJavaFileManager standardJavaFileManager) {
+    public CompileTestFileManager(StandardJavaFileManager standardJavaFileManager, List<CuteApi.ResourceFileBB> resourceFiles) {
         super(standardJavaFileManager);
+        
+        // configure cache for resource files
+        providedResourceFilesCache = new ProvidedResourceFilesCache(resourceFiles);
 
     }
 
@@ -124,7 +163,18 @@ public FileObject getFileForInput(Location location, String packageName, String
             } else {
                 throw new IllegalArgumentException(Constants.Messages.IAE_CANNOT_FIND_FILEOBJECT.produceMessage(uri.toString()));
             }
+        } else if (StandardLocation.CLASS_PATH.equals(location)) {
+        	
+        	// Try to get it from provided resource file cache
+        	FileObject providedResource = this.providedResourceFilesCache.get(packageName, relativeName);
+        	
+        	if (providedResource != null) {
+        		return providedResource;
+        	}
+        	
         }
+        
+        // use standard manager if file haven't been found so far
         return super.getFileForInput(location, packageName, relativeName);
     }
 
@@ -138,8 +188,17 @@ public FileObject getFileForInput(Location location, String packageName, String
      * @return true if JavaFileObject exists, otherwise false
      */
     public boolean existsExpectedJavaFileObject(JavaFileManager.Location location, String className, JavaFileObject.Kind kind) {
-
-        return this.generatedJavaFileObjectCache.contains(uriForJavaFileObject(location, className, kind));
+    	
+    	if (location.isOutputLocation()) {
+    		return this.generatedJavaFileObjectCache.contains(uriForJavaFileObject(location, className, kind));
+    	} 
+    	
+    	try {
+			return super.getJavaFileForInput(location, className, kind) != null;
+		} catch (IOException e) {
+			throw new IllegalStateException("Something went wrong while accessing the default FileManager", e);
+		}
+        
 
     }
 
@@ -152,10 +211,24 @@ public boolean existsExpectedJavaFileObject(JavaFileManager.Location location, S
      * @return true if FileObject exists, otherwise false
      */
     public boolean existsExpectedFileObject(JavaFileManager.Location location, String packageName, String relativeName) {
-
-        return this.generatedFileObjectCache.contains(uriForFileObject(location, packageName, relativeName));
-
-
+    	
+    	// return true if file could be found in resource cache, otherwise check regular file manager
+    	if (StandardLocation.CLASS_PATH.equals(location) && this.providedResourceFilesCache.get(packageName, relativeName) != null) {
+    		return true;
+    	} 
+    	
+    	// otherwise check the generated file object cache
+    	if (location.isOutputLocation()) {
+    		return this.generatedFileObjectCache.contains(uriForFileObject(location, packageName, relativeName));
+    	}
+    	
+    	// use standard file manager for input files
+    	try {
+			return super.getFileForInput(location, packageName, relativeName) != null;
+		} catch (IOException e) {
+			throw new IllegalStateException("Something went wrong while accessing the default FileManager", e);
+		}
+    	
     }
 
 
@@ -166,7 +239,7 @@ interface OutputStreamCallback {
     }
 
 
-    private static URI uriForFileObject(Location location, String packageName, String relativeName) {
+    static URI uriForFileObject(Location location, String packageName, String relativeName) {
         StringBuilder uri = new StringBuilder("mem://").append(location.getName()).append('/');
         if (!packageName.isEmpty()) {
             uri.append(packageName.replace('.', '/')).append('/');
@@ -304,4 +377,5 @@ public void write(byte[] b) throws IOException {
             outputStreamCallback.setContent(this.toByteArray());
         }
     }
+    
 }

cute/src/main/java/io/toolisticon/cute/CuteApi.java

@@ -16,7 +16,9 @@
 import io.toolisticon.fluapigen.api.FluentApiRoot;
 import io.toolisticon.fluapigen.api.MappingAction;
 import io.toolisticon.fluapigen.api.TargetBackingBean;
+import io.toolisticon.fluapigen.validation.api.FluentApiValidator;
 import io.toolisticon.fluapigen.validation.api.NotNull;
+import io.toolisticon.fluapigen.validation.api.Validator;
 
 import javax.annotation.processing.Processor;
 import javax.lang.model.element.Element;
@@ -57,12 +59,13 @@ public interface CompilerTestBB {
 
         UnitTestType getPassInType();
 
-
         List<Class<? extends Processor>> processors();
 
         List<String> compilerOptions();
 
         Set<JavaFileObject> sourceFiles();
+        
+        List<ResourceFileBB> resourceFiles();
 
         Set<String> modules();
 
@@ -122,6 +125,34 @@ default List<String> getNormalizedCompilerOptions() {
 
     }
 
+    @FluentApiBackingBean
+    public interface ResourceFileBB {
+    	
+    	@FluentApiBackingBeanField("targetPackageName")
+    	String targetPackageName();
+    	
+    	@FluentApiBackingBeanField("resource")
+    	String resource();
+    	
+    	
+    	/**
+    	 * Gets the relative file name of the resource
+    	 * @return
+    	 */
+    	default String getRelativeName() {
+    		
+			try {
+				return new File(ResourceFileBB.class.getResource(resource()).toURI()).getName();
+			} catch (URISyntaxException e) {
+				return null;
+			}
+			
+    	}
+    }
+    
+    
+    
+    
     @FluentApiBackingBean
     public interface ExceptionCheckBB {
 
@@ -442,7 +473,21 @@ default BlackBoxTestFinalGivenInterface andSourceFilesFromFolders(String ... fol
             return andSourceFiles(files.toArray(new String[0]));
         }
 
-
+        /**
+         * Adds a resource file to a specific package in the class path. 
+         * By doing that the passed resource file will be available with it's original name in the passed target package.
+         * This shadows existing resource files in CLASS_PATH location!
+         * !!! WARNING - This will work in the tests but it's not guaranteed that your annotation processor will work out of the box with all the different kind of build tools or compilers out there !!!
+         * @param targetPackageName The target package name to use
+         * @param resource The resource to use
+         * @return the next fluent interface
+         */
+        @FluentApiInlineBackingBeanMapping("resourceFiles")
+        BlackBoxTestFinalGivenInterface andResourceFile(
+        		@FluentApiBackingBeanMapping(action = MappingAction.SET, value =  "targetPackageName" , target = TargetBackingBean.INLINE) String targetPackageName, 
+        		@FluentApiBackingBeanMapping(action = MappingAction.SET, value =  "resource" , target = TargetBackingBean.INLINE) @ResourceIsFileAndExists String resource
+        		);
+        
     }
 
     @FluentApiInterface(CompilerTestBB.class)
@@ -620,6 +665,23 @@ default UnitTestGivenInterface useSourceFilesFromFolders(String ... folders) {
             return useSourceFiles(files.toArray(new String[0]));
         }
 
+        
+
+        /**
+         * Adds a resource file to a specific package in the class path. 
+         * By doing that the passed resource file will be available with it's original name in the passed target package.
+         * This shadows existing resource files in CLASS_PATH location!
+         * !!! WARNING - This will work in the tests but it's not guaranteed that your annotation processor will work out of the box with all the different kind of build tools or compilers out there !!!
+         * @param targetPackageName The target package name to use
+         * @param resource The resource to use
+         * @return the next fluent interface
+         */
+        @FluentApiInlineBackingBeanMapping("resourceFiles")
+        UnitTestGivenInterface useResourceFile(
+        		@FluentApiBackingBeanMapping(action = MappingAction.SET, value =  "targetPackageName" , target = TargetBackingBean.INLINE) String targetPackageName, 
+        		@FluentApiBackingBeanMapping(action = MappingAction.SET, value =  "resource" , target = TargetBackingBean.INLINE) @ResourceIsFileAndExists String resource
+        		);
+        
 
         /**
          * Traverse to when section to pass in an Element or a processor instant and to define the unit test scenario.
@@ -1325,6 +1387,40 @@ public <T extends FileObject> GeneratedFileObjectMatcher createMatcher(T expecte
          */
         protected abstract <T extends FileObject> GeneratedFileObjectMatcher createMatcher(T expectedFileObject);
     }
+    
+    // --------------------------------------------------------------------
+    // Validators
+    // --------------------------------------------------------------------
+
+    
+    @FluentApiValidator(value = CuteApi.ResourceIsFileAndExists.ValidatorImpl.class)
+    public @interface ResourceIsFileAndExists {
+
+        class ValidatorImpl implements Validator<String> {
+
+            
+            @Override
+            public boolean validate(String resourceFile) {
+            	URL resourceURL = CuteApi.class.getResource(resourceFile);
+            	if (resourceURL == null) {
+            		throw new IllegalArgumentException("Passed resource '" + resourceFile + " doesn't exist");
+            	}
+            	
+            	
+            	try {
+					if (new File(resourceURL.toURI()).isDirectory()) {
+						throw new IllegalArgumentException("Passed resource '" + resourceFile + " is a directory, but must be a file.");
+					}
+				} catch (URISyntaxException e) {
+					return false;
+				}
+            	
+                return true;
+            }
+
+        }
+
+    }
 
     // --------------------------------------------------------------------
     // Commands