chrisly42/cajon-plugin
1
0
Fork 0
Code Issues 4 Pull Requests 1 Packages Projects Releases Wiki Activity

Implemented AssertThatEnumerableIsEmptyInspection. Improved literal values by constant value calculation, more refactoring.

Browse Source
This commit is contained in:
Chris Hodges 2019-03-24 14:42:02 +01:00
parent e2ffce753c
commit 582e254195
14 changed files with 160 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
README.md
View File

@ -39,6 +39,9 @@ Then AssertJ would tell you the contents of the collection on failure.
> from: assertThat(charSequence/string).isEqualTo("");
> from: assertThat(charSequence/string).hasSize(0);
> to: assertThat(charSequence/string).isEmpty();
- AssertThatEnumerableIsEmpty
> from: assertThat(enumerable).hasSize(0);
> to: assertThat(charSequence/string).isEmpty();
## TODO
- AssertThatArrayHasLiteralSize

27
src/main/java/de/platon42/intellij/plugins/cajon/inspections/AbstractAssertJInspection.kt
View File

@ -27,19 +27,22 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
const val ABSTRACT_BOOLEAN_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractBooleanAssert"
const val ABSTRACT_STRING_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractStringAssert"
const val ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME = "org.assertj.core.api.AbstractCharSequenceAssert"
const val IS_EQUAL_TO = "isEqualTo"
const val IS_NOT_EQUAL_TO = "isNotEqualTo"
const val HAS_SIZE = "hasSize"
const val ABSTRACT_ENUMERABLE_ASSERT_CLASSNAME = "org.assertj.core.api.EnumerableAssert"
val IS_EQUAL_TO_OBJECT = CallMatcher.instanceCall(ABSTRACT_ASSERT_CLASSNAME, IS_EQUAL_TO)
const val IS_EQUAL_TO_METHOD = "isEqualTo"
const val IS_NOT_EQUAL_TO_METHOD = "isNotEqualTo"
const val HAS_SIZE_METHOD = "hasSize"
val IS_EQUAL_TO_OBJECT = CallMatcher.instanceCall(ABSTRACT_ASSERT_CLASSNAME, IS_EQUAL_TO_METHOD)
.parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
val IS_NOT_EQUAL_TO_OBJECT = CallMatcher.instanceCall(ABSTRACT_ASSERT_CLASSNAME, IS_NOT_EQUAL_TO)
val IS_NOT_EQUAL_TO_OBJECT = CallMatcher.instanceCall(ABSTRACT_ASSERT_CLASSNAME, IS_NOT_EQUAL_TO_METHOD)
.parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)!!
val IS_EQUAL_TO_BOOLEAN = CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, IS_EQUAL_TO)
val IS_EQUAL_TO_BOOLEAN = CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, IS_EQUAL_TO_METHOD)
.parameterTypes("boolean")!!
val IS_NOT_EQUAL_TO_BOOLEAN = CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, IS_NOT_EQUAL_TO)
.parameterTypes("boolean")!!
val CHAR_SEQUENCE_HAS_SIZE = CallMatcher.instanceCall(ABSTRACT_CHAR_SEQUENCE_ASSERT_CLASSNAME, HAS_SIZE)
val IS_NOT_EQUAL_TO_BOOLEAN =
CallMatcher.instanceCall(ABSTRACT_BOOLEAN_ASSERT_CLASSNAME, IS_NOT_EQUAL_TO_METHOD)
.parameterTypes("boolean")!!
val HAS_SIZE = CallMatcher.instanceCall(ABSTRACT_ENUMERABLE_ASSERT_CLASSNAME, HAS_SIZE_METHOD)
.parameterTypes("int")!!
}
@ -77,4 +80,10 @@ open class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool() {
ReplaceSimpleMethodCallQuickFix(description, replacementMethod)
)
}
protected fun calculateConstantParameterValue(expression: PsiMethodCallExpression, argIndex: Int): Any? {
val valueExpression = expression.argumentList.expressions[argIndex] ?: return null
val constantEvaluationHelper = JavaPsiFacade.getInstance(expression.project).constantEvaluationHelper
return constantEvaluationHelper.computeConstantExpression(valueExpression)
}
}

13
src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatBooleanIsTrueOrFalseInspection.kt
View File

