First simple working version that generates 20002 random files

- classes and interfaces
- uses random java classes / imports from different modules
- uses generics
- random cross-referencing

Author: iloveeclipse

JavaProjectGenerator/.classpath

@@ -2,5 +2,6 @@
 <classpath>
 	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
 	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="target/generated"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>

JavaProjectGenerator/src/de/loskutov/jpg/Clazz.java

@@ -0,0 +1,93 @@
+package de.loskutov.jpg;
+
+public class Clazz extends JavaElement {
+
+	String implement;
+	String extend;
+	
+	Clazz(String name, String packageName, String implement, String extend) {
+		super(name, packageName);
+		this.implement = implement;
+		this.extend = extend;
+	}
+
+	@Override
+	String generateCode() {
+		boolean object = "java.lang.Object".equals(extend);
+		if(object) {
+			return generateObject();
+		}
+		String s = "package " + packageName + ";\n\n" + 
+				"import " + imports.next() + ";\n\n" +
+				"@SuppressWarnings(\"all\")\n" +
+				"public abstract class " + name + "<E> extends " + extend + "<E> implements " + implement + "<E> {\n\n" + 
+					"\t public E element;\n\n" +
+					"\t public " + fields.next() + " field1;\n\n" +
+					"\t public static " + name + " instance;\n\n" +
+					"\t public static " + name + " getInstance() {\n" +
+					"\t \t return instance;\n" +
+					"\t }\n\n" +
+					"\t public static <T> T create(java.util.List<T> input) {\n" +
+					"\t \t return " + extend + ".create(input);\n" +
+					"\t }\n\n" +
+					"\t public String getName() {\n" +
+					"\t \t return " + extend + ".getInstance().getName();\n" +
+					"\t }\n\n" +
+					"\t public void setName(String string) {\n" +
+					"\t \t " + extend + ".getInstance().setName(getName());\n" +
+					"\t \t return;\n" +
+					"\t }\n\n" +
+					"\t public E get() {\n" +
+					"\t \t return (E)" + extend + ".getInstance().get();\n" +
+					"\t }\n\n" +
+					"\t public void set(Object element) {\n" +
+					"\t \t this.element = (E)element;\n" +
+					"\t \t " + extend + ".getInstance().set(this.element);\n" +
+					"\t }\n\n" +
+					"\t public E call() throws Exception {\n" +
+					"\t \t return (E)" + extend + ".getInstance().call();\n" +
+					"\t }\n" +
+				"}\n";
+		return s;
+	}
+	
+	String generateObject() {
+		String s = "package " + packageName + ";\n" + 
+				"import " + imports.next() + ";\n" +
+				"@SuppressWarnings(\"all\")\n" +
+				"public abstract class " + name + "<E> implements " + implement + "<E> {\n" + 
+					"public E element;\n" +
+					"public " + fields.next() + " field1;\n" +
+					"public static " + name + " instance;\n" +
+					"public static " + name + " getInstance() {\n" +
+					"\t return instance;\n" +
+					"}\n" +
+				
+					"public static <T> T create(java.util.List<T> input) {\n" +
+					"\t return null;\n" +
+					"}\n" +
+					
+					"public String getName() {\n" +
+					"\t return element.toString();\n" +
+					"}\n" +
+					
+					"public void setName(String string) {\n" +
+					"\t return;\n" +
+					"}\n" +
+					
+					"public E get() {\n" +
+					"\t return element;\n" +
+					"}\n" +
+					
+					"public void set(Object element) {\n" +
+					"\t this.element = (E)element;\n" +
+					"}\n" +
+					
+					"public E call() throws Exception {\n" +
+					"\t return (E)getInstance().call();\n" +
+					"}\n" +
+					"}\n";
+		return s;
+	}
+
+}

JavaProjectGenerator/src/de/loskutov/jpg/Interface.java

