* limitations under the License.
 */

plugins {
    id("gradlebuild.distribution.api-java")
}

description = "Plugins and integration with code quality (Checkstyle, PMD, CodeNarc)"

sourceSets {
    main {
        // Incremental Groovy joint-compilation doesn't work with the Error Prone annotation processor
        errorprone.enabled = false
    }
}

dependencies {

    testCompileOnly(toolsJarApi())
    testRuntimeOnly(toolsJar())
    testApi(platform(libs.junit.bom))
    testImplementation(libs.junit.jupiter.api)
    testRuntimeOnly(libs.junit.jupiter.engine)
}

sourceSets {
    "main" { projectDefault() }
    "test" {
        projectDefault()
        generatedTestDir()
    }
}

optInToUnsafeDuringIrConstructionAPI()

projectTest(jUnitMode = JUnitMode.JUnit5) {

            }
        }.files)
        this.manifestFile = moduleIdentity.baseName.map { layout.buildDirectory.file("generated-resources/$it-classpath/$it-classpath.properties").get() }
    }
    sourceSets["main"].output.dir(classpathManifest.map { it.manifestFile.get().asFile.parentFile })
}

/**
 * Walk the resolved graph and discover all external dependencies that are not transitive dependencies

        projectBsrcSiblingFolder.mkdirs()
        projectBsrcFolder.mkdirs()
        srcFolder.mkdirs()
        srcRootFolder1.mkdirs()
        srcRootFolder2.mkdirs()
        file('subprojectA/build.gradle').text = """
sourceSets {
    main {
        java {
            srcDirs = ['src', '../subprojectB/src-sibling', '../src-root', '../src', '../subprojectB/src']
        }
    }
}
"""
        when:

        attributes(Attributes.Name.IMPLEMENTATION_TITLE.toString() to "Gradle Wrapper")
    }
    from(layout.projectDirectory.dir("src/executable/resources"))
    from(sourceSets.main.get().output)
    // Exclude properties files from this project as they are not needed for the executable JAR
    exclude("gradle-*-classpath.properties")
    exclude("gradle-*-parameter-names.properties")
}

    "JavaUtilDate", // We are fine with using Date
    "StringSplitter", // We are fine with using String.split() as is
)

project.plugins.withType<JavaBasePlugin> {
    project.extensions.getByName<SourceSetContainer>("sourceSets").configureEach {
        val extension = this.extensions.create<ErrorProneSourceSetExtension>("errorprone", project.objects.property<Boolean>())
        // Enable it only for the main source set by default, as incremental Groovy

                id('maven-publish')
            }

            group = "com.example"
            version = "1.0"

            // == Add a Gradle 7 variant
            def gradle7 = sourceSets.create('gradle7')
            java {
                registerFeature(gradle7.name) {
                    usingSourceSet(gradle7)
                    capability(project.group.toString(), project.name, project.version.toString())

    inputs.property('args') { // Arguments are covered by the testProjectName and the outputs. We don't want them to contain the absolute path
        return []
    }
    classpath = sourceSets.performanceTest.runtimeClasspath.filter { it.name.contains('groovy') || it.name.contains('guava')  || it.name.contains('gradle-') }
    mainClass = 'org.gradle.performance.generator.DeclarativeDslTestProjectGenerator'

            apply plugin: "java-base"

            java {
                ${extensionSource != null ? "sourceCompatibility = JavaVersion.toVersion('$extensionSource')" : ""}
            }

            sourceSets {
                custom {}
            }

            compileCustomJava {
                ${taskSource != null ? "sourceCompatibility = '$taskSource'" : ""}

                compileOnly 'com.google.guava:guava:21.0'
                testImplementation 'junit:junit:4.13'
            }

            eclipse {
                classpath {
                    testSourceSets = [sourceSets.main]
                    testConfigurations = [configurations.compileClasspath, configurations.runtimeClasspath]
                }
            }
        """
        file('src/main/java').mkdirs()