Added configuration options per sourceSet

README.md

@@ -59,6 +59,24 @@ subprojects {
 You must apply the plugin on every project that has source files. Those classes won't be attributed otherwise.
 Applying it at the root project only, will only make sense on single module builds.
 
+## Disable it for specific `SourceSet`s (Java)
+You can use the `sourceSet.codeOwners.includeAsResources` property to configure it. 
+For instance, the following code will disable it `test`:
+```kotlin
+sourceSets.test {
+    codeOwners.includeAsResources.set(false)
+}
+```
+
+## Disable it for specific `Variant`s (Android)
+You can use the `variant.codeOwners.includeAsResources` property to configure it.
+For instance, the following code will enable it only for `debug`:
+```kotlin
+androidComponents.onVariants {
+    it.codeOwners.includeAsResources.set(it.buildType == "debug")
+}
+```
+
 ## The CODEOWNERS file
 The expected format is the same as [GitHub's](https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-code-owners#codeowners-syntax) and it can be located at any of the following paths:
 - `$rootDir/CODEOWNERS`

plugin/build.gradle.kts

@@ -10,9 +10,7 @@ plugins {
 
 description = "CodeOwners Gradle Plugin"
 
-testing.suites.register<JvmTestSuite>("integrationTest")
-
-val integrationTest by sourceSets
+val integrationTest by testing.suites.registering(JvmTestSuite::class)
 val pluginUnderTestImplementation by configurations.creating
 
 dependencies {
@@ -43,7 +41,7 @@ gradlePlugin {
         tags.addAll("codeowners", "ownership", "attribution")
     }
 
-    testSourceSets(integrationTest)
+    testSourceSets(sourceSets[integrationTest.name])
 }
 
 buildConfig {
@@ -55,6 +53,10 @@ buildConfig {
     )
 }
 
+tasks.check {
+    dependsOn(integrationTest)
+}
+
 tasks.pluginUnderTestMetadata {
     pluginClasspath.from(pluginUnderTestImplementation)
 }

plugin/src/integrationTest/kotlin/io/github/gmazzo/codeowners/CodeOwnersPluginITest.kt

@@ -28,54 +28,94 @@ class CodeOwnersPluginITest {
 
     var androidTestPasses = false
     var androidBuildPasses = false
-    var libTestPasses = false
-    var libBuildPasses = false
-    val projectsBuildsPasses get() = libBuildPasses && androidBuildPasses
+    var lib1TestPasses = false
+    var lib1BuildPasses = false
+    var lib2TestPasses = false
+    var lib2BuildPasses = false
+    val projectsBuildsPasses get() = lib1BuildPasses && lib2BuildPasses && androidBuildPasses
 
     @Test
     @Order(0)
-    fun `lib tests passes`() {
+    fun `lib1 tests passes`() {
         val build = runBuild(":lib1:test")
 
         assertEquals(TaskOutcome.SUCCESS, build.task(":lib1:generateCodeOwnersResources")?.outcome)
+        assertEquals(null, build.task(":lib1:generateTestCodeOwnersResources")?.outcome)
 
-        libTestPasses = true
+        lib1TestPasses = true
     }
 
     @Test
     @Order(2)
-    @EnabledIf("getLibTestPasses")
-    fun `lib builds successfully`() {
+    @EnabledIf("getLib1TestPasses")
+    fun `lib1 builds successfully`() {
         val build = runBuild(":lib1:build")
 
         assertEquals(TaskOutcome.UP_TO_DATE, build.task(":lib1:generateCodeOwnersResources")?.outcome)
+        assertEquals(null, build.task(":lib1:generateTestCodeOwnersResources")?.outcome)
+        assertEquals(TaskOutcome.NO_SOURCE, build.task(":lib1:generateIntegrationTestCodeOwnersResources")?.outcome)
 
-        libBuildPasses = true
+        lib1BuildPasses = true
     }
 
     @Test
     @Order(1)
+    fun `lib2 tests passes`() {
+        val build = runBuild(":lib2:test")
+
+        assertEquals(TaskOutcome.NO_SOURCE, build.task(":lib2:generateDebugCodeOwnersResources")?.outcome)
+        assertEquals(null, build.task(":lib2:generateDebugUnitTestCodeOwnersResources")?.outcome)
+        assertEquals(TaskOutcome.NO_SOURCE, build.task(":lib2:generateReleaseCodeOwnersResources")?.outcome)
+        assertEquals(null, build.task(":lib2:generateReleaseUnitTestCodeOwnersResources")?.outcome)
+
+        lib2TestPasses = true
+    }
+
+    @Test
+    @Order(2)
+    @EnabledIf("getLib2TestPasses")
+    fun `lib2 builds successfully`() {
+        val build = runBuild(":lib2:build", ":lib2:packageDebugAndroidTest")
+
+        assertEquals(TaskOutcome.NO_SOURCE, build.task(":lib2:generateDebugCodeOwnersResources")?.outcome)
+        assertEquals(null, build.task(":lib2:generateDebugUnitTestCodeOwnersResources")?.outcome)
+        assertEquals(TaskOutcome.NO_SOURCE, build.task(":lib2:generateDebugAndroidTestCodeOwnersResources")?.outcome)
+        assertEquals(TaskOutcome.NO_SOURCE, build.task(":lib2:generateReleaseCodeOwnersResources")?.outcome)
+        assertEquals(null, build.task(":lib2:generateReleaseUnitTestCodeOwnersResources")?.outcome)
+
+        lib2BuildPasses = true
+    }
+
+    @Test
+    @Order(3)
     fun `app tests passes`() {
-        val build = runBuild(":app:test")
+        val build = runBuild(":app:test", ":app:packageDebugAndroidTest")
 
         assertEquals(TaskOutcome.SUCCESS, build.task(":app:generateDebugCodeOwnersResources")?.outcome)
+        assertEquals(TaskOutcome.SUCCESS, build.task(":app:generateDebugUnitTestCodeOwnersResources")?.outcome)
+        assertEquals(null, build.task(":app:generateReleaseCodeOwnersResources")?.outcome)
+        assertEquals(null, build.task(":app:generateReleaseUnitTestCodeOwnersResources")?.outcome)
 
         androidTestPasses = true
     }
 
     @Test
-    @Order(2)
+    @Order(4)
     @EnabledIf("getAndroidTestPasses")
     fun `app builds successfully`() {
         val build = runBuild(":app:build")
 
         assertEquals(TaskOutcome.UP_TO_DATE, build.task(":app:generateDebugCodeOwnersResources")?.outcome)
+        assertEquals(TaskOutcome.UP_TO_DATE, build.task(":app:generateDebugUnitTestCodeOwnersResources")?.outcome)
+        assertEquals(TaskOutcome.NO_SOURCE, build.task(":app:generateDebugAndroidTestCodeOwnersResources")?.outcome)
+        assertEquals(null, build.task(":app:generateReleaseCodeOwnersResources")?.outcome)
+        assertEquals(null, build.task(":app:generateReleaseUnitTestCodeOwnersResources")?.outcome)
 
         androidBuildPasses = true
     }
 
     @Test
-    @Order(3)
+    @Order(5)
     @EnabledIf("getProjectsBuildsPasses")
     fun `whole project builds successfully`() {
         val build = runBuild("clean", "build")
@@ -85,4 +125,4 @@ class CodeOwnersPluginITest {
         assertEquals(TaskOutcome.NO_SOURCE, build.task(":lib2:generateDebugCodeOwnersResources")?.outcome)
     }
 
-}
+}

plugin/src/integrationTest/resources/project/app/build.gradle.kts

@@ -9,6 +9,10 @@ android {
     compileSdk = 30
 }
 
+androidComponents.onVariants {
+    it.codeOwners.includeAsResources.set(it.buildType == "debug")
+}
+
 dependencies {
     implementation(project(":lib1"))
     implementation(project(":lib2"))

plugin/src/integrationTest/resources/project/app/src/test/java/org/test/app/AppOwnersTest.java

@@ -10,24 +10,29 @@
 import static org.junit.Assert.assertEquals;
 import static kotlin.collections.SetsKt.setOf;
 
+/**
+ * On <code>debug</code> both <code>app</code> and <code>lib</code>s have owners computed
+ * On <code>release</code>, the build script on <code>app</code> is set up to not to compute them,
+ * so we only have the ones from <code>lib</code>s
+ */
 public class AppOwnersTest {
 
     @Test
     public void ownerOfApp() {
-        assertEquals(setOf("android-devs"), getCodeOwners(AppClass.class));
+        assertEquals(BuildConfig.DEBUG ? setOf("android-devs") : null, getCodeOwners(AppClass.class));
     }
 
     /**
      * Known limitation test: owners if same package but different sources gets merged
      */
     @Test
     public void ownerOfAppUtils() {
-        assertEquals(setOf("kotlin-devs", "android-devs"), getCodeOwners(AppUtils.class));
+        assertEquals(BuildConfig.DEBUG ? setOf("kotlin-devs", "android-devs") : setOf("kotlin-devs"), getCodeOwners(AppUtils.class));
     }
 
     @Test
     public void ownerOfAppUtils2() {
-        assertEquals(setOf("android-devs"), getCodeOwners(AppUtils2.class));
+        assertEquals(BuildConfig.DEBUG ? setOf("android-devs") : setOf("kotlin-devs"), getCodeOwners(AppUtils2.class));
     }
 
     @Test
@@ -37,7 +42,7 @@ public void ownerOfLib() {
 
     @Test
     public void ownerOfLibUtils() {
-        assertEquals(setOf("kotlin-devs", "android-devs"), getCodeOwners(LibUtils.class));
+        assertEquals(BuildConfig.DEBUG ? setOf("kotlin-devs", "android-devs") : setOf("kotlin-devs"), getCodeOwners(LibUtils.class));
     }
 
 }

plugin/src/integrationTest/resources/project/lib1/build.gradle.kts

@@ -3,6 +3,16 @@ plugins {
     id("io.github.gmazzo.codeowners")
 }
 
+val integrationTest by testing.suites.registering(JvmTestSuite::class)
+
+sourceSets.test {
+    codeOwners.includeAsResources.set(false)
+}
+
 dependencies {
     testImplementation("junit:junit:4.13.2")
 }
+
+tasks.check {
+    dependsOn(integrationTest)
+}

plugin/src/integrationTest/resources/project/lib2/build.gradle.kts

@@ -8,3 +8,7 @@ android {
     compileSdk = 30
     buildFeatures.buildConfig = false
 }
+
+androidComponents.onVariants {
+    it.unitTest!!.codeOwners.includeAsResources.set(false)
+}

plugin/src/main/kotlin/CodeOwnersDSL.kt

@@ -0,0 +1,10 @@
+package org.gradle.kotlin.dsl
+
+import com.android.build.api.variant.Component
+import com.android.build.api.variant.Variant
+import io.github.gmazzo.codeowners.CodeOwnersSourceSet
+import org.gradle.api.plugins.ExtensionAware
+
+var Component.codeOwners: CodeOwnersSourceSet
+    get() = (this as ExtensionAware).extensions.getByName<CodeOwnersSourceSet>(Variant::codeOwners.name)
+    internal set(value) = (this as ExtensionAware).extensions.add<CodeOwnersSourceSet>(Variant::codeOwners.name, value)