refactor reading/writing into plugins

build.gradle

@@ -6,9 +6,6 @@ subprojects {
 	apply plugin: 'java'
 	apply plugin: 'maven-publish'
 
-	sourceCompatibility = JavaVersion.VERSION_17
-	targetCompatibility = JavaVersion.VERSION_17
-
 	repositories {
 		mavenLocal()
 		mavenCentral()
@@ -33,6 +30,7 @@ subprojects {
 
 		testImplementation libs.junit
 		testRuntimeOnly libs.junit.engine
+		testRuntimeOnly libs.junit.launcher
 		testImplementation libs.hamcrest
 	}
 
@@ -44,6 +42,8 @@ subprojects {
 
 	java {
 		withSourcesJar()
+		sourceCompatibility = JavaVersion.VERSION_17
+		targetCompatibility = JavaVersion.VERSION_17
 	}
 
 	tasks.withType(JavaCompile).configureEach {

enigma-cli/build.gradle

@@ -9,9 +9,10 @@ dependencies {
 	testImplementation(testFixtures(project(':enigma')))
 }
 
-mainClassName = 'org.quiltmc.enigma.command.Main'
-
-jar.manifest.attributes 'Main-Class': mainClassName
+application {
+	mainClass = 'org.quiltmc.enigma.command.Main'
+	jar.manifest.attributes 'Main-Class': mainClass
+}
 
 publishing {
 	publications {

enigma-cli/src/main/java/org/quiltmc/enigma/command/Argument.java

@@ -17,18 +17,6 @@ public enum Argument {
 		"""
 				A path to the right file or folder to read mappings from, used in commands which take two mapping inputs."""
 	),
-	OUTPUT_MAPPING_FORMAT("<output-mapping-format>",
-		"""
-				The mapping format to use when writing output mappings. Allowed values are (case-insensitive):
-				- TINY_V2:from_namespace:to_namespace (ex: tiny_v2:intermediary:named)
-				- ENIGMA_FILE
-				- ENIGMA_DIRECTORY
-				- ENIGMA_ZIP
-				- SRG_FILE
-				- RECAF
-
-				Proguard is not a valid output format, as writing is unsupported."""
-	),
 	MAPPING_OUTPUT("<mapping-output>",
 		"""
 				A path to the file or folder to write mappings to. Will be created if missing."""
@@ -60,6 +48,14 @@ The decompiler to use when producing output. Allowed values are (case-insensitiv
 	ENIGMA_PROFILE("<enigma-profile>",
 		"""
 				A path to an Enigma profile JSON file, used to apply things like plugins."""
+	),
+	OBFUSCATED_NAMESPACE("<obfuscated-namespace>",
+		"""
+				The namespace to use for obfuscated names when writing mappings. Only used in certain mapping formats."""
+	),
+	DEOBFUSCATED_NAMESPACE("<deobfuscated-namespace>",
+		"""
+				The namespace to use for deobfuscated names when writing mappings. Only used in certain mapping formats."""
 	);
 
 	private final String displayForm;

enigma-cli/src/main/java/org/quiltmc/enigma/command/CheckMappingsCommand.java

@@ -13,7 +13,8 @@
 public class CheckMappingsCommand extends Command {
 	public CheckMappingsCommand() {
 		super(Argument.INPUT_JAR.required(),
-				Argument.INPUT_MAPPINGS.required());
+				Argument.INPUT_MAPPINGS.required()
+		);
 	}
 
 	@Override

enigma-cli/src/main/java/org/quiltmc/enigma/command/Command.java

@@ -12,7 +12,7 @@
 import org.quiltmc.enigma.api.translation.mapping.EntryMapping;
 import org.quiltmc.enigma.api.translation.mapping.MappingDelta;
 import org.quiltmc.enigma.api.translation.mapping.serde.MappingParseException;
-import org.quiltmc.enigma.api.translation.mapping.serde.MappingFormat;
+import org.quiltmc.enigma.api.translation.mapping.serde.MappingsReader;
 import org.quiltmc.enigma.api.translation.mapping.tree.DeltaTrackingTree;
 import org.quiltmc.enigma.api.translation.mapping.tree.EntryTree;
 import org.tinylog.Logger;
@@ -123,7 +123,7 @@ public static Enigma createEnigma() {
 	 * @return the argument, as a string
 	 */
 	protected String getArg(String[] args, int index) {
-		if (index < this.allArguments.size()) {
+		if (index < this.allArguments.size() && index >= 0) {
 			return getArg(args, index, this.allArguments.get(index));
 		} else {
 			throw new RuntimeException("arg index is outside of range of possible arguments! (index: " + index + ", allowed arg count: " + this.allArguments.size() + ")");
@@ -153,17 +153,17 @@ public static EnigmaProject openProject(Path fileJarIn, Path fileMappings, Enigm
 		if (fileMappings != null) {
 			Logger.info("Reading mappings...");
 
-			EntryTree<EntryMapping> mappings = readMappings(fileMappings, progress);
+			EntryTree<EntryMapping> mappings = readMappings(enigma, fileMappings, progress);
 
 			project.setMappings(mappings, new ConsoleProgressListener());
 		}
 
 		return project;
 	}
 
-	protected static EntryTree<EntryMapping> readMappings(Path path, ProgressListener progress) throws MappingParseException, IOException {
-		MappingFormat format = MappingFormat.parseFromFile(path);
-		return format.read(path, progress);
+	protected static EntryTree<EntryMapping> readMappings(Enigma enigma, Path path, ProgressListener progress) throws MappingParseException, IOException {
+		MappingsReader reader = CommandsUtil.getReader(enigma, path);
+		return reader.read(path, progress);
 	}
 
 	protected static File getWritableFile(String path) {

enigma-cli/src/main/java/org/quiltmc/enigma/command/CommandsUtil.java

@@ -0,0 +1,39 @@
+package org.quiltmc.enigma.command;
+
+import org.quiltmc.enigma.api.Enigma;
+import org.quiltmc.enigma.api.service.ReadWriteService;
+import org.quiltmc.enigma.api.translation.mapping.serde.MappingsReader;
+import org.quiltmc.enigma.api.translation.mapping.serde.MappingsWriter;
+
+import java.nio.file.Path;
+
+public class CommandsUtil {
+	public static ReadWriteService getReadWriteService(Enigma enigma, Path file) {
+		var service = enigma.getReadWriteService(file);
+		if (service.isEmpty()) {
+			throw new UnsupportedOperationException("No reader/writer found for file \"" + file + "\"");
+		}
+
+		return service.get();
+	}
+
+	public static MappingsReader getReader(Enigma enigma, Path file) {
+		ReadWriteService service = getReadWriteService(enigma, file);
+
+		if (!service.supportsReading()) {
+			throw new UnsupportedOperationException("Read/write service for file \"" + file + "\" does not support reading!");
+		}
+
+		return service;
+	}
+
+	public static MappingsWriter getWriter(Enigma enigma, Path file) {
+		ReadWriteService service = getReadWriteService(enigma, file);
+
+		if (!service.supportsWriting()) {
+			throw new UnsupportedOperationException("Read/write service for file \"" + file + "\" does not support writing!");
+		}
+
+		return service;
+	}
+}

enigma-cli/src/main/java/org/quiltmc/enigma/command/ComposeMappingsCommand.java

@@ -1,8 +1,8 @@
 package org.quiltmc.enigma.command;
 
 import org.quiltmc.enigma.api.ProgressListener;
+import org.quiltmc.enigma.api.translation.mapping.serde.MappingsReader;
 import org.quiltmc.enigma.util.MappingOperations;
-import org.quiltmc.enigma.api.translation.mapping.serde.MappingFormat;
 import org.quiltmc.enigma.api.translation.mapping.serde.MappingParseException;
 import org.quiltmc.enigma.api.translation.mapping.EntryMapping;
 import org.quiltmc.enigma.api.translation.mapping.serde.MappingFileNameFormat;
@@ -11,27 +11,29 @@
 import org.quiltmc.enigma.api.translation.mapping.tree.EntryTree;
 import org.quiltmc.enigma.util.Utils;
 
+import javax.annotation.Nullable;
 import java.io.IOException;
 import java.nio.file.Path;
 
 public class ComposeMappingsCommand extends Command {
 	public ComposeMappingsCommand() {
 		super(Argument.LEFT_MAPPINGS.required(),
 				Argument.RIGHT_MAPPINGS.required(),
-				Argument.OUTPUT_MAPPING_FORMAT.required(),
 				Argument.MAPPING_OUTPUT.required(),
-				Argument.KEEP_MODE.required());
+				Argument.KEEP_MODE.required()
+		);
 	}
 
 	@Override
 	public void run(String... args) throws IOException, MappingParseException {
 		Path left = getReadablePath(this.getArg(args, 0));
 		Path right = getReadablePath(this.getArg(args, 1));
-		String resultFormat = this.getArg(args, 2);
-		Path result = getWritablePath(this.getArg(args, 3));
-		String keepMode = this.getArg(args, 4);
+		Path result = getWritablePath(this.getArg(args, 2));
+		String keepMode = this.getArg(args, 3);
+		String obfuscatedNamespace = this.getArg(args, 4);
+		String deobfuscatedNamespace = this.getArg(args, 5);
 
-		run(left, right, resultFormat, result, keepMode);
+		run(left, right, result, keepMode, obfuscatedNamespace, deobfuscatedNamespace);
 	}
 
 	@Override
@@ -44,17 +46,17 @@ public String getDescription() {
 		return "Merges the two mapping trees (left and right) into a common (middle) name set, handling conflicts according to the given \"keep mode\".";
 	}
 
-	public static void run(Path leftFile, Path rightFile, String resultFormat, Path resultFile, String keepMode) throws IOException, MappingParseException {
-		MappingSaveParameters saveParameters = new MappingSaveParameters(MappingFileNameFormat.BY_DEOBF, false);
+	public static void run(Path leftFile, Path rightFile, Path resultFile, String keepMode, @Nullable String obfuscatedNamespace, @Nullable String deobfuscatedNamespace) throws IOException, MappingParseException {
+		MappingSaveParameters saveParameters = new MappingSaveParameters(MappingFileNameFormat.BY_DEOBF, false, obfuscatedNamespace, deobfuscatedNamespace);
 
-		MappingFormat leftFormat = MappingFormat.parseFromFile(leftFile);
-		EntryTree<EntryMapping> left = leftFormat.read(leftFile);
-		MappingFormat rightFormat = MappingFormat.parseFromFile(rightFile);
-		EntryTree<EntryMapping> right = rightFormat.read(rightFile);
+		MappingsReader leftReader = CommandsUtil.getReader(createEnigma(), leftFile);
+		EntryTree<EntryMapping> left = leftReader.read(leftFile);
+		MappingsReader rightReader = CommandsUtil.getReader(createEnigma(), rightFile);
+		EntryTree<EntryMapping> right = rightReader.read(rightFile);
 		EntryTree<EntryMapping> result = MappingOperations.compose(left, right, keepMode.equals("left") || keepMode.equals("both"), keepMode.equals("right") || keepMode.equals("both"));
 
+		MappingsWriter writer = CommandsUtil.getWriter(createEnigma(), resultFile);
 		Utils.delete(resultFile);
-		MappingsWriter writer = MappingCommandsUtil.getWriter(resultFormat);
 		writer.write(result, resultFile, ProgressListener.createEmpty(), saveParameters);
 	}
 }

enigma-cli/src/main/java/org/quiltmc/enigma/command/ConvertMappingsCommand.java

@@ -1,32 +1,36 @@
 package org.quiltmc.enigma.command;
 
 import org.quiltmc.enigma.api.ProgressListener;
-import org.quiltmc.enigma.api.translation.mapping.serde.MappingFormat;
 import org.quiltmc.enigma.api.translation.mapping.serde.MappingParseException;
 import org.quiltmc.enigma.api.translation.mapping.EntryMapping;
 import org.quiltmc.enigma.api.translation.mapping.serde.MappingFileNameFormat;
 import org.quiltmc.enigma.api.translation.mapping.serde.MappingSaveParameters;
+import org.quiltmc.enigma.api.translation.mapping.serde.MappingsReader;
 import org.quiltmc.enigma.api.translation.mapping.serde.MappingsWriter;
 import org.quiltmc.enigma.api.translation.mapping.tree.EntryTree;
 import org.quiltmc.enigma.util.Utils;
 
+import javax.annotation.Nullable;
 import java.io.IOException;
 import java.nio.file.Path;
 
 public class ConvertMappingsCommand extends Command {
 	public ConvertMappingsCommand() {
 		super(Argument.INPUT_MAPPINGS.required(),
-				Argument.OUTPUT_MAPPING_FORMAT.required(),
-				Argument.MAPPING_OUTPUT.required());
+				Argument.MAPPING_OUTPUT.required(),
+				Argument.OBFUSCATED_NAMESPACE.required(),
+				Argument.DEOBFUSCATED_NAMESPACE.required()
+		);
 	}
 
 	@Override
 	public void run(String... args) throws IOException, MappingParseException {
 		Path source = getReadablePath(this.getArg(args, 0));
-		String resultFormat = this.getArg(args, 1);
-		Path result = getWritablePath(this.getArg(args, 2));
+		Path result = getWritablePath(this.getArg(args, 1));
+		String obfuscatedNamespace = this.getArg(args, 2);
+		String deobfuscatedNamespace = this.getArg(args, 3);
 
-		run(source, resultFormat, result);
+		run(source, result, obfuscatedNamespace, deobfuscatedNamespace);
 	}
 
 	@Override
@@ -39,14 +43,14 @@ public String getDescription() {
 		return "Converts the provided mappings to a different format.";
 	}
 
-	public static void run(Path source, String resultFormat, Path output) throws MappingParseException, IOException {
-		MappingSaveParameters saveParameters = new MappingSaveParameters(MappingFileNameFormat.BY_DEOBF, false);
+	public static void run(Path source, Path output, @Nullable String obfuscatedNamespace, @Nullable String deobfuscatedNamespace) throws MappingParseException, IOException {
+		MappingSaveParameters saveParameters = new MappingSaveParameters(MappingFileNameFormat.BY_DEOBF, false, obfuscatedNamespace, deobfuscatedNamespace);
 
-		MappingFormat format = MappingFormat.parseFromFile(source);
-		EntryTree<EntryMapping> mappings = format.read(source);
+		MappingsReader reader = CommandsUtil.getReader(createEnigma(), source);
+		EntryTree<EntryMapping> mappings = reader.read(source);
 
 		Utils.delete(output);
-		MappingsWriter writer = MappingCommandsUtil.getWriter(resultFormat);
+		MappingsWriter writer = CommandsUtil.getWriter(createEnigma(), output);
 		writer.write(mappings, output, ProgressListener.createEmpty(), saveParameters);
 	}
 }

enigma-cli/src/main/java/org/quiltmc/enigma/command/DecompileCommand.java

@@ -3,7 +3,7 @@
 import org.quiltmc.enigma.api.EnigmaProject;
 import org.quiltmc.enigma.api.ProgressListener;
 import org.quiltmc.enigma.api.EnigmaProject.DecompileErrorStrategy;
-import org.quiltmc.enigma.api.source.DecompilerService;
+import org.quiltmc.enigma.api.service.DecompilerService;
 import org.quiltmc.enigma.api.source.Decompilers;
 import org.tinylog.Logger;
 

enigma-cli/src/main/java/org/quiltmc/enigma/command/DeobfuscateCommand.java

@@ -9,7 +9,8 @@ public class DeobfuscateCommand extends Command {
 	public DeobfuscateCommand() {
 		super(Argument.INPUT_JAR.required(),
 				Argument.OUTPUT_JAR.required(),
-				Argument.INPUT_MAPPINGS.optional());
+				Argument.INPUT_MAPPINGS.optional()
+		);
 	}
 
 	@Override

enigma-cli/src/main/java/org/quiltmc/enigma/command/DropInvalidMappingsCommand.java

@@ -2,8 +2,8 @@
 
 import org.quiltmc.enigma.api.EnigmaProject;
 import org.quiltmc.enigma.api.ProgressListener;
-import org.quiltmc.enigma.api.translation.mapping.serde.MappingFormat;
 import org.quiltmc.enigma.api.translation.mapping.serde.MappingSaveParameters;
+import org.quiltmc.enigma.api.translation.mapping.serde.MappingsWriter;
 import org.tinylog.Logger;
 
 import java.io.IOException;
@@ -46,7 +46,7 @@ public static void run(Path jarIn, Path mappingsIn, Path mappingsOut) throws Exc
 			return;
 		}
 
-		MappingFormat format = MappingFormat.parseFromFile(mappingsIn);
+		MappingsWriter writer = CommandsUtil.getWriter(createEnigma(), mappingsIn);
 		EnigmaProject project = openProject(jarIn, mappingsIn);
 
 		Logger.info("Dropping invalid mappings...");
@@ -75,6 +75,6 @@ public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IO
 		}
 
 		MappingSaveParameters saveParameters = project.getEnigma().getProfile().getMappingSaveParameters();
-		format.write(project.getRemapper().getMappings(), mappingsOut, ProgressListener.createEmpty(), saveParameters);
+		writer.write(project.getRemapper().getMappings(), mappingsOut, ProgressListener.createEmpty(), saveParameters);
 	}
 }