@ -31,22 +31,21 @@ class AssertThatBooleanIsTrueOrFalseInspection : AbstractAssertJInspection() {
return
}
val equalToExpression = expression.argumentList.expressions[0]!!
val equalToExpression = expression.argumentList.expressions[0] ?: return
if (!TypeConversionUtil.isBooleanType(equalToExpression.type)) {
return
}
val constantEvaluationHelper = JavaPsiFacade.getInstance(holder.project).constantEvaluationHelper
var result = constantEvaluationHelper.computeConstantExpression(equalToExpression)
if (result == null) {
var value = calculateConstantParameterValue(expression, 0)
if (value == null) {
val field = (equalToExpression as? PsiReferenceExpression)?.resolve() as? PsiField
if (field?.containingClass?.qualifiedName == CommonClassNames.JAVA_LANG_BOOLEAN) {
when {
field.name == "TRUE" -> result = true
field.name == "FALSE" -> result = false
field.name == "TRUE" -> value = true
field.name == "FALSE" -> value = false
}
}
}
val expectedResult = result as? Boolean ?: return
val expectedResult = value as? Boolean ?: return
val replacementMethod = if (expectedResult xor flippedBooleanTest) "isTrue()" else "isFalse()"
registerSimplifyMethod(holder, expression, replacementMethod)

34
src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatEnumerableIsEmptyInspection.kt Normal file
View File

@ -0,0 +1,34 @@
package de.platon42.intellij.plugins.cajon.inspections
import com.intellij.codeInspection.ProblemsHolder
import com.intellij.psi.JavaElementVisitor
import com.intellij.psi.PsiElementVisitor
import com.intellij.psi.PsiMethodCallExpression
import org.jetbrains.annotations.NonNls
class AssertThatEnumerableIsEmptyInspection : AbstractAssertJInspection() {
companion object {
@NonNls
private val DISPLAY_NAME = "Asserting an enumerable is empty"
}
override fun getDisplayName() = DISPLAY_NAME
override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
return object : JavaElementVisitor() {
override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
super.visitMethodCallExpression(expression)
val hasSize = HAS_SIZE.test(expression)
if (!hasSize) {
return
}
val value = calculateConstantParameterValue(expression, 0) ?: return
if (value == 0) {
registerSimplifyMethod(holder, expression, "isEmpty()")
}
}
}
}
}

17
src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatStringIsEmptyInspection.kt
View File

@ -3,7 +3,6 @@ package de.platon42.intellij.plugins.cajon.inspections
import com.intellij.codeInspection.ProblemsHolder
import com.intellij.psi.JavaElementVisitor
import com.intellij.psi.PsiElementVisitor
import com.intellij.psi.PsiLiteralExpression
import com.intellij.psi.PsiMethodCallExpression
import org.jetbrains.annotations.NonNls
@ -21,7 +20,7 @@ class AssertThatStringIsEmptyInspection : AbstractAssertJInspection() {
override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
super.visitMethodCallExpression(expression)
val isEqual = IS_EQUAL_TO_OBJECT.test(expression)
val hasSize = CHAR_SEQUENCE_HAS_SIZE.test(expression)
val hasSize = HAS_SIZE.test(expression)
if (!(isEqual || hasSize)) {
return
}
@ -30,17 +29,9 @@ class AssertThatStringIsEmptyInspection : AbstractAssertJInspection() {
return
}
if (isEqual) {
val psiExpression = expression.argumentList.expressions[0] as? PsiLiteralExpression ?: return
if (psiExpression.value == "") {
registerSimplifyMethod(holder, expression, "isEmpty()")
}
} else {
val psiExpression = expression.argumentList.expressions[0] as? PsiLiteralExpression ?: return
if (psiExpression.value == 0) {
registerSimplifyMethod(holder, expression, "isEmpty()")
}
val value = calculateConstantParameterValue(expression, 0) ?: return
if ((isEqual && (value == "")) || (hasSize && (value == 0))) {
registerSimplifyMethod(holder, expression, "isEmpty()")
}
}
}

3
src/main/resources/META-INF/plugin.xml
View File

@ -27,6 +27,9 @@
implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatBooleanIsTrueOrFalseInspection"/>
<localInspection groupPath="Java" shortName="AssertThatStringIsEmpty" enabledByDefault="true" level="WARNING"
implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatStringIsEmptyInspection"/>
<localInspection groupPath="Java" shortName="AssertThatEnumerableIsEmpty" enabledByDefault="true"
level="WARNING"
implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatEnumerableIsEmptyInspection"/>
</extensions>
<actions>

1
src/main/resources/inspectionDescriptions/AssertThatBooleanIsTrueOrFalse.html
View File

@ -3,5 +3,6 @@
Turns assertThat(booleanExpression).isEqualTo(true/false) or assertThat(booleanExpression).isNotEqualTo(true/false)
into assertThat(booleanExpression).isTrue() or assertThat(booleanExpression).isFalse().
<!-- tooltip end -->
<br>Also works with Boolean.TRUE/FALSE.
</body>
</html>

7
src/main/resources/inspectionDescriptions/AssertThatEnumerableIsEmpty.html Normal file
View File

@ -0,0 +1,7 @@
<html>
<body>
Turns assertThat(enumerable).hasSize(0) into assertThat(enumerable).isEmpty().
<!-- tooltip end -->
<br>Works with anything that is enumerable such as arrays, iterables, collections, etc.
</body>
</html>

2
src/main/resources/inspectionDescriptions/AssertThatStringIsEmpty.html
View File

