- introduce new configuration option to ignore by pattern

- introduce tests to verify excluding by pattern works

src/functionalTest/kotlin/kotlinx/validation/test/IgnoredTest.kt

@@ -0,0 +1,99 @@
+/*
+ * Copyright 2016-2020 JetBrains s.r.o.
+ * Use of this source code is governed by the Apache 2.0 License that can be found in the LICENSE.txt file.
+ */
+
+package kotlinx.validation.test
+
+import kotlinx.validation.api.*
+import kotlinx.validation.api.BaseKotlinGradleTest
+import kotlinx.validation.api.assertTaskSuccess
+import kotlinx.validation.api.buildGradleKts
+import kotlinx.validation.api.kotlin
+import kotlinx.validation.api.readFileList
+import kotlinx.validation.api.resolve
+import kotlinx.validation.api.runner
+import kotlinx.validation.api.test
+import org.assertj.core.api.Assertions
+import org.junit.Test
+import kotlin.test.assertTrue
+
+internal class IgnoredTests : BaseKotlinGradleTest() {
+
+    @Test
+    fun `apiCheck should succeed, when given class is not in api-File, but is ignored via ignored pattern`() {
+        val runner = test {
+            buildGradleKts {
+                resolve("/examples/gradle/base/withPlugin.gradle.kts")
+                resolve("/examples/gradle/configuration/ignored/oneValidPattern.gradle.kts")
+            }
+
+            kotlin("BuildConfig.kt") {
+                resolve("/examples/classes/BuildConfig.kt")
+            }
+
+            emptyApiFile(projectName = rootProjectDir.name)
+
+            runner {
+                arguments.add(":apiCheck")
+            }
+        }
+
+        runner.build().apply {
+            assertTaskSuccess(":apiCheck")
+        }
+    }
+
+    @Test
+    fun `apiCheck should succeed, when given class is not in api-File, but is ignored via ignored pattern (based on package)`() {
+        val runner = test {
+            buildGradleKts {
+                resolve("/examples/gradle/base/withPlugin.gradle.kts")
+                resolve("/examples/gradle/configuration/ignored/oneValidPackagePattern.gradle.kts")
+            }
+
+            kotlin("BuildConfig.kt") {
+                resolve("/examples/classes/BuildConfig.kt")
+            }
+
+            emptyApiFile(projectName = rootProjectDir.name)
+
+            runner {
+                arguments.add(":apiCheck")
+            }
+        }
+
+        runner.build().apply {
+            assertTaskSuccess(":apiCheck")
+        }
+    }
+
+    @Test
+    fun `apiDump should not dump ignored classes, when class is excluded via ignored pattern`() {
+        val runner = test {
+            buildGradleKts {
+                resolve("/examples/gradle/base/withPlugin.gradle.kts")
+                resolve("/examples/gradle/configuration/ignored/oneValidPatternPackageClass.gradle.kts")
+            }
+            kotlin("BuildConfig.kt") {
+                resolve("/examples/classes/BuildConfig.kt")
+            }
+            kotlin("AnotherBuildConfig.kt") {
+                resolve("/examples/classes/AnotherBuildConfig.kt")
+            }
+
+            runner {
+                arguments.add(":apiDump")
+            }
+        }
+
+        runner.build().apply {
+            assertTaskSuccess(":apiDump")
+
+            assertTrue(rootProjectApiDump.exists(), "api dump file should exist")
+
+            val expected = readFileList("/examples/classes/AnotherBuildConfig.dump")
+            Assertions.assertThat(rootProjectApiDump.readText()).isEqualToIgnoringNewLines(expected)
+        }
+    }
+}

src/functionalTest/resources/examples/gradle/configuration/ignored/oneValidPackagePattern.gradle.kts

@@ -0,0 +1,8 @@
+/*
+ * Copyright 2016-2024 JetBrains s.r.o.
+ * Use of this source code is governed by the Apache 2.0 License that can be found in the LICENSE.txt file.
+ */
+
+configure<kotlinx.validation.ApiValidationExtension> {
+    ignored.add("com\\/company\\/.+")
+}

src/functionalTest/resources/examples/gradle/configuration/ignored/oneValidPattern.gradle.kts

@@ -0,0 +1,3 @@
+configure<kotlinx.validation.ApiValidationExtension> {
+    ignored.add(".+\\/BuildConfig")
+}

src/functionalTest/resources/examples/gradle/configuration/ignored/oneValidPatternPackageClass.gradle.kts

@@ -0,0 +1,3 @@
+configure<kotlinx.validation.ApiValidationExtension> {
+    ignored.add(".+\\/company\\/BuildConfig")
+}

