v2.2.0, improved ClassBuilder, new JSONWriter for debugging, fixes

fquirin · fquirin · commit 9018416ae0be · 2018-12-28T00:42:06.000+01:00
diff --git a/pom.xml b/pom.xml
@@ -4,7 +4,7 @@
 
     <groupId>net.b07z.sepia.server.core</groupId>
     <artifactId>sepia-core-tools</artifactId>
-    <version>2.1.1</version>
+    <version>2.2.0</version>
     <name>SEPIA Core-Tools</name>
     <description>The Core-Tools repository contains classes and methods that are shared by all SEPIA servers and other tools like the SDK.</description>
     <url>https://github.com/SEPIA-Framework/sepia-core-tools-java</url>
diff --git a/src/main/java/net/b07z/sepia/server/core/tools/ClassBuilder.java b/src/main/java/net/b07z/sepia/server/core/tools/ClassBuilder.java
@@ -1,12 +1,16 @@
 package net.b07z.sepia.server.core.tools;
 
+import java.io.File;
 import java.lang.reflect.Constructor;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Locale;
 
+import javax.tools.Diagnostic;
 import javax.tools.DiagnosticCollector;
 import javax.tools.JavaCompiler;
 import javax.tools.JavaFileObject;
+import javax.tools.StandardJavaFileManager;
 import javax.tools.ToolProvider;
 
 /**
@@ -22,19 +26,18 @@ public class ClassBuilder {
 	 * NOTE! Because getClass always returns non-primitives like "Integer" instead of "int" but they are rarely used, all
 	 * classes are cast to primitives if possible. That means the constructor will not be found if it has "Integer" instead of "int".
 	 * Same is most likely true for the constructors containing the class "Object".
-	 * 
-	 * @param package_name - name of the package, e.g. "java.util". Can be empty.
-	 * @param module_name - name of the class inside the package as string, e.g.: "Date"
-	 * @param arguments - arguments usually passed to the constructor
+	 * @param classLoader - loader that has access to the class. Use null or 'ClassLoader.getSystemClassLoader()' for default.
+	 * @param canonicalClassName - canonical name of the class, e.g.: "java.lang.String"
+	 * @param arguments - arguments usually passed to the constructor (optional).
 	 * @return constructed class
 	 */
