and then God said, let there be fish

- game can now be launched with Cichlid and mods can load
- reworked natives extraction again
- started work on the sushi artifact transform

Author: TropheusJ

build.gradle.kts

@@ -18,10 +18,8 @@ val mcVer = "1.17.1"
 
 dependencies {
     implementation(minecraft.client(mcVer))
-    // compile against Cichlid API
-//    compileOnly(cichlid.loaderApi("0.1.0"))
-    // run with full Cichlid
-//    runtimeOnly(cichlid.loader("0.1.0"))
+    compileOnly(cichlid.api("0.3.2"))
+    cichlidRuntime(cichlid.runtime("0.3.2"))
 }
 
 cichlid {

plugin/src/main/java/io/github/cichlidmc/cichlid_gradle/CichlidGradlePlugin.java

@@ -7,16 +7,22 @@
 import io.github.cichlidmc.cichlid_gradle.extension.repo.CichlidReposExtension;
 import io.github.cichlidmc.cichlid_gradle.extension.repo.MinecraftReposExtension;
 import io.github.cichlidmc.cichlid_gradle.run.RunTaskGeneration;
+import io.github.cichlidmc.cichlid_gradle.transform.TransformedAttribute;
+import org.gradle.api.NamedDomainObjectProvider;
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
+import org.gradle.api.artifacts.ConfigurationContainer;
 import org.gradle.api.artifacts.Dependency;
+import org.gradle.api.artifacts.DependencyScopeConfiguration;
 
 import java.util.Objects;
 
 public abstract class CichlidGradlePlugin implements Plugin<Project> {
 	public static final String NAME = "CichlidGradle";
 	public static final String VERSION = "1.0-SNAPSHOT";
 
+	public static final String CICHLID_CONFIGURATION = "cichlid";
+
 	@Override
 	public void apply(Project project) {
 		CichlidExtension.setup(project);
@@ -25,9 +31,13 @@ public void apply(Project project) {
 		CichlidDepsExtension.setup(project);
 		MinecraftDepsExtension.setup(project);
 		RunTaskGeneration.setup(project);
+		TransformedAttribute.setup(project);
+
+		ConfigurationContainer configurations = project.getConfigurations();
+		setupConfigurations(configurations);
 
 		// listen for all minecraft dependencies to ensure they're downloaded
-		project.getConfigurations().configureEach(
+		configurations.configureEach(
 				configuration -> configuration.getDependencies().configureEach(dep -> {
 					if (isMinecraftDependency(dep)) {
 						String version = Objects.requireNonNull(dep.getVersion());
@@ -38,6 +48,20 @@ public void apply(Project project) {
 		);
 	}
 
+	private static void setupConfigurations(ConfigurationContainer configurations) {
+		// configurations for Cichlid.
+		// you need one configuration for declaring dependencies and another extending it for resolution
+		NamedDomainObjectProvider<DependencyScopeConfiguration> cichlidRuntime = configurations.dependencyScope("cichlidRuntime");
+		// resolvable configuration is non-transitive so it only includes Cichlid itself
+		configurations.resolvable(CICHLID_CONFIGURATION, resolvable -> resolvable.extendsFrom(cichlidRuntime.get()).setTransitive(false));
+
+		// add Cichlid and its dependencies to the runtime classpath
+		configurations.named("runtimeClasspath", runtime -> runtime.extendsFrom(cichlidRuntime.get()));
+
+		// compile classpath must be transformed
+		configurations.named("compileClasspath", compile -> compile.getAttributes().attribute(TransformedAttribute.INSTANCE, true));
+	}
+
 	private static boolean isMinecraftDependency(Dependency dep) {
 		return "net.minecraft".equals(dep.getGroup())
 				&& CichlidCache.MINECRAFT_MODULES.contains(dep.getName())

plugin/src/main/java/io/github/cichlidmc/cichlid_gradle/cache/storage/NativesStorage.java

@@ -16,7 +16,7 @@ public class VersionStorage extends LockableStorage {
 
 	public final MappingsStorage mappings;
 	public final JarsStorage jars;
-	public final NativesStorage natives;
+	public final Path natives;
 	public final RunTemplateStorage runs;
 
 	public final Path completeMarker;
@@ -26,7 +26,7 @@ public VersionStorage(Path root, String version) {
 		this.version = version;
 		this.mappings = new MappingsStorage(root.resolve("mappings"));
 		this.jars = new JarsStorage(root.resolve("jars"), version);
-		this.natives = new NativesStorage(root.resolve("natives"));
+		this.natives = root.resolve("natives");
 		this.runs = new RunTemplateStorage(root.resolve("runs"));
 		this.completeMarker = root.resolve(COMPLETE_MARKER);
 	}

plugin/src/main/java/io/github/cichlidmc/cichlid_gradle/cache/storage/VersionStorage.java

@@ -44,7 +44,7 @@ public void doRun() throws IOException {
 		for (Asset asset : fullIndex.objects.values()) {
 			Path dest = this.storage.object(asset);
 			if (this.shouldDownload(asset, dest)) {
-				FileUtils.downloadSilently(asset, dest);
+				FileUtils.download(asset, dest);
 			}
 		}
 

plugin/src/main/java/io/github/cichlidmc/cichlid_gradle/cache/task/impl/AssetsTask.java

@@ -1,72 +1,82 @@
 package io.github.cichlidmc.cichlid_gradle.cache.task.impl;
 
-import io.github.cichlidmc.cichlid_gradle.cache.storage.NativesStorage;
 import io.github.cichlidmc.cichlid_gradle.cache.task.CacheTask;
 import io.github.cichlidmc.cichlid_gradle.cache.task.TaskContext;
 import io.github.cichlidmc.cichlid_gradle.util.FileUtils;
-import io.github.cichlidmc.cichlid_gradle.util.IterableStream;
 import io.github.cichlidmc.pistonmetaparser.FullVersion;
+import io.github.cichlidmc.pistonmetaparser.version.library.Artifact;
 import io.github.cichlidmc.pistonmetaparser.version.library.Classifier;
 import io.github.cichlidmc.pistonmetaparser.version.library.Library;
 import io.github.cichlidmc.pistonmetaparser.version.library.Natives;
 
 import java.io.IOException;
 import java.nio.file.FileSystem;
 import java.nio.file.FileSystems;
+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.Optional;
 
 public class ExtractNativesTask extends CacheTask {
 	public static final String TEMP_JAR = "temp-jar-for-extracting.jar";
 
-	private final NativesStorage storage;
+	private final Path path;
 	private final FullVersion version;
 
-	protected ExtractNativesTask(TaskContext context, NativesStorage storage, FullVersion version) {
+	protected ExtractNativesTask(TaskContext context, Path path, FullVersion version) {
 		super("ExtractNatives", "Extract native dependencies", context);
-		this.storage = storage;
+		this.path = path;
 		this.version = version;
 	}
 
 	@Override
 	protected void doRun() throws IOException {
-		Path folder = this.storage.folder(this.version.id);
-
 		for (Library library : this.version.libraries) {
+			if (library.artifact.isPresent()) {
+				this.downloadAndExtract(library.artifact.get());
+			}
+
 			Optional<Classifier> maybeClassifier = library.natives.flatMap(Natives::choose);
 			if (maybeClassifier.isPresent()) {
 				Classifier classifier = maybeClassifier.get();
-				this.downloadAndExtract(classifier, folder);
+				this.downloadAndExtract(classifier.artifact);
 			}
 		}
 	}
 
-	private void downloadAndExtract(Classifier classifier, Path folder) throws IOException {
-		Path tempJar = folder.resolve(TEMP_JAR);
-		FileUtils.downloadSilently(classifier.artifact, tempJar);
+	// note: rd-20090515 has the exact same jinput dependency twice for some reason, and is probably not the only weird one.
+	// this information isn't really relevant after some refactoring, but it's good to keep it around.
+	private void downloadAndExtract(Artifact artifact) throws IOException {
+		Path tempJar = this.path.resolve(TEMP_JAR);
+		FileUtils.downloadSilently(artifact, tempJar);
 
 		try (FileSystem fs = FileSystems.newFileSystem(tempJar)) {
 			// jar should have 1 root
 			Path root = fs.getRootDirectories().iterator().next();
-			try (IterableStream<Path> files = new IterableStream<>(Files.list(root))) {
-				for (Path file : files) {
+			Files.walkFileTree(root, new SimpleFileVisitor<>() {
+				@Override
+				public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
 					// the version manifest specifies files that should be excluded from extraction,
 					// but it's undocumented and a pain to handle, and it doesn't even matter in the end
 					// as far as I can tell. The only relevant case is META-INF, which needs to be skipped
 					// to avoid duplicates. META-INF also seems to be the only thing ever specified
 					// as an exclusion, so it makes sense.
+					// class files are also skipped, since we're just extracting the entire jar. Cuts out most files.
 					String fileName = file.getFileName().toString();
-					if (!fileName.endsWith("META-INF")) {
-						Path dest = folder.resolve(fileName);
-						// rd-20090515 has the exact same jinput dependency twice for some reason.
-						// it's probably not the only weird one.
+					if (!fileName.endsWith("META-INF") && !fileName.endsWith(".class")) {
+						Path relative = root.relativize(file);
+						Path dest = ExtractNativesTask.this.path.resolve(relative.toString());
 						if (!Files.exists(dest)) {
+							Files.createDirectories(dest.getParent());
 							Files.copy(file, dest);
 						}
 					}
+
+					return FileVisitResult.CONTINUE;
 				}
-			}
+			});
 		}
 
 		Files.delete(tempJar);

plugin/src/main/java/io/github/cichlidmc/cichlid_gradle/cache/task/impl/ExtractNativesTask.java

@@ -2,30 +2,39 @@
 
 import org.gradle.api.Project;
 import org.gradle.api.artifacts.Dependency;
-import org.gradle.api.artifacts.dsl.DependencyHandler;
+import org.gradle.api.artifacts.ExternalModuleDependency;
+import org.gradle.api.artifacts.dsl.DependencyFactory;
 
 public class CichlidDepsExtension {
 	// can't use managed properties - https://github.com/gradle/gradle/issues/18213
-	private final DependencyHandler deps;
+	private final DependencyFactory factory;
 
-    private CichlidDepsExtension(DependencyHandler deps) {
-        this.deps = deps;
+    private CichlidDepsExtension(DependencyFactory factory) {
+        this.factory = factory;
     }
 
-    public Dependency loader(String version) {
-		return this.deps.create("io.github.cichlidmc:cichlid:" + version);
+    public ExternalModuleDependency runtime(String version) {
+		return this.factory.create("io.github.cichlidmc", "cichlid", version);
 	}
 
-	public Dependency loaderApi(String version) {
-		return this.deps.create("io.github.cichlidmc:cichlid:" + version + ":api");
+	public ExternalModuleDependency api(String version) {
+		ExternalModuleDependency dep = this.runtime(version);
+		dep.capabilities(handler -> handler.requireCapability("io.github.cichlidmc:cichlid-mod-api"));
+		return dep;
 	}
 
-	public Dependency devPlugin(String version) {
-		return this.deps.create("io.github.cichlidmc:dev-plugin:" + version);
+	public ExternalModuleDependency pluginApi(String version) {
+		ExternalModuleDependency dep = this.runtime(version);
+		dep.capabilities(handler -> handler.requireCapability("io.github.cichlidmc:cichlid-plugin-api"));
+		return dep;
+	}
+
+	public Dependency cichlibs(String version) {
+		return this.factory.create("io.github.cichlidmc:cichlibs:" + version);
 	}
 
 	public static void setup(Project project) {
-		CichlidDepsExtension mc = new CichlidDepsExtension(project.getDependencies());
+		CichlidDepsExtension mc = new CichlidDepsExtension(project.getDependencyFactory());
 		project.getDependencies().getExtensions().add("cichlid", mc);
 	}
 }

plugin/src/main/java/io/github/cichlidmc/cichlid_gradle/extension/dep/CichlidDepsExtension.java

@@ -1,8 +1,10 @@
 package io.github.cichlidmc.cichlid_gradle.extension.repo;
 
 import io.github.cichlidmc.cichlid_gradle.cache.CichlidCache;
+import org.gradle.api.Action;
 import org.gradle.api.Project;
 import org.gradle.api.artifacts.dsl.RepositoryHandler;
+import org.gradle.api.artifacts.repositories.MavenArtifactRepository;
 import org.gradle.api.plugins.ExtensionAware;
 
 import java.net.URI;
@@ -14,10 +16,15 @@ private MinecraftReposExtension(Project project) {
         this.project = project;
     }
 
-    public void libraries() {
-        this.project.getRepositories().maven(repo -> {
+    public MavenArtifactRepository libraries() {
+        return this.libraries(repo -> {});
+    }
+
+    public MavenArtifactRepository libraries(Action<? super MavenArtifactRepository> action) {
+        return this.project.getRepositories().maven(repo -> {
             repo.setName("Minecraft Libraries");
             repo.setUrl(URI.create("https://libraries.minecraft.net/"));
+            action.execute(repo);
         });
     }
 

plugin/src/main/java/io/github/cichlidmc/cichlid_gradle/extension/repo/MinecraftReposExtension.java

@@ -1,10 +1,12 @@
 package io.github.cichlidmc.cichlid_gradle.run;
 
+import io.github.cichlidmc.cichlid_gradle.CichlidGradlePlugin;
 import io.github.cichlidmc.cichlid_gradle.cache.CichlidCache;
 import io.github.cichlidmc.cichlid_gradle.cache.storage.VersionStorage;
 import io.github.cichlidmc.cichlid_gradle.extension.CichlidExtension;
 import io.github.cichlidmc.cichlid_gradle.util.ListPatch;
 import org.gradle.api.Project;
+import org.gradle.api.artifacts.Configuration;
 import org.gradle.api.provider.Property;
 import org.gradle.api.provider.Provider;
 import org.gradle.api.tasks.JavaExec;
@@ -59,10 +61,13 @@ private static void generateTask(RunConfiguration config, CichlidCache cache, Pr
 			task.setWorkingDir(runDir);
 			task.doFirst($ -> runDir.mkdirs());
 
+			Configuration cichlid = project.getConfigurations().getByName(CichlidGradlePlugin.CICHLID_CONFIGURATION);
+			for (File agent : cichlid.getFiles()) {
+				task.jvmArgs("-javaagent:" + agent.getAbsolutePath() + "=dist=" + templateName + ",version=" + version);
+			}
+
 			Placeholders.DynamicContext ctx = new Placeholders.DynamicContext(
-					runDir.toPath(),
-					versionCache.natives.root,
-					cache.assets.root
+					runDir.toPath(), versionCache.natives, cache.assets.root
 			);
 			task.args(getArgs(config.getProgramArgs(), template.programArgs(), ctx));
 			task.jvmArgs(getArgs(config.getJvmArgs(), template.jvmArgs(), ctx));

plugin/src/main/java/io/github/cichlidmc/cichlid_gradle/run/RunTaskGeneration.java

@@ -0,0 +1,60 @@
+package io.github.cichlidmc.cichlid_gradle.transform;
+
+import org.gradle.api.artifacts.transform.InputArtifact;
+import org.gradle.api.artifacts.transform.InputArtifactDependencies;
+import org.gradle.api.artifacts.transform.TransformAction;
+import org.gradle.api.artifacts.transform.TransformOutputs;
+import org.gradle.api.artifacts.transform.TransformParameters;
+import org.gradle.api.file.FileCollection;
+import org.gradle.api.file.FileSystemLocation;
+import org.gradle.api.logging.Logger;
+import org.gradle.api.logging.Logging;
+import org.gradle.api.provider.Provider;
+import org.gradle.api.tasks.PathSensitive;
+import org.gradle.api.tasks.PathSensitivity;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+
+// @CacheableTransform
+public abstract class SushiTransformAction implements TransformAction<TransformParameters.None> {
+	private static final Logger logger = Logging.getLogger(SushiTransformAction.class);
+
+	@InputArtifact
+	@PathSensitive(PathSensitivity.NAME_ONLY)
+	public abstract Provider<FileSystemLocation> getInput();
+
+	@InputArtifactDependencies
+	@PathSensitive(PathSensitivity.NAME_ONLY)
+	public abstract FileCollection getDependencies();
+
+	@Override
+	public void transform(TransformOutputs outputs) {
+		File file = this.getInput().get().getAsFile();
+		String name = file.getName();
+
+		if (!name.endsWith(".jar") || true) {
+			File output = outputs.file(file);
+			copy(file, output);
+			return;
+		}
+
+		logger.quiet("transformed " + name);
+		for (File dep : getDependencies()) {
+			logger.quiet("\t- " + dep.getName());
+		}
+
+		String newName = name.replace(".jar", "-transformed.jar");
+		File output = outputs.file(newName);
+		copy(file, output);
+	}
+
+	private static void copy(File from, File to) {
+		try {
+			Files.copy(from.toPath(), to.toPath());
+		} catch (IOException e) {
+			throw new RuntimeException(e);
+		}
+	}
+}