Add support for KSP (#323)

* Rename .java to .kt

* Convert processor ot Kotlin

* Rename .java to .kt

* Convert all processor tests to Kotlin and use com.github.tschuchortdev:kotlin-compile-testing for testing.
Moved all tests over and make them more meaningful by testing what ends up in the index instad of just 1:1 ow which code they generate) which with the index bing binary is unverifiable.

* Cleanup

* Kotlin conversion cleanup and segmentation.

* First step of ksp conversion

* First step of ksp conversion

* Fix delegate and index generation

* Cleanup

* Moved all tests to mockk
Removed old unused dependencies
Check generated source on top of functionality
Split method and class elements into two sets for processing
Fixed index generation for inner classes
Added processor test with inner class
Enabled ksp for sample project

* Fix originating elements for Delegate generation.
Fix originalting elment for Registry generation.
Made unit test when running via ksp not to compiled code check.

* Use | for separator of options

* Fix argument and disable kapt plugin

* Remove no unused jcenter
Fix warning
Updated gradle to 7.1

* Add Kapt test library to show setup for kapt.
Clean up gralde plugin dependency for ksp.
Updated documentation.

* Use public version of xProcessorVersion
Remove airbnb repo dependency

* Add ktlint plugin and clean up the processor.
Also add ktlint to ci checks.

* Better error message match.

* When running ksp allow the incremental flag to not be set and still get the custom processors from config.
Use testKsp to test that behavior.

* Cleanup.

* Typos

* Cleanup and Pr comments.

* Rename .java to .kt

* Made DeepLinkAnnotatedElement a sealed class
Adde Kotlin source base tests.
Cleanup/fixes

* Enable failing tests

* Kotlin conversion

