Refactoring

johnsonlee · May 30, 2022 · c7b6e6a · c7b6e6a
1 parent 67de01e
commit c7b6e6a
Show file tree

Hide file tree

Showing 10 changed files with 79 additions and 28 deletions.
diff --git a/build.gradle.kts b/build.gradle.kts
@@ -9,10 +9,28 @@ buildscript {
 
     dependencies {
         classpath("com.android.tools.build:gradle:4.0.0")
-        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:1.5.31")
-        classpath("io.johnsonlee:sonatype-publish-plugin:1.5.6")
+        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${embeddedKotlinVersion}")
+        classpath("io.johnsonlee:sonatype-publish-plugin:1.6.2")
     }
 }
 
 group = "io.johnsonlee.codegen"
 version = project.properties["version"]?.takeIf { it != DEFAULT_VERSION } ?: "1.0.0-SNAPSHOT"
+
+allprojects {
+    group = rootProject.group
+    version = rootProject.version
+
+    repositories {
+        mavenCentral()
+        google()
+    }
+
+    tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
+        kotlinOptions {
+            freeCompilerArgs = listOf("-Xjsr305=strict", "-Xskip-metadata-version-check")
+            jvmTarget = "1.8"
+        }
+    }
+
+}
diff --git a/compiler/src/main/kotlin/io/johnsonlee/codegen/compiler/CodegenProcessor.kt b/compiler/src/main/kotlin/io/johnsonlee/codegen/compiler/CodegenProcessor.kt
@@ -22,6 +22,7 @@ abstract class CodegenProcessor<T : Annotation> : AbstractProcessor() {
 
     protected val supportedAnnotation: Class<T> by lazy {
         (javaClass.genericSuperclass as ParameterizedType).actualTypeArguments.map {
+            @Suppress("UNCHECKED_CAST")
             it as Class<T>
         }.first()
     }
@@ -60,15 +61,20 @@ abstract class CodegenProcessor<T : Annotation> : AbstractProcessor() {
 
     protected open fun onPostProcessing(processingEnv: ProcessingEnvironment) = Unit
 
-    protected fun <T : Model> generate(template: String, model: T, lang: Language = Language.JAVA) {
+    protected fun <T : Model> generate(template: String, model: T, output: Output) {
         val originatingElements = model.references.map {
             processingEnv.elementUtils.getTypeElement(it)
         }.toTypedArray()
-        when (lang) {
-            Language.JAVA -> generateJavaSources(model, originatingElements)
-            else -> generateSources(lang, model, originatingElements)
-        }.openWriter().use { writer ->
-            engine.render("${template}.${lang.extension}.${engine.extension.lowercase()}", model, writer)
+        when (output) {
+            is Source -> when (output) {
+                 Source.Java -> generateJavaSources(model, originatingElements)
+                else -> generateSources(output, model, originatingElements)
+            }
+            is Resource -> generateResource(output, model, originatingElements)
+            else -> null
+        }?.openWriter()?.use { writer ->
+            val ext = if (output.extension.isNotBlank()) ".${output.extension}" else ""
+            engine.render("${template}${ext}.${engine.extension.toLowerCase()}", model, writer)
             writer.close()
         }
     }
@@ -86,7 +92,7 @@ abstract class CodegenProcessor<T : Annotation> : AbstractProcessor() {
     }
 
     private fun <T : Model> generateSources(
-        lang: Language,
+        source: Source,
         model: T,
         originatingElements: Array<TypeElement>
     ): FileObject {
@@ -95,10 +101,20 @@ abstract class CodegenProcessor<T : Annotation> : AbstractProcessor() {
         return processingEnv.filer.createResource(
             StandardLocation.SOURCE_OUTPUT,
             pkg,
-            "${name}.${lang.extension}",
+            "${name}.${source.extension}",
             *originatingElements
         )
     }
 
+    private fun <T : Model> generateResource(
+        resource: Resource,
+        model: T,
+        originatingElements: Array<TypeElement>
+    ): FileObject = processingEnv.filer.createResource(
+        StandardLocation.CLASS_OUTPUT,
+        "",
+        "${resource.prefix}${File.separator}${model.qualifiedName}",
+        *originatingElements
+    )
 
 }
diff --git a/compiler/src/main/kotlin/io/johnsonlee/codegen/compiler/ElementExtension.kt b/compiler/src/main/kotlin/io/johnsonlee/codegen/compiler/ElementExtension.kt
@@ -7,6 +7,8 @@ import javax.lang.model.element.TypeElement
 
 fun Element.asTypeElement(): TypeElement = MoreElements.asType(this)
 
-inline fun <reified T : Annotation> Element.getAnnotationMirror(): AnnotationMirror {
-    return MoreElements.getAnnotationMirror(this, T::class.java).get()
+inline fun <reified T : Annotation> Element.getAnnotationMirror(): AnnotationMirror? {
+    return MoreElements.getAnnotationMirror(this, T::class.java).takeIf {
+        it.isPresent
+    }?.get()
 }
diff --git a/compiler/src/main/kotlin/io/johnsonlee/codegen/compiler/Language.kt b/compiler/src/main/kotlin/io/johnsonlee/codegen/compiler/Language.kt
diff --git a/compiler/src/main/kotlin/io/johnsonlee/codegen/compiler/Output.kt b/compiler/src/main/kotlin/io/johnsonlee/codegen/compiler/Output.kt
@@ -0,0 +1,16 @@
+package io.johnsonlee.codegen.compiler
+
+interface Output {
+    val extension: String
+}
+
+sealed class Source(override val extension: String) : Output {
+    object Java: Source("java")
+    object Kotlin: Source("kt")
+    object KotlinScript: Source("kts")
+    object Groovy: Source("groovy")
+}
+
+interface Resource : Output {
+    val prefix: String
+}
diff --git a/compiler/src/main/kotlin/io/johnsonlee/codegen/compiler/ProcessingEnvironmentExtension.kt b/compiler/src/main/kotlin/io/johnsonlee/codegen/compiler/ProcessingEnvironmentExtension.kt
@@ -1,5 +1,7 @@
 package io.johnsonlee.codegen.compiler
 
+import java.io.PrintWriter
+import java.io.StringWriter
 import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.AnnotationMirror
 import javax.lang.model.element.Element
@@ -26,5 +28,9 @@ fun ProcessingEnvironment.error(msg: String, element: Element, annotation: Annot
 }
 
 fun ProcessingEnvironment.fatal(e: Throwable) {
-    messager.printMessage(Diagnostic.Kind.ERROR, "FATAL ERROR: ${e.stackTraceToString()}")
+    val stack = StringWriter().run {
+        e.printStackTrace(PrintWriter(this))
+        toString()
+    }
+    messager.printMessage(Diagnostic.Kind.ERROR, "FATAL ERROR: $stack")
 }
diff --git a/example/src/main/kotlin/io/johnsonlee/codegen/example/AutoFactoryCodegen.kt b/example/src/main/kotlin/io/johnsonlee/codegen/example/AutoFactoryCodegen.kt
@@ -2,7 +2,7 @@ package io.johnsonlee.codegen.example
 
 import com.google.auto.service.AutoService
 import io.johnsonlee.codegen.compiler.CodegenProcessor
-import io.johnsonlee.codegen.compiler.Language
+import io.johnsonlee.codegen.compiler.Source
 import io.johnsonlee.codegen.compiler.asElement
 import io.johnsonlee.codegen.compiler.asTypeElement
 import io.johnsonlee.codegen.compiler.error
@@ -14,13 +14,16 @@ import io.johnsonlee.codegen.template.mustache.MustacheEngine
 import javax.annotation.processing.ProcessingEnvironment
 import javax.annotation.processing.Processor
 import javax.annotation.processing.RoundEnvironment
+import javax.annotation.processing.SupportedSourceVersion
+import javax.lang.model.SourceVersion
 import javax.lang.model.element.AnnotationMirror
 import javax.lang.model.element.ElementKind
 import javax.lang.model.element.ExecutableElement
 import javax.lang.model.element.TypeElement
 import javax.lang.model.type.DeclaredType
 
 @AutoService(Processor::class)
+@SupportedSourceVersion(SourceVersion.RELEASE_8)
 class AutoFactoryCodegen : CodegenProcessor<AutoFactory>() {
 
     private val mustache: TemplateEngine by lazy(::MustacheEngine)
@@ -34,7 +37,7 @@ class AutoFactoryCodegen : CodegenProcessor<AutoFactory>() {
     ) {
         roundEnv.onEachAnnotatedElement { element ->
             val implementation = element.asTypeElement()
-            val mirror = element.getAnnotationMirror<AutoFactory>()
+            val mirror = element.getAnnotationMirror<AutoFactory>() ?: return@onEachAnnotatedElement
             mirror.value.takeIf(Set<DeclaredType>::isNotEmpty)?.map(DeclaredType::asTypeElement)?.onEach { api ->
                 if (checkImplementation(implementation, api)) {
                     generateFactory(implementation, mirror)
@@ -82,7 +85,7 @@ class AutoFactoryCodegen : CodegenProcessor<AutoFactory>() {
         generate(
             "template/AutoFactory",
             AutoFactoryModel(implementation.qualifiedName.toString(), args),
-            Language.KOTLIN
+            Source.Kotlin
         )
     }
 }

diff --git a/example/src/main/resources/META-INF/gradle/incremental.annotation.processors b/example/src/main/resources/META-INF/gradle/incremental.annotation.processors
@@ -0,0 +1 @@
+io.johnsonlee.codegen.example.AutoFactoryCodegen,isolating
diff --git a/example/src/main/resources/META-INF/incremental.annotation.processors b/example/src/main/resources/META-INF/incremental.annotation.processors
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.7-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.2-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists