refactored to fluent API and minor refactoring for muliple sources compilation and nested class support

Author: trung

.classpath

@@ -0,0 +1,26 @@
+<?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 kind="src" output="target/test-classes" path="src/test/java">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<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-1.8">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="output" path="target/classes"/>
+</classpath>

.project

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>InMemoryJavaCompiler</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>

.settings/org.eclipse.core.resources.prefs

@@ -0,0 +1,4 @@
+eclipse.preferences.version=1
+encoding//src/main/java=UTF-8
+encoding//src/test/java=UTF-8
+encoding/<project>=UTF-8

.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,5 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
+org.eclipse.jdt.core.compiler.source=1.8

.settings/org.eclipse.m2e.core.prefs

@@ -0,0 +1,4 @@
+activeProfiles=
+eclipse.preferences.version=1
+resolveWorkspaceProjects=true
+version=1

pom.xml

@@ -3,14 +3,16 @@
 
     <groupId>org.mdkt.compiler</groupId>
     <artifactId>InMemoryJavaCompiler</artifactId>
-    <version>1.3-SNAPSHOT</version>
+    <version>1.3.0-SNAPSHOT</version>
     <packaging>jar</packaging>
     <url>https://github.com/trung/InMemoryJavaCompiler</url>
 
     <name>InMemoryJavaCompiler</name>
     <description>Small utility to compile java code in memory</description>
 
     <properties>
+    	<maven.compiler.source>1.8</maven.compiler.source>
+    	<maven.compiler.target>1.8</maven.compiler.target>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <maven-compiler-plugin.version>3.2</maven-compiler-plugin.version>
         <nexus-staging-maven-plugin.version>1.6.3</nexus-staging-maven-plugin.version>
@@ -73,10 +75,6 @@
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
                 <version>${maven-compiler-plugin.version}</version>
-                <configuration>
-                    <source>1.7</source>
-                    <target>1.7</target>
-                </configuration>
             </plugin>
             <plugin>
                 <groupId>org.sonatype.plugins</groupId>

src/main/java/org/mdkt/compiler/DynamicClassLoader.java

@@ -3,28 +3,25 @@
 import java.util.HashMap;
 import java.util.Map;
 
-/**
- * Created by trung on 5/3/15.
- */
 public class DynamicClassLoader extends ClassLoader {
 
-    private Map<String, CompiledCode> customCompiledCode = new HashMap<>();
+	private Map<String, CompiledCode> customCompiledCode = new HashMap<>();
 
-    public DynamicClassLoader(ClassLoader parent) {
-        super(parent);
-    }
+	public DynamicClassLoader(ClassLoader parent) {
+		super(parent);
+	}
 
-    public void addCode(CompiledCode cc) {
-        customCompiledCode.put(cc.getName(), cc);
-    }
+	public void addCode(CompiledCode cc) {
+		customCompiledCode.put(cc.getName(), cc);
+	}
 
-    @Override
-    protected Class<?> findClass(String name) throws ClassNotFoundException {
-        CompiledCode cc = customCompiledCode.get(name);
-        if (cc == null) {
-            return super.findClass(name);
-        }
-        byte[] byteCode = cc.getByteCode();
-        return defineClass(name, byteCode, 0, byteCode.length);
-    }
+	@Override
+	protected Class<?> findClass(String name) throws ClassNotFoundException {
+		CompiledCode cc = customCompiledCode.get(name);
+		if (cc == null) {
+			return super.findClass(name);
+		}
+		byte[] byteCode = cc.getByteCode();
+		return defineClass(name, byteCode, 0, byteCode.length);
+	}
 }

src/main/java/org/mdkt/compiler/InMemoryJavaCompiler.java

@@ -1,81 +1,92 @@
 package org.mdkt.compiler;
 
-import java.io.IOException;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
 
-import javax.tools.Diagnostic;
-import javax.tools.DiagnosticListener;
 import javax.tools.JavaCompiler;
