Add checkstyle (#460)

12 files changed, 284 insertions, 275 deletions

diff --git a/enigma-cli/build.gradle b/enigma-cli/build.gradle
index 5b84196..5281e9e 100644
--- a/enigma-cli/build.gradle
+++ b/enigma-cli/build.gradle
@@ -1,10 +1,10 @@
 plugins {
-    id 'application'
-    id 'com.github.johnrengelman.shadow' version '7.0.0'
+        id 'application'
+        id 'com.github.johnrengelman.shadow' version '7.0.0'
 }
 
 dependencies {
-    implementation project(':enigma')
+        implementation project(':enigma')
 }
 
 mainClassName = 'cuchaz.enigma.command.Main'
@@ -12,9 +12,9 @@ mainClassName = 'cuchaz.enigma.command.Main'
 jar.manifest.attributes 'Main-Class': mainClassName
 
 publishing {
-    publications {
-        shadow(MavenPublication) { publication ->
-            project.shadow.component publication
-        }
-    }
+        publications {
+                shadow(MavenPublication) { publication ->
+                        project.shadow.component publication
+                }
+        }
 }
diff --git a/enigma-cli/src/main/java/cuchaz/enigma/command/CheckMappingsCommand.java b/enigma-cli/src/main/java/cuchaz/enigma/command/CheckMappingsCommand.java
index 75ef225..922d668 100644
--- a/enigma-cli/src/main/java/cuchaz/enigma/command/CheckMappingsCommand.java
+++ b/enigma-cli/src/main/java/cuchaz/enigma/command/CheckMappingsCommand.java
@@ -1,22 +1,21 @@
 package cuchaz.enigma.command;
 
+import java.nio.file.Path;
+import java.util.Set;
+import java.util.stream.Collectors;
+
 import cuchaz.enigma.Enigma;
 import cuchaz.enigma.EnigmaProject;
 import cuchaz.enigma.ProgressListener;
 import cuchaz.enigma.analysis.index.JarIndex;
 import cuchaz.enigma.classprovider.ClasspathClassProvider;
 import cuchaz.enigma.translation.mapping.EntryMapping;
-import cuchaz.enigma.translation.mapping.serde.MappingSaveParameters;
 import cuchaz.enigma.translation.mapping.serde.MappingFormat;
+import cuchaz.enigma.translation.mapping.serde.MappingSaveParameters;
 import cuchaz.enigma.translation.mapping.tree.EntryTree;
 import cuchaz.enigma.translation.representation.entry.ClassEntry;
 
-import java.nio.file.Path;
-import java.util.Set;
-import java.util.stream.Collectors;
-
 public class CheckMappingsCommand extends Command {
-
         public CheckMappingsCommand() {
                 super("checkmappings");
         }
@@ -55,19 +54,11 @@ public class CheckMappingsCommand extends Command {
                 boolean error = false;
 
                 for (Set<ClassEntry> partition : idx.getPackageVisibilityIndex().getPartitions()) {
-                        long packages = partition.stream()
-                                        .map(project.getMapper()::deobfuscate)
-                                        .map(ClassEntry::getPackageName)
-                                        .distinct()
-                                        .count();
+                        long packages = partition.stream().map(project.getMapper()::deobfuscate).map(ClassEntry::getPackageName).distinct().count();
+
                         if (packages > 1) {
                                 error = true;
-                                System.err.println("ERROR: Must be in one package:\n" + partition.stream()
-                                                .map(project.getMapper()::deobfuscate)
-                                                .map(ClassEntry::toString)
-                                                .sorted()
-                                                .collect(Collectors.joining("\n"))
-                                );
+                                System.err.println("ERROR: Must be in one package:\n" + partition.stream().map(project.getMapper()::deobfuscate).map(ClassEntry::toString).sorted().collect(Collectors.joining("\n")));
                         }
                 }
 
diff --git a/enigma-cli/src/main/java/cuchaz/enigma/command/Command.java b/enigma-cli/src/main/java/cuchaz/enigma/command/Command.java
index 0d71f02..04d49f2 100644
--- a/enigma-cli/src/main/java/cuchaz/enigma/command/Command.java
+++ b/enigma-cli/src/main/java/cuchaz/enigma/command/Command.java
@@ -1,21 +1,21 @@
 package cuchaz.enigma.command;
 
+import java.io.File;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+import com.google.common.io.MoreFiles;
+
 import cuchaz.enigma.Enigma;
 import cuchaz.enigma.EnigmaProject;
 import cuchaz.enigma.ProgressListener;
 import cuchaz.enigma.classprovider.ClasspathClassProvider;
 import cuchaz.enigma.translation.mapping.EntryMapping;
-import cuchaz.enigma.translation.mapping.serde.MappingSaveParameters;
 import cuchaz.enigma.translation.mapping.serde.MappingFormat;
+import cuchaz.enigma.translation.mapping.serde.MappingSaveParameters;
 import cuchaz.enigma.translation.mapping.tree.EntryTree;
 
-import java.io.File;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-
-import com.google.common.io.MoreFiles;
-
 public abstract class Command {
         public final String name;
 
@@ -63,15 +63,19 @@ public abstract class Command {
                 if (path == null) {
                         return null;
                 }
+
                 File file = new File(path).getAbsoluteFile();
                 File dir = file.getParentFile();
+
                 if (dir == null) {
                         throw new IllegalArgumentException("Cannot write file: " + path);
                 }
+
                 // quick fix to avoid stupid stuff in Gradle code
                 if (!dir.isDirectory()) {
                         dir.mkdirs();
                 }
+
                 return file;
         }
 
@@ -79,10 +83,13 @@ public abstract class Command {
                 if (path == null) {
                         return null;
                 }
+
                 File dir = new File(path).getAbsoluteFile();
+
                 if (!dir.exists()) {
                         throw new IllegalArgumentException("Cannot write to folder: " + dir);
                 }
+
                 return dir;
         }
 
@@ -90,10 +97,13 @@ public abstract class Command {
                 if (path == null) {
                         return null;
                 }
+
                 File file = new File(path).getAbsoluteFile();
+
                 if (!file.exists()) {
                         throw new IllegalArgumentException("Cannot find file: " + file.getAbsolutePath());
                 }
+
                 return file;
         }
 
@@ -101,10 +111,13 @@ public abstract class Command {
                 if (path == null) {
                         return null;
                 }
+
                 Path file = Paths.get(path).toAbsolutePath();
+
                 if (!Files.exists(file)) {
                         throw new IllegalArgumentException("Cannot find file: " + file.toString());
                 }
+
                 return file;
         }
 
@@ -116,11 +129,11 @@ public abstract class Command {
                                 return null;
                         }
                 }
+
                 return args[i];
         }
 
         public static class ConsoleProgressListener implements ProgressListener {
-
                 private static final int ReportTime = 5000; // 5s
 
                 private int totalWork;
@@ -146,6 +159,7 @@ public abstract class Command {
                                 System.out.println(String.format("\tProgress: %3d%%", percent));
                                 this.lastReportTime = now;
                         }
+
                         if (isLastUpdate) {
                                 double elapsedSeconds = (now - this.startTime) / 1000.0;
                                 System.out.println(String.format("Finished in %.1f seconds", elapsedSeconds));
diff --git a/enigma-cli/src/main/java/cuchaz/enigma/command/ComposeMappingsCommand.java b/enigma-cli/src/main/java/cuchaz/enigma/command/ComposeMappingsCommand.java
index e10fd47..7e9002d 100644
--- a/enigma-cli/src/main/java/cuchaz/enigma/command/ComposeMappingsCommand.java
+++ b/enigma-cli/src/main/java/cuchaz/enigma/command/ComposeMappingsCommand.java
@@ -1,42 +1,42 @@
 package cuchaz.enigma.command;
 
-import cuchaz.enigma.translation.mapping.MappingOperations;
-import cuchaz.enigma.translation.mapping.serde.MappingParseException;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
 import cuchaz.enigma.translation.mapping.EntryMapping;
+import cuchaz.enigma.translation.mapping.MappingOperations;
 import cuchaz.enigma.translation.mapping.serde.MappingFileNameFormat;
+import cuchaz.enigma.translation.mapping.serde.MappingParseException;
 import cuchaz.enigma.translation.mapping.serde.MappingSaveParameters;
 import cuchaz.enigma.translation.mapping.tree.EntryTree;
 import cuchaz.enigma.utils.Utils;
 
-import java.io.IOException;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-
 public class ComposeMappingsCommand extends Command {
-    public ComposeMappingsCommand() {
-        super("compose-mappings");
-    }
-
-    @Override
-    public String getUsage() {
-        return "<left-format> <left> <right-format> <right> <result-format> <result> <keep-mode>";
-    }
-
-    @Override
-    public boolean isValidArgument(int length) {
-        return length == 7;
-    }
-
-    @Override
-    public void run(String... args) throws IOException, MappingParseException {
-        MappingSaveParameters saveParameters = new MappingSaveParameters(MappingFileNameFormat.BY_DEOBF);
-
-        EntryTree<EntryMapping> left = MappingCommandsUtil.read(args[0], Paths.get(args[1]), saveParameters);
-        EntryTree<EntryMapping> right = MappingCommandsUtil.read(args[2], Paths.get(args[3]), saveParameters);
-        EntryTree<EntryMapping> result = MappingOperations.compose(left, right, args[6].equals("left") || args[6].equals("both"), args[6].equals("right") || args[6].equals("both"));
-
-        Path output = Paths.get(args[5]);
-        Utils.delete(output);
-        MappingCommandsUtil.write(result, args[4], output, saveParameters);
-    }
+        public ComposeMappingsCommand() {
+                super("compose-mappings");
+        }
+
+        @Override
+        public String getUsage() {
+                return "<left-format> <left> <right-format> <right> <result-format> <result> <keep-mode>";
+        }
+
+        @Override
+        public boolean isValidArgument(int length) {
+                return length == 7;
+        }
+
+        @Override
+        public void run(String... args) throws IOException, MappingParseException {
+                MappingSaveParameters saveParameters = new MappingSaveParameters(MappingFileNameFormat.BY_DEOBF);
+
+                EntryTree<EntryMapping> left = MappingCommandsUtil.read(args[0], Paths.get(args[1]), saveParameters);
+                EntryTree<EntryMapping> right = MappingCommandsUtil.read(args[2], Paths.get(args[3]), saveParameters);
+                EntryTree<EntryMapping> result = MappingOperations.compose(left, right, args[6].equals("left") || args[6].equals("both"), args[6].equals("right") || args[6].equals("both"));
+
+                Path output = Paths.get(args[5]);
+                Utils.delete(output);
+                MappingCommandsUtil.write(result, args[4], output, saveParameters);
+        }
 }
diff --git a/enigma-cli/src/main/java/cuchaz/enigma/command/ConvertMappingsCommand.java b/enigma-cli/src/main/java/cuchaz/enigma/command/ConvertMappingsCommand.java
index 144d89c..99b27e1 100644
--- a/enigma-cli/src/main/java/cuchaz/enigma/command/ConvertMappingsCommand.java
+++ b/enigma-cli/src/main/java/cuchaz/enigma/command/ConvertMappingsCommand.java
@@ -1,39 +1,39 @@
 package cuchaz.enigma.command;
 
-import cuchaz.enigma.translation.mapping.serde.MappingParseException;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
 import cuchaz.enigma.translation.mapping.EntryMapping;
 import cuchaz.enigma.translation.mapping.serde.MappingFileNameFormat;
+import cuchaz.enigma.translation.mapping.serde.MappingParseException;
 import cuchaz.enigma.translation.mapping.serde.MappingSaveParameters;
 import cuchaz.enigma.translation.mapping.tree.EntryTree;
 import cuchaz.enigma.utils.Utils;
 
-import java.io.IOException;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-
 public class ConvertMappingsCommand extends Command {
-    public ConvertMappingsCommand() {
-        super("convert-mappings");
-    }
-
-    @Override
-    public String getUsage() {
-        return "<source-format> <source> <result-format> <result>";
-    }
-
-    @Override
-    public boolean isValidArgument(int length) {
-        return length == 4;
-    }
-
-    @Override
-    public void run(String... args) throws IOException, MappingParseException {
-        MappingSaveParameters saveParameters = new MappingSaveParameters(MappingFileNameFormat.BY_DEOBF);
-
-        EntryTree<EntryMapping> mappings = MappingCommandsUtil.read(args[0], Paths.get(args[1]), saveParameters);
-
-        Path output = Paths.get(args[3]);
-        Utils.delete(output);
-        MappingCommandsUtil.write(mappings, args[2], output, saveParameters);
-    }
+        public ConvertMappingsCommand() {
+                super("convert-mappings");
+        }
+
+        @Override
+        public String getUsage() {
+                return "<source-format> <source> <result-format> <result>";
+        }
+
+        @Override
+        public boolean isValidArgument(int length) {
+                return length == 4;
+        }
+
+        @Override
+        public void run(String... args) throws IOException, MappingParseException {
+                MappingSaveParameters saveParameters = new MappingSaveParameters(MappingFileNameFormat.BY_DEOBF);
+
+                EntryTree<EntryMapping> mappings = MappingCommandsUtil.read(args[0], Paths.get(args[1]), saveParameters);
+
+                Path output = Paths.get(args[3]);
+                Utils.delete(output);
+                MappingCommandsUtil.write(mappings, args[2], output, saveParameters);
+        }
 }
diff --git a/enigma-cli/src/main/java/cuchaz/enigma/command/DecompileCommand.java b/enigma-cli/src/main/java/cuchaz/enigma/command/DecompileCommand.java
index 12a4e88..020bd97 100644
--- a/enigma-cli/src/main/java/cuchaz/enigma/command/DecompileCommand.java
+++ b/enigma-cli/src/main/java/cuchaz/enigma/command/DecompileCommand.java
@@ -1,17 +1,16 @@
 package cuchaz.enigma.command;
 
+import java.lang.reflect.Field;
+import java.nio.file.Path;
+import java.util.Locale;
+
 import cuchaz.enigma.EnigmaProject;
-import cuchaz.enigma.ProgressListener;
 import cuchaz.enigma.EnigmaProject.DecompileErrorStrategy;
+import cuchaz.enigma.ProgressListener;
 import cuchaz.enigma.source.DecompilerService;
 import cuchaz.enigma.source.Decompilers;
 
-import java.lang.reflect.Field;
-import java.nio.file.Path;
-import java.util.Locale;
-
 public class DecompileCommand extends Command {
-
         public DecompileCommand() {
                 super("decompile");
         }
diff --git a/enigma-cli/src/main/java/cuchaz/enigma/command/DeobfuscateCommand.java b/enigma-cli/src/main/java/cuchaz/enigma/command/DeobfuscateCommand.java
index b0d2a7d..c8e6200 100644
--- a/enigma-cli/src/main/java/cuchaz/enigma/command/DeobfuscateCommand.java
+++ b/enigma-cli/src/main/java/cuchaz/enigma/command/DeobfuscateCommand.java
@@ -1,12 +1,11 @@
 package cuchaz.enigma.command;
 
+import java.nio.file.Path;
+
 import cuchaz.enigma.EnigmaProject;
 import cuchaz.enigma.ProgressListener;
 
-import java.nio.file.Path;
-
 public class DeobfuscateCommand extends Command {
-
         public DeobfuscateCommand() {
                 super("deobfuscate");
         }
diff --git a/enigma-cli/src/main/java/cuchaz/enigma/command/InvertMappingsCommand.java b/enigma-cli/src/main/java/cuchaz/enigma/command/InvertMappingsCommand.java
index 0780a96..af24978 100644
--- a/enigma-cli/src/main/java/cuchaz/enigma/command/InvertMappingsCommand.java
+++ b/enigma-cli/src/main/java/cuchaz/enigma/command/InvertMappingsCommand.java
@@ -1,41 +1,41 @@
 package cuchaz.enigma.command;
 
-import cuchaz.enigma.translation.mapping.MappingOperations;
-import cuchaz.enigma.translation.mapping.serde.MappingParseException;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
 import cuchaz.enigma.translation.mapping.EntryMapping;
+import cuchaz.enigma.translation.mapping.MappingOperations;
 import cuchaz.enigma.translation.mapping.serde.MappingFileNameFormat;
+import cuchaz.enigma.translation.mapping.serde.MappingParseException;
 import cuchaz.enigma.translation.mapping.serde.MappingSaveParameters;
 import cuchaz.enigma.translation.mapping.tree.EntryTree;
 import cuchaz.enigma.utils.Utils;
 
-import java.io.IOException;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-
 public class InvertMappingsCommand extends Command {
-    public InvertMappingsCommand() {
-        super("invert-mappings");
-    }
-
-    @Override
-    public String getUsage() {
-        return "<source-format> <source> <result-format> <result>";
-    }
-
-    @Override
-    public boolean isValidArgument(int length) {
-        return length == 4;
-    }
-
-    @Override
-    public void run(String... args) throws IOException, MappingParseException {
-        MappingSaveParameters saveParameters = new MappingSaveParameters(MappingFileNameFormat.BY_DEOBF);
-
-        EntryTree<EntryMapping> source = MappingCommandsUtil.read(args[0], Paths.get(args[1]), saveParameters);
-        EntryTree<EntryMapping> result = MappingOperations.invert(source);
-
-        Path output = Paths.get(args[3]);
-        Utils.delete(output);
-        MappingCommandsUtil.write(result, args[2], output, saveParameters);
-    }
+        public InvertMappingsCommand() {
+                super("invert-mappings");
+        }
+
+        @Override
+        public String getUsage() {
+                return "<source-format> <source> <result-format> <result>";
+        }
+
+        @Override
+        public boolean isValidArgument(int length) {
+                return length == 4;
+        }
+
+        @Override
+        public void run(String... args) throws IOException, MappingParseException {
+                MappingSaveParameters saveParameters = new MappingSaveParameters(MappingFileNameFormat.BY_DEOBF);
+
+                EntryTree<EntryMapping> source = MappingCommandsUtil.read(args[0], Paths.get(args[1]), saveParameters);
+                EntryTree<EntryMapping> result = MappingOperations.invert(source);
+
+                Path output = Paths.get(args[3]);
+                Utils.delete(output);
+                MappingCommandsUtil.write(result, args[2], output, saveParameters);
+        }
 }
diff --git a/enigma-cli/src/main/java/cuchaz/enigma/command/Main.java b/enigma-cli/src/main/java/cuchaz/enigma/command/Main.java
index 0a4c1b9..9021ff1 100644
--- a/enigma-cli/src/main/java/cuchaz/enigma/command/Main.java
+++ b/enigma-cli/src/main/java/cuchaz/enigma/command/Main.java
@@ -1,36 +1,39 @@
 /*******************************************************************************
- * Copyright (c) 2015 Jeff Martin.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Lesser General Public
- * License v3.0 which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/lgpl.html
- * <p>
- * Contributors:
- * Jeff Martin - initial API and implementation
- ******************************************************************************/
+* Copyright (c) 2015 Jeff Martin.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the GNU Lesser General Public
+* License v3.0 which accompanies this distribution, and is available at
+* http://www.gnu.org/licenses/lgpl.html
+*
+* <p>Contributors:
+* Jeff Martin - initial API and implementation
+******************************************************************************/
 
 package cuchaz.enigma.command;
 
-import cuchaz.enigma.Enigma;
-
 import java.util.LinkedHashMap;
 import java.util.Locale;
 import java.util.Map;
 
-public class Main {
+import cuchaz.enigma.Enigma;
 
+public class Main {
         private static final Map<String, Command> COMMANDS = new LinkedHashMap<>();
 
         public static void main(String... args) throws Exception {
                 try {
                         // process the command
-                        if (args.length < 1)
+                        if (args.length < 1) {
                                 throw new IllegalArgumentException("Requires a command");
+                        }
+
                         String command = args[0].toLowerCase(Locale.ROOT);
 
                         Command cmd = COMMANDS.get(command);
-                        if (cmd == null)
+
+                        if (cmd == null) {
                                 throw new IllegalArgumentException("Command not recognized: " + command);
+                        }
 
                         if (!cmd.isValidArgument(args.length - 1)) {
                                 throw new CommandHelpException(cmd);
@@ -74,6 +77,7 @@ public class Main {
 
         private static void register(Command command) {
                 Command old = COMMANDS.put(command.name, command);
+
                 if (old != null) {
                         System.err.println("Command " + old + " with name " + command.name + " has been substituted by " + command);
                 }
@@ -90,7 +94,6 @@ public class Main {
         }
 
         private static final class CommandHelpException extends IllegalArgumentException {
-
                 final Command command;
 
                 CommandHelpException(Command command) {
diff --git a/enigma-cli/src/main/java/cuchaz/enigma/command/MapSpecializedMethodsCommand.java b/enigma-cli/src/main/java/cuchaz/enigma/command/MapSpecializedMethodsCommand.java
index 46da89a..644b08d 100644
--- a/enigma-cli/src/main/java/cuchaz/enigma/command/MapSpecializedMethodsCommand.java
+++ b/enigma-cli/src/main/java/cuchaz/enigma/command/MapSpecializedMethodsCommand.java
@@ -1,5 +1,10 @@
 package cuchaz.enigma.command;
 
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Map;
+
 import cuchaz.enigma.ProgressListener;
 import cuchaz.enigma.analysis.IndexTreeBuilder;
 import cuchaz.enigma.analysis.index.BridgeMethodIndex;
@@ -18,60 +23,55 @@ import cuchaz.enigma.translation.mapping.tree.HashEntryTree;
 import cuchaz.enigma.translation.representation.entry.MethodEntry;
 import cuchaz.enigma.utils.Utils;
 
-import java.io.IOException;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.util.Map;
-
 public class MapSpecializedMethodsCommand extends Command {
-    public MapSpecializedMethodsCommand() {
-        super("map-specialized-methods");
-    }
+        public MapSpecializedMethodsCommand() {
+                super("map-specialized-methods");
+        }
 
-    @Override
-    public String getUsage() {
-        return "<jar> <source-format> <source> <result-format> <result>";
-    }
+        @Override
+        public String getUsage() {
+                return "<jar> <source-format> <source> <result-format> <result>";
+        }
 
-    @Override
-    public boolean isValidArgument(int length) {
-        return length == 5;
-    }
+        @Override
+        public boolean isValidArgument(int length) {
+                return length == 5;
+        }
 
-    @Override
-    public void run(String... args) throws IOException, MappingParseException {
-        run(Paths.get(args[0]), args[1], Paths.get(args[2]), args[3], Paths.get(args[4]));
-    }
+        @Override
+        public void run(String... args) throws IOException, MappingParseException {
+                run(Paths.get(args[0]), args[1], Paths.get(args[2]), args[3], Paths.get(args[4]));
+        }
 
-    public static void run(Path jar, String sourceFormat, Path sourcePath, String resultFormat, Path output) throws IOException, MappingParseException {
-        MappingSaveParameters saveParameters = new MappingSaveParameters(MappingFileNameFormat.BY_DEOBF);
-        EntryTree<EntryMapping> source = MappingCommandsUtil.read(sourceFormat, sourcePath, saveParameters);
-        EntryTree<EntryMapping> result = new HashEntryTree<>();
+        public static void run(Path jar, String sourceFormat, Path sourcePath, String resultFormat, Path output) throws IOException, MappingParseException {
+                MappingSaveParameters saveParameters = new MappingSaveParameters(MappingFileNameFormat.BY_DEOBF);
+                EntryTree<EntryMapping> source = MappingCommandsUtil.read(sourceFormat, sourcePath, saveParameters);
+                EntryTree<EntryMapping> result = new HashEntryTree<>();
 
-        JarClassProvider jcp = new JarClassProvider(jar);
-        JarIndex jarIndex = JarIndex.empty();
-        jarIndex.indexJar(jcp.getClassNames(), new CachingClassProvider(jcp), ProgressListener.none());
+                JarClassProvider jcp = new JarClassProvider(jar);
+                JarIndex jarIndex = JarIndex.empty();
+                jarIndex.indexJar(jcp.getClassNames(), new CachingClassProvider(jcp), ProgressListener.none());
 
-        BridgeMethodIndex bridgeMethodIndex = jarIndex.getBridgeMethodIndex();
-        Translator translator = new MappingTranslator(source, jarIndex.getEntryResolver());
-            IndexTreeBuilder indexTreeBuilder = new IndexTreeBuilder(jarIndex);
+                BridgeMethodIndex bridgeMethodIndex = jarIndex.getBridgeMethodIndex();
+                Translator translator = new MappingTranslator(source, jarIndex.getEntryResolver());
+                IndexTreeBuilder indexTreeBuilder = new IndexTreeBuilder(jarIndex);
 
-        // Copy all non-specialized methods
-        for (EntryTreeNode<EntryMapping> node : source) {
-            if (!(node.getEntry() instanceof MethodEntry) || !bridgeMethodIndex.isSpecializedMethod((MethodEntry) node.getEntry())) {
-                result.insert(node.getEntry(), node.getValue());
-            }
-        }
+                // Copy all non-specialized methods
+                for (EntryTreeNode<EntryMapping> node : source) {
+                        if (!(node.getEntry() instanceof MethodEntry) || !bridgeMethodIndex.isSpecializedMethod((MethodEntry) node.getEntry())) {
+                                result.insert(node.getEntry(), node.getValue());
+                        }
+                }
 
-        // Add correct mappings for specialized methods
-        for (Map.Entry<MethodEntry, MethodEntry> entry : bridgeMethodIndex.getBridgeToSpecialized().entrySet()) {
-            MethodEntry bridge = entry.getKey();
-            MethodEntry specialized = indexTreeBuilder.buildMethodInheritance(translator, entry.getValue()).getMethodEntry();
-            String name = translator.translate(bridge).getName();
-            result.insert(specialized, new EntryMapping(name));
-        }
+                // Add correct mappings for specialized methods
+                for (Map.Entry<MethodEntry, MethodEntry> entry : bridgeMethodIndex.getBridgeToSpecialized().entrySet()) {
+                        MethodEntry bridge = entry.getKey();
+                        MethodEntry specialized = indexTreeBuilder.buildMethodInheritance(translator, entry.getValue()).getMethodEntry();
+                        String name = translator.translate(bridge).getName();
+                        result.insert(specialized, new EntryMapping(name));
+                }
 
-        Utils.delete(output);
-        MappingCommandsUtil.write(result, resultFormat, output, saveParameters);
-    }
+                Utils.delete(output);
+                MappingCommandsUtil.write(result, resultFormat, output, saveParameters);
+        }
 }
diff --git a/enigma-cli/src/main/java/cuchaz/enigma/command/MappingCommandsUtil.java b/enigma-cli/src/main/java/cuchaz/enigma/command/MappingCommandsUtil.java
index d365129..787625b 100644
--- a/enigma-cli/src/main/java/cuchaz/enigma/command/MappingCommandsUtil.java
+++ b/enigma-cli/src/main/java/cuchaz/enigma/command/MappingCommandsUtil.java
@@ -1,10 +1,14 @@
 package cuchaz.enigma.command;
 
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
 import cuchaz.enigma.ProgressListener;
-import cuchaz.enigma.translation.mapping.serde.MappingParseException;
 import cuchaz.enigma.translation.mapping.EntryMapping;
+import cuchaz.enigma.translation.mapping.serde.MappingFormat;
+import cuchaz.enigma.translation.mapping.serde.MappingParseException;
 import cuchaz.enigma.translation.mapping.serde.MappingSaveParameters;
-import cuchaz.enigma.translation.mapping.serde.*;
 import cuchaz.enigma.translation.mapping.serde.enigma.EnigmaMappingsReader;
 import cuchaz.enigma.translation.mapping.serde.enigma.EnigmaMappingsWriter;
 import cuchaz.enigma.translation.mapping.serde.tiny.TinyMappingsReader;
@@ -12,76 +16,77 @@ import cuchaz.enigma.translation.mapping.serde.tiny.TinyMappingsWriter;
 import cuchaz.enigma.translation.mapping.serde.tinyv2.TinyV2Writer;
 import cuchaz.enigma.translation.mapping.tree.EntryTree;
 
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-
 public final class MappingCommandsUtil {
-    private MappingCommandsUtil() {}
-
-    public static EntryTree<EntryMapping> read(String type, Path path, MappingSaveParameters saveParameters) throws MappingParseException, IOException {
-        if (type.equals("enigma")) {
-            return (Files.isDirectory(path) ? EnigmaMappingsReader.DIRECTORY : EnigmaMappingsReader.ZIP).read(path, ProgressListener.none(), saveParameters);
-        }
-
-        if (type.equals("tiny")) {
-            return TinyMappingsReader.INSTANCE.read(path, ProgressListener.none(), saveParameters);
-        }
-
-        MappingFormat format = null;
-        try {
-            format = MappingFormat.valueOf(type.toUpperCase());
-        } catch (IllegalArgumentException ignored) {
-            if (type.equals("tinyv2")) {
-                format = MappingFormat.TINY_V2;
-            }
-        }
-
-        if (format != null) {
-            return format.getReader().read(path, ProgressListener.none(), saveParameters);
-        }
-
-        throw new IllegalArgumentException("no reader for " + type);
-    }
-
-    public static void write(EntryTree<EntryMapping> mappings, String type, Path path, MappingSaveParameters saveParameters) {
-        if (type.equals("enigma")) {
-            EnigmaMappingsWriter.DIRECTORY.write(mappings, path, ProgressListener.none(), saveParameters);
-            return;
-        }
-
-        if (type.startsWith("tinyv2:") || type.startsWith("tiny_v2:")) {
-            String[] split = type.split(":");
-
-            if (split.length != 3) {
-                throw new IllegalArgumentException("specify column names as 'tinyv2:from_namespace:to_namespace'");
-            }
-
-            new TinyV2Writer(split[1], split[2]).write(mappings, path, ProgressListener.none(), saveParameters);
-            return;
-        }
-
-        if (type.startsWith("tiny:")) {
-            String[] split = type.split(":");
-
-            if (split.length != 3) {
-                throw new IllegalArgumentException("specify column names as 'tiny:from_column:to_column'");
-            }
-
-            new TinyMappingsWriter(split[1], split[2]).write(mappings, path, ProgressListener.none(), saveParameters);
-            return;
-        }
-
-        MappingFormat format = null;
-        try {
-            format = MappingFormat.valueOf(type.toUpperCase());
-        } catch (IllegalArgumentException ignored) {}
-
-        if (format != null) {
-            format.getWriter().write(mappings, path, ProgressListener.none(), saveParameters);
-            return;
-        }
-
-        throw new IllegalArgumentException("no writer for " + type);
-    }
+        private MappingCommandsUtil() {
+        }
+
+        public static EntryTree<EntryMapping> read(String type, Path path, MappingSaveParameters saveParameters) throws MappingParseException, IOException {
+                if (type.equals("enigma")) {
+                        return (Files.isDirectory(path) ? EnigmaMappingsReader.DIRECTORY : EnigmaMappingsReader.ZIP).read(path, ProgressListener.none(), saveParameters);
+                }
+
+                if (type.equals("tiny")) {
+                        return TinyMappingsReader.INSTANCE.read(path, ProgressListener.none(), saveParameters);
+                }
+
+                MappingFormat format = null;
+
+                try {
+                        format = MappingFormat.valueOf(type.toUpperCase());
+                } catch (IllegalArgumentException ignored) {
+                        if (type.equals("tinyv2")) {
+                                format = MappingFormat.TINY_V2;
+                        }
+                }
+
+                if (format != null) {
+                        return format.getReader().read(path, ProgressListener.none(), saveParameters);
+                }
+
+                throw new IllegalArgumentException("no reader for " + type);
+        }
+
+        public static void write(EntryTree<EntryMapping> mappings, String type, Path path, MappingSaveParameters saveParameters) {
+                if (type.equals("enigma")) {
+                        EnigmaMappingsWriter.DIRECTORY.write(mappings, path, ProgressListener.none(), saveParameters);
+                        return;
+                }
+
+                if (type.startsWith("tinyv2:") || type.startsWith("tiny_v2:")) {
+                        String[] split = type.split(":");
+
+                        if (split.length != 3) {
+                                throw new IllegalArgumentException("specify column names as 'tinyv2:from_namespace:to_namespace'");
+                        }
+
+                        new TinyV2Writer(split[1], split[2]).write(mappings, path, ProgressListener.none(), saveParameters);
+                        return;
+                }
+
+                if (type.startsWith("tiny:")) {
+                        String[] split = type.split(":");
+
+                        if (split.length != 3) {
+                                throw new IllegalArgumentException("specify column names as 'tiny:from_column:to_column'");
+                        }
+
+                        new TinyMappingsWriter(split[1], split[2]).write(mappings, path, ProgressListener.none(), saveParameters);
+                        return;
+                }
+
+                MappingFormat format = null;
+
+                try {
+                        format = MappingFormat.valueOf(type.toUpperCase());
+                } catch (IllegalArgumentException ignored) {
+                        // ignored
+                }
+
+                if (format != null) {
+                        format.getWriter().write(mappings, path, ProgressListener.none(), saveParameters);
+                        return;
+                }
+
+                throw new IllegalArgumentException("no writer for " + type);
+        }
 }
diff --git a/enigma-cli/src/test/java/cuchaz/enigma/command/CheckMappingsCommandTest.java b/enigma-cli/src/test/java/cuchaz/enigma/command/CheckMappingsCommandTest.java
index a29bba4..8cfa49e 100644
--- a/enigma-cli/src/test/java/cuchaz/enigma/command/CheckMappingsCommandTest.java
+++ b/enigma-cli/src/test/java/cuchaz/enigma/command/CheckMappingsCommandTest.java
@@ -1,21 +1,19 @@
 package cuchaz.enigma.command;
 
-import org.junit.Test;
-
 import java.io.File;
 
+import org.junit.Test;
+
 public class CheckMappingsCommandTest {
         private static final String PACKAGE_ACCESS = "../enigma/build/test-obf/packageAccess.jar";
 
         @Test(expected = IllegalStateException.class)
         public void testWrong() throws Exception {
-                new CheckMappingsCommand().run(new File(PACKAGE_ACCESS).getAbsolutePath(), new File("src/test/resources" +
-                                "/packageAccess/wrongMappings").getAbsolutePath());
+                new CheckMappingsCommand().run(new File(PACKAGE_ACCESS).getAbsolutePath(), new File("src/test/resources" + "/packageAccess/wrongMappings").getAbsolutePath());
         }
 
         @Test
         public void testRight() throws Exception {
-                new CheckMappingsCommand().run(new File(PACKAGE_ACCESS).getAbsolutePath(), new File("src/test/resources" +
-                                "/packageAccess/correctMappings").getAbsolutePath());
+                new CheckMappingsCommand().run(new File(PACKAGE_ACCESS).getAbsolutePath(), new File("src/test/resources" + "/packageAccess/correctMappings").getAbsolutePath());
         }
 }