feat: add surf-api-processor module with AutoService support

- Introduced `surf-api-processor` module for symbol processing.
- Implemented `AutoServiceSymbolProcessor` to handle dependencies and service generation.
- Updated `build.gradle.kts` and `settings.gradle.kts` to include the new module.
- Removed unused library from `surf-api-gradle-plugin`.
- Bumped version to 1.4.1.

Author: twisti-dev

build.gradle.kts

@@ -34,7 +34,8 @@ apiValidation {
             "surf-api-bukkit-server",
             "surf-api-velocity-server",
             "surf-api-standalone",
-            "surf-api-gradle-plugin"
+            "surf-api-gradle-plugin",
+            "surf-api-processor"
         )
     )
 

buildSrc/src/main/kotlin/core-convention.gradle.kts

@@ -27,11 +27,16 @@ repositories {
 
 dependencies {
     compileOnly(libs.auto.service.annotations)
-    ksp(libs.auto.service)
+    ksp(project(":surf-api-gradle-plugin:surf-api-processor"))
 
     compileOnlyApi("org.jetbrains:annotations:24.1.0")
 }
 
+ksp {
+    arg("autoserviceKsp.verbose", "true")
+    arg("autoserviceKsp.verify", "true")
+}
+
 extensions.configure<KotlinJvmProjectExtension> {
     val javaVersion: String by project
 

gradle/libs.versions.toml

@@ -58,11 +58,11 @@ auto-service = "1.1.1"
 auto-service-ksp = "1.2.0"
 ktor = "3.1.1"
 glm = "0.9.9.1-12"
+ksp-version = "2.2.0-2.0.2"
 
 # Plugin versions
 maven-repo-auth = "3.0.4"
 shadow-gradle-plugin = "9.0.0"
-ksp-gradle-plugin = "2.2.0-2.0.2"
 run-paper-gradle-plugin = "2.3.1"
 dokka = "2.0.0"
 
@@ -159,7 +159,8 @@ kotlin-no-arg = { module = "org.jetbrains.kotlin:kotlin-noarg", version.ref = "k
 kotlin-serialization = { module = "org.jetbrains.kotlin.plugin.serialization:org.jetbrains.kotlin.plugin.serialization.gradle.plugin", version.ref = "kotlinVersion" }
 maven-repo-auth = { module = "org.hibernate.build.maven-repo-auth:org.hibernate.build.maven-repo-auth.gradle.plugin", version.ref = "maven-repo-auth" }
 shadow-gradle-plugin = { module = "com.gradleup.shadow:shadow-gradle-plugin", version.ref = "shadow-gradle-plugin" }
-ksp-gradle-plugin = { module = "com.google.devtools.ksp:com.google.devtools.ksp.gradle.plugin", version.ref = "ksp-gradle-plugin" }
+ksp-gradle-plugin = { module = "com.google.devtools.ksp:com.google.devtools.ksp.gradle.plugin", version.ref = "ksp-version" }
+ksp-api = { module = "com.google.devtools.ksp:symbol-processing-api", version.ref = "ksp-version" }
 plugin-yml-paper-gradle-plugin = { module = "de.eldoria.plugin-yml.paper:de.eldoria.plugin-yml.paper.gradle.plugin", version.ref = "plugin-yml-paper" }
 run-paper-gradle-plugin = { module = "xyz.jpenilla.run-paper:xyz.jpenilla.run-paper.gradle.plugin", version.ref = "run-paper-gradle-plugin" }
 dokka-gradle-plugin = { module = "org.jetbrains.dokka:org.jetbrains.dokka.gradle.plugin", version.ref = "dokka" }
@@ -170,7 +171,7 @@ run-paper = { id = "xyz.jpenilla.run-paper", version.ref = "run-paper-gradle-plu
 maven-repo-auth = { id = "org.hibernate.build.maven-repo-auth", version.ref = "maven-repo-auth" }
 dokka = { id = "org.jetbrains.dokka", version.ref = "dokka" }
 kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlinVersion" }
-ksp = { id = "com.google.devtools.ksp", version.ref = "ksp-gradle-plugin" }
+ksp = { id = "com.google.devtools.ksp", version.ref = "ksp-version" }
 
 [bundles]
 ktor-client = ["ktor-client-core", "ktor-client-okhttp", "ktor-client-content-negotiation", "ktor-serialization-kotlinx-json"]

settings.gradle.kts

@@ -22,6 +22,7 @@ include(":surf-api-velocity:surf-api-velocity-server")
 
 include("surf-api-standalone")
 include("surf-api-gradle-plugin")
+include("surf-api-gradle-plugin:surf-api-processor")
 
 if (!ci) {
     include(":surf-api-bukkit:surf-api-bukkit-plugin-test")

surf-api-gradle-plugin/build.gradle.kts

@@ -20,7 +20,7 @@ plugins {
 group = groupId
 version = buildString {
     append(mcVersion)
-    append("-1.4.0")
+    append("-1.4.1")
     if (snapshot) append("-SNAPSHOT")
 }
 
@@ -107,7 +107,6 @@ val generateConstants by tasks.registering {
     inputs.property("libs.paper.api", libs.paper.api.get().toString())
     inputs.property("libs.velocity.api", libs.velocity.api.get().toString())
     inputs.property("libs.auto.service.annotations", libs.auto.service.annotations.get().toString())
-    inputs.property("libs.auto.service", libs.auto.service.asProvider().get().toString())
     inputs.property("libs.versions.commandapi", libs.versions.commandapi.get().toString())
     inputs.property("libs.versions.placeholder.api", libs.versions.placeholder.api.get().toString())
     inputs.property("libs.versions.luckperms", libs.versions.luckperms.get().toString())
@@ -122,6 +121,7 @@ val generateConstants by tasks.registering {
     outputs.dir(constantsOutputDir)
 
     doLast {
+        val generator = project(":surf-api-gradle-plugin:surf-api-processor")
         val content = """
             |package dev.slne.surf.surfapi.gradle.generated
             |
@@ -132,7 +132,7 @@ val generateConstants by tasks.registering {
             |    const val PAPER_API = "${libs.paper.api.get()}"
             |    const val VELOCITY_API = "${libs.velocity.api.get()}"
             |    const val AUTO_SERVICE_ANNOTATIONS = "${libs.auto.service.annotations.get()}"
-            |    const val AUTO_SERVICE = "${libs.auto.service.asProvider().get()}"
+            |    const val AUTO_SERVICE = "${generator.group}:${generator.name}:${generator.version}"
             |
             |    const val JAVA_VERSION = $javaVersion
             |    const val MINECRAFT_VERSION = "$mcVersion"

surf-api-gradle-plugin/src/main/kotlin/dev/slne/surf/surfapi/gradle/platform/common/CommonSurfPlugin.kt

@@ -123,51 +123,32 @@ abstract class CommonSurfPlugin<E : CommonSurfExtension>(
             }
         }
 
-        project.configurations.configureEach {
-            if (isCanBeResolved) {
-                incoming.afterResolve {
-                    val deps = resolutionResult.allDependencies
-                        .map { it.requested.displayName }
-                        .toSet()
-
-                    dependencyDependentRelocations.forEach { (needle, relocations) ->
-                        if (deps.any { it.contains(needle) }) {
-                            logger.lifecycle("Dependency $needle found. Applying relocations.")
-                            project.tasks.withType<ShadowJar>().configureEach {
-                                relocations.forEach { (from, to) ->
-                                    logger.lifecycle("Relocating $from to $to")
-                                    relocate(from, to)
-                                }
-                            }
+        tasks.withType<ShadowJar>().configureEach {
+            val depsProvider = project.provider {
+                project.configurations
+                    .asSequence()
+                    .filter { it.isCanBeResolved }
+                    .flatMap { cfg ->
+                        cfg.incoming.resolutionResult.allDependencies.asSequence()
+                    }
+                    .map { it.requested.displayName }
+                    .toSet()
+            }
+
+            doFirst {
+                val deps = depsProvider.get()
+                dependencyDependentRelocations.forEach { (needle, relos) ->
+                    if (deps.any { it.contains(needle) }) {
+                        logger.lifecycle("Dependency $needle found — applying relocations.")
+                        relos.forEach { (from, to) ->
+                            logger.lifecycle("Relocating $from to $to")
+                            relocate(from, to)
                         }
                     }
                 }
             }
         }
 
-
-//        gradle.projectsEvaluated {
-//            tasks.withType<ShadowJar> {
-//                val deps = project.configurations
-//                    .filter { it.isCanBeResolved }
-//                    .map { it.incoming.resolutionResult.allDependencies }
-//                    .flatten()
-//                    .map { it.requested.displayName }
-//                    .distinct()
-//                    .toList()
-//
-//                dependencyDependentRelocations.forEach { (dependency, relocations) ->
-//                    if (deps.any { it.contains(dependency) }) {
-//                        logger.warn("Dependency $dependency found. Applying relocations.")
-//                        relocations.forEach { (from, to) ->
-//                            logger.warn("Relocating $from to $to")
-//                            relocate(from, to)
-//                        }
-//                    }
-//                }
-//            }
-//        }
-
         configure<JavaPluginExtension> {
             withSourcesJar()
             withJavadocJar()

surf-api-gradle-plugin/surf-api-processor/build.gradle.kts

@@ -0,0 +1,24 @@
+// region properties
+val mcVersion: String by project
+val groupId = findProperty("group") as String
+val snapshot = (findProperty("snapshot") as String).toBooleanStrict()
+// endregion
+
+plugins {
+    kotlin("jvm")
+}
+
+group = groupId
+version = buildString {
+    append(mcVersion)
+    append("-1.0.0")
+    if (snapshot) append("-SNAPSHOT")
+}
+
+dependencies {
+    implementation(libs.ksp.api)
+    implementation(libs.auto.service.annotations)
+
+    // https://mvnrepository.com/artifact/com.squareup/kotlinpoet
+    implementation("com.squareup:kotlinpoet:2.2.0")
+}

surf-api-gradle-plugin/surf-api-processor/src/main/kotlin/dev/slne/surf/surfapi/processor/autoservice/AutoServiceSymbolProcessor.kt

@@ -0,0 +1,178 @@
+package dev.slne.surf.surfapi.processor.autoservice
+
+import com.google.auto.service.AutoService
+import com.google.devtools.ksp.closestClassDeclaration
+import com.google.devtools.ksp.getAllSuperTypes
+import com.google.devtools.ksp.isLocal
+import com.google.devtools.ksp.processing.Dependencies
+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.google.devtools.ksp.symbol.KSFile
+import com.google.devtools.ksp.symbol.KSType
+import com.squareup.kotlinpoet.ClassName
+import java.io.IOException
+
+class AutoServiceSymbolProcessor(environment: SymbolProcessorEnvironment) : SymbolProcessor {
+
+    companion object {
+        private val SERVICE_ANNOTATION = AutoService::class.java.name
+    }
+
+    private val logger = environment.logger
+    private val codeGenerator = environment.codeGenerator
+
+    // Map: serviceFqName -> set of (impl binary name, source file)
+    private val providers = mutableMapOf<String, MutableSet<Pair<String, KSFile?>>>()
+
+    private val verify = environment.options["autoserviceKsp.verify"]?.toBoolean() == true
+    private val verbose = environment.options["autoserviceKsp.verbose"]?.toBoolean() == true
+
+
+    override fun process(resolver: Resolver): List<KSAnnotated> {
+        val deferred = mutableListOf<KSAnnotated>()
+
+        resolver.getSymbolsWithAnnotation(SERVICE_ANNOTATION)
+            .filterIsInstance<KSClassDeclaration>()
+            .forEach { implementer ->
+                val annotation = implementer.annotations.firstOrNull {
+                    it.annotationType.resolve().declaration.qualifiedName?.asString() == SERVICE_ANNOTATION
+                } ?: run {
+                    logger.error("@AutoService annotation not found on element", implementer)
+                    return@forEach
+                }
+
+                val argValue =
+                    annotation.arguments.firstOrNull { it.name?.asString() == "value" }?.value
+                val providerTypes: List<KSType> = when (argValue) {
+                    is List<*> -> argValue.filterIsInstance<KSType>()
+                    is KSType -> listOf(argValue)
+                    null -> emptyList()
+                    else -> emptyList()
+                }
+
+                if (providerTypes.isEmpty()) {
+                    logger.error(
+                        "No service interfaces specified in @AutoService. " +
+                                "Use @AutoService(YourService::class).",
+                        annotation
+                    )
+                }
+
+                for (providerType in providerTypes) {
+                    if (providerType.isError) {
+                        deferred += implementer
+                        continue
+                    }
+
+                    val providerDecl = providerType.declaration.closestClassDeclaration()
+                    if (providerDecl == null) {
+                        deferred += implementer
+                        continue
+                    }
+
+                    when (checkImplementer(implementer, providerType)) {
+                        ValidationResult.VALID -> {
+                            val key = providerDecl.toBinaryName()
+                            val impl = implementer.toBinaryName()
+                            providers.getOrPut(key) { mutableSetOf() }
+                                .add(impl to implementer.containingFile)
+                        }
+
+                        ValidationResult.INVALID -> {
+                            logger.error(
+                                "Service providers must implement their service interface. " +
+                                        "${implementer.qualifiedName?.asString()} does not implement " +
+                                        providerDecl.qualifiedName?.asString(),
+                                implementer
+                            )
+                        }
+
+                        ValidationResult.DEFERRED -> {
+                            deferred += implementer
+                        }
+                    }
+                }
+            }
+
+        return deferred
+    }
+
+    override fun finish() {
+        generateAndClearConfigFiles()
+    }
+
+    private fun generateAndClearConfigFiles() {
+        for ((serviceFqName, impls) in providers) {
+            val resourcePath = "META-INF/services/$serviceFqName"
+            log("Working on resource file: $resourcePath")
+
+            try {
+                val allServices = impls.asSequence().map { it.first }.toSortedSet()
+                log("New service file contents: $allServices")
+
+                val ksFiles = impls.mapNotNull { it.second }
+                log("Originating files: ${ksFiles.map(KSFile::fileName)}")
+
+                val deps = if (ksFiles.isEmpty()) {
+                    Dependencies(aggregating = true)
+                } else {
+                    Dependencies(aggregating = true, sources = ksFiles.toTypedArray())
+                }
+
+                codeGenerator.createNewFileByPath(deps, resourcePath, "").bufferedWriter()
+                    .use { writer ->
+                        for (service in allServices) {
+                            writer.write(service)
+                            writer.newLine()
+                        }
+                    }
+
+                log("Wrote to: $resourcePath")
+            } catch (e: IOException) {
+                logger.error("Unable to create $resourcePath, $e")
+            }
+        }
+    }
+
+    private fun log(message: String) {
+        if (verbose) {
+            logger.info(message)
+        }
+    }
+
+
+    private fun KSClassDeclaration.toClassName(): ClassName {
+        require(!isLocal()) { "Local/anonymous classes are not supported!" }
+        val pkg = packageName.asString()
+        val typesString = qualifiedName!!.asString().removePrefix("$pkg.")
+        val simpleNames = typesString.split(".")
+        return ClassName(pkg, simpleNames)
+    }
+
+    private fun KSClassDeclaration.toBinaryName(): String = toClassName().reflectionName()
+
+    private fun checkImplementer(
+        implementer: KSClassDeclaration,
+        providerType: KSType,
+    ): ValidationResult {
+        if (!verify) return ValidationResult.VALID
+
+        for (superType in implementer.getAllSuperTypes()) {
+            if (superType.isError) return ValidationResult.DEFERRED
+            // Accept equal types or assignable in either direction
+            if (superType == providerType ||
+                superType.isAssignableFrom(providerType) ||
+                providerType.isAssignableFrom(superType)
+            ) {
+                return ValidationResult.VALID
+            }
+        }
+
+        return ValidationResult.INVALID
+    }
+
+    private enum class ValidationResult { VALID, INVALID, DEFERRED }
+}

surf-api-gradle-plugin/surf-api-processor/src/main/kotlin/dev/slne/surf/surfapi/processor/autoservice/AutoServiceSymbolProcessorProvider.kt

@@ -0,0 +1,11 @@
+package dev.slne.surf.surfapi.processor.autoservice
+
+import com.google.devtools.ksp.processing.SymbolProcessor
+import com.google.devtools.ksp.processing.SymbolProcessorEnvironment
+import com.google.devtools.ksp.processing.SymbolProcessorProvider
+
+class AutoServiceSymbolProcessorProvider: SymbolProcessorProvider {
+    override fun create(environment: SymbolProcessorEnvironment): SymbolProcessor {
+        return AutoServiceSymbolProcessor(environment)
+    }
+}

surf-api-gradle-plugin/surf-api-processor/src/main/resources/META-INF/services/com.google.devtools.ksp.processing.SymbolProcessorProvider

@@ -0,0 +1 @@
+dev.slne.surf.surfapi.processor.autoservice.AutoServiceSymbolProcessorProvider