Interface JavaExecable

src/main/java/com/diffplug/gradle/JavaExecable.java:89–148

Easy way to execute code from a Gradle plugin in a separate JVM. Create an class which implements `JavaExecable`. It should have some fields which are input, some fields which are output, and a `run()` method. Here's what happens when you call JavaExecable#exec(Project, JavaExecable), -

 *
 */
public interface JavaExecable extends Serializable, Throwing.Runnable {
	static final String BUILDSCRIPT_CLASSPATH = "classpath";

	/**
	 * @param project	the project on which we'll call {@link Project#javaexec(Action)}.
	 * @param input		the JavaExecable which we'll take as input and call run() on.
	 * @param settings	any extra settings you'd like to set on the JavaExec (e.g. heap)
	 * @return the JavaExecable after it has had run() called.
	 */
	public static <T extends JavaExecable> T exec(Project project, T input, Action<JavaExecSpec> settings) throws Throwable {
		// copy the classpath from the project's buildscript (and its parents)
		List<FileCollection> classpaths = TreeStream.toParent(ProjectPlugin.treeDef(), project)
				.map(p -> p.getBuildscript().getConfigurations().getByName(BUILDSCRIPT_CLASSPATH))
				.collect(Collectors.toList());
		// add the gradleApi, workaround from https://discuss.gradle.org/t/gradle-doesnt-add-the-same-dependencies-to-classpath-when-applying-plugins/9759/6?u=ned_twigg
		classpaths.add(project.getConfigurations().detachedConfiguration(project.getDependencies().gradleApi()));
		// add stuff from the local classloader too, to fix testkit's classpath
		classpaths.add(project.files(JavaExecableImp.fromLocalClassloader()));
		// run it
		return JavaExecableImp.execInternal(input, project.files(classpaths), settings, execSpec -> JavaExecWinFriendly.javaExec(project, execSpec));
	}

	/** @see #exec(Project, JavaExecable, Action) */
	public static <T extends JavaExecable> T exec(Project project, T input) throws Throwable {
		return exec(project, input, unused -> {});
	}

	/** @see #exec(Project, JavaExecable, Action) */
	public static <T extends JavaExecable> T execWithoutGradle(T input, Action<JavaExecSpec> settings) throws Throwable {
		Set<File> classpath = JavaExecableImp.fromLocalClassloader();
		Project project = ProjectBuilder.builder().build();
		return JavaExecableImp.execInternal(input, project.files(classpath), settings, execSpec -> JavaExecWinFriendly.javaExec(project, execSpec));
	}

	/** @see #exec(Project, JavaExecable, Action) */
	public static <T extends JavaExecable> T execWithoutGradle(T input) throws Throwable {
		return execWithoutGradle(input, unused -> {});
	}

	/** Main which works in conjunction with {@link JavaExecable#exec(Project, JavaExecable, Action)}. */
	public static void main(String[] args) throws IOException {
		File file = new File(args[0]);
		try {
			// read the target object from the file
			JavaExecable javaExecOutside = SerializableMisc.read(file);
			// run the object's run method
			javaExecOutside.run();
			// save the object back to file
			SerializableMisc.write(file, javaExecOutside);
		} catch (Throwable t) {
			// if it's an exception, write it out to file
			SerializableMisc.writeThrowable(file, t);
		}
	}

	/** Encapsulates whether something is run internally or externally. */
	public enum Mode {
		INTERNAL, EXTERNAL