* Make sure to generate java source files in correct package like it is done for room (mentioned here tschuchortdev/kotlin-compile-testing#105 (comment)) but this also does not work.

Disabled ksp test for inner classes in java because of tschuchortdev/kotlin-compile-testing#105

* Add missing import
Add Kotlin based module

* Add note about Kotlin source files when using KSP.

* Remove note about kapt/ksp coexistance.

Co-authored-by: Andreas Rossbacher <[email protected]>

Author: rossbacher

.travis.yml

@@ -23,7 +23,7 @@ branches:
 notifications:
   email: false
 
-script: ./gradlew assemble check
+script: ./gradlew assemble check lintKotlin
 
 sudo: false
 

README.md

@@ -292,16 +292,93 @@ which saves you from defining a lot prefixes.
 
 Add to your project `build.gradle` file (Latest version is [![DeeplinkDispatch version](https://badge.fury.io/gh/airbnb%2FDeepLinkDispatch.svg)](https://badge.fury.io/gh/airbnb%2FDeepLinkDispatch)
 ): 
+```groovy
+dependencies {
+  implementation 'com.airbnb:deeplinkdispatch:x.x.x'
+}
+```
+
+DeeplinkDispatch supports three ways to run the annotation processor dependin on which one you choose
+the setup is slightly different.
+
+### KSP
+
+When using Kotlin we strongly suggest to use KSP as it can bring major speed improvements.
+
+To run the processor via KSP you first have to apply the KSP plugin. Add the dependency to the
+`build.gradle` file of your main project:
+
+```groovy
+buildscript {
+
+    apply from: rootProject.file("dependencies.gradle")
+
+    repositories {
+        google()
+        gradlePluginPortal()
+    }
+    dependencies {
+        classpath "com.google.devtools.ksp:com.google.devtools.ksp.gradle.plugin:<ksp-version>"
+    }
+}
+```
+
+Apply the plugin in the `build.gradle` file of the project you want to use it:
+
+```groovy
+plugins {
+  id("com.google.devtools.ksp")
+}
+```
+
+and don't forget the dependency to the annotation procesor and DeepLinkDispatch itself:
+
+```groovy
+dependencies {
+  implementation 'com.airbnb:deeplinkdispatch:x.x.x'
+  ksp 'com.airbnb:deeplinkdispatch-processor:x.x.x'
+}
+```
+
+**Note:** When using KSP (you have `ksp 'com.airbnb:deeplinkdispatch-processor:x.x.x'` in your dependencies) at least one Kotlin source file *must* be present in the project or no output will be generated!
+
+As an example the main `sample` app is set up using KSP.
+
+### Kapt
+
+If your project is already setup for Kotlin the only thing you have to add is the plugin:
+
+```groovy
+plugins {
+  id("kotlin-kapt")
+}
+```
+
+and don't forget the dependency to the annotation procesor and DeepLinkDispatch itself:
+
+```groovy
+dependencies {
+  implementation 'com.airbnb:deeplinkdispatch:x.x.x'
+  kapt 'com.airbnb:deeplinkdispatch-processor:x.x.x'
+}
+```
+
+As an example the `sample-kapt-library` is set up using Kapt
+
+### Java annotation processor
+
+Just add the dependency to DeepLinkDispatch and to the annotation processor:
+
 ```groovy
 dependencies {
   implementation 'com.airbnb:deeplinkdispatch:x.x.x'
   annotationProcessor 'com.airbnb:deeplinkdispatch-processor:x.x.x'
 }
 ```
 
-_For **Kotlin** you should use_ `kapt` _instead of_ `annotationProcessor`
+As an example the `sample-library` is set up using the Java annotation processor
 
-Create your deep link module(s) (**new on DeepLinkDispatch v3**). For every class you annotate with `@DeepLinkModule`, DeepLinkDispatch will generate a "Registry" class, which contains a registry of all your `@DeepLink` annotations.
+When this is done, create your deep link module(s) (**new on DeepLinkDispatch v3**). For every class you annotate with `@DeepLinkModule`, DeepLinkDispatch will generate a "Registry" class, which contains a registry of all your `@DeepLink` annotations.
 
 ```java
 /** This will generate a AppDeepLinkModuleRegistry class */
@@ -387,7 +464,7 @@ When upgrading to 5.x+ you may experience some breaking API changes. Read about
 
 ### Incremental annotation processing
 
-You must update your build.gradle to opt into incremental annotation processing. When enabled, all custom deep link annotations must be registered in the build.gradle (comma separated), otherwise they will be silently ignored.
+You must update your build.gradle to opt into incremental annotation processing. When enabled, all custom deep link annotations must be registered in the build.gradle (pipe (`|`) separated), otherwise they will be silently ignored.
 
 Examples of this configuration are as follows: 
 
@@ -397,7 +474,7 @@ javaCompileOptions {
   annotationProcessorOptions {
     arguments = [
       'deepLink.incremental': 'true',
-      'deepLink.customAnnotations': 'com.airbnb.AppDeepLink,com.airbnb.WebDeepLink'
+      'deepLink.customAnnotations': 'com.airbnb.AppDeepLink|com.airbnb.WebDeepLink'
     ]
   }
 }
@@ -408,11 +485,23 @@ javaCompileOptions {
 kapt {
   arguments {
     arg("deepLink.incremental", "true")
-    arg("deepLink.customAnnotations", "com.airbnb.AppDeepLink,com.airbnb.WebDeepLink")
+    arg("deepLink.customAnnotations", "com.airbnb.AppDeepLink|com.airbnb.WebDeepLink")
   }
 }
 ```
 
+**KSP**
+
+KSP is always incremental and you always have to provide the list of `deepLink.customAnnotation` if
+you have any or they will not be processed.
+
+```groovy
+ksp {
+  arg("deepLink.incremental", "true")
+  arg("deepLink.customAnnotations", "com.airbnb.AppDeepLink|com.airbnb.WebDeepLink")
+}
+```
+
 ### Performance
 
 Starting with v5 DeeplinkDispatch is designed to be very fast in resolving deep links even if there are a lot of them. To ensure we do not regress from this benchmark tests using [`androidx.benchmark`](https://developer.android.com/studio/profile/benchmark#top_of_page) were added.
@@ -457,7 +546,7 @@ tasks.withType(JavaCompile) {
 }
 ```
 
-If you are using Kotlin this is how you can enable it for kapt
+When using Kotlin Kapt
 ```groovy
 kapt {
   arguments {
@@ -466,6 +555,13 @@ kapt {
 }
 ```
 
+and if you are using KSP
+```groovy
+kapt {
+  arg("deepLinkDoc.output", "${buildDir}/doc/deeplinks.txt")
+}
+```
+
 The documentation will be generated in the following format:
 ```
 * {DeepLink1}\n|#|\n[Description part of javadoc]\n|#|\n{ClassName}#[MethodName]\n|##|\n

build.gradle

@@ -7,7 +7,7 @@ buildscript {
     repositories {
         google()
         mavenCentral()
-        jcenter() // Still needed for some old dependencies
+        gradlePluginPortal()
         maven { url "https://oss.sonatype.org/service/local/repositories/snapshots/content/" }
     }
     dependencies {
@@ -17,6 +17,8 @@ buildscript {
         classpath deps.benchmarkGradlePlugin
         // Dokka is needed on classpath for vanniktech publish plugin
         classpath deps.dokkaPlugin
+        classpath deps.kspGradlePlugin
+        classpath deps.ktlintGradlePlugin
     }
 }
 
@@ -26,7 +28,6 @@ allprojects {
     repositories {
         google()
         mavenCentral()
-        jcenter() // Still needed for some old dependencies
     }
 }
 

deeplinkdispatch-base/src/main/java/com/airbnb/deeplinkdispatch/DeepLinkEntry.kt

@@ -103,6 +103,6 @@ data class DeepLinkEntry(
     }
 
     override fun toString(): String {
-        return "uriTemplate: $uriTemplate activity: ${activityClass.name} method: $method"
+        return "uriTemplate: $uriTemplate className: $className method: $method"
     }
 }

deeplinkdispatch-base/src/main/java/com/airbnb/deeplinkdispatch/DeepLinkSpec.java

@@ -44,5 +44,5 @@
 // are not so we need to mark them as RetentionPolicy.RUNTIME.
 @Retention(RetentionPolicy.RUNTIME)
 public @interface DeepLinkSpec {
-  String[] prefix();
+   String[] prefix();
 }

deeplinkdispatch-processor/build.gradle

@@ -1,5 +1,6 @@
 apply plugin: 'java'
 apply plugin: 'kotlin'
+apply plugin: 'org.jmailen.kotlinter'
 
 sourceCompatibility = 1.8
 
@@ -11,8 +12,9 @@ dependencies {
   implementation deps.jsr305
   implementation deps.kotlinStdLib
   implementation deps.javaPoet
-  implementation deps.autoCommon
   implementation deps.androidXAnnotations
+  implementation deps.ksp
+  implementation deps.xProcessor
 
   testImplementation deps.junit
   testImplementation deps.assertJ
@@ -21,8 +23,9 @@ dependencies {
   // Cannot depend on them from Maven as they are .aar and not .jar files (this is a java project)
   testImplementation fileTree(dir: 'libs', include: ['androidx.localbroadcastmanager-1.0.0-beta1.jar','androidx.core-1.0.0-beta1.jar'])
   testImplementation deps.compileTesting
-  testImplementation deps.truth
-  testImplementation deps.mockito
+  testImplementation deps.compileTestingKsp
+  testImplementation deps.mockk
+  testImplementation deps.kotlinReflect
   testImplementation files("${System.properties['java.home']}/../lib/tools.jar")
 }
 
@@ -31,3 +34,11 @@ checkstyle {
   showViolations true
   configProperties = ['checkstyle.cache.file': rootProject.file('build/checkstyle.cache')]
 }
+
+tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
+  kotlinOptions {
+    jvmTarget = "1.8"
+    freeCompilerArgs += "-Xopt-in=kotlin.RequiresOptIn"
+    freeCompilerArgs += "-Xopt-in=androidx.room.compiler.processing.ExperimentalProcessingApi"
+  }
+}

deeplinkdispatch-processor/src/main/java/com/airbnb/deeplinkdispatch/BaseProcessor.kt

@@ -0,0 +1,65 @@
+package com.airbnb.deeplinkdispatch
+
+import androidx.room.compiler.processing.XProcessingEnv
+import androidx.room.compiler.processing.XRoundEnv
+import androidx.room.compiler.processing.XTypeElement
+import androidx.room.compiler.processing.compat.XConverters.toXProcessing
+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 javax.annotation.processing.AbstractProcessor
+import javax.annotation.processing.ProcessingEnvironment
+import javax.annotation.processing.RoundEnvironment
+import javax.lang.model.SourceVersion
+import javax.lang.model.element.TypeElement
+
+/**
+ * Creates a unified abstraction for processors of both KSP and java annotation processing.
+ */
+abstract class BaseProcessor(val symbolProcessorEnvironment: SymbolProcessorEnvironment?) :
+    AbstractProcessor(),
+    SymbolProcessor {
+
+    lateinit var environment: XProcessingEnv
+        private set
+
+    override fun getSupportedSourceVersion(): SourceVersion = SourceVersion.RELEASE_8
+
+    final override fun init(processingEnv: ProcessingEnvironment) {
+        super<AbstractProcessor>.init(processingEnv)
+        environment = XProcessingEnv.create(processingEnv)
+    }
+
+    final override fun process(annotations: Set<TypeElement>, roundEnv: RoundEnvironment): Boolean {
+        if (roundEnv.errorRaised()) {
+            onError()
+        }
+
+        process(annotations.map { it.toXProcessing(environment) }.toSet(), environment, XRoundEnv.create(environment, roundEnv))
+
+        if (roundEnv.processingOver()) {
+            finish()
+        }
+
+        return false
+    }
+
+    final override fun process(resolver: Resolver): List<KSAnnotated> {
+        val symbolProcessorEnvironment = requireNotNull(symbolProcessorEnvironment)
+        environment = XProcessingEnv.create(
+            symbolProcessorEnvironment.options,
+            resolver,
+            symbolProcessorEnvironment.codeGenerator,
+            symbolProcessorEnvironment.logger
+        )
+        process(null, environment, XRoundEnv.create(environment))
+        return emptyList()
+    }
+
+    abstract fun process(
+        annotations: Set<XTypeElement>?,
+        environment: XProcessingEnv,
+        round: XRoundEnv
+    )
+}