search-mappings command

enigma-cli/build.gradle

@@ -6,6 +6,7 @@ plugins {
 
 dependencies {
 	shadow(implementation project(':enigma'))
+	implementation libs.asm
 	testImplementation(testFixtures(project(':enigma')))
 }
 

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

@@ -8,6 +8,11 @@
 import java.util.function.BiFunction;
 import java.util.stream.Stream;
 
+/**
+ * Encapsulates logic for parsing a list of {@link Argument}s into values. Also provides access to the argument list.
+ *
+ * @param <P> the type the argument values are packed in
+ */
 final class ArgsParser<P> implements Iterable<Argument<?>> {
 	static <T> ArgsParser<T> of(Argument<T> arg) {
 		return new ArgsParser<>(ImmutableList.of(arg), (values, from) -> from.parse(arg, values));
@@ -119,6 +124,58 @@ static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, P> ArgsParser<P> of(
 		);
 	}
 
+	static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, P> ArgsParser<P> of(
+			Argument<T1> arg1, Argument<T2> arg2, Argument<T3> arg3, Argument<T4> arg4, Argument<T5> arg5,
+			Argument<T6> arg6, Argument<T7> arg7, Argument<T8> arg8, Argument<T9> arg9, Argument<T10> arg10,
+			Argument<T11> arg11,
+			Packer11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, P> packer
+	) {
+		return new ArgsParser<>(
+				ImmutableList.of(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11),
+				(values, from) -> packer.pack(
+					from.parse(arg1, values), from.parse(arg2, values), from.parse(arg3, values),
+					from.parse(arg4, values), from.parse(arg5, values), from.parse(arg6, values),
+					from.parse(arg7, values), from.parse(arg8, values), from.parse(arg9, values),
+					from.parse(arg10, values), from.parse(arg11, values)
+				)
+		);
+	}
+
+	static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, P> ArgsParser<P> of(
+			Argument<T1> arg1, Argument<T2> arg2, Argument<T3> arg3, Argument<T4> arg4, Argument<T5> arg5,
+			Argument<T6> arg6, Argument<T7> arg7, Argument<T8> arg8, Argument<T9> arg9, Argument<T10> arg10,
+			Argument<T11> arg11, Argument<T12> arg12,
+			Packer12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, P> packer
+	) {
+		return new ArgsParser<>(
+				ImmutableList.of(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12),
+				(values, from) -> packer.pack(
+					from.parse(arg1, values), from.parse(arg2, values), from.parse(arg3, values),
+					from.parse(arg4, values), from.parse(arg5, values), from.parse(arg6, values),
+					from.parse(arg7, values), from.parse(arg8, values), from.parse(arg9, values),
+					from.parse(arg10, values), from.parse(arg11, values), from.parse(arg12, values)
+				)
+		);
+	}
+
+	static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, P> ArgsParser<P> of(
+			Argument<T1> arg1, Argument<T2> arg2, Argument<T3> arg3, Argument<T4> arg4, Argument<T5> arg5,
+			Argument<T6> arg6, Argument<T7> arg7, Argument<T8> arg8, Argument<T9> arg9, Argument<T10> arg10,
+			Argument<T11> arg11, Argument<T12> arg12, Argument<T13> arg13,
+			Packer13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, P> packer
+	) {
+		return new ArgsParser<>(
+				ImmutableList.of(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13),
+				(values, from) -> packer.pack(
+					from.parse(arg1, values), from.parse(arg2, values), from.parse(arg3, values),
+					from.parse(arg4, values), from.parse(arg5, values), from.parse(arg6, values),
+					from.parse(arg7, values), from.parse(arg8, values), from.parse(arg9, values),
+					from.parse(arg10, values), from.parse(arg11, values), from.parse(arg12, values),
+					from.parse(arg13, values)
+				)
+		);
+	}
+
 	private final ImmutableList<Argument<?>> args;
 
 	private final BiFunction<Map<String, String>, ArgParser, P> impl;
@@ -199,6 +256,21 @@ interface Packer10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, P> {
 		P pack(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10);
 	}
 
+	@FunctionalInterface
+	interface Packer11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, P> {
+		P pack(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11);
+	}
+
+	@FunctionalInterface
+	interface Packer12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, P> {
+		P pack(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12);
+	}
+
+	@FunctionalInterface
+	interface Packer13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, P> {
+		P pack(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13);
+	}
+
 	static final class Empty {
 		static final Empty INSTANCE = new Empty();
 

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

@@ -13,6 +13,8 @@
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Predicate;
+import java.util.regex.Pattern;
+import java.util.regex.PatternSyntaxException;
 import java.util.stream.Collectors;
 
 /**
@@ -32,63 +34,81 @@ final class Argument<T> {
 	static final char NAME_DELIM = '=';
 
 	static final String ALTERNATIVES_DELIM = "|";
+
 	static final String BOOL_TYPE = true + ALTERNATIVES_DELIM + false;
 	static final String PATH_TYPE = "path";
+	static final String INT_TYPE = "int";
+	static final String PATTERN_TYPE = "regex";
 
 	static Argument<Path> ofPath(String name, String explanation) {
-		return new Argument<>(name, PATH_TYPE, string -> getPath(string).orElse(null), explanation);
+		return new Argument<>(name, PATH_TYPE, string -> parsePath(string).orElse(null), explanation);
 	}
 
 	static Argument<Path> ofFile(String name, String explanation) {
-		return new Argument<>(name, PATH_TYPE, Argument::getFile, explanation);
+		return new Argument<>(name, PATH_TYPE, Argument::parseFile, explanation);
 	}
 
 	static Argument<Path> ofFolder(String name, String explanation) {
-		return new Argument<>(name, PATH_TYPE, Argument::getFolder, explanation);
+		return new Argument<>(name, PATH_TYPE, Argument::parseFolder, explanation);
 	}
 
 	static Argument<Path> ofReadablePath(String name, String explanation) {
-		return new Argument<>(name, PATH_TYPE, Argument::getReadablePath, explanation);
+		return new Argument<>(name, PATH_TYPE, Argument::parseReadablePath, explanation);
 	}
 
 	static Argument<Path> ofReadableFile(String name, String explanation) {
-		return new Argument<>(name, PATH_TYPE, Argument::getReadableFile, explanation);
+		return new Argument<>(name, PATH_TYPE, Argument::parseReadableFile, explanation);
 	}
 
 	static Argument<Path> ofReadableFolder(String name, String explanation) {
-		return new Argument<>(name, PATH_TYPE, Argument::getReadableFolder, explanation);
+		return new Argument<>(name, PATH_TYPE, Argument::parseReadableFolder, explanation);
 	}
 
 	static Argument<Path> ofWritablePath(String name, String explanation) {
-		return new Argument<>(name, PATH_TYPE, Argument::getWritablePath, explanation);
+		return new Argument<>(name, PATH_TYPE, Argument::parseWritablePath, explanation);
 	}
 
 	static Argument<Path> ofWritableFile(String name, String explanation) {
-		return new Argument<>(name, PATH_TYPE, Argument::getWritableFile, explanation);
+		return new Argument<>(name, PATH_TYPE, Argument::parseWritableFile, explanation);
 	}
 
 	static Argument<Path> ofWritableFolder(String name, String explanation) {
-		return new Argument<>(name, PATH_TYPE, Argument::getWritableFolder, explanation);
+		return new Argument<>(name, PATH_TYPE, Argument::parseWritableFolder, explanation);
 	}
 
 	/**
 	 * Creates a string argument whose {@code typeDescription} lists expected values.
 	 */
 	static Argument<String> ofLenientEnum(String name, Class<? extends Enum<?>> type, String explanation) {
-		final String alternatives = Arrays.stream(type.getEnumConstants())
-				.map(Object::toString)
-				.collect(Collectors.joining(ALTERNATIVES_DELIM));
-		return ofString(name, alternatives, explanation);
+		return ofString(name, alternativesOf(type), explanation);
+	}
+
+	static <E extends Enum<E>> Argument<E> ofEnum(String name, Class<E> type, String explanation) {
+		return new Argument<>(name, alternativesOf(type), string -> parseEnum(type, string), explanation);
 	}
 
 	static Argument<Boolean> ofBool(String name, String explanation) {
-		return new Argument<>(name, BOOL_TYPE, Boolean::parseBoolean, explanation);
+		return new Argument<>(name, BOOL_TYPE, Argument::parseBool, explanation);
+	}
+
+	static Argument<Integer> ofInt(String name, String explanation) {
+		return new Argument<>(name, INT_TYPE, Argument::parseInt, explanation);
 	}
 
 	static Argument<String> ofString(String name, String typeDescription, String explanation) {
 		return new Argument<>(name, typeDescription, Function.identity(), explanation);
 	}
 
+	static Argument<Pattern> ofPattern(String name, String explanation) {
+		return new Argument<>(name, PATTERN_TYPE, Argument::parsePattern, explanation);
+	}
+
+	private static String alternativesOf(Class<? extends Enum<?>> type) {
+		return Arrays.stream(type.getEnumConstants())
+			.map(Object::toString)
+			.collect(Collectors.joining(ALTERNATIVES_DELIM));
+	}
+
 	private final String name;
 	private final Function<String, T> fromString;
 	private final String displayForm;
@@ -111,48 +131,48 @@ static Argument<String> ofString(String name, String typeDescription, String exp
 		this.explanation = explanation;
 	}
 
-	static Path getFile(String path) {
-		return verifyFile(getPath(path)).orElse(null);
+	static Path parseFile(String path) {
+		return verifyFile(parsePath(path)).orElse(null);
 	}
 
-	static Path getFolder(String path) {
-		return verifyFolder(getPath(path)).orElse(null);
+	static Path parseFolder(String path) {
+		return verifyFolder(parsePath(path)).orElse(null);
 	}
 
-	static Path getReadablePath(String path) {
-		return getExistentPath(path).orElse(null);
+	static Path parseReadablePath(String path) {
+		return parseExistentPath(path).orElse(null);
 	}
 
-	static Path getReadableFile(String path) {
-		return verify(getExistentPath(path), Files::isRegularFile, "Not a file: ").orElse(null);
+	static Path parseReadableFile(String path) {
+		return verify(parseExistentPath(path), Files::isRegularFile, "Not a file: ").orElse(null);
 	}
 
-	static Path getReadableFolder(String path) {
-		return getExistentFolder(path).orElse(null);
+	static Path parseReadableFolder(String path) {
+		return parseExistentFolder(path).orElse(null);
 	}
 
-	static Path getWritablePath(String path) {
-		return getParentedPath(path).orElse(null);
+	static Path parseWritablePath(String path) {
+		return parseParentedPath(path).orElse(null);
 	}
 
-	static Path getWritableFile(String path) {
-		return verifyFile(getParentedPath(path)).orElse(null);
+	static Path parseWritableFile(String path) {
+		return verifyFile(parseParentedPath(path)).orElse(null);
 	}
 
-	static Path getWritableFolder(String path) {
-		return getExistentFolder(path).orElse(null);
+	static Path parseWritableFolder(String path) {
+		return parseExistentFolder(path).orElse(null);
 	}
 
-	static Optional<Path> getExistentFolder(String path) {
-		return verify(getExistentPath(path), Files::isDirectory, "Not a folder: ");
+	static Optional<Path> parseExistentFolder(String path) {
+		return verify(parseExistentPath(path), Files::isDirectory, "Not a folder: ");
 	}
 
-	static Optional<Path> getExistentPath(String path) {
-		return verify(getPath(path), Files::exists, "Cannot find path: ");
+	static Optional<Path> parseExistentPath(String path) {
+		return verify(parsePath(path), Files::exists, "Cannot find path: ");
 	}
 
-	static Optional<Path> getParentedPath(String path) {
-		return peek(getPath(path), child -> {
+	static Optional<Path> parseParentedPath(String path) {
+		return peek(parsePath(path), child -> {
 			final Path parent = child.getParent();
 			if (parent == null) {
 				throw new IllegalArgumentException("Cannot write path: " + child);
@@ -166,13 +186,45 @@ static Optional<Path> getParentedPath(String path) {
 		});
 	}
 
-	static Optional<Path> getPath(String path) {
+	static Optional<Path> parsePath(String path) {
 		return Optional.ofNullable(path)
 			.filter(string -> !string.isEmpty())
 			.map(Paths::get)
 			.map(Path::toAbsolutePath);
 	}
 
+	static Pattern parsePattern(String regex) {
+		if (regex == null || regex.isEmpty()) {
+			return null;
+		}
+
+		try {
+			return Pattern.compile(regex);
+		} catch (PatternSyntaxException e) {
+			throw new IllegalArgumentException(e);
+		}
+	}
+
+	static <E extends Enum<E>> E parseEnum(Class<E> type, String name) {
+		return name == null ? null : Enum.valueOf(type, name);
+	}
+
+	static Boolean parseBool(String value) {
+		return value == null ? null : Boolean.parseBoolean(value);
+	}
+
+	static Integer parseInt(String integer) {
+		if (integer == null || integer.isEmpty()) {
+			return null;
+		} else {
+			try {
+				return Integer.parseInt(integer);
+			} catch (NumberFormatException e) {
+				throw new IllegalArgumentException(e);
+			}
+		}
+	}
+
 	@SuppressWarnings("OptionalUsedAsFieldOrParameterType")
 	static Optional<Path> verifyFile(Optional<Path> path) {
 		// !directory so it's true for non-existent files

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

@@ -45,8 +45,8 @@
  */
 public abstract sealed class Command<R, O> permits
 		CheckMappingsCommand, ComposeMappingsCommand, ConvertMappingsCommand, DecompileCommand, DeobfuscateCommand,
-		DropInvalidMappingsCommand, FillClassMappingsCommand, HelpCommand, InsertProposedMappingsCommand,
-		InvertMappingsCommand, MapSpecializedMethodsCommand, PrintStatsCommand {
+		DropInvalidMappingsCommand, FillClassMappingsCommand, SearchMappingsCommand, HelpCommand,
+		InsertProposedMappingsCommand, InvertMappingsCommand, MapSpecializedMethodsCommand, PrintStatsCommand {
 	private static final int EARLIEST_ARG_DELIM_INDEX = 1;
 
 	@VisibleForTesting

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

@@ -47,7 +47,8 @@ private FillClassMappingsCommand() {
 	void runImpl(Required required, Optional optional) throws Exception {
 		run(
 				required.inputJar, required.inputMappings, required.mappingOutput,
-				optional.fillAll, optional.obfuscatedNamespace, optional.deobfuscatedNamespace
+				optional.fillAll != null && optional.fillAll,
+				optional.obfuscatedNamespace, optional.deobfuscatedNamespace
 		);
 	}
 
@@ -133,5 +134,5 @@ private static void recursiveAddMappings(EntryTree<EntryMapping> mappings, JarIn
 
 	record Required(Path inputJar, Path inputMappings, Path mappingOutput) { }
 
-	record Optional(boolean fillAll, String obfuscatedNamespace, String deobfuscatedNamespace) { }
+	record Optional(Boolean fillAll, String obfuscatedNamespace, String deobfuscatedNamespace) { }
 }

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

@@ -24,7 +24,8 @@ public class Main {
 				DropInvalidMappingsCommand.INSTANCE,
 				FillClassMappingsCommand.INSTANCE,
 				HelpCommand.INSTANCE,
-				PrintStatsCommand.INSTANCE
+				PrintStatsCommand.INSTANCE,
+				SearchMappingsCommand.INSTANCE
 			)
 			.collect(toImmutableMap(Command::getName, Function.identity()));