Merge pull request #89 from AntonButov/rework-main-sreem

rework main streem

code-factory-processor/src/main/kotlin/com/code/factory/CodeFilter.kt

@@ -6,9 +6,9 @@ import com.google.devtools.ksp.symbol.KSClassDeclaration
 import com.google.devtools.ksp.symbol.KSDeclaration
 
 interface CodeFilter {
-    fun getFilteredDeclarations(
+    fun getFilteredCodeDeclarations(
         resolver: Resolver,
-        interfaceWithOutDeclaration: Sequence<KSClassDeclaration>,
+        interfaceWithOutDeclaration: KSClassDeclaration,
     ): Sequence<KSDeclaration>
 }
 
@@ -21,14 +21,14 @@ internal class CodeFilterImpl(
     private val getAllDeclarationFinder: AllDeclarationFinder,
     private val codeResolver: CodeResolver,
 ) : CodeFilter {
-    override fun getFilteredDeclarations(
+    override fun getFilteredCodeDeclarations(
         resolver: Resolver,
-        interfaceWithOutDeclaration: Sequence<KSClassDeclaration>,
+        interfaceWithOutDeclaration: KSClassDeclaration,
     ): Sequence<KSDeclaration> {
-        val codeInterfaceWithOutDeclaration = codeResolver.getCodeString(interfaceWithOutDeclaration).joinToString("\n") // #81
+        val codeInterfaceWithOutDeclarationCode = codeResolver.getCodeString(interfaceWithOutDeclaration)
         return getAllDeclarationFinder.getAllDeclaration(resolver)
             .filter {
-                it.qualifiedName!!.asString() in codeInterfaceWithOutDeclaration
+                it.qualifiedName!!.asString() in codeInterfaceWithOutDeclarationCode
             }
     }
 }

code-factory-processor/src/main/kotlin/com/code/factory/TestCodeFilter.kt

@@ -1,30 +1,34 @@
 package com.code.factory
 
-import Storage
 import com.code.factory.coderesolver.CodeResolver
-import com.code.factory.coderesolver.codeResolver
-import com.google.devtools.ksp.processing.Resolver
-import com.google.devtools.ksp.symbol.KSDeclaration
 
 interface TestCodeFilter {
-    fun getFilteredTestDeclarations(resolver: Resolver): Sequence<KSDeclaration>
+    fun getFilteredTestCode(
+        declarations: Sequence<String>,
+        basePath: String,
+    ): Sequence<String>
 }
 
 fun testCodeFilter(
-    storage: Storage,
+    testFilesResolver: TestFilesResolver,
     codeResolver: CodeResolver,
-): TestCodeFilter = TestCodeFilterImpl(storage, codeResolver)
+): TestCodeFilter = TestCodeFilterImpl(testFilesResolver, codeResolver)
 
 class TestCodeFilterImpl(
-    private val storage: Storage,
+    private val testFilesResolver: TestFilesResolver,
     private val codeResolver: CodeResolver,
 ) : TestCodeFilter {
-    override fun getFilteredTestDeclarations(resolver: Resolver): Sequence<KSDeclaration> {
-        val declarationsNames = storage.getNamesForTestFilter()
-        return resolver.getAllFiles()
-            .filter {
-                val codeOfTest = codeResolver.getCodeString(it)
-                declarationsNames.any { it in codeOfTest }
-            }.getAllDeclarations()
+    override fun getFilteredTestCode(
+        declarationNames: Sequence<String>,
+        basePath: String,
+    ): Sequence<String> {
+        val testFiles = testFilesResolver.getTestFiles(basePath)
+        return testFiles
+            .map {
+                codeResolver.getCode(it.path)
+            }
+            .filter { codeOfTest ->
+                declarationNames.any { it in codeOfTest }
+            }
     }
 }

code-factory-processor/src/main/kotlin/com/code/factory/TestFilesResolver.kt

@@ -0,0 +1,22 @@
+package com.code.factory
+
+import java.io.File
+
+interface TestFilesResolver {
+    fun getTestFiles(basePath: String): Sequence<File>
+}
+
+fun testFileResolver(): TestFilesResolver {
+    return TestFilesResolverImpl()
+}
+
+internal class TestFilesResolverImpl : TestFilesResolver {
+    override fun getTestFiles(basePath: String): Sequence<File> {
+        return findKtFiles(File(basePath))
+    }
+
+    private fun findKtFiles(directory: File): Sequence<File> {
+        return directory.walkTopDown()
+            .filter { it.isFile && it.extension == "kt" }
+    }
+}

code-factory-processor/src/main/kotlin/com/code/factory/TestSourcePathResolver.kt

@@ -0,0 +1,17 @@
+package com.code.factory
+
+import com.google.devtools.ksp.processing.Resolver
+
+interface TestSourcePathResolver {
+    fun getSourcesPath(mainResolver: Resolver): String
+}
+
+fun testSourcePathResolver(): TestSourcePathResolver {
+    return GetTestSourcePathResolver()
+}
+
+internal class GetTestSourcePathResolver : TestSourcePathResolver {
+    override fun getSourcesPath(mainResolver: Resolver): String {
+        return "${mainResolver.getAllFiles().first().filePath.split("main").first()}test/"
+    }
+}

code-factory-processor/src/main/kotlin/com/code/factory/bridge/Bridge.kt

@@ -1,9 +1,6 @@
 package com.code.factory.bridge
 
-import Storage
-import com.code.factory.CompileChecker
 import com.code.factory.coderesolver.CodeResolver
-import com.code.factory.writer.WriterData
 import com.google.devtools.ksp.processing.KSPLogger
 import com.google.devtools.ksp.symbol.KSClassDeclaration
 import com.google.devtools.ksp.symbol.KSDeclaration
@@ -20,29 +17,25 @@ interface BridgeFactory {
 
 sealed interface Bridge {
     interface BridgeMain : Bridge {
-        fun saveDeclarations(allDeclarations: Sequence<KSDeclaration>)
-
-        fun saveInterFaceWithOutDeclaration(interfaceWithOutImpl: KSClassDeclaration)
+        suspend fun getCode(
+            testCode: Sequence<String>,
+            declarations: Sequence<KSDeclaration>,
+            interfaceWithOutImpl: KSClassDeclaration,
+        ): WriterData?
     }
 
-    interface BridgeTest : Bridge {
-        suspend fun getCode(testDeclarations: Sequence<KSDeclaration>): WriterData?
-    }
+    interface BridgeTest : Bridge
 
     interface BridgeGenerated : Bridge
 }
 
 fun bridgeFactory(
-    storage: Storage,
-    compileChecker: CompileChecker,
     codeResolver: CodeResolver,
     logger: KSPLogger,
     path: String,
-): BridgeFactory = BridgeFactoryImpl(storage, compileChecker, codeResolver, logger, path)
+): BridgeFactory = BridgeFactoryImpl(codeResolver, logger, path)
 
 internal class BridgeFactoryImpl(
-    private val storage: Storage,
-    private val compileChecker: CompileChecker,
     private val codeResolver: CodeResolver,
     private val logger: KSPLogger,
     private val path: String,
@@ -52,21 +45,13 @@ internal class BridgeFactoryImpl(
 
     override fun createMain(): Bridge.BridgeMain =
         keyLogic(
-            mock = BridgeMainWork(storage, codeResolver),
-            work = BridgeMainWork(storage, codeResolver),
+            mock = BridgeMainWork(codeResolver, openAiServiceMock(logger)),
+            work = BridgeMainWork(codeResolver, openAiService(apiKey, logger)),
         )
 
-    override fun createTest(): Bridge.BridgeTest =
-        keyLogic(
-            mock = BridgeTestWork(codeResolver, storage, openAiServiceMock(logger), compileChecker),
-            work = BridgeTestWork(codeResolver, storage, openAiService(apiKey, logger), compileChecker),
-        )
+    override fun createTest(): Bridge.BridgeTest = BridgeTestWork()
 
-    override fun createGenerated(): Bridge.BridgeGenerated =
-        keyLogic(
-            mock = BridgeGeneratedMock(),
-            work = BridgeGeneratedWork(),
-        )
+    override fun createGenerated(): Bridge.BridgeGenerated = BridgeGeneratedWork()
 
     private fun <B : Bridge> keyLogic(
         mock: B,