From 8b0da63f86a6302241aefbf528272e996673c460 Mon Sep 17 00:00:00 2001
From: chrisly42 <chrisly@platon42.de>
Date: Tue, 23 Apr 2019 18:19:47 +0200
Subject: [PATCH] Another fix for AssertThatGuavaOptional inspection regarding
 using the same family name for slightly different quick fix executions
 (really, Jetbrains, this sucks for no reason). Consolidated location of
 methods.

---
 README.md                                     |  4 +++
 build.gradle                                  |  7 ++++-
 .../inspections/AbstractAssertJInspection.kt  | 14 +++++-----
 .../AssertThatBinaryExpressionInspection.kt   | 26 ++++++++---------
 .../AssertThatGuavaOptionalInspection.kt      | 28 +++++++++++++------
 .../AssertThatInstanceOfInspection.kt         | 22 +++++++--------
 ...tThatInvertedBooleanConditionInspection.kt | 20 ++++++-------
 .../AssertThatStringExpressionInspection.kt   | 28 +++++++++----------
 .../AssertThatGuavaOptionalInspectionTest.kt  | 25 +++++++++--------
 9 files changed, 99 insertions(+), 75 deletions(-)

diff --git a/README.md b/README.md
index e264293..93af54d 100644
--- a/README.md
+++ b/README.md
@@ -327,6 +327,10 @@ Feel free to use the code (in package de.platon42.intellij.jupiter) for your pro
 
 ## Changelog
 
+#### V0.7 (unreleased)
+- Another fix for AssertThatGuavaOptional inspection regarding using the same family name for slightly different quick fix executions
+  (really, Jetbrains, this sucks for no reason).
+
 #### V0.6 (22-Apr-19)
 - New AssertThatStringExpression inspection that will move ```isEmpty()```, ```equals()```, ```equalsIgnoreCase()```, ```contains()```,
   ```startsWith()```, and ```endsWith()``` out of actual expression.
diff --git a/build.gradle b/build.gradle
index bae5092..cef0c0c 100644
--- a/build.gradle
+++ b/build.gradle
@@ -5,7 +5,7 @@ plugins {
 }
 
 group 'de.platon42'