-import javax.tools.JavaFileObject;
 import javax.tools.ToolProvider;
 
 /**
- * Created by trung on 5/3/15.
- * Edited by turpid-monkey on 9/25/15, added support for multiple, dependent compile units.
+ * Complile Java sources in-memory
  */
 public class InMemoryJavaCompiler {
-	JavaCompiler javac;
-	DynamicClassLoader classLoader;
+	private JavaCompiler javac;
+	private DynamicClassLoader classLoader;
 
-	Map<String, SourceCode> clazzCode = new HashMap<String, SourceCode>();
+	private Map<String, SourceCode> sourceCodes = new HashMap<String, SourceCode>();
 
-	public InMemoryJavaCompiler(ClassLoader parent) {
-		this(ToolProvider.getSystemJavaCompiler(), parent);
+	public static InMemoryJavaCompiler newInstance() {
+		return new InMemoryJavaCompiler();
 	}
 
-	public InMemoryJavaCompiler(JavaCompiler javac, ClassLoader parent) {
-		this.javac = javac;
-		this.classLoader = new DynamicClassLoader(parent);
-	}
-
-	public InMemoryJavaCompiler() {
-		this(ToolProvider.getSystemJavaCompiler(), ClassLoader
-				.getSystemClassLoader());
+	private InMemoryJavaCompiler() {
+		this.javac = ToolProvider.getSystemJavaCompiler();
+		this.classLoader = new DynamicClassLoader(ClassLoader.getSystemClassLoader());
 	}
 
-	public void addSource(String className, String sourceCodeInText)
-			throws Exception {
-		clazzCode.put(className, new SourceCode(className, sourceCodeInText));
+	public InMemoryJavaCompiler useParentClassLoader(ClassLoader parent) {
+		this.classLoader = new DynamicClassLoader(parent);
+		return this;
 	}
 
+	/**
+	 * Compile all sources
+	 *
+	 * @return
+	 * @throws Exception
+	 */
 	public Map<String, Class<?>> compileAll() throws Exception {
-		Collection<SourceCode> compilationUnits = clazzCode.values();
+		if (sourceCodes.size() == 0) {
+			throw new Exception("No source code to compile");
+		}
+		Collection<SourceCode> compilationUnits = sourceCodes.values();
 		CompiledCode[] code;
-		
+
 		code = new CompiledCode[compilationUnits.size()];
 		Iterator<SourceCode> iter = compilationUnits.iterator();
-		for (int i=0; i<code.length; i++)
-		{
+		for (int i = 0; i < code.length; i++) {
 			code[i] = new CompiledCode(iter.next().getClassName());
 		}
-		
-		ExtendedStandardJavaFileManager fileManager = new ExtendedStandardJavaFileManager(
-				javac.getStandardFileManager(null, null, null), classLoader);
-		JavaCompiler.CompilationTask task = javac.getTask(null, fileManager,
-				null, null, null, compilationUnits);
+
+		ExtendedStandardJavaFileManager fileManager = new ExtendedStandardJavaFileManager(javac.getStandardFileManager(null, null, null), classLoader);
+		JavaCompiler.CompilationTask task = javac.getTask(null, fileManager, null, null, null, compilationUnits);
 		boolean result = task.call();
-		if (!result)
+		if (!result) {
 			throw new RuntimeException("Unknown error during compilation.");
+		}
+
 		Map<String, Class<?>> classes = new HashMap<String, Class<?>>();
-		for (String className : clazzCode.keySet()) {
+		for (String className : sourceCodes.keySet()) {
 			classes.put(className, classLoader.loadClass(className));
 		}
 		return classes;
 	}
 
-	public static Class<?> compile(String className, String sourceCodeInText)
-			throws Exception {
-		InMemoryJavaCompiler comp = new InMemoryJavaCompiler();
-		comp.addSource(className, sourceCodeInText);
-		Map<String, Class<?>> clzzes = comp.compileAll();
-		Class<?> result = clzzes.get(className);
-		return result;
+	/**
+	 * Compile single source
+	 *
+	 * @param className
+	 * @param sourceCode
+	 * @return
+	 * @throws Exception
+	 */
+	public Class<?> compile(String className, String sourceCode) throws Exception {
+		return addSource(className, sourceCode).compileAll().get(className);
 	}
-	
-	public DynamicClassLoader getClassLoader() {
-		return classLoader;
+
+	/**
+	 * Add source code to the compiler
+	 *
+	 * @param className
+	 * @param sourceCode
+	 * @return
+	 * @throws Exception
+	 * @see {@link #compileAll()}
+	 */
+	public InMemoryJavaCompiler addSource(String className, String sourceCode) throws Exception {
+		sourceCodes.put(className, new SourceCode(className, sourceCode));
+		return this;
 	}
 }

src/test/java/org/mdkt/compiler/InMemoryJavaCompilerTest.java

@@ -1,60 +1,53 @@
 package org.mdkt.compiler;
 
-import java.io.StringWriter;
 import java.util.Map;
 
 import org.junit.Assert;
 import org.junit.Test;
 
-/**
- * Created by trung on 5/3/15.
- */
 public class InMemoryJavaCompilerTest {
 
-    @Test
-    public void compile_whenTypical() throws Exception {
-        StringBuffer sourceCode = new StringBuffer();
-
-        sourceCode.append("package org.mdkt;\n");
-        sourceCode.append("public class HelloClass {\n");
-        sourceCode.append("   public String hello() { return \"hello\"; }");
-        sourceCode.append("}");
-
-        Class<?> helloClass = InMemoryJavaCompiler.compile("org.mdkt.HelloClass", sourceCode.toString());
-        Assert.assertNotNull(helloClass);
-        Assert.assertEquals(1, helloClass.getDeclaredMethods().length);
-    }
-    
-    @Test
-    public void compile_severalFiles() throws Exception {
-    	String cls1 = "public class A{ public B b() { return new B(); }}";
-        String cls2 = "public class B{ public String toString() { return \"B!\"; }}";
-        
-        InMemoryJavaCompiler compiler = new InMemoryJavaCompiler();
-        compiler.addSource("A", cls1);
-        compiler.addSource("B", cls2);
-        Map<String,Class<?>> compiled = compiler.compileAll();
-        ;
-        Assert.assertNotNull(compiled.get("A"));
-        Assert.assertNotNull(compiled.get("B"));
-
-        Class<?> aClass = compiled.get("A");
-        Object a = aClass.newInstance();
-        Assert.assertEquals("B!", aClass.getMethod("b").invoke(a).toString());
-    }
-    
-    @Test
-    public void compile_filesWithInnerClasses() throws Exception {
-    	StringBuffer sourceCode = new StringBuffer();
-
-        sourceCode.append("package org.mdkt;\n");
-        sourceCode.append("public class HelloClass {\n");
-        sourceCode.append("   private static class InnerHelloWorld { int inner; }\n");
-        sourceCode.append("   public String hello() { return \"hello\"; }");
-        sourceCode.append("}");
-
-        Class<?> helloClass = InMemoryJavaCompiler.compile("org.mdkt.HelloClass", sourceCode.toString());
-        Assert.assertNotNull(helloClass);
-        Assert.assertEquals(1, helloClass.getDeclaredMethods().length);
-    }
+	@Test
+	public void compile_WhenTypical() throws Exception {
+		StringBuffer sourceCode = new StringBuffer();
+
+		sourceCode.append("package org.mdkt;\n");
+		sourceCode.append("public class HelloClass {\n");
+		sourceCode.append("   public String hello() { return \"hello\"; }");
+		sourceCode.append("}");
+
+		Class<?> helloClass = InMemoryJavaCompiler.newInstance().compile("org.mdkt.HelloClass", sourceCode.toString());
+		Assert.assertNotNull(helloClass);
+		Assert.assertEquals(1, helloClass.getDeclaredMethods().length);
+	}
+
+	@Test
+	public void compile_WhenMultipleSources() throws Exception {
+		String cls1 = "public class A{ public B b() { return new B(); }}";
+		String cls2 = "public class B{ public String toString() { return \"B!\"; }}";
+
+		Map<String, Class<?>> compiled = InMemoryJavaCompiler.newInstance().addSource("A", cls1).addSource("B", cls2).compileAll();
+
+		Assert.assertNotNull(compiled.get("A"));
+		Assert.assertNotNull(compiled.get("B"));
+
+		Class<?> aClass = compiled.get("A");
+		Object a = aClass.newInstance();
+		Assert.assertEquals("B!", aClass.getMethod("b").invoke(a).toString());
+	}
+
+	@Test
+	public void compile_WhenSourceContainsInnerClasses() throws Exception {
+		StringBuffer sourceCode = new StringBuffer();
+
+		sourceCode.append("package org.mdkt;\n");
+		sourceCode.append("public class HelloClass {\n");
+		sourceCode.append("   private static class InnerHelloWorld { int inner; }\n");
+		sourceCode.append("   public String hello() { return \"hello\"; }");
+		sourceCode.append("}");
+
+		Class<?> helloClass = InMemoryJavaCompiler.newInstance().compile("org.mdkt.HelloClass", sourceCode.toString());
+		Assert.assertNotNull(helloClass);
+		Assert.assertEquals(1, helloClass.getDeclaredMethods().length);
+	}
 }