fix generateRulesDocumentation task to pick up dependencies in serviceloader

nebula-archrules-gradle-plugin/src/main/kotlin/com/netflix/nebula/archrules/gradle/ArchrulesLibraryPlugin.kt

@@ -77,6 +77,7 @@ class ArchrulesLibraryPlugin : Plugin<Project> {
                 description = "Generates documentation for ArchRules"
                 group = "documentation"
                 rulesClasspath.from(archRulesSourceSet.output)
+                rulesClasspath.from(project.configurations.named(archRulesSourceSet.runtimeClasspathConfigurationName))
                 outputFile.convention(
                     project.layout.buildDirectory.file("docs/archrules.md")
                 )

nebula-archrules-gradle-plugin/src/main/kotlin/com/netflix/nebula/archrules/gradle/GenerateRulesDocumentationTask.kt

@@ -11,6 +11,7 @@ import org.gradle.api.tasks.CacheableTask
 import org.gradle.api.tasks.Classpath
 import org.gradle.api.tasks.OutputFile
 import org.gradle.api.tasks.TaskAction
+import java.io.File
 import java.net.URLClassLoader
 import java.util.ServiceLoader
 
@@ -26,10 +27,24 @@ abstract class GenerateRulesDocumentationTask : DefaultTask() {
     @TaskAction
     fun generateDocs() {
         val rules = mutableListOf<RuleMetadata>()
-        val classPathUrls = rulesClasspath.files.map { it.toURI().toURL() }.toTypedArray()
+        val classpathUrls = rulesClasspath.files.map { it.toURI().toURL() }.toTypedArray()
 
-        URLClassLoader(classPathUrls, this.javaClass.classLoader).use { classLoader ->
-            ServiceLoader.load(ArchRulesService::class.java, classLoader).forEach { service ->
+        val ownArchRulesClasses = rulesClasspath.files.map {
+            File(
+                it,
+                "META-INF/services/com.netflix.nebula.archrules.core.ArchRulesService"
+            )
+        }
+            .firstOrNull { it.exists() }
+            ?.readLines()
+            ?.filter { it.isNotBlank() && !it.startsWith("#") }
+            ?.toSet()
+            ?: emptySet()
+
+        URLClassLoader(classpathUrls, this.javaClass.classLoader).use { classLoader ->
+            ServiceLoader.load(ArchRulesService::class.java, classLoader)
+                .filter { it.javaClass.name in ownArchRulesClasses }
+                .forEach { service ->
                 val serviceClassName = service.javaClass.name
                 service.rules.forEach { (ruleName, archRule) ->
                     rules.add(

nebula-archrules-gradle-plugin/src/test/kotlin/com/netflix/nebula/archrules/gradle/ArchrulesLibraryPluginTest.kt

@@ -339,10 +339,23 @@ class ArchrulesLibraryPluginTest {
             properties {
                 buildCache(true)
             }
-            settings {
-                name("library-with-rules")
+            subProject("common") {
+                plugins {
+                    id("java-library")
+                }
+                repositories {
+                    mavenCentral()
+                }
+                dependencies("""
+                    api("com.tngtech.archunit:archunit:1.+")
+                """.trimIndent())
+                src {
+                    main {
+                        commonPredicateHelpers()
+                    }
+                }
             }
-            rootProject {
+            subProject("archrules-library") {
                 plugins {
                     id("java-library")
                     id("com.netflix.nebula.archrules.library")
@@ -355,23 +368,25 @@ class ArchrulesLibraryPluginTest {
                     sourceSet("archRules") {
                         dontUseRule()
                         exampleDeprecatedHighArchRule()
+                        kotlinDeprecatedRuleUsingPredicateHelper()
                     }
                 }
                 dependencies("""
                     archRulesImplementation("com.netflix.nebula:archrules-nullability:0.+")
+                    archRulesImplementation(project(":common"))
                 """.trimIndent()
                 )
             }
         }
 
-        val result = runner.run("generateRulesDocumentation", "--stacktrace") {
+        val result = runner.run(":archrules-library:generateRulesDocumentation", "--stacktrace") {
             forwardOutput()
         }
 
-        assertThat(result.task(":generateRulesDocumentation"))
+        assertThat(result.task(":archrules-library:generateRulesDocumentation"))
             .hasOutcome(TaskOutcome.SUCCESS, TaskOutcome.FROM_CACHE)
 
-        val docsFile = projectDir.resolve("build/docs/archrules.md")
+        val docsFile = projectDir.resolve("archrules-library/build/docs/archrules.md")
         assertThat(docsFile).exists()
 
         assertThat(docsFile.readText())
@@ -382,6 +397,7 @@ class ArchrulesLibraryPluginTest {
                 "\n" +
                 "**Priority:** HIGH")
             .contains("## dont use")
+            .contains("## kotlinDeprecated")
             .doesNotContain("## public classes should be @NullMarked")
     }
 }

nebula-archrules-gradle-plugin/src/test/kotlin/com/netflix/nebula/archrules/gradle/TestKitDslExtensions.kt

@@ -386,4 +386,55 @@ public class NullabilityArchRulesTest {
 }
 """
     )
-}
+}
+
+fun SourceSetBuilder.commonPredicateHelpers() {
+    java("com/example/common/MyPredicates.java",
+        //language=java
+        """
+package com.example.common;
+import com.tngtech.archunit.base.DescribedPredicate;
+import static com.tngtech.archunit.core.domain.properties.CanBeAnnotated.Predicates.annotatedWith;
+public class MyPredicates {
+    public static DescribedPredicate<com.tngtech.archunit.core.domain.properties.CanBeAnnotated> kotlinDeprecated() {
+        return annotatedWith("kotlin.Deprecated")
+                .or(annotatedWith("kotlin.DeprecatedSinceKotlin"))
+                .as("kotlin deprecated");
+    }
+}
+        """)
+}
+
+fun SourceSetBuilder.kotlinDeprecatedRuleUsingPredicateHelper() {
+    java(
+        "com/example/library/KotlinDeprecatedRules.java",
+        //language=java
+        """
+package com.example.library;
+
+import com.netflix.nebula.archrules.core.ArchRulesService;
+import com.tngtech.archunit.lang.ArchRule;
+import com.tngtech.archunit.lang.Priority;
+import com.tngtech.archunit.lang.syntax.ArchRuleDefinition;
+import java.util.Map;
+import static com.tngtech.archunit.core.domain.JavaAccess.Predicates.target;
+import static com.tngtech.archunit.core.domain.JavaAccess.Predicates.targetOwner;
+import static com.tngtech.archunit.core.domain.properties.CanBeAnnotated.Predicates.annotatedWith;
+import static com.example.common.MyPredicates.kotlinDeprecated;
+
+public class KotlinDeprecatedRules implements ArchRulesService {
+    public static final ArchRule noKotlinDeprecated = ArchRuleDefinition.priority(Priority.LOW)
+            .noClasses()
+            .should().accessTargetWhere(targetOwner(kotlinDeprecated()))
+            .orShould().accessTargetWhere(target(kotlinDeprecated()))
+            .orShould().dependOnClassesThat(kotlinDeprecated())
+            .allowEmptyShould(true);
+
+    @Override
+    public Map<String, ArchRule> getRules() {
+        return Map.of("kotlinDeprecated", noKotlinDeprecated);
+    }
+}
+"""
+    )
+}