Updated ktlint to use Android format. Tidied up code.

EranBoudjnah · Nov 9, 2023 · 79bdbe4 · 79bdbe4
1 parent db68018
commit 79bdbe4
Show file tree

Hide file tree

Showing 12 changed files with 800 additions and 730 deletions.
diff --git a/app/src/main/java/com/mitteloupe/testit/generator/TestFilePathFormatter.kt b/app/src/main/java/com/mitteloupe/testit/generator/TestFilePathFormatter.kt
@@ -14,7 +14,10 @@ class TestFilePathFormatter(
         if (pathRegex.containsMatchIn(sourceFileName)) {
             val sourcePath = sourceFileName.substringBeforeLast(fileSeparator) + fileSeparator
             pathRegex.replace(sourcePath) { matchResult ->
-                "${fileSeparator}src${fileSeparator}test$fileSeparator${matchResult.groupValues[2]}$fileSeparator"
+                "${fileSeparator}src" +
+                    "${fileSeparator}test" +
+                    "$fileSeparator${matchResult.groupValues[2]}" +
+                    fileSeparator
             }
         } else {
             null

diff --git a/app/src/main/java/com/mitteloupe/testit/generator/TestStringBuilder.kt b/app/src/main/java/com/mitteloupe/testit/generator/TestStringBuilder.kt
@@ -103,12 +103,14 @@ class TestStringBuilder(
         isParameterized -> {
             append("${mockerCodeGenerator.testClassParameterizedRunnerAnnotation}\n")
         }
+
         hasMockableConstructorParameters -> {
             mockerCodeGenerator.testClassBaseRunnerAnnotation?.let { annotation ->
                 append("$annotation\n")
             }
             this
         }
+
         else -> this
     }
 
@@ -121,7 +123,8 @@ class TestStringBuilder(
             append("(\n")
                 .append(
                     parameters.joinToString(",\n") { parameter ->
-                        "${indent()}private val ${parameter.name}: ${parameter.type.toKotlinString()}"
+                        "${indent()}private val ${parameter.name}: " +
+                            parameter.type.toKotlinString()
                     }
                 )
                 .append("\n)")
@@ -184,7 +187,8 @@ class TestStringBuilder(
                 },
                 {
                     "${classUnderTest.className}(" +
-                        classUnderTest.constructorParameters.joinToString(", ") { parameter -> parameter.name } +
+                        classUnderTest.constructorParameters
+                            .joinToString(", ") { parameter -> parameter.name } +
                         ")\n"
                 }
             ).append("${indent()}}")
@@ -384,7 +388,10 @@ class TestStringBuilder(
         .append(indent(2))
         .append {
             when (exceptionCaptureMethod) {
-                ExceptionCaptureMethod.TRY_CATCH -> "assertEquals(expectedException, actualException)\n"
+                ExceptionCaptureMethod.TRY_CATCH -> {
+                    "assertEquals(expectedException, actualException)\n"
+                }
+
                 ExceptionCaptureMethod.ANNOTATION_EXPECTS -> "// Exception is thrown\n"
                 else -> "$defaultAssertionStatement\n"
             }
@@ -396,7 +403,9 @@ class TestStringBuilder(
         expectedSuffix: String
     ) = onlyIf(function.hasReturnValue() && isParameterized) {
         append(
-            "${indent(2)}assertEquals(${function.expectedReturnValueVariableName(expectedSuffix)}, $actualValueVariableName)\n"
+            indent(2) + "assertEquals(" +
+                function.expectedReturnValueVariableName(expectedSuffix) + ", " +
+                actualValueVariableName + ")\n"
         )
     }
 
@@ -407,7 +416,9 @@ class TestStringBuilder(
     ) = append("${indent()}private lateinit var $classUnderTestVariableName: $className")
         .appendBlankLine()
 
-    private fun appendParameterizedCompanionObject(classUnderTest: ClassMetadata): TestStringBuilder {
+    private fun appendParameterizedCompanionObject(
+        classUnderTest: ClassMetadata
+    ): TestStringBuilder {
         val parameters = getFunctionParametersAsConstructorParameters(classUnderTest.functions)
         return appendParameterizedCompanionObject(parameters)
     }

diff --git a/app/src/main/java/com/mitteloupe/testit/generator/mocking/MockitoCodeGenerator.kt b/app/src/main/java/com/mitteloupe/testit/generator/mocking/MockitoCodeGenerator.kt
@@ -35,14 +35,15 @@ class MockitoCodeGenerator(
     }
 
     override fun getConstructorMock(parameterName: String, parameterType: DataType) =
-        "${indent()}@Mock\n" +
-            "${indent()}private lateinit var $parameterName: ${parameterType.toNonNullableKotlinString()}"
+        """${indent()}@Mock
+${indent()}private lateinit var $parameterName: ${parameterType.toNonNullableKotlinString()}"""
 
     override fun getMockedInstance(variableType: DataType) =
         "mock<${variableType.toNonNullableKotlinString()}>()"
 
     override fun getAbstractClassUnderTest(classUnderTest: ClassMetadata) =
-        "mock(defaultAnswer = Mockito.CALLS_REAL_METHODS${constructorArgumentsForAbstract(classUnderTest)})"
+        "mock(defaultAnswer = " +
+            "Mockito.CALLS_REAL_METHODS${constructorArgumentsForAbstract(classUnderTest)})"
 
     override fun setIsParameterizedTest() {
         super.setIsParameterizedTest()
@@ -91,8 +92,8 @@ class MockitoCodeGenerator(
         if (classUnderTest.constructorParameters.isEmpty()) {
             ""
         } else {
-            val arguments =
-                classUnderTest.constructorParameters.joinToString(", ") { parameter -> parameter.name }
+            val arguments = classUnderTest.constructorParameters
+                .joinToString(", ") { parameter -> parameter.name }
             ", useConstructor = UseConstructor.withArguments($arguments)"
         }
 }
diff --git a/app/src/main/java/com/mitteloupe/testit/grammer/parsing/Parser.kt b/app/src/main/java/com/mitteloupe/testit/grammer/parsing/Parser.kt
@@ -6,6 +6,8 @@ import com.mitteloupe.testit.grammer.KotlinParseTreeNodeType
 import com.mitteloupe.testit.grammer.KotlinParserException
 import com.mitteloupe.testit.grammer.KotlinToken
 import com.mitteloupe.testit.grammer.KotlinTokensList
+import java.io.ByteArrayInputStream
+import java.nio.charset.StandardCharsets
 import org.antlr.v4.runtime.BaseErrorListener
 import org.antlr.v4.runtime.CharStreams
 import org.antlr.v4.runtime.CommonToken
@@ -20,8 +22,6 @@ import org.antlr.v4.runtime.tree.ParseTree
 import org.antlr.v4.runtime.tree.TerminalNodeImpl
 import org.jetbrains.kotlin.spec.grammar.KotlinLexer
 import org.jetbrains.kotlin.spec.grammar.KotlinParser
-import java.io.ByteArrayInputStream
-import java.nio.charset.StandardCharsets
 
 internal object Parser {
     private val errorLexerListener = object : BaseErrorListener() {

diff --git a/app/src/main/java/com/mitteloupe/testit/parser/AntlrKotlinFileParser.kt b/app/src/main/java/com/mitteloupe/testit/parser/AntlrKotlinFileParser.kt
@@ -133,7 +133,9 @@ class AntlrKotlinFileParser(
             ::extractFunctionMetadataFromNode
         )
 
-    private fun extractStaticFunctionsMetadataFromNode(code: KotlinParseTree): StaticFunctionsMetadata {
+    private fun extractStaticFunctionsMetadataFromNode(
+        code: KotlinParseTree
+    ): StaticFunctionsMetadata {
         val staticFunctions = code.applyToChildNodes(
             listOf("topLevelObject", "declaration", "functionDeclaration"),
             ::extractFunctionMetadataFromNode
@@ -201,7 +203,9 @@ class AntlrKotlinFileParser(
 
         return functionName?.let { validFunctionName ->
             if (!isAbstract) {
-                functionParameters.forEach { typedParameter -> addAnyKnownImports(typedParameter.type) }
+                functionParameters.forEach { typedParameter ->
+                    addAnyKnownImports(typedParameter.type)
+                }
             }
 
             extensionReceiverType?.let {
@@ -307,7 +311,9 @@ class AntlrKotlinFileParser(
             when (dataType) {
                 is DataType.Specific -> listOf(dataType.name)
                 is DataType.Generic -> getAllSpecificTypes(*dataType.genericTypes) + dataType.name
-                is DataType.Lambda -> getAllSpecificTypes(*dataType.inputParameterTypes) + dataType.name
+                is DataType.Lambda -> {
+                    getAllSpecificTypes(*dataType.inputParameterTypes) + dataType.name
+                }
             }
         }
 

diff --git a/app/src/test/java/com/mitteloupe/testit/generator/TestFilePathFormatterTest.kt b/app/src/test/java/com/mitteloupe/testit/generator/TestFilePathFormatterTest.kt
@@ -37,8 +37,8 @@ class TestFilePathFormatterTest {
     @Test
     fun `Given unrecognized file name when getTestFilePath then returns null`() {
         // Given
-        val sourceFileName =
-            "/Users/me/Projects/TestIt/app/source/main/java/com/mitteloupe/testit/generator/TestFilePathFormatter.kt"
+        val sourceFileName = "/Users/me/Projects/TestIt/" +
+            "app/source/main/java/com/mitteloupe/testit/generator/TestFilePathFormatter.kt"
 
         // When
         val actual = classUnderTest.getTestFilePath(sourceFileName)