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

Added first version of AssertThatPathExpression for a limited number transformations (more stuff is possible, but requires detection and transformation of static Files-methods).

Browse Source
This commit is contained in:
chrisly42
2019-11-17 19:10:41 +01:00
parent 8d03b3734c
commit 8133f3850f
8 changed files with 366 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatPathExpressionInspection.kt
+51
View File
@@ -0,0 +1,51 @@
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.PsiExpressionStatement
import com.siyeh.ig.callMatcher.CallMatcher
class AssertThatPathExpressionInspection : AbstractMoveOutInspection() {
companion object {
private const val DISPLAY_NAME = "Asserting a path specific expression"
private const val JAVA_NIO_PATH = "java.nio.file.Path"
private val MAPPINGS = listOf(
MoveOutMapping(
CallMatcher.instanceCall(JAVA_NIO_PATH, "isAbsolute").parameterCount(0),
"isAbsolute", "isRelative", expectBoolean = true
),
MoveOutMapping(
CallMatcher.instanceCall(JAVA_NIO_PATH, "startsWith").parameterTypes(JAVA_NIO_PATH),
"startsWithRaw", expectBoolean = true
),
MoveOutMapping(
CallMatcher.instanceCall(JAVA_NIO_PATH, "endsWith").parameterTypes(JAVA_NIO_PATH),
"endsWithRaw", expectBoolean = true
),
MoveOutMapping(
CallMatcher.instanceCall(JAVA_NIO_PATH, "getParent").parameterCount(0),
"hasParentRaw",
expectedMatcher = IS_EQUAL_TO_OBJECT
),
MoveOutMapping(
CallMatcher.instanceCall(JAVA_NIO_PATH, "getParent").parameterCount(0),
"hasNoParentRaw", expectNullNonNull = true
)
)
}
override fun getDisplayName() = DISPLAY_NAME
override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
return object : JavaElementVisitor() {
override fun visitExpressionStatement(statement: PsiExpressionStatement) {
super.visitExpressionStatement(statement)
createInspectionsForMappings(statement, holder, MAPPINGS)
}
}
}
}
src/main/resources/META-INF/plugin.xml
+2
View File
@@ -47,6 +47,8 @@
implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatCollectionOrMapExpressionInspection"/>
<localInspection groupPath="Java" shortName="AssertThatFileExpression" enabledByDefault="true" level="WARNING"
implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatFileExpressionInspection"/>
<localInspection groupPath="Java" shortName="AssertThatPathExpression" enabledByDefault="true" level="WARNING"
implementationClass="de.platon42.intellij.plugins.cajon.inspections.AssertThatPathExpressionInspection"/>
<localInspection groupPath="Java" shortName="JoinAssertThatStatements" enabledByDefault="true" level="WARNING"
implementationClass="de.platon42.intellij.plugins.cajon.inspections.JoinAssertThatStatementsInspection"/>
src/main/resources/inspectionDescriptions/AssertThatPathExpression.html
+7
View File
@@ -0,0 +1,7 @@
<html>
<body>
Operates on assertions on objects of type Path. Turns assertThat(file.someMethod(arg)).someAssertion() into assertThat(path).someMethod(arg).
<!-- tooltip end -->
<br>someMethod() can be isAbsolute(), getParent(), startsWith() and endsWith().
</body>
</html>
src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatPathExpressionInspectionTest.kt
+24
View File
@@ -0,0 +1,24 @@
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 AssertThatPathExpressionInspectionTest : AbstractCajonTest() {
@Test
@TestDataSubPath("inspections/PathExpression")
internal fun assertThat_with_certain_Path_methods(@MyFixture myFixture: JavaCodeInsightTestFixture) {
myFixture.enableInspections(AssertThatPathExpressionInspection::class.java)
myFixture.configureByFile("PathExpressionBefore.java")
executeQuickFixes(myFixture, Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isAbsolute() instead"), 3)
executeQuickFixes(myFixture, Regex.fromLiteral("Remove isAbsolute() of actual expression and use assertThat().isRelative() instead"), 3)
executeQuickFixes(myFixture, Regex.fromLiteral("Remove startsWith() of actual expression and use assertThat().startsWithRaw() instead"), 3)
executeQuickFixes(myFixture, Regex.fromLiteral("Remove endsWith() of actual expression and use assertThat().endsWithRaw() instead"), 3)
executeQuickFixes(myFixture, Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasNoParentRaw() instead"), 2)
executeQuickFixes(myFixture, Regex.fromLiteral("Remove getParent() of actual expression and use assertThat().hasParentRaw() instead"), 1)
myFixture.checkResultByFile("PathExpressionAfter.java")
}
}
src/test/resources/inspections/PathExpression/PathExpressionAfter.java
+126
View File
@@ -0,0 +1,126 @@
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
public class PathExpression {
private void pathExpression() {
Path path = Paths.get("foo");
Path otherPath = Paths.get("bar");
assertThat(path).as("foo").isAbsolute();
assertThat(path).isAbsolute();
assertThat(path).isAbsolute();
assertThat(path).as("foo").isRelative();
assertThat(path).isRelative();
assertThat(path).isRelative();
assertThat(path).hasParentRaw(otherPath);
assertThat(path.getParent()).isNotEqualTo(otherPath);
assertThat(path).hasNoParentRaw();
assertThat(path).hasNoParentRaw();
assertThat(path.getParent()).isNotEqualTo(null);
assertThat(path.getParent()).isNotNull();
assertThat(path).as("foo").startsWithRaw(otherPath);
assertThat(path).startsWithRaw(otherPath);
assertThat(path).startsWithRaw(otherPath);
assertThat(path.startsWith(otherPath)).as("foo").isEqualTo(false);
assertThat(path.startsWith(otherPath)).isNotEqualTo(true);
assertThat(path.startsWith(otherPath)).isFalse();
assertThat(path.startsWith("otherPath")).as("foo").isEqualTo(true);
assertThat(path.startsWith("otherPath")).isNotEqualTo(false);
assertThat(path.startsWith("otherPath")).isTrue();
assertThat(path.startsWith("otherPath")).as("foo").isEqualTo(false);
assertThat(path.startsWith("otherPath")).isNotEqualTo(true);
assertThat(path.startsWith("otherPath")).isFalse();
assertThat(path).as("foo").endsWithRaw(otherPath);
assertThat(path).endsWithRaw(otherPath);
assertThat(path).endsWithRaw(otherPath);
assertThat(path.endsWith(otherPath)).as("foo").isEqualTo(false);
assertThat(path.endsWith(otherPath)).isNotEqualTo(true);
assertThat(path.endsWith(otherPath)).isFalse();
assertThat(path.endsWith("otherPath")).as("foo").isEqualTo(true);
assertThat(path.endsWith("otherPath")).isNotEqualTo(false);
assertThat(path.endsWith("otherPath")).isTrue();
assertThat(path.endsWith("otherPath")).as("foo").isEqualTo(false);
assertThat(path.endsWith("otherPath")).isNotEqualTo(true);
assertThat(path.endsWith("otherPath")).isFalse();
assertThat(Files.isReadable(path)).as("foo").isEqualTo(true);
assertThat(Files.isReadable(path)).isNotEqualTo(false);
assertThat(Files.isReadable(path)).isTrue();
assertThat(Files.isReadable(path)).as("foo").isEqualTo(false);
assertThat(Files.isReadable(path)).isNotEqualTo(true);
assertThat(Files.isReadable(path)).isFalse();
assertThat(Files.isWritable(path)).as("foo").isEqualTo(true);
assertThat(Files.isWritable(path)).isNotEqualTo(false);
assertThat(Files.isWritable(path)).isTrue();
assertThat(Files.isWritable(path)).as("foo").isEqualTo(false);
assertThat(Files.isWritable(path)).isNotEqualTo(true);
assertThat(Files.isWritable(path)).isFalse();
assertThat(Files.isExecutable(path)).as("foo").isEqualTo(true);
assertThat(Files.isExecutable(path)).isNotEqualTo(false);
assertThat(Files.isExecutable(path)).isTrue();
assertThat(Files.isExecutable(path)).as("foo").isEqualTo(false);
assertThat(Files.isExecutable(path)).isNotEqualTo(true);
assertThat(Files.isExecutable(path)).isFalse();
assertThat(Files.isDirectory(path)).as("foo").isEqualTo(true);
assertThat(Files.isDirectory(path)).isNotEqualTo(false);
assertThat(Files.isDirectory(path)).isTrue();
assertThat(Files.isDirectory(path)).as("foo").isEqualTo(false);
assertThat(Files.isDirectory(path)).isNotEqualTo(true);
assertThat(Files.isDirectory(path)).isFalse();
assertThat(Files.isRegularFile(path)).as("foo").isEqualTo(true);
assertThat(Files.isRegularFile(path)).isNotEqualTo(false);
assertThat(Files.isRegularFile(path)).isTrue();
assertThat(Files.isRegularFile(path)).as("foo").isEqualTo(false);
assertThat(Files.isRegularFile(path)).isNotEqualTo(true);
assertThat(Files.isRegularFile(path)).isFalse();
assertThat(Files.isSymbolicLink(path)).as("foo").isEqualTo(true);
assertThat(Files.isSymbolicLink(path)).isNotEqualTo(false);
assertThat(Files.isSymbolicLink(path)).isTrue();
assertThat(Files.isSymbolicLink(path)).as("foo").isEqualTo(false);
assertThat(Files.isSymbolicLink(path)).isNotEqualTo(true);
assertThat(Files.isSymbolicLink(path)).isFalse();
assertThat(Files.exists(path)).as("foo").isEqualTo(true);
assertThat(Files.exists(path)).isNotEqualTo(false);
assertThat(Files.exists(path)).isTrue();
assertThat(Files.exists(path)).as("foo").isEqualTo(false);
assertThat(Files.exists(path)).isNotEqualTo(true);
assertThat(Files.exists(path)).isFalse();
assertThat(Files.notExists(path)).as("foo").isEqualTo(true);
assertThat(Files.notExists(path)).isNotEqualTo(false);
assertThat(Files.notExists(path)).isTrue();
assertThat(Files.notExists(path)).as("foo").isEqualTo(false);
assertThat(Files.notExists(path)).isNotEqualTo(true);
assertThat(Files.notExists(path)).isFalse();
assertThat(Files.list(path)).isEmpty();
assertThat(Files.list(path)).isNotEmpty();
assertThat(Files.readAllBytes(path)).isEqualTo(new byte[1]);
assertThat(Files.readAllLines(path)).containsExactly("foo");
assertThat(Files.lines(path)).containsExactly("foo");
assertThat(path.getName()).endsWith(".foo"); // could be turned into .hasExtension("foo"), but not always.
assertThat(path.getName()).as("foo").isEqualTo("foo").as("bar").isEqualTo("bar");
org.junit.Assert.assertThat(path, null);
fail("oh no!");
}
}
src/test/resources/inspections/PathExpression/PathExpressionBefore.java
+126
View File
@@ -0,0 +1,126 @@
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
public class PathExpression {
private void pathExpression() {
Path path = Paths.get("foo");
Path otherPath = Paths.get("bar");
assertThat(path.isAbsolute()).as("foo").isEqualTo(true);
assertThat(path.isAbsolute()).isNotEqualTo(false);
assertThat(path.isAbsolute()).isTrue();
assertThat(path.isAbsolute()).as("foo").isEqualTo(false);
assertThat(path.isAbsolute()).isNotEqualTo(true);
assertThat(path.isAbsolute()).isFalse();
assertThat(path.getParent()).isEqualTo(otherPath);
assertThat(path.getParent()).isNotEqualTo(otherPath);
assertThat(path.getParent()).isEqualTo(null);
assertThat(path.getParent()).isNull();
assertThat(path.getParent()).isNotEqualTo(null);
assertThat(path.getParent()).isNotNull();
assertThat(path.startsWith(otherPath)).as("foo").isEqualTo(true);
assertThat(path.startsWith(otherPath)).isNotEqualTo(false);
assertThat(path.startsWith(otherPath)).isTrue();
assertThat(path.startsWith(otherPath)).as("foo").isEqualTo(false);
assertThat(path.startsWith(otherPath)).isNotEqualTo(true);
assertThat(path.startsWith(otherPath)).isFalse();
assertThat(path.startsWith("otherPath")).as("foo").isEqualTo(true);
assertThat(path.startsWith("otherPath")).isNotEqualTo(false);
assertThat(path.startsWith("otherPath")).isTrue();
assertThat(path.startsWith("otherPath")).as("foo").isEqualTo(false);
assertThat(path.startsWith("otherPath")).isNotEqualTo(true);
assertThat(path.startsWith("otherPath")).isFalse();
assertThat(path.endsWith(otherPath)).as("foo").isEqualTo(true);
assertThat(path.endsWith(otherPath)).isNotEqualTo(false);
assertThat(path.endsWith(otherPath)).isTrue();
assertThat(path.endsWith(otherPath)).as("foo").isEqualTo(false);
assertThat(path.endsWith(otherPath)).isNotEqualTo(true);
assertThat(path.endsWith(otherPath)).isFalse();
assertThat(path.endsWith("otherPath")).as("foo").isEqualTo(true);
assertThat(path.endsWith("otherPath")).isNotEqualTo(false);
assertThat(path.endsWith("otherPath")).isTrue();
assertThat(path.endsWith("otherPath")).as("foo").isEqualTo(false);
assertThat(path.endsWith("otherPath")).isNotEqualTo(true);
assertThat(path.endsWith("otherPath")).isFalse();
assertThat(Files.isReadable(path)).as("foo").isEqualTo(true);
assertThat(Files.isReadable(path)).isNotEqualTo(false);
assertThat(Files.isReadable(path)).isTrue();
assertThat(Files.isReadable(path)).as("foo").isEqualTo(false);
assertThat(Files.isReadable(path)).isNotEqualTo(true);
assertThat(Files.isReadable(path)).isFalse();
assertThat(Files.isWritable(path)).as("foo").isEqualTo(true);
assertThat(Files.isWritable(path)).isNotEqualTo(false);
assertThat(Files.isWritable(path)).isTrue();
assertThat(Files.isWritable(path)).as("foo").isEqualTo(false);
assertThat(Files.isWritable(path)).isNotEqualTo(true);
assertThat(Files.isWritable(path)).isFalse();
assertThat(Files.isExecutable(path)).as("foo").isEqualTo(true);
assertThat(Files.isExecutable(path)).isNotEqualTo(false);
assertThat(Files.isExecutable(path)).isTrue();
assertThat(Files.isExecutable(path)).as("foo").isEqualTo(false);
assertThat(Files.isExecutable(path)).isNotEqualTo(true);
assertThat(Files.isExecutable(path)).isFalse();
assertThat(Files.isDirectory(path)).as("foo").isEqualTo(true);
assertThat(Files.isDirectory(path)).isNotEqualTo(false);
assertThat(Files.isDirectory(path)).isTrue();
assertThat(Files.isDirectory(path)).as("foo").isEqualTo(false);
assertThat(Files.isDirectory(path)).isNotEqualTo(true);
assertThat(Files.isDirectory(path)).isFalse();
assertThat(Files.isRegularFile(path)).as("foo").isEqualTo(true);
assertThat(Files.isRegularFile(path)).isNotEqualTo(false);
assertThat(Files.isRegularFile(path)).isTrue();
assertThat(Files.isRegularFile(path)).as("foo").isEqualTo(false);
assertThat(Files.isRegularFile(path)).isNotEqualTo(true);
assertThat(Files.isRegularFile(path)).isFalse();
assertThat(Files.isSymbolicLink(path)).as("foo").isEqualTo(true);
assertThat(Files.isSymbolicLink(path)).isNotEqualTo(false);
assertThat(Files.isSymbolicLink(path)).isTrue();
assertThat(Files.isSymbolicLink(path)).as("foo").isEqualTo(false);
assertThat(Files.isSymbolicLink(path)).isNotEqualTo(true);
assertThat(Files.isSymbolicLink(path)).isFalse();
assertThat(Files.exists(path)).as("foo").isEqualTo(true);
assertThat(Files.exists(path)).isNotEqualTo(false);
assertThat(Files.exists(path)).isTrue();
assertThat(Files.exists(path)).as("foo").isEqualTo(false);
assertThat(Files.exists(path)).isNotEqualTo(true);
assertThat(Files.exists(path)).isFalse();
assertThat(Files.notExists(path)).as("foo").isEqualTo(true);
assertThat(Files.notExists(path)).isNotEqualTo(false);
assertThat(Files.notExists(path)).isTrue();
assertThat(Files.notExists(path)).as("foo").isEqualTo(false);
assertThat(Files.notExists(path)).isNotEqualTo(true);
assertThat(Files.notExists(path)).isFalse();
assertThat(Files.list(path)).isEmpty();
assertThat(Files.list(path)).isNotEmpty();
assertThat(Files.readAllBytes(path)).isEqualTo(new byte[1]);
assertThat(Files.readAllLines(path)).containsExactly("foo");
assertThat(Files.lines(path)).containsExactly("foo");
assertThat(path.getName()).endsWith(".foo"); // could be turned into .hasExtension("foo"), but not always.
assertThat(path.getName()).as("foo").isEqualTo("foo").as("bar").isEqualTo("bar");
org.junit.Assert.assertThat(path, null);
fail("oh no!");
}
}