@@ -0,0 +1,32 @@
+package de.loskutov.jpg;
+
+public class Interface extends JavaElement {
+
+	private String extend;
+
+	Interface(String name, String packageName, String extend) {
+		super(name, packageName);
+		this.extend = extend;
+	}
+
+	@Override
+	String generateCode() {
+		String s = "package " + packageName + ";\n\n" + 
+				"import " + imports.next() + ";\n\n" +
+				"@SuppressWarnings(\"all\")\n" +
+				"public interface " + name + "<E> extends " + extend + "<E> {\n\n" + 
+
+				     "\t " + fields.next() + " ifield = null;\n\n" +
+					
+					"\t String getName();\n\n" +
+					
+					"\t void setName(String s);\n\n" +
+					
+					"\t E get();\n\n" +
+					
+					"\t void set(E e);\n\n" +
+				"}\n";
+		return s;
+	}
+
+}

JavaProjectGenerator/src/de/loskutov/jpg/JavaElement.java

@@ -0,0 +1,79 @@
+package de.loskutov.jpg;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.List;
+
+public abstract class JavaElement {
+	
+	static final List<String> IMPORTS = Arrays.asList( 
+			"java.awt.datatransfer.*",
+			"java.beans.beancontext.*",
+			"java.io.*",
+			"java.rmi.*",
+			"java.nio.file.*",
+			"java.sql.*",
+			"java.util.logging.*",
+			"java.util.zip.*",
+			"javax.annotation.processing.*",
+			"javax.lang.model.*",
+			"javax.management.*",
+			"javax.naming.directory.*",
+			"javax.net.ssl.*",
+			"javax.rmi.ssl.*"
+			);
+	
+	static final List<String> FIELDS = Arrays.asList(
+			"java.awt.datatransfer.DataFlavor",
+			"java.beans.beancontext.BeanContext",
+			"java.io.File",
+			"java.rmi.Remote",
+			"java.nio.file.FileStore",
+			"java.sql.Array",
+			"java.util.logging.Filter",
+			"java.util.zip.Deflater",
+			"javax.annotation.processing.Completion",
+			"javax.lang.model.AnnotatedConstruct",
+			"javax.management.Attribute",
+			"javax.naming.directory.DirContext",
+			"javax.net.ssl.ExtendedSSLSession",
+			"javax.rmi.ssl.SslRMIClientSocketFactory"
+			);
+	
+	String name;
+	String packageName;
+	Ring<String> imports;
+	Ring<String> fields;
+	
+	JavaElement(String name, String packageName){
+		this.name = name;
+		this.packageName = packageName;
+		imports = new Ring<>(IMPORTS);
+		fields = new Ring<>(FIELDS); 
+	}
+	
+	abstract String generateCode();
+	
+	void persist(Path root) throws IOException {
+		try(BufferedWriter writer = createWriter(root)){
+			String code = generateCode();
+			writer.append(code);
+			writer.flush();
+		}
+	}
+	
+	String fqn() {
+		return packageName + "." + name;
+	}
+	
+	BufferedWriter createWriter(Path root) throws IOException {
+		Path path = root.resolve(packageName.replace('.', File.separatorChar)).resolve(name + ".java");
+		Files.createDirectories(path.getParent());
+		return Files.newBufferedWriter(path, StandardCharsets.UTF_8);
+	}
+}

JavaProjectGenerator/src/de/loskutov/jpg/Main.java

