Minecraft: noun

WIP work towards source transforms, featuring MinecraftDefinition

Author: TropheusJ

build.gradle.kts

@@ -14,23 +14,25 @@ repositories {
     minecraft.versions()
 }
 
-val mcVer = "1.21.5"
+val mc by minecraft.creating {
+    version = "1.21.5"
+}
 
 dependencies {
-    implementation(minecraft.of {
-        client()
-        version(mcVer)
-    })
+    println("adding dependencies")
+    mc.transformer(fileTree("src/main/resources/transformers"))
+
+    implementation(mc.dependency)
 
     compileOnly(cichlid.api("0.3.2"))
     cichlidRuntime(cichlid.runtime("0.3.2"))
 }
 
 cichlid {
     runs {
-        register("client") {
-            version = mcVer
-        }
+//        register("client") {
+//            version = mcVer
+//        }
 //        register("client 1.21.4") {
 //            version = "1.21.4"
 //            template = "client"

gradle.properties

@@ -1,4 +1,5 @@
 org.gradle.jvmargs = -Xmx8G
 org.gradle.caching=true
 org.gradle.configuration-cache=true
-cichlid.use_project_cache=true
+#org.gradle.unsafe.isolated-projects=true
+cichlid.use_local_cache=true

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.14-rc-3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.14-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

plugin/src/main/java/fish/cichlidmc/cichlid_gradle/CichlidGradlePlugin.java

@@ -3,19 +3,34 @@
 import fish.cichlidmc.cichlid_gradle.cache.CichlidCache;
 import fish.cichlidmc.cichlid_gradle.cache.mcmaven.McMavenConnectorFactory;
 import fish.cichlidmc.cichlid_gradle.extension.CichlidExtension;
+import fish.cichlidmc.cichlid_gradle.extension.def.MinecraftDefinition;
+import fish.cichlidmc.cichlid_gradle.extension.def.MinecraftDefinitionImpl;
 import fish.cichlidmc.cichlid_gradle.extension.dep.CichlidDepsExtension;
-import fish.cichlidmc.cichlid_gradle.extension.dep.MinecraftDepsExtension;
 import fish.cichlidmc.cichlid_gradle.extension.repo.CichlidReposExtension;
 import fish.cichlidmc.cichlid_gradle.extension.repo.MinecraftReposExtension;
 import fish.cichlidmc.cichlid_gradle.run.RunTaskGeneration;
+import fish.cichlidmc.cichlid_gradle.util.Utils;
+import org.gradle.api.Action;
+import org.gradle.api.NamedDomainObjectContainer;
 import org.gradle.api.NamedDomainObjectProvider;
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
+import org.gradle.api.artifacts.Configuration;
 import org.gradle.api.artifacts.ConfigurationContainer;
+import org.gradle.api.artifacts.Dependency;
 import org.gradle.api.artifacts.DependencyScopeConfiguration;
+import org.gradle.api.artifacts.ModuleIdentifier;
+import org.gradle.api.internal.artifacts.cache.ArtifactResolutionControl;
+import org.gradle.api.internal.artifacts.cache.ModuleResolutionControl;
+import org.gradle.api.internal.artifacts.configurations.ResolutionStrategyInternal;
+import org.gradle.api.internal.artifacts.ivyservice.resolutionstrategy.DefaultCachePolicy;
 import org.gradle.api.internal.artifacts.repositories.transport.RepositoryTransportFactory;
+import org.jetbrains.annotations.Nullable;
 
 import javax.inject.Inject;
+import java.lang.reflect.Field;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
 
 public class CichlidGradlePlugin implements Plugin<Project> {
 	public static final String NAME = "CichlidGradle";
@@ -36,16 +51,17 @@ public void apply(Project project) {
 		CichlidReposExtension.setup(project);
 		MinecraftReposExtension.setup(project);
 		CichlidDepsExtension.setup(project);
-		MinecraftDepsExtension.setup(project);
 		RunTaskGeneration.setup(project);
+		MinecraftDefinition.setup(project);
 
-		ConfigurationContainer configurations = project.getConfigurations();
-		setupConfigurations(configurations);
+		setupConfigurations(project);
 
-		McMavenConnectorFactory.inject(this.repositoryTransportFactory, CichlidCache.get(project));
+		McMavenConnectorFactory.inject(this.repositoryTransportFactory, project);
 	}
 
-	private static void setupConfigurations(ConfigurationContainer configurations) {
+	private static void setupConfigurations(Project project) {
+		ConfigurationContainer configurations = project.getConfigurations();
+
 		// configurations for Cichlid.
 		// you need one configuration for declaring dependencies and another extending it for resolution
 		NamedDomainObjectProvider<DependencyScopeConfiguration> cichlidRuntime = configurations.dependencyScope("cichlidRuntime");
@@ -54,5 +70,81 @@ private static void setupConfigurations(ConfigurationContainer configurations) {
 
 		// add Cichlid and its dependencies to the runtime classpath
 		configurations.named("runtimeClasspath", runtime -> runtime.extendsFrom(cichlidRuntime.get()));
+
+		// minecraft dependencies are set as changing so the current transformers are always applied.
+		// we need to set its cache duration to 0, but gradle API only allows you to do that per-configuration.
+		// it's possible with some internals though.
+		configurations.configureEach(CichlidGradlePlugin::disableMinecraftCaching);
+
+		// if we try to resolve transformers for the first time in the mcmaven, an error
+		// is thrown because the current thread is already resolving a configuration,
+		// so we need to resolve them right before they're actually needed.
+
+		NamedDomainObjectContainer<MinecraftDefinition> defs = MinecraftDefinition.getExtension(project);
+
+		// for each configuration, right before resolution:
+		// - check if any dependencies are Minecraft
+		// - if so, find the corresponding definition
+		// - if it exists, resolve its transformers
+		configurations.configureEach(configuration -> configuration.getIncoming().beforeResolve(resolvable -> {
+			for (Dependency dep : resolvable.getDependencies()) {
+				if (!isMinecraft(dep))
+					continue;
+
+				String defName = dep.getVersion();
+				if (defName == null)
+					continue;
+
+				MinecraftDefinitionImpl def = (MinecraftDefinitionImpl) defs.findByName(defName);
+				if (def == null)
+					continue;
+
+				// call iterator to make sure they're actually resolved
+				def.resolvableTransformers().getIncoming().getFiles().iterator();
+			}
+		}));
+	}
+
+	private static void disableMinecraftCaching(Configuration configuration) {
+		try {
+			ResolutionStrategyInternal strategy = (ResolutionStrategyInternal) configuration.getResolutionStrategy();
+			DefaultCachePolicy policy = (DefaultCachePolicy) strategy.getCachePolicy();
+
+			Field moduleCacheRulesField = DefaultCachePolicy.class.getDeclaredField("moduleCacheRules");
+			moduleCacheRulesField.setAccessible(true);
+			Field artifactCacheRulesField = DefaultCachePolicy.class.getDeclaredField("artifactCacheRules");
+			artifactCacheRulesField.setAccessible(true);
+
+			List<Action<? super ModuleResolutionControl>> moduleCacheRules = Utils.get(moduleCacheRulesField, policy);
+			List<Action<? super ArtifactResolutionControl>> artifactCacheRules = Utils.get(artifactCacheRulesField, policy);
+
+			// add to the ends of the lists to get final say.
+			// gradle conveniently adds to the front.
+
+			moduleCacheRules.add(control -> {
+				if (isMinecraft(control.getRequest().getModule())) {
+					control.cacheFor(0, TimeUnit.SECONDS);
+				}
+			});
+			artifactCacheRules.add(control -> {
+				if (isMinecraft(control.getRequest().getId().getComponentIdentifier().getModuleIdentifier())) {
+					control.cacheFor(0, TimeUnit.SECONDS);
+				}
+			});
+		} catch (Throwable t) {
+			throw new RuntimeException("Error accessing Gradle internals! You probably need to update Gradle, CichlidGradle, or both", t);
+		}
+	}
+
+	private static boolean isMinecraft(ModuleIdentifier id) {
+		return isMinecraft(id.getGroup(), id.getName());
+	}
+
+	private static boolean isMinecraft(Dependency dep) {
+		return isMinecraft(dep.getGroup(), dep.getName());
+	}
+
+	private static boolean isMinecraft(@Nullable String group, @Nullable String module) {
+		return CichlidCache.MINECRAFT_GROUP.equals(group) && CichlidCache.MINECRAFT_MODULE.equals(module);
 	}
 }

plugin/src/main/java/fish/cichlidmc/cichlid_gradle/cache/CichlidCache.java

@@ -6,10 +6,10 @@
 import fish.cichlidmc.pistonmetaparser.FullVersion;
 import fish.cichlidmc.pistonmetaparser.manifest.Version;
 import org.gradle.api.Project;
+import org.gradle.api.invocation.Gradle;
 
 import java.nio.file.Path;
 import java.util.Objects;
-import java.util.Set;
 
 /**
  * Interface for Cichlid's global Minecraft cache. Holds no state, just interfaces with the filesystem.
@@ -37,13 +37,10 @@
  * </ul>
  */
 public final class CichlidCache {
-	// pattern is relative to root
 	public static final String MINECRAFT_GROUP = "net.minecraft";
-	public static final Set<String> MINECRAFT_MODULES = Set.of(
-			"minecraft-client", "minecraft-server", "minecraft-merged", "minecraft-bundler"
-	);
+	public static final String MINECRAFT_MODULE = "minecraft";
 
-	public static final String PROJECT_CACHE_PROPERTY = "cichlid.use_project_cache";
+	public static final String LOCAL_CACHE_PROPERTY = "cichlid.use_local_cache";
 	public static final int FORMAT = 1;
 	public static final String PATH = "cichlid-gradle-cache/v" + FORMAT;
 
@@ -94,10 +91,11 @@ public static Path getPath(Project project) {
 	}
 
 	private static Path getGradleCache(Project project) {
-		if (Objects.equals(project.findProperty(PROJECT_CACHE_PROPERTY), "true")) {
-			return project.file(".gradle").toPath();
+		Gradle gradle = project.getGradle();
+		if (Objects.equals(project.findProperty(LOCAL_CACHE_PROPERTY), "true")) {
+			return gradle.getRootProject().file(".gradle").toPath();
 		} else {
-			return project.getGradle().getGradleUserHomeDir().toPath().resolve("caches");
+			return gradle.getGradleUserHomeDir().toPath().resolve("caches");
 		}
 	}
 }

plugin/src/main/java/fish/cichlidmc/cichlid_gradle/cache/mcmaven/McMavenConnectorFactory.java

@@ -1,6 +1,10 @@
 package fish.cichlidmc.cichlid_gradle.cache.mcmaven;
 
 import fish.cichlidmc.cichlid_gradle.cache.CichlidCache;
+import fish.cichlidmc.cichlid_gradle.extension.def.MinecraftDefinition;
+import org.gradle.api.InvalidUserDataException;
+import org.gradle.api.NamedDomainObjectContainer;
+import org.gradle.api.Project;
 import org.gradle.api.internal.artifacts.repositories.transport.RepositoryTransportFactory;
 import org.gradle.authentication.Authentication;
 import org.gradle.internal.resource.connector.ResourceConnectorFactory;
@@ -9,21 +13,26 @@
 import org.gradle.internal.resource.transfer.ExternalResourceConnector;
 
 import java.lang.reflect.Field;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
 public final class McMavenConnectorFactory implements ResourceConnectorFactory {
-	public static final Set<String> PROTOCOLS = Set.of(MinecraftMaven.PROTOCOL);
+	public final String protocol;
+	private final ExternalResourceConnector connector;
 
-	private final CichlidCache cache;
-
-	public McMavenConnectorFactory(CichlidCache cache) {
-		this.cache = cache;
+	public McMavenConnectorFactory(String protocol, MinecraftMaven mcMaven) {
+		this.protocol = protocol;
+		this.connector = new DefaultExternalResourceConnector(
+				new McMavenResourceAccessor(mcMaven),
+				NoOpResourceLister.INSTANCE,
+				NoOpUploader.INSTANCE
+		);
 	}
 
 	@Override
 	public Set<String> getSupportedProtocols() {
-		return PROTOCOLS;
+		return Set.of(this.protocol);
 	}
 
 	@Override
@@ -33,27 +42,45 @@ public Set<Class<? extends Authentication>> getSupportedAuthentication() {
 
 	@Override
 	public ExternalResourceConnector createResourceConnector(ResourceConnectorSpecification connectionDetails) {
-		return new DefaultExternalResourceConnector(
-				new McMavenResourceAccessor(this.cache),
-				NoOpResourceLister.INSTANCE,
-				NoOpUploader.INSTANCE
-		);
+		return this.connector;
 	}
 
 	// built-in implementations use ServiceLoader, but that only works for Gradle modules.
-	public static void inject(RepositoryTransportFactory factory, CichlidCache cache) {
+	// a new one is registered for each project anyway. Each has a unique protocol based on project path.
+	public static void inject(RepositoryTransportFactory factory, Project project) {
+		List<ResourceConnectorFactory> list = extractFactories(factory);
+		Set<String> protocols = collectProtocols(list);
+
+		String protocol = MinecraftMaven.createProtocol(project);
+		if (protocols.contains(protocol)) {
+			throw new InvalidUserDataException("Multiple projects generate the URI protocol '" + protocol + "', including " + project.getPath());
+		}
+
+		CichlidCache cache = CichlidCache.get(project);
+		NamedDomainObjectContainer<MinecraftDefinition> defs = MinecraftDefinition.getExtension(project);
+		MinecraftMaven mcMaven = new MinecraftMaven(defs, cache);
+
+		list.add(new McMavenConnectorFactory(protocol, mcMaven));
+	}
+
+	@SuppressWarnings("unchecked")
+	private static List<ResourceConnectorFactory> extractFactories(RepositoryTransportFactory factory) {
 		try {
 			Field registeredProtocols = RepositoryTransportFactory.class.getDeclaredField("registeredProtocols");
 			registeredProtocols.setAccessible(true);
-			@SuppressWarnings("unchecked")
-			List<ResourceConnectorFactory> list = (List<ResourceConnectorFactory>) registeredProtocols.get(factory);
-			// don't add if it already exists
-			if (list.stream().anyMatch(f -> f instanceof McMavenConnectorFactory))
-				return;
-
-			list.add(new McMavenConnectorFactory(cache));
-		} catch (ReflectiveOperationException e) {
+			return (List<ResourceConnectorFactory>) registeredProtocols.get(factory);
+		} catch (ReflectiveOperationException | ClassCastException e) {
 			throw new RuntimeException("Error accessing Gradle internals! You probably need to update Gradle, CichlidGradle, or both", e);
 		}
 	}
+
+	private static Set<String> collectProtocols(List<ResourceConnectorFactory> factories) {
+		Set<String> protocols = new HashSet<>();
+		for (ResourceConnectorFactory factory : factories) {
+			if (factory instanceof McMavenConnectorFactory mcMavenFactory) {
+				protocols.add(mcMavenFactory.protocol);
+			}
+		}
+		return protocols;
+	}
 }

plugin/src/main/java/fish/cichlidmc/cichlid_gradle/cache/mcmaven/McMavenResourceAccessor.java

@@ -1,6 +1,5 @@
 package fish.cichlidmc.cichlid_gradle.cache.mcmaven;
 
-import fish.cichlidmc.cichlid_gradle.cache.CichlidCache;
 import fish.cichlidmc.cichlid_gradle.util.FileUtils;
 import org.gradle.api.resources.ResourceException;
 import org.gradle.internal.hash.HashCode;
@@ -22,8 +21,8 @@
 public final class McMavenResourceAccessor implements ExternalResourceAccessor {
 	private final MinecraftMaven mcMaven;
 
-	public McMavenResourceAccessor(CichlidCache cache) {
-		this.mcMaven = new MinecraftMaven(cache);
+	public McMavenResourceAccessor(MinecraftMaven mcMaven) {
+		this.mcMaven = mcMaven;
 	}
 
 	@Nullable