build.gradle

/*
 * Copyright 2010 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import org.gradle.build.Install
import org.gradle.gradlebuild.testing.integrationtests.cleanup.EmptyDirectoryCheck
import org.gradle.gradlebuild.ProjectGroups
import org.gradle.modules.PatchExternalModules
import org.gradle.gradlebuild.BuildEnvironment

plugins {
    id 'java-base'
    id 'gradlebuild.build-types'
    id 'gradlebuild.ci-reporting'
    // TODO Apply this plugin in the BuildScanConfigurationPlugin once binary plugins can apply plugins via the new plugin DSL
    // We have to apply it here at the moment, so that when the build scan plugin is auto-applied via --scan can detect that
    // the plugin has been already applied. For that the plugin has to be applied with the new plugin DSL syntax.
    id "com.gradle.build-scan"
}

defaultTasks 'assemble'
archivesBaseName = 'gradle'

buildTypes {
    sanityCheck {
        tasks "classes", "doc:checkstyleApi", "codeQuality", "docs:check", "distribution:checkBinaryCompatibility", "javadocAll"
        projectProperties ignoreIncomingBuildReceipt: true
    }

    // Used by the first phase of the build pipeline, running only last version on multiversion - tests
    quickTest {
        tasks "test", "integTest", "crossVersionTest"
    }

    // Used for builds to run all tests, but not necessarily on all platforms
    fullTest {
        tasks "test", "forkingIntegTest", "forkingCrossVersionTest"
        projectProperties testAllVersions: true
    }

    // Used for builds to test the code on certain platforms
    platformTest {
        tasks "test", "forkingIntegTest", "forkingCrossVersionTest"
        projectProperties testAllVersions: true, testAllPlatforms: true
    }

    // Tests not using the daemon mode
    noDaemonTest {
        tasks "noDaemonIntegTest"
        projectProperties useAllDistribution: true
    }

    // Run the integration tests using the parallel executer
    parallelTest {
        tasks "parallelIntegTest"
    }

    performanceTests {
        tasks "performance:performanceTest"
    }

    performanceExperiments {
        tasks "performance:performanceExperiments"
    }

    fullPerformanceTests {
        tasks "performance:fullPerformanceTest"
    }

    distributedPerformanceTests {
        tasks "performance:distributedPerformanceTest"
    }

    distributedPerformanceExperiments {
        tasks "performance:distributedPerformanceExperiment"
    }

    distributedFullPerformanceTests {
        tasks "performance:distributedFullPerformanceTest"
    }

    // Used for cross version tests on CI
    allVersionsCrossVersionTest {
        tasks "allVersionsCrossVersionTests"
    }

    quickFeedbackCrossVersionTest {
        tasks "quickFeedbackCrossVersionTests"
    }

    // Used to build production distros and smoke test them
    packageBuild {
        tasks "verifyIsProductionBuildEnvironment", "clean", "buildDists", "distributions:integTest"
    }

    // Used to build production distros and smoke test them
    promotionBuild {
        tasks "verifyIsProductionBuildEnvironment", "clean", "docs:check", "buildDists", "distributions:integTest", "uploadArchives"
    }

    soakTest {
        tasks "soak:soakTest"
        projectProperties testAllVersions: true
    }
}

allprojects {
    group = 'org.gradle'

    repositories {
        maven { url 'https://repo.gradle.org/gradle/libs-releases' }
        maven { url 'https://repo.gradle.org/gradle/libs-milestones' }
        maven { url "https://repo.gradle.org/gradle/libs-snapshots" }
    }

    // patchExternalModules lives in the root project - we need to activate normalization there, too.
    normalization {
        runtimeClasspath {
            ignore 'org/gradle/build-receipt.properties'
        }
    }
}

apply plugin: "cleanup"
apply plugin: "gradlebuild.available-java-installations"
apply plugin: "gradlebuild.buildscan"
apply from: "gradle/versioning.gradle"
apply from: "gradle/dependencies.gradle"
apply from: "gradle/dependenciesMetadataRules.gradle.kts"
apply plugin: "gradlebuild.minify"
apply from: "gradle/testDependencies.gradle"
apply plugin: "gradlebuild.wrapper"
apply plugin: "gradlebuild.ide"
apply plugin: "gradlebuild.no-resolution-at-configuration"
apply from: "gradle/publicApi.gradle"
apply plugin: "gradlebuild.update-versions"
apply plugin: "gradlebuild.dependency-vulnerabilities"
apply plugin: "gradlebuild.add-verify-production-environment-task"


subprojects {
    version = rootProject.version

    if (project in ProjectGroups.INSTANCE.getJavaProjects(project)) {
        apply plugin: "gradlebuild.java-projects"
    }

    if (project in ProjectGroups.INSTANCE.getPublishedProjects(project)) {
        apply plugin: "gradlebuild.publish-public-libraries"
    }

    apply from: "$rootDir/gradle/codeQualityConfiguration.gradle.kts"
    apply plugin: "gradlebuild.task-properties-validation"
    apply plugin: "gradlebuild.test-files-cleanup"
}

configurations {
    coreRuntime {
        attributes { attribute(Usage.USAGE_ATTRIBUTE, project.objects.named(Usage, Usage.JAVA_RUNTIME)) }
        canBeResolved = true
        canBeConsumed = false
        visible = false
    }
    coreRuntimeExtensions {
        attributes { attribute(Usage.USAGE_ATTRIBUTE, project.objects.named(Usage, Usage.JAVA_RUNTIME)) }
        canBeResolved = true
        canBeConsumed = false
        visible = false
    }
    externalModules {
        visible = false
    }
    // Configuration used to resolve external modules before patching them with versions from core runtime
    externalModulesRuntime {
        visible = false
        extendsFrom coreRuntime
        extendsFrom externalModules
    }
    // Combines the 'coreRuntime' with the patched external module jars
    runtime {
        visible = false
        extendsFrom coreRuntime
    }
    gradlePlugins {
        visible = false
    }
    testRuntime {
        extendsFrom runtime
        extendsFrom gradlePlugins
    }

    all {
        attributes.attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage, Usage.JAVA_RUNTIME))
    }
}

ext.allTestRuntimeDependencies = configurations.testRuntime.allDependencies

def patchedExternalModulesDir = new File(buildDir, "external/files")
def patchedExternalModules = files({ -> fileTree(patchedExternalModulesDir).files.sort() })
patchedExternalModules.builtBy 'patchExternalModules'

dependencies {
    externalModules "org.gradle:gradle-kotlin-dsl:${BuildEnvironment.gradleKotlinDslVersion}"
    externalModules "org.gradle:gradle-kotlin-dsl-tooling-builders:${BuildEnvironment.gradleKotlinDslVersion}"
    coreRuntime project(':launcher')
    coreRuntime project(':runtimeApiInfo')
    runtime project(':wrapper')
    runtime project(":installationBeacon")
    runtime patchedExternalModules
    gradlePlugins ProjectGroups.INSTANCE.getPluginProjects(project)
    gradlePlugins ProjectGroups.INSTANCE.getImplementationPluginProjects(project)
    gradlePlugins project(':workers')
    gradlePlugins project(':dependencyManagement')
    gradlePlugins project(':testKit')

    coreRuntimeExtensions project(':dependencyManagement') //See: DynamicModulesClassPathProvider.GRADLE_EXTENSION_MODULES
    coreRuntimeExtensions project(':pluginUse')
    coreRuntimeExtensions project(':workers')
    coreRuntimeExtensions patchedExternalModules
}

ext.allCoreRuntimeExtensions = configurations.coreRuntimeExtensions.allDependencies

task patchExternalModules(type: PatchExternalModules) {
    allModules = configurations.externalModulesRuntime
    coreModules = configurations.coreRuntime
    modulesToPatch = configurations.externalModules
    destination = patchedExternalModulesDir
}

evaluationDependsOn ":distributions"

task install(type: Install) {
    description = 'Installs the minimal distribution into directory $gradle_installPath'
    group = 'build'
    with project(":distributions").binDistImage
    installDirPropertyName = 'gradle_installPath'
}

task installAll(type: Install) {
    description = 'Installs the full distribution into directory $gradle_installPath'
    group = 'build'
    with project(":distributions").allDistImage
    installDirPropertyName = 'gradle_installPath'
}

afterEvaluate {
    if (gradle.startParameter.isBuildCacheEnabled()) {
        rootProject.availableJavaInstallations.validateBuildCacheConfiguration(gradle.settings.buildCache)
    }
}