@@ -1,9 +1,126 @@
 package de.loskutov.jpg;
 
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.SimpleFileVisitor;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
 public class Main {
+	
+	public static void main(String[] args) throws IOException {
+		File rootDir = new File("./target/generated/");
+        System.out.println("Writing to "  + rootDir.getAbsolutePath());
+        Path root = rootDir.toPath();
+		
+		
+		int depth = 10;
+		int roots = 10;
+		int classes = 100;
+
+		new JavaBuilder(depth, roots, classes, root).build();
+	}
+}
+
+class JavaBuilder {
+	
+	static List<String> namesList = IntStream.rangeClosed('a', 'z').mapToObj(x -> String.valueOf((char)x))
+			.collect(Collectors.toList());
+	
+	int depth;
+	int roots;
+	private Ring<String> pnames;
+	private Path root;
+
+	private List<Clazz> classes;
 
-	public static void main(String[] args) {
+	private List<Interface> interfaces;
+
+	private int countClasses;
+	
+	public JavaBuilder(int depth, int roots, int countClasses, Path root) {
+		this.depth = depth;
+		this.roots = roots;
+		this.countClasses = countClasses;
+		this.root = root;
+		pnames = new Ring<>(namesList);
+		classes = new ArrayList<>();
+		interfaces = new ArrayList<>();
+	}
+	
+	void build() throws IOException {
+		Files.walkFileTree(root, new SimpleFileVisitor<Path>() {
+			   @Override
+			   public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
+			       Files.delete(file);
+			       return FileVisitResult.CONTINUE;
+			   }
+
+			   @Override
+			   public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
+			       Files.delete(dir);
+			       return FileVisitResult.CONTINUE;
+			   }
+			});
+		Files.createDirectories(root);
+		
+		List<Package> rootPackages = new ArrayList<>();
+		for (int i = 0; i < roots; i++) {
+			Package p = createPackage(pnames.next(), null);
+			rootPackages.add(p);
+		}
 
+		for (Package r : rootPackages) {
+			Stream<Package> stream = Stream.iterate(r, x -> new Package(pnames.next(), x)).limit(depth);
+			stream.forEach(p -> {
+				createInterfaces(p);
+				createClasses(p);
+			});
+		}
+		List<JavaElement> elements = new ArrayList<>(interfaces);
+		elements.addAll(classes);
+		elements.forEach(this::generateFile);
+		System.out.println("Generated " + elements.size() + " classes");
 	}
 
+	private void generateFile(JavaElement e) {
+		try {
+			e.persist(root);
+		} catch (IOException e1) {
+			e1.printStackTrace();
+		}
+	}
+	
+	void createInterfaces(Package p) {
+		Ring<Interface> toImplement = new Ring<>(interfaces, countClasses);
+		if(interfaces.isEmpty()) {
+			interfaces.add(new Interface("IFoo0", p.getFqn(), "java.util.concurrent.Callable"));
+		}
+		toImplement.stream().forEach(i -> {				
+			interfaces.add(new Interface("IFoo" + interfaces.size(), p.getFqn(), toImplement.next().fqn()));
+		});
+	}
+	
+	void createClasses(Package p) {
+		Ring<Interface> implement = new Ring<>(interfaces, countClasses);
+		Ring<Clazz> toExtend = new Ring<>(classes, countClasses);
+		if (classes.isEmpty()) {
+			classes.add(new Clazz("Element0", p.getFqn(), implement.next().fqn(), "java.lang.Object"));
+		}
+		toExtend.stream().forEach(x -> {
+			classes.add(new Clazz("Element" + classes.size(), p.getFqn(), implement.next().fqn(), toExtend.next().fqn()));
+		});
+	}
+	
+	Package createPackage(String name, Package parent) {
+		return new Package(name, parent);
+	}
+	
 }

JavaProjectGenerator/src/de/loskutov/jpg/Package.java

@@ -0,0 +1,13 @@
+package de.loskutov.jpg;
+
+public class Package {
+	private String fqn;
+	
+	Package(String name, Package parent){
+		this.fqn = parent == null? name : parent.fqn + "." + name;
+	}
+	
+	public String getFqn() {
+		return fqn;
+	}
+}

JavaProjectGenerator/src/de/loskutov/jpg/Ring.java

@@ -0,0 +1,41 @@
+package de.loskutov.jpg;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Stream;
+
+public class Ring<E> {
+	private List<E> choices;
+	int cursor = -1;
+	private int limit;
+	
+	Ring(List<E> list){
+		this(list, -1);
+	}
+	
+	Ring(List<E> list, int limit){
+		this.limit = limit;
+		if(list instanceof ArrayList) {
+			this.choices = list;
+		} else {
+			this.choices = new ArrayList<>(list);
+		}
+		Collections.shuffle(choices);
+	}
+	
+	E next() {
+		cursor ++;
+		if(cursor >= choices.size()) {
+			cursor = 0;
+		}
+		return choices.get(cursor);
+	}
+	
+	Stream<E> stream(){
+		if(limit > 0) {			
+			return Stream.generate(() -> next()).limit(limit);
+		}
+		return Stream.generate(() -> next());
+	}
+}