-version '0.6'
+version '0.7'
 
 repositories {
     mavenCentral()
@@ -40,6 +40,11 @@ intellij {
 
 patchPluginXml {
     changeNotes """
+  <h4>V0.7 (unreleased)</h4>
+    <ul>
+      <li>Another fix for AssertThatGuavaOptional inspection regarding using the same family name for slightly different quick fix executions
+          (really, Jetbrains, this sucks for no reason).
+    </ul>  
   <h4>V0.6 (22-Apr-19)</h4>
     <ul>
       <li>New AssertThatStringExpression inspection that will move isEmpty(), equals(), equalsIgnoreCase(), contains(),
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AbstractAssertJInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AbstractAssertJInspection.kt
index 7aaa07f..892dd5b 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AbstractAssertJInspection.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AbstractAssertJInspection.kt
@@ -184,16 +184,16 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
         replacementMethod: String,
         quickFixSupplier: (String, String) -> LocalQuickFix
     ) {
-        registerConciseMethod(REPLACE_DESCRIPTION_TEMPLATE, oldExpectedCallExpression, replacementMethod, quickFixSupplier, holder, expression)
+        registerConciseMethod(REPLACE_DESCRIPTION_TEMPLATE, holder, expression, oldExpectedCallExpression, replacementMethod, quickFixSupplier)
     }
 
-    private fun registerConciseMethod(
+    protected fun registerConciseMethod(
         descriptionTemplate: String,
+        holder: ProblemsHolder,
+        expression: PsiMethodCallExpression,
         oldExpectedCallExpression: PsiMethodCallExpression,
         replacementMethod: String,
-        quickFixSupplier: (String, String) -> LocalQuickFix,
-        holder: ProblemsHolder,
-        expression: PsiMethodCallExpression
+        quickFixSupplier: (String, String) -> LocalQuickFix
     ) {
         val originalMethod = getOriginalMethodName(oldExpectedCallExpression) ?: return
         val description = descriptionTemplate.format(originalMethod, replacementMethod)
@@ -209,7 +209,7 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
         replacementMethod: String,
         quickFixSupplier: (String, String) -> LocalQuickFix
     ) {
-        registerConciseMethod(REMOVE_EXPECTED_OUTMOST_DESCRIPTION_TEMPLATE, oldExpectedCallExpression, replacementMethod, quickFixSupplier, holder, expression)
+        registerConciseMethod(REMOVE_EXPECTED_OUTMOST_DESCRIPTION_TEMPLATE, holder, expression, oldExpectedCallExpression, replacementMethod, quickFixSupplier)
     }
 
     protected fun registerRemoveActualOutmostMethod(
@@ -219,7 +219,7 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
         replacementMethod: String,
         quickFixSupplier: (String, String) -> LocalQuickFix
     ) {
-        registerConciseMethod(REMOVE_ACTUAL_OUTMOST_DESCRIPTION_TEMPLATE, oldExpectedCallExpression, replacementMethod, quickFixSupplier, holder, expression)
+        registerConciseMethod(REMOVE_ACTUAL_OUTMOST_DESCRIPTION_TEMPLATE, holder, expression, oldExpectedCallExpression, replacementMethod, quickFixSupplier)
     }
 
     protected fun calculateConstantParameterValue(expression: PsiMethodCallExpression, argIndex: Int): Any? {
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBinaryExpressionInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBinaryExpressionInspection.kt
index 8061382..4f5cbe6 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBinaryExpressionInspection.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBinaryExpressionInspection.kt
@@ -76,19 +76,19 @@ class AssertThatBinaryExpressionInspection : AbstractAssertJInspection() {
                     SplitBinaryExpressionMethodCallQuickFix(desc, method, pickRightOperand = swapExpectedAndActual)
                 }
             }
-
-            private fun registerSplitMethod(
-                holder: ProblemsHolder,
-                expression: PsiMethodCallExpression,
-                type: String,
-                replacementMethod: String,
-                quickFixSupplier: (String, String) -> LocalQuickFix
-            ) {
-                val description = SPLIT_EXPRESSION_DESCRIPTION_TEMPLATE.format(type)
-                val message = MORE_MEANINGFUL_MESSAGE_TEMPLATE.format(type)
-                val quickfix = quickFixSupplier(description, replacementMethod)
-                holder.registerProblem(expression, message, quickfix)
-            }
         }
     }
+
+    private fun registerSplitMethod(
+        holder: ProblemsHolder,
+        expression: PsiMethodCallExpression,
+        type: String,
+        replacementMethod: String,
+        quickFixSupplier: (String, String) -> LocalQuickFix
+    ) {
+        val description = SPLIT_EXPRESSION_DESCRIPTION_TEMPLATE.format(type)
+        val message = MORE_MEANINGFUL_MESSAGE_TEMPLATE.format(type)
+        val quickfix = quickFixSupplier(description, replacementMethod)
+        holder.registerProblem(expression, message, quickfix)
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatGuavaOptionalInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatGuavaOptionalInspection.kt
index 71308ef..ead9119 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatGuavaOptionalInspection.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatGuavaOptionalInspection.kt
@@ -14,6 +14,9 @@ class AssertThatGuavaOptionalInspection : AbstractAssertJInspection() {
 
     companion object {
         private const val DISPLAY_NAME = "Asserting an Optional (Guava)"
+        private const val REPLACE_GUAVA_DESCRIPTION_TEMPLATE = "Replace %s() with Guava assertThat().%s()"
+        private const val REMOVE_EXPECTED_OUTMOST_GUAVA_DESCRIPTION_TEMPLATE = "Remove unwrapping of expected expression and replace %s() with Guava assertThat().%s()"
+        private const val REMOVE_ACTUAL_OUTMOST_GUAVA_DESCRIPTION_TEMPLATE = "Unwrap actual expression and replace %s() with Guava assertThat().%s()"
     }
 
     override fun getDisplayName() = DISPLAY_NAME
@@ -62,12 +65,7 @@ class AssertThatGuavaOptionalInspection : AbstractAssertJInspection() {
                     if (isEqualTo) {
                         val innerExpectedCall = expectedCallExpression.firstArg as? PsiMethodCallExpression ?: return
                         if (CallMatcher.anyOf(GUAVA_OPTIONAL_OF, GUAVA_OPTIONAL_FROM_NULLABLE).test(innerExpectedCall)) {
-                            registerRemoveExpectedOutmostMethod(holder, expression, expectedCallExpression, MethodNames.CONTAINS) { desc, method ->
-                                QuickFixWithPostfixDelegate(
-                                    RemoveExpectedOutmostMethodCallQuickFix(desc, method),
-                                    ForGuavaPostFix.REPLACE_BY_GUAVA_ASSERT_THAT_AND_STATIC_IMPORT
-                                )
-                            }
+                            registerRemoveExpectedOutmostGuavaMethod(holder, expression, expectedCallExpression, MethodNames.CONTAINS)
                         } else if (GUAVA_OPTIONAL_ABSENT.test(innerExpectedCall)) {
                             registerSimplifyForGuavaMethod(holder, expectedCallExpression, MethodNames.IS_ABSENT)
                         }
@@ -82,6 +80,20 @@ class AssertThatGuavaOptionalInspection : AbstractAssertJInspection() {
         }
     }
 
+    private fun registerRemoveExpectedOutmostGuavaMethod(
+        holder: ProblemsHolder,
+        expression: PsiMethodCallExpression,
+        oldExpectedCallExpression: PsiMethodCallExpression,
+        replacementMethod: String
+    ) {
+        registerConciseMethod(REMOVE_EXPECTED_OUTMOST_GUAVA_DESCRIPTION_TEMPLATE, holder, expression, oldExpectedCallExpression, replacementMethod) { desc, method ->
+            QuickFixWithPostfixDelegate(
+                RemoveExpectedOutmostMethodCallQuickFix(desc, method),
+                ForGuavaPostFix.REPLACE_BY_GUAVA_ASSERT_THAT_AND_STATIC_IMPORT
+            )
+        }
+    }
+
     private fun registerRemoveActualOutmostForGuavaMethod(
         holder: ProblemsHolder,
         expression: PsiMethodCallExpression,
@@ -89,7 +101,7 @@ class AssertThatGuavaOptionalInspection : AbstractAssertJInspection() {
         replacementMethod: String,
         noExpectedExpression: Boolean = false
     ) {
-        registerRemoveActualOutmostMethod(holder, expression, oldExpectedCallExpression, replacementMethod) { desc, method ->
+        registerConciseMethod(REMOVE_ACTUAL_OUTMOST_GUAVA_DESCRIPTION_TEMPLATE, holder, expression, oldExpectedCallExpression, replacementMethod) { desc, method ->
             QuickFixWithPostfixDelegate(
                 RemoveActualOutmostMethodCallQuickFix(desc, method, noExpectedExpression),
                 ForGuavaPostFix.REPLACE_BY_GUAVA_ASSERT_THAT_AND_STATIC_IMPORT
@@ -99,7 +111,7 @@ class AssertThatGuavaOptionalInspection : AbstractAssertJInspection() {
 
     private fun registerSimplifyForGuavaMethod(holder: ProblemsHolder, expression: PsiMethodCallExpression, replacementMethod: String) {
         val originalMethod = getOriginalMethodName(expression) ?: return
-        val description = REPLACE_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
+        val description = REPLACE_GUAVA_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
         val message = SIMPLIFY_MESSAGE_TEMPLATE.format(originalMethod, replacementMethod)
         val quickFix = QuickFixWithPostfixDelegate(
             ReplaceSimpleMethodCallQuickFix(description, replacementMethod),
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInstanceOfInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInstanceOfInspection.kt
index d576a56..bbf0ee2 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInstanceOfInspection.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInstanceOfInspection.kt
@@ -38,17 +38,17 @@ class AssertThatInstanceOfInspection : AbstractAssertJInspection() {
                     registerRemoveInstanceOfMethod(holder, expression, replacementMethod, ::RemoveInstanceOfExpressionQuickFix)
                 }
             }
-
-            private fun registerRemoveInstanceOfMethod(
-                holder: ProblemsHolder,
-                expression: PsiMethodCallExpression,
-                replacementMethod: String,
-                quickFixSupplier: (String, String) -> LocalQuickFix
-            ) {
-                val description = REPLACE_INSTANCEOF_DESCRIPTION_TEMPLATE.format(replacementMethod)
-                val quickfix = quickFixSupplier(description, replacementMethod)
-                holder.registerProblem(expression, MOVE_OUT_INSTANCEOF_MESSAGE, quickfix)
-            }
         }
     }
+
+    private fun registerRemoveInstanceOfMethod(
+        holder: ProblemsHolder,
+        expression: PsiMethodCallExpression,
+        replacementMethod: String,
+        quickFixSupplier: (String, String) -> LocalQuickFix
+    ) {
+        val description = REPLACE_INSTANCEOF_DESCRIPTION_TEMPLATE.format(replacementMethod)
+        val quickfix = quickFixSupplier(description, replacementMethod)
+        holder.registerProblem(expression, MOVE_OUT_INSTANCEOF_MESSAGE, quickfix)
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInvertedBooleanConditionInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInvertedBooleanConditionInspection.kt
index 8553e3e..ddf1934 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInvertedBooleanConditionInspection.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatInvertedBooleanConditionInspection.kt
@@ -36,16 +36,16 @@ class AssertThatInvertedBooleanConditionInspection : AbstractAssertJInspection()
                     registerInvertMethod(holder, expression, replacementMethod, ::RemoveUnaryExpressionQuickFix)
                 }
             }
-
-            private fun registerInvertMethod(
-                holder: ProblemsHolder,
-                expression: PsiMethodCallExpression,
-                replacementMethod: String,
-                quickFixSupplier: (String, String) -> LocalQuickFix
-            ) {
-                val quickfix = quickFixSupplier(INVERT_CONDITION_DESCRIPTION, replacementMethod)
-                holder.registerProblem(expression, INVERT_CONDITION_MESSAGE, quickfix)
-            }
         }
     }
+
+    private fun registerInvertMethod(
+        holder: ProblemsHolder,
+        expression: PsiMethodCallExpression,
+        replacementMethod: String,
+        quickFixSupplier: (String, String) -> LocalQuickFix
+    ) {
+        val quickfix = quickFixSupplier(INVERT_CONDITION_DESCRIPTION, replacementMethod)
+        holder.registerProblem(expression, INVERT_CONDITION_MESSAGE, quickfix)
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringExpressionInspection.kt b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringExpressionInspection.kt
index 7e57f40..8b3f07b 100644
--- a/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringExpressionInspection.kt
+++ b/src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringExpressionInspection.kt
@@ -76,23 +76,23 @@ class AssertThatStringExpressionInspection : AbstractAssertJInspection() {
                     }
                 }
             }
-
-            private fun registerMoveOutMethod(
-                holder: ProblemsHolder,
-                expression: PsiMethodCallExpression,
-                oldActualExpression: PsiMethodCallExpression,
-                replacementMethod: String,
-                quickFixSupplier: (String, String) -> LocalQuickFix
-            ) {
-                val originalMethod = getOriginalMethodName(oldActualExpression) ?: return
-                val description = MOVE_EXPECTED_EXPRESSION_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
-                val message = MOVING_OUT_MESSAGE_TEMPLATE.format(originalMethod)
-                val quickfix = quickFixSupplier(description, replacementMethod)
-                holder.registerProblem(expression, message, quickfix)
-            }
         }
     }
 
+    private fun registerMoveOutMethod(
+        holder: ProblemsHolder,
+        expression: PsiMethodCallExpression,
+        oldActualExpression: PsiMethodCallExpression,
+        replacementMethod: String,
+        quickFixSupplier: (String, String) -> LocalQuickFix
+    ) {
+        val originalMethod = getOriginalMethodName(oldActualExpression) ?: return
+        val description = MOVE_EXPECTED_EXPRESSION_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
+        val message = MOVING_OUT_MESSAGE_TEMPLATE.format(originalMethod)
+        val quickfix = quickFixSupplier(description, replacementMethod)
+        holder.registerProblem(expression, message, quickfix)
+    }
+
     private class Mapping(
         val callMatcher: CallMatcher,
         val replacementForTrue: String,
diff --git a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatGuavaOptionalInspectionTest.kt b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatGuavaOptionalInspectionTest.kt
index 086c8ee..5e01219 100644
--- a/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatGuavaOptionalInspectionTest.kt
+++ b/src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatGuavaOptionalInspectionTest.kt
@@ -17,16 +17,19 @@ internal class AssertThatGuavaOptionalInspectionTest : AbstractCajonTest() {
         runTest {
             myFixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
             myFixture.configureByFile("GuavaOptionalBefore.java")
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isEqualTo() with isPresent()"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isNotEqualTo() with isPresent()"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isPresent()"), 3)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isEqualTo() with isAbsent()"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isAbsent()"), 3)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isNotEqualTo() with isAbsent()"), 2)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isTrue() with isPresent()"), 1)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isFalse() with isAbsent()"), 1)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isEqualTo() with contains()"), 1)
-            executeQuickFixes(myFixture, Regex.fromLiteral("Remove unwrapping of expected expression and replace isEqualTo() with contains()"), 6)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isEqualTo() with Guava assertThat().isPresent()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isNotEqualTo() with Guava assertThat().isPresent()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with isPresent()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isNotEqualTo() with Guava assertThat().isPresent()"), 1)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isEqualTo() with Guava assertThat().isAbsent()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isAbsent()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with Guava assertThat().isAbsent()"), 1)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isNotEqualTo() with Guava assertThat().isAbsent()"), 2)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isTrue() with Guava assertThat().isPresent()"), 1)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isFalse() with Guava assertThat().isAbsent()"), 1)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Unwrap actual expression and replace isEqualTo() with Guava assertThat().contains()"), 1)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Remove unwrapping of expected expression and replace isEqualTo() with contains()"), 4)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Remove unwrapping of expected expression and replace isEqualTo() with Guava assertThat().contains()"), 2)
             myFixture.checkResultByFile("GuavaOptionalAfter.java")
         }
     }
@@ -46,7 +49,7 @@ internal class AssertThatGuavaOptionalInspectionTest : AbstractCajonTest() {
         runTest {
             myFixture.enableInspections(AssertThatGuavaOptionalInspection::class.java)
             myFixture.configureByFile("WithoutPriorGuavaImportBefore.java")
-            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with isAbsent()"), 1)
+            executeQuickFixes(myFixture, Regex.fromLiteral("Replace isEqualTo() with Guava assertThat().isAbsent()"), 1)
             executeQuickFixes(myFixture, Regex(".*eplace .* with .*"), 6)
             myFixture.checkResultByFile("WithoutPriorGuavaImportAfter.java")
         }