src/main/kotlin/ApiValidationExtension.kt

@@ -38,6 +38,14 @@ public open class ApiValidationExtension {
      */
     public var ignoredClasses: MutableSet<String> = HashSet()
 
+    /**
+     * Defines a regex pattern used to define classes and packages that are ignored by the API check.
+     *
+     * Example of such a package could be `.+\/internal\/.+`.
+     * An example of such a class could be `.+\/BuildConfig`
+     */
+    public var ignored: MutableSet<String> = HashSet()
+
     /**
      * Fully qualified names of annotations that can be used to explicitly mark public declarations. 
      * If at least one of [publicMarkers], [publicPackages] or [publicClasses] is defined,

src/main/kotlin/BuildTaskBase.kt

@@ -9,6 +9,7 @@ import org.gradle.api.DefaultTask
 import org.gradle.api.provider.SetProperty
 import org.gradle.api.tasks.Input
 import org.gradle.api.tasks.Internal
+import java.util.regex.Pattern
 
 public abstract class BuildTaskBase : DefaultTask() {
     private val extension = project.apiValidationExtensionOrNull
@@ -25,6 +26,18 @@ public abstract class BuildTaskBase : DefaultTask() {
         )
     }
 
+    private fun patternSetProperty(provider: ApiValidationExtension.() -> Set<Pattern>): SetProperty<Pattern> {
+        return project.objects.setProperty(Pattern::class.java).convention(
+            project.provider {
+                if (extension == null) {
+                    emptySet()
+                } else {
+                    provider(extension)
+                }
+            }
+        )
+    }
+
     @get:Input
     public val ignoredPackages: SetProperty<String> = stringSetProperty { ignoredPackages }
 
@@ -34,6 +47,9 @@ public abstract class BuildTaskBase : DefaultTask() {
     @get:Input
     public val ignoredClasses: SetProperty<String> = stringSetProperty { ignoredClasses }
 
+    @get:Input
+    public val ignored: SetProperty<Pattern> = patternSetProperty { ignored.map { Pattern.compile(it) }.toSet() }
+
     @get:Input
     public val publicPackages: SetProperty<String> = stringSetProperty { publicPackages }
 

src/main/kotlin/KotlinApiBuildTask.kt

@@ -71,7 +71,7 @@ public abstract class KotlinApiBuildTask @Inject constructor(
                 publicPackages.get() + publicPackagesNames,
                 publicClasses.get(), publicMarkers.get()
             )
-            .filterOutNonPublic(ignoredPackages.get() + ignoredPackagesNames, ignoredClasses.get())
+            .filterOutNonPublic(ignored.get(), ignoredPackages.get() + ignoredPackagesNames, ignoredClasses.get())
             .filterOutAnnotated(nonPublicMarkers.get().map(::replaceDots).toSet())
 
         outputApiFile.asFile.get().bufferedWriter().use { writer ->

src/main/kotlin/api/KotlinSignaturesLoading.kt

@@ -12,6 +12,7 @@ import org.objectweb.asm.tree.*
 import java.io.*
 import java.util.*
 import java.util.jar.*
+import java.util.regex.Pattern
 
 @ExternalApi
 @Suppress("unused")
@@ -247,6 +248,7 @@ public fun List<ClassBinarySignature>.extractAnnotatedPackages(targetAnnotations
 
 @ExternalApi
 public fun List<ClassBinarySignature>.filterOutNonPublic(
+    nonPublic: Collection<Pattern> = emptyList(),
     nonPublicPackages: Collection<String> = emptyList(),
     nonPublicClasses: Collection<String> = emptyList()
 ): List<ClassBinarySignature> {
@@ -255,6 +257,8 @@ public fun List<ClassBinarySignature>.filterOutNonPublic(
 
     val classByName = associateBy { it.name }
 
+    fun ClassBinarySignature.isNonPublic() = nonPublic.any { it.matcher(name).matches() }
+
     fun ClassBinarySignature.isPublicAndAccessible(): Boolean =
         isEffectivelyPublic &&
                 (outerName == null || classByName[outerName]?.let { outerClass ->
@@ -281,7 +285,7 @@ public fun List<ClassBinarySignature>.filterOutNonPublic(
     }
 
     return filter {
-        !it.isInPackages(nonPublicPackagePaths) && !it.isInClasses(excludedClasses) && it.isPublicAndAccessible()
+        !it.isInPackages(nonPublicPackagePaths) && !it.isInClasses(excludedClasses) && it.isPublicAndAccessible() && !it.isNonPublic()
     }
         .map { it.flattenNonPublicBases() }
         .filterNot { it.isNotUsedWhenEmpty && it.memberSignatures.isEmpty() }