implementation(project(":basics"))
    implementation(project(":module-identity"))
    implementation("net.ltgt.gradle:gradle-errorprone-plugin:3.1.0")

    implementation("org.gradle.kotlin.kotlin-dsl:org.gradle.kotlin.kotlin-dsl.gradle.plugin:4.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")

            implementationClass = "gradlebuild.integrationtests.ide.AndroidStudioProvisioningPlugin"
        }
    }
}

dependencies {
    implementation("gradlebuild:basics")
    implementation("gradlebuild:module-identity")

    implementation(project(":cleanup"))
    implementation(project(":dependency-modules"))

    testImplementation("junit:junit")

    id("gradlebuild.build-logic.kotlin-dsl-gradle-plugin")
}

description = "Provides a plugin to generate samples using internal build init APIs"

dependencies {
    implementation("gradlebuild:basics")
    implementation("org.gradle.guides:gradle-guides-plugin")
    implementation("org.asciidoctor:asciidoctor-gradle-jvm") {
        because("This is a transitive dependency of 'gradle-guides-plugin' not declared there")
    }

        )
    }

    @TempDir
    lateinit var projectDir: Path

    private
    val implementation = PackageListGenerator.Implementation(DEFAULT_EXCLUDES_FOR_TEST)

    private
    fun getRelocatedPackages(files: Sequence<Path>): List<String> = mutableListOf<String>().apply {
        implementation.collectPackages(files.toList()).dump(false, this::add)
    }

    @Test

        archiveVersion = moduleIdentity.version.map { it.baseVersion.version }
        manifest.attributes(
            mapOf(
                Attributes.Name.IMPLEMENTATION_TITLE.toString() to "Gradle",
                Attributes.Name.IMPLEMENTATION_VERSION.toString() to moduleIdentity.version.map { it.baseVersion.version }
            )
        )
    }
}

fun configureClasspathManifestGeneration() {

## Composition by architecture modules

Each [architecture module and platform](platforms.md) can contribute code to any of the elements.
Not every module contributes to every element.

                        repositories {
                            mavenCentral()
                        }
                        dependencies {
                            "implementation"(gradleApi())
                            "implementation"(kotlin("stdlib"))
                        }
                    }
                    project(":v1") {
                        version = "1.0"
                    }

# Development best practices

This is a collection of best practices for Gradle implementation.
Should and should not do's.

## Error messages and suggestions

Traditionally, if an error occurred, the error message and the possible solution were provided to the console via a single String in the corresponding exception.
That meant possible solutions for Problems could be scattered all over the console output.

 * which collects necessary information for build scan.
 */
fun <T : AbstractBuildScanInfoCollectingService> Project.registerBuildScanInfoCollectingService(
    /* the implementation class to collect information from task execution result */
    klass: Class<T>,
    /* which tasks we need to monitor? For example, cache-miss-monitor monitors `AbstractCompile` tasks */
    taskFilter: (Task) -> Boolean,

dependencies {
    rules("gradlebuild:code-quality-rules") {
        because("Provides rules defined in XML files")
    }
    codenarc("gradlebuild:code-quality-rules") {
        because("Provides the IntegrationTestFixturesRule implementation")
    }
    codenarc("org.codenarc:CodeNarc:$codenarcVersion")
    codenarc(embeddedKotlin("stdlib"))

    components {
        withModule<CodeNarcRule>("org.codenarc:CodeNarc") {