* we'll make sure to filter the list of packages before generating the file.
 *
 * It is assumed that the layout of the directories follow the JVM conventions. This allows us to effectively skip opening the class files to determine the real package name.
 */
@CacheableTask
abstract class PackageListGenerator : DefaultTask() {

    companion object {

        api(kotlin("compiler-embeddable")) { version { strictly(kotlinVersion) } }
        api("org.jlleitschuh.gradle:ktlint-gradle:10.3.0")
        api("org.gradle.kotlin:gradle-kotlin-dsl-conventions:0.9.0")
        api("com.autonomousapps:dependency-analysis-gradle-plugin:1.31.0")
        api("com.squareup.okio:okio:3.4.0") {

    // This Kotlin version should only be updated when updating the above kotlin-dsl version
    implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:1.9.23")
    implementation("org.gradle.kotlin:gradle-kotlin-dsl-conventions")
    implementation("org.gradle:test-retry-gradle-plugin:1.5.2")

- **Flexibility and Control:** Java serialization offers limited control over the serialization process, such as excluding certain fields, customizing naming conventions, and handling complex data structures more gracefully.

- **Security:** Java serialization poses security risks, especially related to deserialization vulnerabilities.

            task.getInputEncoding().convention(Charset.defaultCharset().name());
            task.getOutputEncoding().convention(Charset.defaultCharset().name());

            task.getMarkdownFile().convention(extension.getReleaseNotes().getMarkdownFile());
            task.getDestinationFile().convention(extension.getStagingRoot().file("release-notes/raw.html"));
        });

plugins {
    java
    id("gradlebuild.dependency-modules")
}

extensions.create<IntegrationTestExtension>("integTest").apply {
    usesJavadocCodeSnippets.convention(false)
    testJvmXmx.convention("512m")
}

val sourceSet = addSourceSet(TestType.INTEGRATION)
addDependenciesAndConfigurations(TestType.INTEGRATION.prefix)
createTasks(sourceSet, TestType.INTEGRATION)

        // Enable it only for the main source set by default, as incremental Groovy
        // joint-compilation doesn't work with the Error Prone annotation processor
        extension.enabled.convention(this.name == "main")

        project.dependencies.addProvider(
            annotationProcessorConfigurationName,
            extension.enabled.filter { it }.map { "com.google.errorprone:error_prone_core:2.24.1" }
        )

    val isSnapshot = !finalRelease.isPresent && !rcNumber.isPresent && !milestoneNumber.isPresent

    moduleIdentity.version.convention(GradleVersion.version(versionNumber))
    moduleIdentity.snapshot.convention(isSnapshot)
    moduleIdentity.buildTimestamp.convention(buildTimestamp)
    moduleIdentity.promotionBuild.convention(isPromotionBuild)

    moduleIdentity.releasedVersions = provider {
        ReleasedVersionsDetails(

            task.into(extension.getDocumentationRenderedRoot());
        });

        extension.getSourceRoot().convention(layout.getProjectDirectory().dir("src/docs"));
        extension.getDocumentationRenderedRoot().convention(layout.getBuildDirectory().dir("docs"));
        extension.getStagingRoot().convention(layout.getBuildDirectory().dir("working"));

        ConfigurableFileTree css = objects.fileTree();

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

plugins {
    id("org.gradle.kotlin-dsl.ktlint-convention")
}

tasks {
    runKtlintCheckOverKotlinScripts {
        // Only check the build files, not all *.kts files in the project
        includes += listOf("*.gradle.kts")
    }