-	public static Object construct(String package_name, String module_name, Object... arguments){
-		if (!package_name.isEmpty()){
-			module_name = package_name + "." + module_name;		//package_name and module_name are separated in case the package_name changes
-		}
+	public static Object construct(ClassLoader classLoader, String canonicalClassName, Object... arguments){
 		try{
+			if (classLoader == null){
+				classLoader = ClassLoader.getSystemClassLoader();
+			}
 			Object clazz;
-			if (arguments.length > 0){
+			if (arguments != null && arguments.length > 0){
 				Class<?>[] arg_clazzes = new Class[arguments.length];
 				for (int i=0; i<arguments.length; i++){
 					arg_clazzes[i] = arguments[i].getClass();
@@ -56,55 +59,76 @@ public static Object construct(String package_name, String module_name, Object..
 						arg_clazzes[i] = Short.TYPE;
 					}
 				}
-				Constructor<?> conztructor = Class.forName(module_name).getConstructor(arg_clazzes);
+				Constructor<?> conztructor = Class.forName(canonicalClassName, true, classLoader).getConstructor(arg_clazzes);
 				clazz = conztructor.newInstance(arguments);
 			}else{
-				Constructor<?> conztructor = Class.forName(module_name).getConstructor();
+				Constructor<?> conztructor = Class.forName(canonicalClassName, true, classLoader).getConstructor();
 				clazz = conztructor.newInstance();
 			}
 			return clazz;
 			
 		}catch (Exception e){
 			e.printStackTrace();
-			throw new RuntimeException(DateTime.getLogDate() + " ERROR - Class not found: " + module_name, e);
+			throw new RuntimeException(DateTime.getLogDate() + " ERROR - Class not found: " + canonicalClassName, e);
 		}
 	}
 
 	/**
 	 * Constructs a new instance of a class just by using the name of the class.<br>
 	 * 
-	 * @param module_name - name of the class inside the package as string, e.g.: "Date"
+	 * @param canonicalClassName - canonical name of the class, e.g.: "java.lang.String"
 	 * @return constructed class
 	 */
-	public static Object construct(String module_name){
-		try{
-			Object clazz;
-			Constructor<?> conztructor = Class.forName(module_name).getConstructor();
-			clazz = conztructor.newInstance();
-			return clazz;
-			
-		}catch (Exception e){
-			e.printStackTrace();
-			throw new RuntimeException(DateTime.getLogDate() + " ERROR - Class not found: " + module_name, e);
-		}
+	public static Object construct(String canonicalClassName){
+		return construct(null, canonicalClassName);
 	}
 	
 	/**
 	 * Experimental string source-code compiler.
-	 * @param className
-	 * @param classCode
-	 * @param fileName
+	 * @param className - full class name including package, e.g. com.example.my_package.MyNewClass
+	 * @param classCode - source-code as seen in Java files
+	 * @param targetFolder - parent directory of compiled class file (without package-path) or null
 	 */
-	public static void compile(String className, String classCode, String fileName){
+	public static void compile(String className, String classCode, File targetFolder){
 		JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
+		if (compiler == null){
+			String msg = "Cannot find Java compiler! "
+					+ "Please upgrade from JRE to JDK or check JAVA_HOME: " + System.getProperty("java.home");
+			//Debugger.println(msg, 1);
+			throw new RuntimeException(msg);
+		}
 	    DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<JavaFileObject>();
 	    
 	    List<JavaFileObject> compilationUnits = new ArrayList<JavaFileObject>();
         JavaFileObject file = new SourceCodeFromString(className, classCode);
         compilationUnits.add(file);
+        
+        // This sets up the class path that the compiler will use.
+        // I've added the .jar file that contains the DoStuff interface within in it...
+        List<String> optionList = new ArrayList<>();
+        String folderOrMemory = "MEMORY ONLY";
+        if (targetFolder != null){
+        	folderOrMemory = targetFolder.getAbsolutePath().toString();
+        	optionList.add("-d");
+        	optionList.add(folderOrMemory);
+        }
+        /*
+        optionList.add("-classpath");
+        optionList.add(System.getProperty("java.class.path") + ";dist/InlineCompiler.jar"); 	//example for classpath
+        */
+        StandardJavaFileManager fileManager = compiler.getStandardFileManager(diagnostics, null, null);
 
-	    JavaCompiler.CompilationTask task = compiler.getTask(null, null, diagnostics, null, null, compilationUnits);
-	    System.out.println(task.call() + diagnostics.getDiagnostics().toString()); //passes every time
+	    JavaCompiler.CompilationTask task = compiler.getTask(null, fileManager, diagnostics, optionList, null, compilationUnits);
+	    if (task.call()){
+	    	//Done
+	    	Debugger.println("Compiled '" + className + "' to '" + folderOrMemory, 3);
+	    }else{
+	    	//Error(s)
+	    	for (Diagnostic<? extends JavaFileObject> diagnostic : diagnostics.getDiagnostics()){
+	    		Debugger.println("ClassBuilder - compiling of '" + diagnostic.getSource().toUri() + "' failed. Error: \n" +
+	    				"Line " + diagnostic.getLineNumber() + ": " + diagnostic.getMessage(Locale.ENGLISH), 1);
+            }
+	    }
 	}
 
 }
diff --git a/src/main/java/net/b07z/sepia/server/core/tools/Debugger.java b/src/main/java/net/b07z/sepia/server/core/tools/Debugger.java
@@ -46,7 +46,7 @@ else if (type == 3 && log){
 	 */
 	public static void printStackTrace(Throwable ex, int numTraces){
 		StackTraceElement[] ste = ex.getStackTrace(); 
-		if (ste != null){
+		if (ste != null && ste.length > 0){
 			for (int i=0; i<Math.min(5, ste.length); i++){
 				Debugger.println("TRACE: " + ex.getStackTrace()[i], 1);
 			}
diff --git a/src/main/java/net/b07z/sepia/server/core/tools/JSON.java b/src/main/java/net/b07z/sepia/server/core/tools/JSON.java
@@ -140,14 +140,15 @@ public static void printJSON(JSONObject input){
 	}
 	
 	/**
-	 * Print content of JSONObject in a kind of prettier way. Keys and values must be convertible to string!
+	 * Print content of JSONObject in a kind of prettier way to stdOut. Keys and values must be convertible to string!<br>
+	 * Used only for quick debugging, if you need more options us {@link JSONWriter}.
 	 */
 	public static void printJSONpretty(JSONObject input){
 		printJSONpretty(input, "-");
 	}
 	/**
-	 * Print content of JSONObject in a kind of prettier way. Keys and values must be convertible to string!
-	 * The "indentSymbol" is used at the beginning of a line to make the hierarchy clear. 
+	 * Print content of JSONObject in a kind of prettier way. Keys and values must be convertible to string!<br>
+	 * Used only for quick debugging, if you need more options us {@link JSONWriter}.
 	 */
 	@SuppressWarnings("unchecked")
 	public static void printJSONpretty(JSONObject input, String indentSymbol){
diff --git a/src/main/java/net/b07z/sepia/server/core/tools/JSONWriter.java b/src/main/java/net/b07z/sepia/server/core/tools/JSONWriter.java
@@ -0,0 +1,117 @@
+package net.b07z.sepia.server.core.tools;
+
+import java.io.IOException;
+import java.io.StringWriter;
+import java.io.Writer;
+
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+
+/**
+ * Creates pretty strings from JSON objects.
+ * Sample usage:
+ * <pre>
+ * Writer writer = new JSONWriter();
+ * jsonobject.writeJSONString(writer);
+ * System.out.println(writer.toString());
+ * OR:
+ * String s = JSONWriter.getPrettyString(jsonObject);
+ * </pre>
+ * 
+ * @author Elad Tabak
+ * @author Maciej Komosinski, minor improvements, 2015
+ * @author Florian Quirin, minor improvements, 2018
+ * @since 28-Nov-2011
+ * @version 0.3
+ */
+public class JSONWriter extends StringWriter
+{
+	final String indentstring;
+	final String spaceaftercolon;
+
+	private int indentlevel = 0;
+	
+	/**
+	 * Default constructor with 4 space indentation and 1 space after colons.
+	 */
+	public JSONWriter(){
+		this.indentstring = "    "; 		//default indentation
+		this.spaceaftercolon = " "; 	//use "" if you don't want space after colon
+	}
+	/**
+	 * Constructor with custom indentation and space-after-colon string.
+	 * @param indentation - default: "    " (4 spaces for next indentation level)
+	 * @param colonSpace - default: " " (1 space after each colon)
+	 */
+	public JSONWriter(String indentation, String colonSpace){
+		this.indentstring = indentation;
+		this.spaceaftercolon = colonSpace;
+	}
+	
+	/**
+	 * Get default, pretty JSON string. Returns null on error!
+	 * @param jo - JSONObject to print pretty
+	 * @return String or null
+	 */
+	public static String getPrettyString(JSONObject jo){
+		Writer sw = new JSONWriter();
+		try {
+			jo.writeJSONString(sw);
+			return sw.toString()
+					.replaceAll("\\[(\\n|\\s)+]", "[]")
+					.replaceAll("\\{(\\n|\\s)+}", "{}");
+		} catch (IOException e) {
+			e.printStackTrace();
+			return null;
+		}
+	}
+	/**
+	 * Get default, pretty JSON string. Returns null on error!
+	 * @param ja - JSONArray to print pretty
+	 * @return String or null
+	 */
+	public static String getPrettyString(JSONArray ja){
+		Writer sw = new JSONWriter();
+		try {
+			ja.writeJSONString(sw);
+			return sw.toString()
+					.replaceAll("\\[(\\n|\\s)+]", "[]")
+					.replaceAll("\\{(\\n|\\s)+}", "{}");
+		} catch (IOException e) {
+			e.printStackTrace();
+			return null;
+		}
+	}
+
+	@Override
+	public void write(int c)
+	{
+		char ch = (char) c;
+		if (ch == '[' || ch == '{')	{
+			super.write(c);
+			super.write('\n');
+			indentlevel++;
+			writeIndentation();
+		} else if (ch == ',') {
+			super.write(c);
+			super.write('\n');
+			writeIndentation();
+		} else if (ch == ']' || ch == '}') {
+			super.write('\n');
+			indentlevel--;
+			writeIndentation();
+			super.write(c);
+		} else if (ch == ':') {
+			super.write(c);
+			super.write(spaceaftercolon);
+		} else {
+			super.write(c);
+		}
+
+	}
+	private void writeIndentation() {
+		for (int i = 0; i < indentlevel; i++) {
+			super.write(indentstring);
+		}
+	}
+}
diff --git a/src/main/java/net/b07z/sepia/server/core/tools/RuntimeInterface.java b/src/main/java/net/b07z/sepia/server/core/tools/RuntimeInterface.java
@@ -14,7 +14,7 @@
  */
 public class RuntimeInterface {
 	
-	public static final boolean isWindows = System.getProperty("os.name").toLowerCase().startsWith("windows");
+	public static Boolean isWindows = null;
 	public static Charset windowsShellCodepage = null; 
 	
 	/**
@@ -71,6 +71,17 @@ public String toString(CharSequence delimiter){
 		}
 	}
 	
+	/**
+	 * Is the runtime a Windows OS?
+	 * @return
+	 */
+	public static boolean isWindows(){
+		if (isWindows == null){
+			isWindows = System.getProperty("os.name").toLowerCase().startsWith("windows");
+		}
+		return isWindows;
+	}
+	
 	/**
 	 * We need to run the shell codepage command to get proper windows encoding (is there REALLY no BETTER WAY??).
 	 * @return
@@ -104,7 +115,7 @@ public static RuntimeResult runCommand(String[] command){
 	}
 	public static RuntimeResult runCommand(String[] command, long customTimeout){
 		Charset encoding = StandardCharsets.UTF_8;
-		if (isWindows && windowsShellCodepage == null && !command[0].equals("chcp")){
+		if (isWindows() && windowsShellCodepage == null && !command[0].equals("chcp")){
 			RuntimeResult rtr = getWindowsShellCodepage(); 
 			if (rtr.getStatusCode() != 0){
 				return new RuntimeResult(1, null, rtr.getException());
@@ -122,7 +133,7 @@ public static RuntimeResult runCommand(String[] command, long customTimeout){
 			//process = Runtime.getRuntime().exec(command); 	//old way
 			ProcessBuilder builder = new ProcessBuilder();
 			String[] osPart;
-			if (isWindows){
+			if (isWindows()){
 				osPart = new String[]{"cmd.exe", "/c"};
 			}else{
 				osPart = new String[]{"sh", "-c"};
diff --git a/src/main/java/net/b07z/sepia/server/core/tools/SourceCodeFromString.java b/src/main/java/net/b07z/sepia/server/core/tools/SourceCodeFromString.java
@@ -12,6 +12,11 @@
 public class SourceCodeFromString extends SimpleJavaFileObject {
     final String code;
 
+    /**
+     * Construct the new source by giving the (full) class name and code content.
+     * @param name - full class name, e.g. com.example.my_package.MyNewClass
+     * @param code - Java source-code as seen in .java files (including package and import sections)
+     */
     public SourceCodeFromString(String name, String code){
         super(URI.create("string:///" + name.replace('.','/') + Kind.SOURCE.extension), Kind.SOURCE);
         this.code = code;
diff --git a/src/test/java/tools/Test_ClassBuilder.java b/src/test/java/tools/Test_ClassBuilder.java
diff --git a/src/test/java/tools/ToolsPlayground.java b/src/test/java/tools/ToolsPlayground.java

Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ else if (type == 3 && log){`
`46`	`46`	`*/`
`47`	`47`	`public static void printStackTrace(Throwable ex, int numTraces){`
`48`	`48`	`StackTraceElement[] ste = ex.getStackTrace();`
`49`		`- if (ste != null){`
	`49`	`+ if (ste != null && ste.length > 0){`
`50`	`50`	`for (int i=0; i<Math.min(5, ste.length); i++){`
`51`	`51`	`Debugger.println("TRACE: " + ex.getStackTrace()[i], 1);`
`52`	`52`	`}`