@ -2,6 +2,6 @@
<body>
Turns assertThat(string).isEqualTo("") or assertThat(string).hasSize(0) into assertThat(string).isEmpty().
<!-- tooltip end -->
Also works with CharSequences.
<br>Also works with CharSequences.
</body>
</html>

25
src/test/java/de/platon42/intellij/playground/Playground.java
View File

@ -1,12 +1,26 @@
package de.platon42.intellij.playground;
import org.assertj.core.api.ListAssert;
import java.util.ArrayList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.*;
public class Playground {
private void sizeOfList() {
assertThat("string").as("foo").hasSize(0);
assertThat(new StringBuilder()).as("bar").hasSize(0);
ListAssert<String> etc = assertThat(new ArrayList<String>()).as("etc");
etc.hasSize(0);
assertThat(new Long[1]).as("etc").hasSize(0);
assertThat("string").as("foo").isEmpty();
assertThat(new StringBuilder()).as("bar").isEmpty();
assertThat(new ArrayList<Long>()).as("etc").isEmpty();
assertThat(new Long[1]).as("etc").isEmpty();
assertThat(new ArrayList<>().size()).isEqualTo(1);
}
@ -54,4 +68,15 @@ public class Playground {
assertThat(foo).hasSize(0);
}
private void junitAssertions() {
assertTrue(true);
assertTrue("message", true);
assertFalse(true);
assertFalse("message", true);
assertEquals(1L, 2L);
assertEquals("message", 1L, 2L);
assertNotEquals(1L, 2L);
assertNotEquals("message", 1L, 2L);
}
}

21
src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatEnumerableIsEmptyInspectionTest.kt Normal file
View File

@ -0,0 +1,21 @@
package de.platon42.intellij.plugins.cajon.inspections
import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
import de.platon42.intellij.jupiter.MyFixture
import de.platon42.intellij.jupiter.TestDataSubPath
import de.platon42.intellij.plugins.cajon.AbstractCajonTest
import org.junit.jupiter.api.Test
internal class AssertThatEnumerableIsEmptyInspectionTest : AbstractCajonTest() {
@Test
@TestDataSubPath("inspections/EnumerableIsEmpty")
internal fun assertThat_with_hasSize_zero_can_use_isEmpty(@MyFixture myFixture: JavaCodeInsightTestFixture) {
runTest {
myFixture.enableInspections(AssertThatEnumerableIsEmptyInspection::class.java)
myFixture.configureByFile("EnumerableIsEmptyBefore.java")
executeQuickFixes(myFixture, Regex("Replace hasSize.*"), 4)
myFixture.checkResultByFile("EnumerableIsEmptyAfter.java")
}
}
}

18
src/test/resources/inspections/EnumerableIsEmpty/EnumerableIsEmptyAfter.java Normal file
View File

@ -0,0 +1,18 @@
import java.util.ArrayList;
import static org.assertj.core.api.Assertions.assertThat;
public class EnumerableIsEmpty {
private void enumerableIsEmpty() {
assertThat("string").as("foo").isEmpty();
assertThat(new StringBuilder()).as("bar").isEmpty();
assertThat(new ArrayList<Long>()).as("etc").isEmpty();
assertThat(new Long[1]).as("etc").isEmpty();
assertThat("string").as("foo").hasSize(1);
assertThat(new StringBuilder()).as("bar").hasSize(1);
assertThat(new ArrayList<Long>()).as("etc").hasSize(1);
assertThat(new Long[1]).as("etc").hasSize(1);
}
}

18
src/test/resources/inspections/EnumerableIsEmpty/EnumerableIsEmptyBefore.java Normal file
View File

@ -0,0 +1,18 @@
import java.util.ArrayList;
import static org.assertj.core.api.Assertions.assertThat;
public class EnumerableIsEmpty {
private void enumerableIsEmpty() {
assertThat("string").as("foo").hasSize(0);
assertThat(new StringBuilder()).as("bar").hasSize(0 + 0);
assertThat(new ArrayList<Long>()).as("etc").hasSize(10 / 100);
assertThat(new Long[1]).as("etc").hasSize(1 - 1);
assertThat("string").as("foo").hasSize(1);
assertThat(new StringBuilder()).as("bar").hasSize(1);
assertThat(new ArrayList<Long>()).as("etc").hasSize(1);
assertThat(new Long[1]).as("etc").hasSize(1);
}
}

2
src/test/resources/inspections/StringIsEmpty/StringIsEmptyBefore.java
View File

@ -11,7 +11,7 @@ public class StringIsEmpty {
assertThat(string).as("bar").hasSize(0);
assertThat(stringBuilder).isEqualTo("foo");
assertThat(stringBuilder).as("foo").isEqualTo("");
assertThat(stringBuilder).as("foo").isEqualTo("" + "");
assertThat(stringBuilder).as("bar").hasSize(0);
assertThat(new Object()).isEqualTo("");