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:
Chris Hodges 2019-11-17 19:10:41 +01:00
parent 8d03b3734c
commit 8133f3850f
8 changed files with 366 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
README.md
View File

@ -333,6 +333,32 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
to: assertThat(file).isNotEmptyDirectory();
```
- AssertThatPathExpression
Moves ```Path``` method calls inside ```assertThat()``` out.
Note: Uses hasParentRaw() instead of hasParent() for quickfixes, because it is semantically
equivalent. For most cases though, hasParent() will show identical behavior.
```
from: assertThat(path.isAbsolute()).isTrue();
to: assertThat(path).isAbsolute();
from: assertThat(path.isAbsolute()).isFalse();
to: assertThat(path).isRelative();
from: assertThat(path.getParent()).isEqualTo(pathname);
to: assertThat(path).hasParentRaw(pathname);
from: assertThat(path.getParent()).isNull();
to: assertThat(path).hasNoParentRaw();
from: assertThat(path.startsWith(otherPath)).isTrue();
to: assertThat(path).startsWithRaw(otherPath);
from: assertThat(path.endsWith(otherPath)).isTrue();
to: assertThat(path).endsWithRaw(otherPath);
```
- AssertThatEnumerableIsEmpty
Uses ```isEmpty()``` for ```hasSize(0)``` iterable assertions instead.
@ -644,6 +670,8 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
#### V1.7 (unreleased)
- Fixed a lapsuus in AssertThatFileExpression also transforming ```.listFiles()``` with a filter argument.
- Added first version of AssertThatPathExpression for a limited number transformations (more stuff is possible,
but requires detection and transformation of static ```Files```-methods).
#### V1.6 (30-Sep-19)
- Really fixed AssertThatGuavaOptional inspections to avoid conversions from ```.get()``` to ```.contains()```

2
build.gradle
View File

@ -46,6 +46,8 @@ patchPluginXml {
<h4>V1.7 (unreleased)</h4>
<ul>
<li>Fixed a lapsuus in AssertThatFileExpression also transforming listFiles() with a filter argument.
<li>Added first version of AssertThatPathExpression for a limited number transformations (more stuff is possible,
but requires detection and transformation of static Files-methods).
</ul>
<p>Full changelog available at <a href="https://github.com/chrisly42/cajon-plugin#changelog">Github project site</a>.</p>
"""

51
src/main/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatPathExpressionInspection.kt Normal file
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)
}
}
}
}

2
src/main/resources/META-INF/plugin.xml
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"/>

7
src/main/resources/inspectionDescriptions/AssertThatPathExpression.html Normal file
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>

24
src/test/java/de/platon42/intellij/plugins/cajon/inspections/AssertThatPathExpressionInspectionTest.kt Normal file
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")
}
}

126
src/test/resources/inspections/PathExpression/PathExpressionAfter.java Normal file
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!");
}
}

126
src/test/resources/inspections/PathExpression/PathExpressionBefore.java Normal file
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!");
}
}