Fixed source sets locations and task inputs

Author: Mr3zee

docs/environment.md

@@ -61,6 +61,12 @@ Go to `Settings` -> `Build, Execution, Deployment` -> `Build Tools` -> `Gradle`
 - `Distribution` is set to `Wrapper`
 - `Gradle JVM` is set to `JAVA_HOME` and the value is correct
 
+## Android SDK
+In the root of the project you should create a `local.properties` file with the location of the Android SDK:
+```properties
+sdk.dir=/Users/<user>/Library/Android/sdk
+```
+
 ## Git and GitHub
 
 Make sure your commit signing is set up. Check the

gradle-plugin/build.gradle.kts

@@ -4,6 +4,9 @@
 
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import util.other.generateSource
+import kotlin.io.path.Path
+import kotlin.io.path.absolutePathString
+import kotlin.io.path.readLines
 
 plugins {
     `kotlin-dsl`
@@ -105,14 +108,24 @@ generateSource(
 
 val globalRootDir: String by extra
 
+val androidHome = System.getenv("ANDROID_HOME")
+    ?: Path(globalRootDir, "local.properties")
+        .readLines()
+        .find { it.startsWith("sdk.dir=") }
+        ?.substringAfter("=")
+        ?.trim()
+    ?: error("ANDROID_HOME is not set")
+
 generateSource(
     name = "TestVersions",
     text = """
         package kotlinx.rpc
         
         const val RPC_VERSION: String = "${libs.versions.kotlinx.rpc.get()}"
         
-        const val BUILD_REPO: String = "${File(globalRootDir).resolve("build/repo").absolutePath}"
+        const val ANDROID_HOME_DIR: String = "$androidHome"
+        
+        const val BUILD_REPO: String = "${Path(globalRootDir, "build", "repo").absolutePathString()}"
     """.trimIndent(),
     chooseSourceSet = { test }
 )

gradle-plugin/src/main/kotlin/kotlinx/rpc/buf/tasks/BufExecTask.kt

@@ -50,8 +50,13 @@ public abstract class BufExecTask @Inject constructor(
     @get:InputFile
     internal abstract val bufExecutable: Property<File>
 
+    /**
+     * Whether to enable debug logging for the `buf` command using `--debug` option.
+     *
+     * @see <a href="https://buf.build/docs/reference/cli/buf/#debug">Debugging</a>
+     */
     @get:Input
-    internal abstract val debug: Property<Boolean>
+    public abstract val debug: Property<Boolean>
 
     /**
      * The `buf` command to execute.
@@ -127,14 +132,14 @@ internal fun <T : BufExecTask> Project.registerBufExecTask(
 ): TaskProvider<T> = tasks.register(name, clazz, properties).apply {
     configure {
         val executableConfiguration = configurations.named(BUF_EXECUTABLE_CONFIGURATION)
-        bufExecutable.set(project.provider { executableConfiguration.get().singleFile })
-        this.workingDir.set(workingDir)
+        bufExecutable.convention(project.provider { executableConfiguration.get().singleFile })
+        this.workingDir.convention(workingDir)
 
         val buf = provider { rpcExtension().protoc.get().buf }
-        configFile.set(buf.flatMap { it.configFile })
-        logFormat.set(buf.flatMap { it.logFormat })
-        bufTimeoutInWholeSeconds.set(buf.flatMap { it.timeout.map { duration -> duration.inWholeSeconds } })
-        debug.set(gradle.startParameter.logLevel == LogLevel.DEBUG)
+        configFile.convention(buf.flatMap { it.configFile })
+        logFormat.convention(buf.flatMap { it.logFormat })
+        bufTimeoutInWholeSeconds.convention(buf.flatMap { it.timeout.map { duration -> duration.inWholeSeconds } })
+        debug.convention(gradle.startParameter.logLevel == LogLevel.DEBUG)
 
         configuration()
     }

gradle-plugin/src/main/kotlin/kotlinx/rpc/buf/tasks/BufGenerateTask.kt

@@ -5,7 +5,6 @@
 package kotlinx.rpc.buf.tasks
 
 import kotlinx.rpc.protoc.PROTO_GROUP
-import kotlinx.rpc.rpcExtension
 import kotlinx.rpc.protoc.ProtocPlugin
 import org.gradle.api.Project
 import org.gradle.api.provider.ListProperty
@@ -17,6 +16,7 @@ import org.gradle.api.tasks.TaskProvider
 import java.io.File
 import kotlinx.rpc.buf.BufGenerateExtension
 import kotlinx.rpc.protoc.DefaultProtoSourceSet
+import kotlinx.rpc.protoc.DefaultProtocExtension
 import kotlinx.rpc.protoc.ProtoTask
 import org.gradle.api.file.SourceDirectorySet
 import org.gradle.api.provider.Provider
@@ -32,16 +32,22 @@ import javax.inject.Inject
 public abstract class BufGenerateTask @Inject internal constructor(
     properties: ProtoTask.Properties,
 ) : BufExecTask(properties) {
-    // used to properly calculate output directories
+    /**
+     * List of plugin names used during `buf generate` command execution.
+     *
+     * @see kotlinx.rpc.protoc.ProtoSourceSet.plugins
+     * @see kotlinx.rpc.protoc.ProtocExtension.plugins
+     * @see ProtocPlugin
+     */
     @get:Input
-    internal abstract val pluginNames: ListProperty<String>
+    public abstract val pluginNames: ListProperty<String>
 
     /**
      * List of executable files used during `buf generate` command execution.
      *
      * @see [ProtocPlugin.Artifact.Local.executableFiles]
      */
-    // unsued, but required for Gradle to properly recognise inputs
+    // unsued, but required for Gradle to properly recognize inputs
     @get:InputFiles
     public abstract val executableFiles: ListProperty<File>
 
@@ -132,6 +138,7 @@ public abstract class BufGenerateTask @Inject internal constructor(
 }
 
 internal fun Project.registerBufGenerateTask(
+    protocExtension: DefaultProtocExtension,
     protoSourceSet: DefaultProtoSourceSet,
     workingDir: File,
     outputDirectory: File,
@@ -146,15 +153,15 @@ internal fun Project.registerBufGenerateTask(
         group = PROTO_GROUP
         description = "Generates code from .proto files using 'buf generate'"
 
-        val generate = provider { rpcExtension().protoc.get().buf.generate }
+        val generate = protocExtension.buf.generate
 
-        includeImports.set(generate.flatMap { it.includeImports })
-        includeWkt.set(generate.flatMap { it.includeWkt })
-        errorFormat.set(generate.flatMap { it.errorFormat })
+        includeImports.convention(generate.includeImports)
+        includeWkt.convention(generate.includeWkt)
+        errorFormat.convention(generate.errorFormat)
 
-        this.outputDirectory.set(outputDirectory)
+        this.outputDirectory.convention(outputDirectory)
 
-        this.pluginNames.set(includedPlugins.map { it.map { plugin -> plugin.name } })
+        pluginNames.convention(includedPlugins.map { it.map { plugin -> plugin.name } })
 
         configure()
     }

gradle-plugin/src/main/kotlin/kotlinx/rpc/buf/tasks/GenerateBufGenYaml.kt

@@ -169,13 +169,13 @@ internal fun Project.registerGenerateBufGenYamlTask(
             }
         }
 
-        plugins.set(pluginsProvider)
+        plugins.convention(pluginsProvider)
 
         val bufGenYamlFile = buildSourceSetsDir
             .resolve(BUF_GEN_YAML)
             .ensureRegularFileExists()
 
-        bufGenFile.set(bufGenYamlFile)
+        bufGenFile.convention(bufGenYamlFile)
 
         configure()
     }

gradle-plugin/src/main/kotlin/kotlinx/rpc/buf/tasks/GenerateBufYaml.kt

@@ -96,15 +96,15 @@ internal fun Project.registerGenerateBufYamlTask(
     val task = tasks.register("${GenerateBufYaml.NAME_PREFIX}$capitalizeName", GenerateBufYaml::class, properties)
 
     task.configure {
-        protoSourceDir.set(buildSourceSetsProtoDir.name)
-        importSourceDir.set(buildSourceSetsImportDir.name)
-        this.withImport.set(withImport)
+        protoSourceDir.convention(buildSourceSetsProtoDir.name)
+        importSourceDir.convention(buildSourceSetsImportDir.name)
+        this.withImport.convention(withImport)
 
         val bufYamlFile = buildSourceSetsDir
             .resolve(BUF_YAML)
             .ensureRegularFileExists()
 
-        bufFile.set(bufYamlFile)
+        bufFile.convention(bufYamlFile)
 
         configure()
     }

gradle-plugin/src/main/kotlin/kotlinx/rpc/protoc/DefaultProtoSourceSet.kt

@@ -77,7 +77,9 @@ internal open class DefaultProtoSourceSet(
     )
 
     private val explicitApiModeEnabled = project.provider {
-        project.the<KotlinProjectExtension>().explicitApi != ExplicitApiMode.Disabled
+        val isMain = androidProperties.orNull?.isTest?.not() ?: name.lowercase().endsWith("main")
+
+        isMain && project.the<KotlinProjectExtension>().explicitApi != ExplicitApiMode.Disabled
     }
 
     override val plugins = project.objects.setProperty<ProtocPlugin>()
@@ -104,9 +106,7 @@ internal open class DefaultProtoSourceSet(
     }
 
     private fun initPlugin(copy: ProtocPlugin, configure: Action<ProtocPlugin>?) {
-        if (this@DefaultProtoSourceSet.name.lowercase().endsWith("main")) {
-            copy.options.put("explicitApiModeEnabled", explicitApiModeEnabled)
-        }
+        copy.options.put("explicitApiModeEnabled", explicitApiModeEnabled)
 
         configure?.execute(copy)
     }
@@ -158,9 +158,9 @@ internal open class DefaultProtoSourceSet(
         imports.addAll(protoSourceSet.flatMap { it.imports.checkSelfImport() })
     }
 
-    override fun importsAllFrom(protoSourceSet: Provider<List<ProtoSourceSet>>) {
-        imports.addAll(protoSourceSet.checkSelfImport())
-        imports.addAll(protoSourceSet.map { list -> list.flatMap { it.imports.checkSelfImport().get() } })
+    override fun importsAllFrom(protoSourceSets: Provider<List<ProtoSourceSet>>) {
+        imports.addAll(protoSourceSets.checkSelfImport())
+        imports.addAll(protoSourceSets.map { list -> list.flatMap { it.imports.checkSelfImport().get() } })
     }
 
     override fun importsFrom(protoSourceSet: NamedDomainObjectProvider<ProtoSourceSet>) {
@@ -190,6 +190,8 @@ internal open class DefaultProtoSourceSet(
 
         source(protoSourceSet.sourceDirectorySet)
         imports.addAll(protoSourceSet.imports.checkSelfImport())
+
+        plugins.addAll(protoSourceSet.plugins)
     }
 
     @JvmName("checkSelfImport_provider")

gradle-plugin/src/main/kotlin/kotlinx/rpc/protoc/DefaultProtocExtension.kt

@@ -248,6 +248,7 @@ internal open class DefaultProtocExtension @Inject constructor(
         val sourceSetsProtoDirFileTree = project.fileTree(buildSourceSetsProtoDir)
 
         val bufGenerateTask = project.registerBufGenerateTask(
+            protocExtension = this,
             protoSourceSet = protoSourceSet,
             workingDir = buildSourceSetsDir,
             outputDirectory = project.protoBuildDirGenerated.resolve(baseName),
@@ -268,8 +269,8 @@ internal open class DefaultProtocExtension @Inject constructor(
                 }
             )
 
-            protoFiles.set(processProtoTask.map { it.outputs.files })
-            importProtoFiles.set(processImportProtoTask.map { it.outputs.files })
+            protoFiles.convention(processProtoTask.map { it.outputs.files })
+            importProtoFiles.convention(processImportProtoTask.map { it.outputs.files })
 
             dependsOn(generateBufGenYamlTask)
             dependsOn(generateBufYamlTask)
@@ -303,8 +304,8 @@ internal open class DefaultProtocExtension @Inject constructor(
             sourceSetsProtoDirFileTree = sourceSetsProtoDirFileTree,
             properties = properties,
         ) {
-            protoFiles.set(processProtoTask.map { it.outputs.files })
-            importProtoFiles.set(processImportProtoTask.map { it.outputs.files })
+            protoFiles.convention(processProtoTask.map { it.outputs.files })
+            importProtoFiles.convention(processImportProtoTask.map { it.outputs.files })
         }
 
         protoSourceSet.tasksConfigured.set(true)
@@ -333,7 +334,19 @@ internal open class DefaultProtocExtension @Inject constructor(
         project.withLegacyAndroid {
             // android + kotlin is always done in withKotlin above
             languageSets.filterIsInstance<AndroidSourceSet>().forEach { sourceSet ->
-                sourceSet.java.srcDirs(javaOutputs)
+                // todo fails with
+                //
+                // Caused by: org.gradle.internal.typeconversion.UnsupportedNotationException: Cannot convert the provided notation to a File: [].
+                // The following types/formats are supported:
+                //   - A String or CharSequence path, for example 'src/main/java' or '/usr/include'.
+                //   - A String or CharSequence URI, for example 'file:/usr/include'.
+                //   - A File instance.
+                //   - A Path instance.
+                //   - A Directory instance.
+                //   - A RegularFile instance.
+                //   - A URI or URL instance of file.
+                //   - A TextResource instance.
+//                sourceSet.java.srcDir(javaOutputs)
             }
         }
     }
@@ -347,9 +360,9 @@ internal open class DefaultProtocExtension @Inject constructor(
             plugins.filter(pluginFilter).map { it.name }.toSet()
         }
 
-        return bufGenerateTask.flatMap { task ->
+        return bufGenerateTask.map { task ->
             val pluginsSet = plugins.get()
-            task.outputSourceDirectories.map { list -> list.filter { it.name in pluginsSet } }
+            task.outputSourceDirectories.get().filter { it.name in pluginsSet }
         }
     }