Bug fixes

 - Fixed class mappings not being created
 - Fixed libraries being included both in plugin zip and Knit jar
 - Improved build.gradle and plugin.xml
 - Fixed renaming constructor parameters not working
 - Added support for classes in the default package
 - Improved instructions

Author: Runemoro

build.gradle

@@ -4,7 +4,7 @@ plugins {
 }
 
 group 'org.dimdev'
-version '1.0.1'
+version '1.0.2'
 
 sourceCompatibility = 1.8
 
@@ -21,10 +21,14 @@ dependencies {
     compile 'cuchaz:enigma:0.12.2.62:lib'
 }
 
-jar {
-    from configurations.compile.collect { it.isDirectory() ? it : zipTree(it) }
-}
-
 intellij {
     version '2018.3'
 }
+
+processResources {
+    filesMatching('plugin.xml') {
+        expand 'version': project.version
+    }
+
+    inputs.property 'version', project.version
+}

src/main/java/org/dimdev/knit/KnitRefactoringListenerProvider.java

@@ -22,7 +22,7 @@ public RefactoringElementListener getListener(PsiElement element) {
         if (element instanceof PsiClass) {
             oldName = RenameHandler.getClassName((PsiClass) element);
         } else if (element instanceof PsiMethod) {
-            oldName = ((PsiMethod) element).getName();
+            oldName = ((PsiMethod) element).isConstructor() ? "<init>" : ((PsiMethod) element).getName();
         } else if (element instanceof PsiField) {
             oldName = ((PsiField) element).getName();
         } else {

src/main/java/org/dimdev/knit/MappingsService.java

@@ -52,8 +52,4 @@ public void clearMappings() {
     public boolean hasMappings() {
         return mappings != null;
     }
-
-    static { // TODO: this should probably go somewhere else
-
-    }
 }

src/main/java/org/dimdev/knit/RenameHandler.java

@@ -5,8 +5,11 @@
 import com.intellij.openapi.components.ServiceManager;
 import com.intellij.psi.*;
 import cuchaz.enigma.mapping.*;
+import cuchaz.enigma.throwables.MappingConflict;
 
 public class RenameHandler {
+    public static final String NO_PACKAGE_PREFIX = "nopackage/";
+    public static final int MAX_OBFUSCATED_NAME_LENGTH = 3;
     private final MappingsService mappingsService = ServiceManager.getService(MappingsService.class);
 
     public void handleRename(String oldName, PsiElement element) {
@@ -15,49 +18,61 @@ public void handleRename(String oldName, PsiElement element) {
         }
 
         if (element instanceof PsiClass) {
-            ClassMapping mapping = getClassMapping(oldName);
+            PsiClass clazz = (PsiClass) element;
+
+            ClassMapping mapping = getOrCreateClassMapping(oldName);
             if (mapping != null) {
-                mappingsService.getMappings().setClassDeobfName(mapping, getClassName((PsiClass) element));
+                mappingsService.getMappings().setClassDeobfName(mapping, getClassName(clazz));
             }
         }
 
         if (element instanceof PsiField) {
-            ClassMapping classMapping = getClassMapping(getClassName(((PsiField) element).getContainingClass()));
-            FieldMapping fieldMapping = getOrCreateFieldMapping((PsiField) element, oldName);
-            classMapping.setFieldName(fieldMapping.getObfName(), fieldMapping.getObfDesc(), ((PsiField) element).getName());
+            PsiField field = (PsiField) element;
+
+            ClassMapping classMapping = getOrCreateClassMapping(getClassName(field.getContainingClass()));
+            FieldMapping fieldMapping = getOrCreateFieldMapping(field, oldName);
+            classMapping.setFieldName(fieldMapping.getObfName(), fieldMapping.getObfDesc(), field.getName());
         }
 
         if (element instanceof PsiMethod) {
-            ClassMapping classMapping = getClassMapping(getClassName(((PsiMethod) element).getContainingClass()));
-            MethodMapping methodMapping = getOrCreateMethodMapping((PsiMethod) element, oldName);
-            classMapping.setMethodName(methodMapping.getObfName(), methodMapping.getObfDesc(), ((PsiMethod) element).getName());
+            PsiMethod method = (PsiMethod) element;
+
+            if (method.isConstructor()) {
+                return;
+            }
+
+            ClassMapping classMapping = getOrCreateClassMapping(getClassName(method.getContainingClass()));
+            MethodMapping methodMapping = getOrCreateMethodMapping(method, oldName);
+            classMapping.setMethodName(methodMapping.getObfName(), methodMapping.getObfDesc(), method.getName());
         }
 
         if (element instanceof PsiParameter) {
-            PsiElement declarationScope = ((PsiParameter) element).getDeclarationScope();
+            PsiParameter parameter = (PsiParameter) element;
+
+            PsiElement declarationScope = parameter.getDeclarationScope();
             if (declarationScope instanceof PsiMethod) {
                 MethodMapping mapping = getOrCreateMethodMapping((PsiMethod) declarationScope, ((PsiMethod) declarationScope).getName());
 
                 if (mapping != null) {
                     int index = ((PsiMethod) declarationScope).hasModifier(JvmModifier.STATIC) ? 0 : 1;
                     boolean found = false;
-                    for (PsiParameter parameter : ((PsiMethod) declarationScope).getParameterList().getParameters()) {
-                        if (parameter.equals(element)) {
+                    for (PsiParameter currentParameter : ((PsiMethod) declarationScope).getParameterList().getParameters()) {
+                        if (currentParameter.equals(parameter)) {
                             found = true;
                             break;
                         }
-                        index += parameter.getType().equals(PsiType.LONG) || parameter.getType().equals(PsiType.DOUBLE) ? 2 : 1;
+                        index += currentParameter.getType().equals(PsiType.LONG) || currentParameter.getType().equals(PsiType.DOUBLE) ? 2 : 1;
                     }
 
                     if (found) {
-                        mapping.setLocalVariableName(index, ((PsiParameter) element).getName());
+                        mapping.setLocalVariableName(index, parameter.getName());
                     }
                 }
             }
         }
     }
 
-    private ClassMapping getClassMapping(String className) {
+    private ClassMapping getOrCreateClassMapping(String className) {
         // Try getting deobfuscated class mapping
         ClassMapping mapping = mappingsService.getMappings().getClassByDeobf(className);
 
@@ -66,12 +81,27 @@ private ClassMapping getClassMapping(String className) {
             mapping = mappingsService.getMappings().getClassByObf(className);
         }
 
+        // If that doesn't work either, create a new class mapping
+        if (mapping == null && className.length() <= MAX_OBFUSCATED_NAME_LENGTH) {
+            try {
+                mapping = new ClassMapping(className);
+                mappingsService.getMappings().addClassMapping(mapping);
+            } catch (MappingConflict e) {
+                throw new IllegalStateException("Both getClassByDeobf and getClassByObf returned null yet addClassMapping " +
+                                                "threw a MappingConflict exception", e);
+            }
+        }
+
         return mapping;
     }
 
     private MethodMapping getOrCreateMethodMapping(PsiMethod method, String actualName) {
+        if (method.isConstructor()) {
+            actualName = "<init>";
+        }
+
         // Get mapping for containing class
-        ClassMapping classMapping = getClassMapping(getClassName(method.getContainingClass()));
+        ClassMapping classMapping = getOrCreateClassMapping(getClassName(method.getContainingClass()));
         if (classMapping == null) {
             return null;
         }
@@ -86,7 +116,7 @@ private MethodMapping getOrCreateMethodMapping(PsiMethod method, String actualNa
         }
 
         // If that doesn't work either, create a new method mapping
-        if (mapping == null) {
+        if (mapping == null && actualName.length() <= MAX_OBFUSCATED_NAME_LENGTH) {
             mapping = new MethodMapping(actualName, descriptor);
             classMapping.addMethodMapping(mapping);
         }
@@ -96,7 +126,7 @@ private MethodMapping getOrCreateMethodMapping(PsiMethod method, String actualNa
 
     private FieldMapping getOrCreateFieldMapping(PsiField field, String actualName) {
         // Get mapping for containing class
-        ClassMapping classMapping = getClassMapping(getClassName(field.getContainingClass()));
+        ClassMapping classMapping = getOrCreateClassMapping(getClassName(field.getContainingClass()));
         if (classMapping == null) {
             return null;
         }
@@ -111,7 +141,7 @@ private FieldMapping getOrCreateFieldMapping(PsiField field, String actualName)
         }
 
         // If that doesn't work either, create a new field mapping
-        if (mapping == null) {
+        if (mapping == null && actualName.length() <= MAX_OBFUSCATED_NAME_LENGTH) {
             mapping = new FieldMapping(actualName, descriptor, actualName, Mappings.EntryModifier.UNCHANGED);
             classMapping.addFieldMapping(mapping);
         }
@@ -134,7 +164,12 @@ public TypeDescriptor obfuscateDescriptor(TypeDescriptor descriptor) {
     }
 
     public static String getClassName(PsiClass element) {
-        return JVMNameUtil.getClassVMName(element).replace('.', '/');
+        String className = JVMNameUtil.getClassVMName(element).replace('.', '/');
+
+        if (className.startsWith(NO_PACKAGE_PREFIX)) {
+            className = className.substring(NO_PACKAGE_PREFIX.length());
+        }
+        return className;
     }
 
     public static String getDescriptor(PsiType type) {

src/main/resources/META-INF/plugin.xml

@@ -1,31 +1,61 @@
 <idea-plugin>
     <id>org.dimdev.knit</id>
     <name>Knit</name>
-    <version>1.0</version>
+    <version>${version}</version>
     <vendor url="https://www.dimdev.org">Dimensional Development</vendor>
 
     <description>
         <![CDATA[
-        <p>Adds support for editing Enigma mappings directly in IntelliJ.<br/></p>
+        <p>Adds support for editing Enigma mappings directly in IntelliJ.</p>
 
-        <b>Usage:</b>
+        <h2>Instructions</h2>
+
+        <h3>Setting up Minecraft sources</h3>
         <ol>
-            <li>Set up a gradle project with this build.gradle (last updated for 18w50a): https://paste.dimdev.org/raw/yoxamudixi</li>
+            <li>Set up a gradle project with <a href="https://paste.dimdev.org/raw/yoxamudixi">this build.gradle (last updated for 18w50a)</a>.</li>
             <li>Export source code from enigma to src/main/java</li>
             <li>Open the project in IntelliJ with the plugin installed</li>
-            <li>Click 'Refactor > Enable Remapping' and select the Enigma 'mappings' folder</li>
+            <li>Move all classes in the default package to a new package named "nopackage" (can't be named something else)</li>
+            <li>Do a regex find-replace (Ctrl-Shift-R, check "Regex") and replace "\n\nimport" with "\n\nimport nopackage;\nimport"</li>
+        </ol>
+
+        <h3>Enabling remapping</h3>
+        <ol>
+            <li>Click "Refactor | Enable Remapping" and select the Enigma "mappings" folder</li>
             <li>Rename classes, fields, methods, and parameters through Shift-F6</li>
-            <li>Save every once in a while using 'Refactor > Save Mappings'</li>
+            <li>Save every once in a while using "Refactor | Save Mappings"</li>
         </ol>
 
-        <p><i>Note:</i> You may want to disable IntelliJ's "search and strings and comments" feature. It slows things down
-        and finds lots of false matches when renaming one letter names.</p>
+        <p><i>Note 1:</i> You may want to disable IntelliJ's "search and strings and comments" feature since it can lead to false matches
+        when renaming obfuscated names. To do this, you can press Shift-F6 twice when renaming the first name and unchecking all boxes.
+        It will stay disabled for the current project until you manually re-enable it.</p>
+
+        <p><i>Note 2:</i> Undo is not yet supported. If you want to change a name after renaming it, just rename it again. If you accidentally
+        undo, just redo and change the name.</p>
+
+        <h2>Source code</h2>
+
+        <a href="https://github.com/DimensionalDevelopment/knit">https://github.com/DimensionalDevelopment/knit</a></p>
         ]]>
     </description>
 
     <change-notes>
-        1.0.1 - Updated Enigma version
-        1.0 - Initial release
+        <![CDATA[
+        <b>1.0.2</b>
+        <ul>
+            <li>Fixed class mappings not being created</li>
+            <li>Fixed libraries being included both in plugin zip and Knit jar</li>
+            <li>Fixed renaming constructor parameters not working</li>
+            <li>Added support for classes in default package</li>
+            <li>Improved instructions</li>
+        </ul>
+        <b>1.0.1</b>
+        <ul>
+            <li>Updated Enigma version</li>
+        </ul>
+        <b>1.0</b>
+            <li>Initial release</li>
+        ]]>
     </change-notes>
 
     <idea-version since-build="173.0"/>
@@ -40,9 +70,7 @@
         <action id="Knit.EnableRemapping" class="org.dimdev.knit.EnableRemappingAction" text="Enable Remapping" description="Enable or disable remapping mode">
             <add-to-group group-id="RefactoringMenu"/>
         </action>
-    </actions>
 
-    <actions>
         <action id="Knit.SaveMappings" class="org.dimdev.knit.SaveMappingsAction" text="Save Mappings" description="Save mappings to directory they were loaded from">
             <add-to-group group-id="RefactoringMenu"/>
         </action>