Plugin error handling (but this time it works) (#330)

* add Version

* add EnigmaPlugin::supportsEnigmaVersion
add current version part constants to Enigma
extract individual part comparators in Version

* check EnigmaPlugin::supportsEnigmaVersion and throw if false

* improve error message

* add TestConsistentVersions

* tweak whitespace

* minor tweaks

* Integer::toString instead of Integer::parseInt

* improve javadoc

* remove redundant word from javadoc

* javadoc Version

* add missing 'the passed'

* add copyAndBumpEnigma task

* rename copyAndBumpEnigma -> syncBumpAndJarEngima
Sync instead of Copy to ensure old output is deleted
run jar task in bumped copy

* add DummyEnigmaPlugin test input

* got runDummyPluginAgainstBumpedEnigma working well enough to tell that the inlined constant approach doesn't work

* add EnigmaVersionMarked annotation

* make EnigmaVersionMarked annotation work

* remove EnigmaVersionMarked
remove default EnigmaPlugin::supportsEnigmaVersion implementation

* add PreHandlingDummyEnigmaPlugin

* update runDummyPluginAgainstBumpedEnigma task -> runRecommendedImplPluginAgainstBumpedEnigma

* improve bumped jar filtering

* add runPreHandlingPluginAgainstCurrentEnigma task

* catch AbstractMethodError when calling supportsEnigmaVersion

* check runPreHandlingPluginAgainstCurrentEnigma for expected output and rename -> testPreHandlingPluginAgainstCurrentEnigma

* check runRecommendedImplPluginAgainstBumpedEnigma for expected output and rename -> testRecommendedImplPluginAgainstBumpedEnigma

* make test depende on dummy plugin tests

* exclude enigma-cli build dir from bumped copy

* add AnyVersionEnigmaPlugin for test plugins

* add reminder to update Enigma's version int constants

* rename DummyEnigmaPlugin -> RecommendedImplEnigmaPlugin

* add Version methods instead of exposing Comparators

* remove unused import

* improve comments, rename task

* add error messages to TestConsistentVersions

* remove commented code

* replace getAsFile() with asFile

---------

Co-authored-by: ix0rai <[email protected]>

Author: supersaiyansubtlety

build.gradle

@@ -31,6 +31,7 @@ subprojects {
 	}
 
 	group = 'org.quiltmc'
+	// When bumping version, remember to update the int constants in Enigma!
 	version = '2.6.2'
 
 	var ENV = System.getenv()

enigma/build.gradle

@@ -1,11 +1,43 @@
 import proguard.gradle.ProGuardTask
 
+import java.nio.file.Files
+import java.util.regex.Pattern
+
 plugins {
 	id 'checkstyle'
 	id 'java-library'
 	id 'java-test-fixtures'
 }
 
+interface ExecProvider {
+	@javax.inject.Inject
+	ExecOperations getOperations()
+}
+final EXEC = objects.newInstance(ExecProvider).operations
+
+final dummyPluginPath = project.file('src/dummyPlugin').toPath()
+Closure<SourceSet> configureDummyPluginSourceSet = {
+	final dir = dummyPluginPath.resolve(it.name);
+	java {
+		srcDirs dir.resolve('java')
+	}
+
+	resources {
+		srcDirs dir.resolve('resources')
+	}
+}
+
+sourceSets {
+	recommendedImplPlugin configureDummyPluginSourceSet
+	preHandlingPlugin configureDummyPluginSourceSet
+}
+
+configurations {
+	recommendedImplPluginRuntimeClasspath.extendsFrom runtimeClasspath
+	recommendedImplPluginCompileClasspath.extendsFrom compileClasspath
+	// preHandlingPlugin doesn't extend because it has its own EnigmaPlugin interface
+}
+
 dependencies {
 	implementation libs.bundles.asm
 
@@ -20,6 +52,9 @@ dependencies {
 
 	testFixturesImplementation libs.asm
 	testFixturesImplementation libs.asm.tree
+
+	recommendedImplPluginImplementation(project)
+	// preHandlingPlugin doesn't depend on project because it has its own EnigmaPlugin interface
 }
 
 // Generate "version.properties" file
@@ -117,6 +152,214 @@ file('src/test/java/org/quiltmc/enigma/input').listFiles().each { f ->
 	}
 }
 
+final dummyPluginsDest = project.layout.buildDirectory.dir('dummy-plugin')
+final recommendedImplPluginJar = tasks.register('recommendedImplPluginJar', Jar) {
+	from sourceSets.recommendedImplPlugin.output
+
+	archiveFileName = "recommended-impl-plugin.jar"
+	destinationDirectory = dummyPluginsDest
+}
+
+final pluginJarTask = tasks.register('preHandlingPluginJar', Jar) {
+	from sourceSets.preHandlingPlugin.output
+
+	archiveFileName = "pre-handling-plugin.jar"
+	destinationDirectory = dummyPluginsDest
+}
+
+final testPreHandlingPluginAgainstCurrentEnigma = tasks
+		.register('testPreHandlingPluginAgainstCurrentEnigma', JavaExec) { task ->
+	final projectVersion = project.version
+
+	inputs.property('projectVersion', projectVersion)
+
+	final cliShadowJarTask = project(':enigma-cli').tasks.named('shadowJar', Jar)
+	dependsOn(cliShadowJarTask, pluginJarTask)
+
+	final pluginJarFile = pluginJarTask.flatMap(Jar::getArchiveFile)
+	final cliShadowJar = cliShadowJarTask.flatMap(Jar::getArchiveFile)
+
+	inputs.files(cliShadowJar, pluginJarFile)
+
+	mainClass = 'org.quiltmc.enigma.command.Main'
+
+	classpath(cliShadowJar, pluginJarFile)
+
+	errorOutput new ByteArrayOutputStream()
+
+	ignoreExitValue true
+
+	doFirst {
+		args 'print-stats', pluginJarFile.get().asFile, pluginJarFile.get().asFile
+	}
+
+	doLast {
+		final err = errorOutput.toString()
+		if (!err.contains('Plugin was probably built using a pre-2.7 version of Enigma.')) {
+			throw new GradleException(
+				"""
+				PreHandlingPlugin did not fail as expected!
+					Error output:
+					${err}
+				""".stripIndent()
+			)
+		}
+	}
+}
+
+// copying, bumping, and jar-ing must all be one task because they all output to bumped-enigma-copy
+final copyBumpAndJarEnigma = tasks.register("copyBumpAndJarEnigma", Sync) {
+	inputs.property('projectVersion', project.version)
+
+	final destPath = 'bumped-enigma-copy'
+
+	from project.rootDir
+	into project.layout.buildDirectory.map { it.dir(destPath) }
+
+	final excludedProjectDirs = [ project(':enigma-server'), project(':enigma-swing') ]
+		.collect { it.projectDir }
+
+	final excludedPaths = [
+		'.git', '.github', '.gradle', '.idea', 'gradlew', 'gradlew.bat', 'gradle/wrapper',
+		'buildSrc/.gradle', 'buildSrc/build',
+		project.projectDir.toPath().resolve('src/dummyPlugin'),
+		project(':enigma-cli').projectDir.toPath().resolve('build')
+	].collect { rootProject.file(it) }
+
+	final Set<File> excluded = excludedProjectDirs + excludedPaths
+
+	exclude {
+		it.file in excluded
+	}
+
+	// This can't be done lazily in doFirst because it needs to be excluded when task dependencies are checked
+	// so the task doesn't depend on processDummyPluginResources.
+	exclude {
+		it.file in project.layout.buildDirectory.get().asFile
+	}
+
+	// already excluded whole build dir, but just in case: explicitly exclude dest dir to avoid copy recursion
+	exclude {
+		it.file in destinationDir
+	}
+
+	doFirst {
+		// prevent accidental task recursion
+		if (source.getElements().get().any { it.asFile.toPath().iterator().any { it.toString() == destPath } }) {
+			throw new GradleException("${name} cannot be run from its own copy!")
+		}
+	}
+
+	final projectRootDir = project.rootDir
+	doLast {
+		final dest = destinationDir.toPath()
+
+		// only bump minor version, don't bother resetting patch to 0
+		bumpCopyVersion(dest.resolve('build.gradle'), 'version', ~/(?m)^\s*version = '\d+.(\d+).\d+(?:\+.*)?'$/)
+		bumpCopyVersion(
+			dest.resolve('enigma/src/main/java/org/quiltmc/enigma/api/Enigma.java'),
+			'MINOR_VERSION', ~/(?m)^\s*public static final int MINOR_VERSION = (\d+);$/
+		)
+
+		// this causes the task to always be out-of-date
+		// copying gradle/wrapper, etc. and executing the copy instead did not help
+		EXEC.exec {
+			workingDir(destinationDir)
+
+			final executableName = System.properties['os.name'].toLowerCase().contains('windows')
+				? './gradlew.bat' : './gradlew'
+			executable(projectRootDir.toPath().resolve(executableName))
+			args ':enigma-cli:shadowJar'
+		}
+	}
+}
+
+static void bumpCopyVersion(java.nio.file.Path path, String variableName, Pattern pattern) {
+	final matcher = pattern.matcher(path.text)
+	if (matcher.find()) {
+		final firstStart = matcher.start()
+
+		final number = Integer.parseInt(matcher.group(1))
+
+		final numberStart = matcher.start(1)
+		final numberEnd = matcher.end(1)
+
+		if (matcher.find()) {
+			throw new GradleException(
+				"Found multiple occurences of ${variableName} in ${path.last()} at ${firstStart} and ${matcher.start()}!"
+			)
+		}
+
+		path.text = path.text.substring(0, numberStart) + (number + 1) + path.text.substring(numberEnd)
+	} else {
+		throw new GradleException("Failed to find ${variableName} in copy's ${path.last()}!")
+	}
+}
+
+final testRecommendedImplPluginAgainstBumpedEnigma = tasks
+		.register('testRecommendedImplPluginAgainstBumpedEnigma', JavaExec) {
+	final projectVersion = project.version
+
+	inputs.property('projectVersion', projectVersion)
+
+	final projectDir = project.projectDir
+	final libsDir = project.layout.buildDirectory.dir('libs')
+	final Provider<java.nio.file.Path> bumpedJarPath = copyBumpAndJarEnigma
+		.map(Sync::getDestinationDir)
+		.zip(libsDir) { bumpDest, libs ->
+			final relativeBuildLibs = projectDir.toPath().relativize(libs.asFile.toPath())
+			final copyBuildLibs = bumpDest.toPath().resolve('enigma-cli').resolve(relativeBuildLibs)
+
+			final bumpedJars = Files
+				.find(copyBuildLibs, 1) { path, attributes ->
+					!path.fileName.toString().endsWith("${projectVersion}-all.jar")
+						&& path.fileName.toString().endsWith('-all.jar')
+				}
+				.toList()
+
+			if (bumpedJars.isEmpty()) {
+				throw new GradleException('No bumped Enigma jar to run!')
+			} else if (bumpedJars.size() > 1) {
+				throw new GradleException('Multiple bumped Enigma jars found!')
+			} else {
+				return bumpedJars.first()
+			}
+		}
+
+	dependsOn(copyBumpAndJarEnigma, recommendedImplPluginJar)
+
+	final pluginJarFile = recommendedImplPluginJar.flatMap(Jar::getArchiveFile)
+
+	inputs.files(bumpedJarPath, pluginJarFile)
+
+	mainClass = 'org.quiltmc.enigma.command.Main'
+
+	classpath(bumpedJarPath, pluginJarFile)
+
+	errorOutput new ByteArrayOutputStream()
+
+	ignoreExitValue true
+
+	doFirst {
+		args 'print-stats', pluginJarFile.get().asFile, pluginJarFile.get().asFile
+	}
+
+	doLast {
+		final err = errorOutput.toString()
+		if (!err.contains('Plugin does not support Enigma ')) {
+			throw new GradleException(
+				"""
+				RecommendedImplPlugin did not fail as expected!
+					Error output:
+					${err}
+				""".stripIndent()
+			)
+		}
+	}
+}
+
+test.dependsOn(testPreHandlingPluginAgainstCurrentEnigma, testRecommendedImplPluginAgainstBumpedEnigma)
+
 publishing {
 	publications {
 		"$project.name"(MavenPublication) {

enigma/src/dummyPlugin/preHandlingPlugin/java/org/quiltmc/enigma/api/EnigmaPlugin.java

@@ -0,0 +1,8 @@
+package org.quiltmc.enigma.api;
+
+/**
+ * Copy of Enigma 2.6.2's EnigmaPlugin
+ */
+public interface EnigmaPlugin {
+	void init(EnigmaPluginContext ctx);
+}

enigma/src/dummyPlugin/preHandlingPlugin/java/org/quiltmc/enigma/api/EnigmaPluginContext.java

@@ -0,0 +1,7 @@
+package org.quiltmc.enigma.api;
+
+/**
+ * Copy of Enigma 2.6.2's EnigmaPluginContext with contents removed.
+ */
+public interface EnigmaPluginContext {
+}

enigma/src/dummyPlugin/preHandlingPlugin/java/org/quiltmc/internal/dummy_plugin/PreHandlingDummyEnigmaPlugin.java

@@ -0,0 +1,15 @@
+package org.quiltmc.internal.dummy_plugin;
+
+import org.quiltmc.enigma.api.EnigmaPluginContext;
+import org.quiltmc.enigma.api.EnigmaPlugin;
+
+/**
+ * A dummy plugin to be compiled against a (copied) pre-error-handling version of Enigma and run against
+ * a post-error-handling version.
+ */
+public class PreHandlingDummyEnigmaPlugin implements EnigmaPlugin {
+	@Override
+	public void init(EnigmaPluginContext ctx) {
+		throw new UnsupportedOperationException(PreHandlingDummyEnigmaPlugin.class.getSimpleName() + " initialized!");
+	}
+}

enigma/src/dummyPlugin/preHandlingPlugin/resources/META-INF/services/org.quiltmc.enigma.api.EnigmaPlugin

@@ -0,0 +1 @@
+org.quiltmc.internal.dummy_plugin.PreHandlingDummyEnigmaPlugin

enigma/src/dummyPlugin/recommendedImplPlugin/java/org/quiltmc/internal/dummy_plugin/RecommendedImplEnigmaPlugin.java

@@ -0,0 +1,33 @@
+package org.quiltmc.internal.dummy_plugin;
+
+import org.quiltmc.enigma.api.Enigma;
+import org.quiltmc.enigma.api.EnigmaPlugin;
+import org.quiltmc.enigma.api.EnigmaPluginContext;
+import org.quiltmc.enigma.util.Version;
+
+import javax.annotation.Nonnull;
+
+/**
+ * A dummy plugin to be compiled against the current Enigma version and run against the copied+bumped Enigma version
+ * generated by the build script to test the recommended {@link EnigmaPlugin#supportsEnigmaVersion(Version)}
+ * implementation.
+ */
+public class RecommendedImplEnigmaPlugin implements EnigmaPlugin {
+	public static final String NAME = "Recommended Implementation Enigma Plugin";
+
+	@Override
+	public void init(EnigmaPluginContext ctx) {
+		throw new UnsupportedOperationException(NAME + " initialized!");
+	}
+
+	@Override
+	public boolean supportsEnigmaVersion(@Nonnull Version enigmaVersion) {
+		return Enigma.MAJOR_VERSION == enigmaVersion.major()
+			&& Enigma.MINOR_VERSION == enigmaVersion.minor();
+	}
+
+	@Override
+	public String getName() {
+		return NAME;
+	}
+}

enigma/src/dummyPlugin/recommendedImplPlugin/resources/META-INF/services/org.quiltmc.enigma.api.EnigmaPlugin

@@ -0,0 +1 @@
+org.quiltmc.internal.dummy_plugin.RecommendedImplEnigmaPlugin