Custom compilation class path (#2).

* ClassFactory now takes two additional arguments: additional compiler options and parent class loader that is used to load classes that lambda depends on.
* InMemoryClassLoader can now use custom parent class loader.
* InMemoryFileManager now implements StandardJavaFileManager instead of just JavaFileManager. It turns out that Eclipse compiler treats implementations of StandardJavaFileManager differently and it's the only way to make the custom class path work.
* ClassPathExtractor static helper class contains two ways of automatically extracting the classpath of the current JVM, the simpler one is used by default.
* LamdaFactory passes custom class path as an additional compiler option to the ClassFactory.
* LambdaFactoryConfiguration has two new fields: parentClassLoader and compilationClassPath.
* Responsibility of selecting the default java compiler has been moved from LambdaFactory to LambdaFactoryConfiguration.

Author: greenjoe

CHANGELOG.md

@@ -1,3 +1,6 @@
+# 1.3
+* Custom compilation class path. User can now specify a class path and a class loader used when creating lambda. By default, current JVM class path is used. Thanks to that users can now use custom classes and interfaces in lambda codes (previously only standard library classes were available).
+
 # 1.2
 * Dynamic type references. User can now pass a String type name to the constructor of the DynamicTypeReference class instead of statically creating a TypeReference instance with an appropriate generic type.
 

README.md

@@ -31,9 +31,9 @@ assertEquals("ABC101DEF", decorate.apply(101));
 ```
 (You can visit [tests directory](https://github.com/greenjoe/lambdaFromString/tree/master/src/test/java/pl/joegreen/lambdaFromString) to see additional examples.)
 
-By default only java.util.function.* is imported by the class, as it is needed by the library itself. If you would like to import additional classes, you can specify imports in the configuration, as shown below. Please note that only Java standard library classes are available on the compilation classpath in the current version of library, so you cannot import your own classes. 
+By default only java.util.function.* is imported by the class, as it is needed by the library itself. If you would like to import additional classes, you can specify imports in the configuration, as shown below. Please note that classes used in a lambda need to be available on the classpath used by the library. It can be configured, by default the java.class.path system property is used (it should work fine in most cases).
 
-Imports can be passed as `Class<?>` instances or strings (string form is the only way to use * wildcard). Static imports are also supported and can be passed as strings. 
+Imports can be passed as `Class<?>` instances or strings (string form is the only way to use wildcards). Static imports are also supported and can be passed as strings.
 
 ```java
 LambdaFactory factory = LambdaFactory.get(
@@ -62,7 +62,7 @@ You can get it from Maven Central:
 <dependency>
 	<groupId>pl.joegreen</groupId>
 	<artifactId>lambda-from-string</artifactId>
-	<version>1.2</version>
+	<version>1.3</version>
 </dependency>
 ```
 It has only one external Maven dependency: [Eclipse JDT Core Batch Compiler](http://mvnrepository.com/artifact/org.eclipse.jdt.core.compiler/ecj). That dependency was added because Java compiler is a part of JDK (located in tools.jar) and it's not available in pure JRE. When client applications were running on JRE then no Java compiler was available at runtime and the LambdaFromString library failed to compile lambda code. Eclipse ECJ makes it possible to use LambdaFromString even in cases when only JRE is available at runtime. 
@@ -77,7 +77,7 @@ If you are sure that your application will be running on JDK and you want to use
 	</exclusion>
 </exclusions>
 ```
-In that case you can also use lambdaFromString without Maven by just downloading a [single jar](http://central.maven.org/maven2/pl/joegreen/lambda-from-string/1.2/lambda-from-string-1.2.jar). 
+In that case you can also use lambdaFromString without Maven by just downloading a [single jar](http://central.maven.org/maven2/pl/joegreen/lambda-from-string/1.2/lambda-from-string-1.2.jar).
 
 ## How it works? 
 

src/main/java/pl/joegreen/lambdaFromString/ClassPathExtractor.java

@@ -0,0 +1,21 @@
+package pl.joegreen.lambdaFromString;
+
+import java.io.File;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.Arrays;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+public class ClassPathExtractor {
+    public static String getJavaPropertyClassPath(){
+        return Optional.ofNullable(System.getProperty("java.class.path")).orElse("");
+    }
+
+    public static String getCurrentContextClassLoaderClassPath(){
+        URLClassLoader contextClassLoader = (URLClassLoader) Thread.currentThread().getContextClassLoader();
+        return Arrays.stream(contextClassLoader.getURLs())
+                .map(URL::getFile)
+                .collect(Collectors.joining(File.pathSeparator));
+    }
+}

src/main/java/pl/joegreen/lambdaFromString/LambdaCreationException.java

@@ -12,8 +12,9 @@ public LambdaCreationException(ClassCompilationException classCompilationExcepti
         super(classCompilationException);
         compilationDetails = classCompilationException.getCompilationDetails();
     }
-    public LambdaCreationException(Exception ex) {
-        super(ex);
+
+    public LambdaCreationException(Throwable t) {
+        super(t);
         compilationDetails = Optional.empty();
     }
 

src/main/java/pl/joegreen/lambdaFromString/LambdaFactory.java

@@ -5,13 +5,12 @@
 
 import javax.tools.JavaCompiler;
 import java.lang.reflect.Method;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Optional;
 
 public class LambdaFactory {
 
-    protected static Optional<JavaCompiler> DEFAULT_COMPILER = JavaCompilerProvider.findDefaultJavaCompiler();
-
     /**
      * Returns a LambdaFactory instance with default configuration.
      * @throws JavaCompilerNotFoundException if the library cannot find any java compiler
@@ -26,34 +25,35 @@ public static LambdaFactory get() {
      * in the configuration
      */
     public static LambdaFactory get(LambdaFactoryConfiguration configuration) {
-        JavaCompiler compiler = getConfiguredOrDefaultCompiler(configuration);
+        JavaCompiler compiler = Optional.ofNullable(configuration.getJavaCompiler()).orElseThrow(JavaCompilerNotFoundException::new);
         return new LambdaFactory(
                 configuration.getDefaultHelperClassSourceProvider(),
                 configuration.getClassFactory(),
                 compiler,
                 configuration.getImports(),
-                configuration.getStaticImports());
-    }
-
-    private static JavaCompiler getConfiguredOrDefaultCompiler(LambdaFactoryConfiguration configuration) {
-        return configuration.getJavaCompiler()
-                .orElse(DEFAULT_COMPILER
-                        .orElseThrow(JavaCompilerNotFoundException::new));
+                configuration.getStaticImports(),
+                configuration.getCompilationClassPath(),
+                configuration.getParentClassLoader());
     }
 
     private final HelperClassSourceProvider helperProvider;
     private final ClassFactory classFactory;
     private final JavaCompiler javaCompiler;
     private final List<String> imports;
     private final List<String> staticImports;
+    private final String compilationClassPath;
+    private final ClassLoader parentClassLoader;
 
     private LambdaFactory(HelperClassSourceProvider helperProvider, ClassFactory classFactory,
-                          JavaCompiler javaCompiler, List<String> imports, List<String> staticImports) {
+                          JavaCompiler javaCompiler, List<String> imports, List<String> staticImports,
+                          String compilationClassPath, ClassLoader parentClassLoader) {
         this.helperProvider = helperProvider;
         this.classFactory = classFactory;
         this.javaCompiler = javaCompiler;
         this.imports = imports;
         this.staticImports = staticImports;
+        this.compilationClassPath = compilationClassPath;
+        this.parentClassLoader = parentClassLoader;
     }
 
     /**
@@ -69,20 +69,25 @@ private LambdaFactory(HelperClassSourceProvider helperProvider, ClassFactory cla
     public <T> T createLambda(String code, TypeReference<T> typeReference) throws LambdaCreationException {
         String helperClassSource = helperProvider.getHelperClassSource(typeReference.toString(), code, imports, staticImports);
         try {
-            Class<?> helperClass = classFactory.createClass(helperProvider.getHelperClassName(), helperClassSource, javaCompiler);
+            Class<?> helperClass = classFactory.createClass(helperProvider.getHelperClassName(), helperClassSource, javaCompiler, createOptionsForCompilationClasspath(compilationClassPath), parentClassLoader);
             Method lambdaReturningMethod = helperClass.getMethod(helperProvider.getLambdaReturningMethodName());
             @SuppressWarnings("unchecked")
             // the whole point of the class template and runtime compilation is to make this cast work well :-)
                     T lambda = (T) lambdaReturningMethod.invoke(null);
             return lambda;
-        } catch (ReflectiveOperationException | RuntimeException e) {
+        } catch (ReflectiveOperationException | RuntimeException | NoClassDefFoundError e) {
+            // NoClassDefFoundError can be thrown if provided parent class loader cannot load classes used by the lambda
             throw new LambdaCreationException(e);
         } catch (ClassCompilationException classCompilationException) {
-            // knows type of the cause so it get CompilationDetails
+            // that catch differs from the catch above as the exact exception type is known and additional details can be extracted
             throw new LambdaCreationException(classCompilationException);
         }
     }
 
+    private List<String> createOptionsForCompilationClasspath(String compilationClassPath) {
+        return Arrays.asList("-classpath", compilationClassPath);
+    }
+
     /**
      * Convenience wrapper for {@link #createLambda(String, TypeReference)}
      * which throws unchecked exception instead of checked one.

src/main/java/pl/joegreen/lambdaFromString/LambdaFactoryConfiguration.java

@@ -10,13 +10,15 @@
 import static java.util.stream.Stream.concat;
 
 public class LambdaFactoryConfiguration {
-
+    protected static Optional<JavaCompiler> DEFAULT_COMPILER = JavaCompilerProvider.findDefaultJavaCompiler();
 
     private HelperClassSourceProvider helperClassSourceProvider;
     private ClassFactory classFactory;
     private List<String> staticImports;
     private List<String> imports;
-    private Optional<JavaCompiler> javaCompiler;
+    private String compilationClassPath;
+    private ClassLoader parentClassLoader;
+    private JavaCompiler javaCompiler;
 
     public static LambdaFactoryConfiguration get() {
         return new LambdaFactoryConfiguration();
@@ -27,18 +29,23 @@ private LambdaFactoryConfiguration() {
         classFactory = new DefaultClassFactory();
         staticImports = Collections.unmodifiableList(new ArrayList<>());
         imports = Collections.unmodifiableList(new ArrayList<>());
-        javaCompiler = Optional.empty();
+        compilationClassPath = ClassPathExtractor.getJavaPropertyClassPath();
+        parentClassLoader = this.getClass().getClassLoader();
+        javaCompiler = DEFAULT_COMPILER.orElse(null);
     }
 
-
     private LambdaFactoryConfiguration copy() {
         return new LambdaFactoryConfiguration()
-                .setClassFactory(classFactory)
                 .setDefaultHelperClassSourceProvider(helperClassSourceProvider)
+                .setClassFactory(classFactory)
+                .setStaticImports(staticImports)
                 .setImports(imports)
-                .setStaticImports(staticImports);
+                .setCompilationClassPath(compilationClassPath)
+                .setParentClassLoader(parentClassLoader)
+                .setJavaCompiler(javaCompiler);
     }
 
+
     public HelperClassSourceProvider getDefaultHelperClassSourceProvider() {
         return helperClassSourceProvider;
     }
@@ -55,61 +62,93 @@ public List<String> getImports() {
         return imports;
     }
 
-    public Optional<JavaCompiler> getJavaCompiler() {
+    public String getCompilationClassPath() {
+        return compilationClassPath;
+    }
+
+    public ClassLoader getParentClassLoader() {
+        return parentClassLoader;
+    }
+
+    public JavaCompiler getJavaCompiler() {
         return javaCompiler;
     }
+
     /**
-     *  Changes classFactory which is responsible for compiling the helper class and loading it into the memory. <br>
-     *  Should be used only in rare cases when you cannot get the exact functionality
-     *  you want from the library and want to change some of its inner behavior. The interface accepted by this method
-     *  can change between library versions and cause compilation errors if you decide to use it.
+     * Changes helperClassSourceProvider which provides a code template for the class to be compiled. <br>
+     * Should be used only in rare cases when you cannot get the exact functionality
+     * you want from the library and want to change some of its inner behavior. The interface accepted by this method
+     * can change between library versions and cause compilation errors if you decide to use it.
      */
-    public LambdaFactoryConfiguration withClassFactory(ClassFactory classFactory){
-        return copy().setClassFactory(classFactory);
+    public LambdaFactoryConfiguration withHelperClassSourceProvider(HelperClassSourceProvider helperSourceProvider) {
+        return copy().setDefaultHelperClassSourceProvider(helperSourceProvider);
     }
 
     /**
-     *  Changes helperClassSourceProvider which provides a code template for the class to be compiled. <br>
-     *  Should be used only in rare cases when you cannot get the exact functionality
-     *  you want from the library and want to change some of its inner behavior. The interface accepted by this method
-     *  can change between library versions and cause compilation errors if you decide to use it.
+     * Changes classFactory which is responsible for compiling the helper class and loading it into the memory. <br>
+     * Should be used only in rare cases when you cannot get the exact functionality
+     * you want from the library and want to change some of its inner behavior. The interface accepted by this method
+     * can change between library versions and cause compilation errors if you decide to use it.
      */
-    public LambdaFactoryConfiguration withHelperClassSourceProvider(HelperClassSourceProvider helperSourceProvider){
-        return copy().setDefaultHelperClassSourceProvider(helperSourceProvider);
+    public LambdaFactoryConfiguration withClassFactory(ClassFactory classFactory) {
+        return copy().setClassFactory(classFactory);
     }
 
     /**
-     * Overrides default JavaCompiler instance. <br>It can be used to force using JDK compiler when the Eclipse Compiler
-     * is also available. Completely different compiler instance can also be passed but in that case it is possible
-     * that some changes will have to be made in the class factory ({@link #withClassFactory(ClassFactory)}).
+     * Adds static imports that will be visible in the lambda code. Each string should consist of what is
+     * normally written between "import static " and ";" in the import statement. Imports can contain * wildcards.
      */
-    public LambdaFactoryConfiguration withJavaCompiler(JavaCompiler javaCompiler){
-        return copy().setJavaCompiler(javaCompiler);
+    public LambdaFactoryConfiguration withStaticImports(String... newStaticImports) {
+        return copy().setStaticImports(listWithNewElements(staticImports, newStaticImports));
     }
 
     /**
      * Adds imports that will be visible in the lambda code. Each string should consist of what is
      * normally written between "import " and ";" in the import statement. Imports can contain * wildcards.
      */
-    public LambdaFactoryConfiguration withImports(String... newImports){
+    public LambdaFactoryConfiguration withImports(String... newImports) {
         return copy().setImports(listWithNewElements(imports, newImports));
     }
 
     /**
      * Adds imports that will be visible in the lambda code. To add an import with * wildcard
      * please use{@link #withImports(String...)}.
      */
-    public LambdaFactoryConfiguration withImports(Class<?>... newImports){
+    public LambdaFactoryConfiguration withImports(Class<?>... newImports) {
         String[] stringImports = Arrays.stream(newImports).map(Class::getCanonicalName).toArray(String[]::new);
         return withImports(stringImports);
     }
 
+    /** Overrides default compilation classpath (default is taken from the java.class.path system property).
+     * Changing the classpath may sometimes result in a need to provide a custom parent class loader {@link #withParentClassLoader(ClassLoader)
+     * so that it can load classes provided in the given class path.
+     */
+    public LambdaFactoryConfiguration withCompilationClassPath(String compilationClassPath) {
+        return copy().setCompilationClassPath(compilationClassPath);
+    }
+
     /**
-     * Adds static imports that will be visible in the lambda code. Each string should consist of what is
-     * normally written between "import static " and ";" in the import statement. Imports can contain * wildcards.
+     * Overrides default parent class loader (by default a class loader loading this class is used).
+     * Provided class loader has to be able to load all the classes used by compiled lambda expressions
+     * (either itself or by calling its parent class loader).
      */
-    public LambdaFactoryConfiguration withStaticImports(String... newStaticImports){
-        return copy().setStaticImports(listWithNewElements(staticImports, newStaticImports));
+    public LambdaFactoryConfiguration withParentClassLoader(ClassLoader parentClassLoader) {
+        return copy().setParentClassLoader(parentClassLoader);
+    }
+
+    /**
+     * Overrides default JavaCompiler instance. <br>It can be used to force using JDK compiler when the Eclipse Compiler
+     * is also available. Completely different compiler instance can also be passed but in that case it is possible
+     * that some changes will have to be made in the class factory ({@link #withClassFactory(ClassFactory)}).
+     */
+    public LambdaFactoryConfiguration withJavaCompiler(JavaCompiler javaCompiler) {
+        return copy().setJavaCompiler(javaCompiler);
+    }
+
+
+    private LambdaFactoryConfiguration setDefaultHelperClassSourceProvider(HelperClassSourceProvider helperClassSourceProvider) {
+        this.helperClassSourceProvider = helperClassSourceProvider;
+        return this;
     }
 
     private LambdaFactoryConfiguration setClassFactory(ClassFactory classFactory) {
@@ -127,17 +166,22 @@ private LambdaFactoryConfiguration setImports(List<String> imports) {
         return this;
     }
 
-    private LambdaFactoryConfiguration setDefaultHelperClassSourceProvider(HelperClassSourceProvider helperClassSourceProvider) {
-        this.helperClassSourceProvider = helperClassSourceProvider;
+    private LambdaFactoryConfiguration setCompilationClassPath(String classPath) {
+        this.compilationClassPath = classPath;
+        return this;
+    }
+
+    private LambdaFactoryConfiguration setParentClassLoader(ClassLoader parentClassLoader) {
+        this.parentClassLoader = parentClassLoader;
         return this;
     }
 
     private LambdaFactoryConfiguration setJavaCompiler(JavaCompiler javaCompiler) {
-        this.javaCompiler = Optional.of(javaCompiler);
+        this.javaCompiler = javaCompiler;
         return this;
     }
 
-    private static <T> List<T> listWithNewElements(List<T> oldList, T... newElements){
+    private static <T> List<T> listWithNewElements(List<T> oldList, T... newElements) {
         return Collections.unmodifiableList(concat(oldList.stream(), Arrays.stream(newElements)).collect(toList()));
     }
 
@@ -152,6 +196,8 @@ public boolean equals(Object o) {
         if (!classFactory.equals(that.classFactory)) return false;
         if (!staticImports.equals(that.staticImports)) return false;
         if (!imports.equals(that.imports)) return false;
+        if (!compilationClassPath.equals(that.compilationClassPath)) return false;
+        if (!parentClassLoader.equals(that.parentClassLoader)) return false;
         return javaCompiler.equals(that.javaCompiler);
 
     }
@@ -162,7 +208,10 @@ public int hashCode() {
         result = 31 * result + classFactory.hashCode();
         result = 31 * result + staticImports.hashCode();
         result = 31 * result + imports.hashCode();
+        result = 31 * result + compilationClassPath.hashCode();
+        result = 31 * result + parentClassLoader.hashCode();
         result = 31 * result + javaCompiler.hashCode();
         return result;
     }
+
 }