Merge branch 'develop'

app/src/main/java/com/omegar/mvp/BasePresenter.kt

@@ -5,6 +5,5 @@ package com.omegar.mvp
  * Created by Anton Knyazev on 09.06.2023.
  * Copyright (c) 2023 Omega https://omega-r.com
  */
-@InjectViewState
-open class BasePresenter<T: Number, VIEW: BaseView>: MvpPresenter<VIEW>() {
+open class BasePresenter<T: Number, M, VIEW: BaseView<M>>: MvpPresenter<VIEW>() {
 }

app/src/main/java/com/omegar/mvp/BaseView.kt

@@ -5,7 +5,7 @@ package com.omegar.mvp
  * Created by Anton Knyazev on 09.06.2023.
  * Copyright (c) 2023 Omega https://omega-r.com
  */
-interface BaseView: MvpView {
+interface BaseView<M>: MvpView {
 
     fun base() {}
 

app/src/main/java/com/omegar/mvp/MoxyActivity.kt

@@ -2,16 +2,16 @@ package com.omegar.mvp
 
 import android.os.Bundle
 import android.widget.Toast
-import com.omegar.mvp.ktx.providePresenter
 import kotlin.time.Duration
 import kotlin.time.Duration.Companion.seconds
 
-class MoxyActivity: MvpAppCompatActivity(R.layout.activity_moxy), MoxyView {
+class MoxyActivity: MvpAppCompatActivity(R.layout.activity_moxy), MoxyView<Int> {
 
     companion object {
         var first: Boolean = true
     }
 
+
     private val presenter: MoxyPresenter by providePresenter {
         MoxyPresenter()
     }

app/src/main/java/com/omegar/mvp/MoxyFragment.kt

@@ -2,11 +2,10 @@ package com.omegar.mvp
 
 import android.content.Intent
 import android.widget.Toast
-import com.omegar.mvp.ktx.providePresenter
 import kotlin.time.Duration
 import kotlin.time.Duration.Companion.seconds
 
-class MoxyFragment : MvpAppCompatFragment(R.layout.activity_moxy), MoxyView {
+class MoxyFragment : MvpAppCompatFragment(R.layout.activity_moxy), MoxyView<Int> {
 
     private val presenter: MoxyPresenter by providePresenter {
         MoxyPresenter()

app/src/main/java/com/omegar/mvp/MoxyPresenter.kt

@@ -2,9 +2,7 @@ package com.omegar.mvp
 
 import kotlin.time.Duration
 
-
-@InjectViewState
-class MoxyPresenter : BasePresenter<Long, MoxyView>() {
+class MoxyPresenter : BasePresenter<Long, Int, MoxyView<Int>>() {
 
     init {
         viewState.showToast("Hello World!")

app/src/main/java/com/omegar/mvp/MoxyView.kt

@@ -4,7 +4,7 @@ import com.omegar.mvp.viewstate.strategy.MoxyViewCommand
 import com.omegar.mvp.viewstate.strategy.StrategyType.ONE_EXECUTION
 import kotlin.time.Duration
 
-interface MoxyView: Addon<Long>, BaseView {
+interface MoxyView<M>: Addon<Long>, BaseView<M> {
 
 
     var duration: Duration

moxy/build.gradle

@@ -33,5 +33,4 @@ java {
 }
 
 dependencies {
-    compileOnly project(":moxy:stub-reflector")
 }

moxy/compiler/src/main/java/com/omegar/mvp/compiler/MvpCompiler.kt

@@ -1,16 +1,16 @@
 package com.omegar.mvp.compiler
 
+import com.google.devtools.ksp.getClassDeclarationByName
 import com.google.devtools.ksp.processing.Resolver
 import com.google.devtools.ksp.processing.SymbolProcessor
 import com.google.devtools.ksp.processing.SymbolProcessorEnvironment
 import com.google.devtools.ksp.symbol.KSAnnotated
 import com.google.devtools.ksp.symbol.KSClassDeclaration
-import com.omegar.mvp.InjectViewState
+import com.omegar.mvp.MvpPresenter
+import com.omegar.mvp.MvpView
 import com.omegar.mvp.compiler.entities.View
 import com.omegar.mvp.compiler.ksp.KspViewParser
-import com.omegar.mvp.compiler.processors.MoxyReflectorGenerator
 import com.omegar.mvp.compiler.processors.ViewStateGenerator
-import com.squareup.kotlinpoet.ksp.toClassName
 import com.squareup.kotlinpoet.ksp.writeTo
 
 /**
@@ -22,41 +22,27 @@ class MvpCompiler(environment: SymbolProcessorEnvironment) : SymbolProcessor {
     private val codeGenerator = environment.codeGenerator
     private val logger = environment.logger
     private var isProcessed = false
-    private val currentReflectorPackageName =
-        environment.options.getOrDefault("moxyReflectorPackage", NamingRules.moxyReflectorPackageName)
-
 
     override fun process(resolver: Resolver): List<KSAnnotated> {
         if (isProcessed) {
             return emptyList()
         }
         isProcessed = true
+        val mvpView = resolver.getClassDeclarationByName(MvpView::class.qualifiedName!!)!!.asStarProjectedType()
+        val mvpPresenter = resolver.getClassDeclarationByName(MvpPresenter::class.qualifiedName!!)!!.asStarProjectedType()
 
-        val parser = KspViewParser(currentReflectorPackageName, logger, resolver)
+        val parser = KspViewParser(logger, resolver, mvpView)
         val viewStateGenerator = ViewStateGenerator()
-        val moxyReflectorGenerator = MoxyReflectorGenerator(currentReflectorPackageName)
-
-        val symbols = resolver.getSymbolsWithAnnotation(InjectViewState::class.qualifiedName!!)
-
-        val uniqueViews = HashSet<String>()
 
-        val views = symbols
+        resolver.getAllFiles()
+            .flatMap { it.declarations }
             .filterIsInstance<KSClassDeclaration>()
-            .flatMap {
-                generateSequence(seedFunction = { parser(it) }, nextFunction = View::parent)
-            }
-            .distinctBy { it.presenterClassName.canonicalName + it.className.canonicalName }
-            .onEach {
-                if (!uniqueViews.contains(it.className.canonicalName) && it.reflectorPackage == currentReflectorPackageName) {
-                    uniqueViews += it.className.canonicalName
-                    viewStateGenerator(it).writeTo(codeGenerator = codeGenerator, aggregating = true)
-                }
-            }
+            .filter { mvpPresenter.isAssignableFrom(it.asStarProjectedType()) }
+            .flatMap { generateSequence(seedFunction = { parser(it) }, nextFunction = View::parent) }
+            .filter { it.needGenerate }
+            .distinctBy { it.className.canonicalName }
             .toList()
-
-        if (currentReflectorPackageName == NamingRules.moxyReflectorPackageName) {
-            moxyReflectorGenerator(views).writeTo(codeGenerator = codeGenerator, aggregating = true)
-        }
+            .forEach { viewStateGenerator(it).writeTo(codeGenerator = codeGenerator, aggregating = false) }
 
         return emptyList()
     }

moxy/compiler/src/main/java/com/omegar/mvp/compiler/NamingRules.kt

@@ -12,7 +12,7 @@ import java.util.Locale
 object NamingRules {
 
     val String.viewStateName
-        get() = "$this\$\$State"
+        get() = "${this.replace("View", "MvpView")}State"
 
     val View.viewStateName
         get() = name.viewStateName

moxy/compiler/src/main/java/com/omegar/mvp/compiler/entities/TaggedEntiity.kt

@@ -18,4 +18,8 @@ open class Tagged {
         taggedMap[cls] = value
     }
 
+    fun copyTagged(tagged: Tagged) {
+        taggedMap.putAll(tagged.taggedMap)
+    }
+
 }

moxy/compiler/src/main/java/com/omegar/mvp/compiler/entities/View.kt

@@ -1,6 +1,7 @@
 package com.omegar.mvp.compiler.entities
 
 import com.google.devtools.ksp.symbol.KSType
+import com.omegar.mvp.compiler.NamingRules.viewStateClassName
 import com.omegar.mvp.compiler.extensions.safeParameterizedBy
 import com.omegar.mvp.viewstate.strategy.StrategyType
 import com.squareup.kotlinpoet.ClassName
@@ -13,19 +14,19 @@ import com.squareup.kotlinpoet.TypeVariableName
  */
 data class View(
     val className: ClassName,
-    val presenterClassName: ClassName,
+    val presenterClassParamsMap: MutableMap<ClassName, List<TypeVariableName>>,
+    val viewTypePresenterParams: MutableMap<ClassName, List<TypeName>>,
     val methods: List<Method>,
     val viewTypeParams: List<TypeVariableName>,
-    val presenterInnerTypeParams: List<TypeName>,
-    val reflectorPackage: String,
-    val parent: View?
+    val viewTypeResolvedParams: List<TypeName>,
+    val parent: View?,
+    val needGenerate: Boolean
 ) : Tagged() {
 
     val name: String = className.simpleName
 
     val viewTypeNameWithParams = className.safeParameterizedBy(viewTypeParams)
 
-
     init {
         val nameCountMap = mutableMapOf<String, Int>()
         methods.forEach {

moxy/compiler/src/main/java/com/omegar/mvp/compiler/extensions/ClassNameExtenions.kt

@@ -4,5 +4,5 @@ import com.squareup.kotlinpoet.ClassName
 import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
 import com.squareup.kotlinpoet.TypeName
 
-fun ClassName.safeParameterizedBy(typeArguments: List<TypeName>): TypeName =
-    if (typeArguments.isEmpty()) this else parameterizedBy(typeArguments)
+fun ClassName.safeParameterizedBy(typeArguments: List<TypeName>?): TypeName =
+    if (typeArguments.isNullOrEmpty()) this else parameterizedBy(typeArguments)

moxy/compiler/src/main/java/com/omegar/mvp/compiler/extensions/KspExtensions.kt

@@ -0,0 +1,12 @@
+package com.omegar.mvp.compiler.extensions
+
+import com.google.devtools.ksp.symbol.KSAnnotated
+import com.google.devtools.ksp.symbol.KSAnnotation
+import kotlin.reflect.KClass
+
+fun <T : Annotation> KSAnnotated.getAnnotationsByType(annotationKClass: KClass<T>): Sequence<KSAnnotation> {
+    return this.annotations.filter {
+        it.shortName.getShortName() == annotationKClass.simpleName && it.annotationType.resolve().declaration
+            .qualifiedName?.asString() == annotationKClass.qualifiedName
+    }
+}

moxy/compiler/src/main/java/com/omegar/mvp/compiler/extensions/TypeSpecExtensions.kt

@@ -10,8 +10,12 @@ import com.squareup.kotlinpoet.TypeSpec
  */
 
 fun TypeSpec.toFileSpec(packageName: String): FileSpec {
+    return toFileSpecBuilder(packageName)
+        .build()
+}
+
+fun TypeSpec.toFileSpecBuilder(packageName: String): FileSpec.Builder {
     return FileSpec.builder(packageName, name!!)
         .addType(this)
         .indent("\t")
-        .build()
 }

moxy/compiler/src/main/java/com/omegar/mvp/compiler/ksp/KspOriginatingMarker.kt

@@ -1,7 +1,6 @@
 package com.omegar.mvp.compiler.ksp
 
 import com.google.devtools.ksp.symbol.KSFile
-import com.omegar.mvp.RegisterMoxyReflectorPackages
 import com.omegar.mvp.compiler.entities.Tagged
 import com.omegar.mvp.compiler.processors.OriginatingMarker
 import com.squareup.kotlinpoet.FunSpec