val manifestClasspath = configurations.dependencyScope("manifestClasspath")
val resolveManifestClasspath = configurations.resolvable("resolveManifestClasspath") {
    isTransitive = false
    extendsFrom(manifestClasspath.get())
    configureAsRuntimeJarClasspath(objects)
}

tasks.jar.configure {
    val classpath = resolveManifestClasspath.flatMap { configuration ->

    normalizedDistributionZip.distributionZip = configurations["${prefix}TestNormalizedDistributionPath"]
    binDistributionZip.distributionZip = configurations["${prefix}TestBinDistributionPath"]
    allDistributionZip.distributionZip = configurations["${prefix}TestAllDistributionPath"]
    docsDistributionZip.distributionZip = configurations["${prefix}TestDocsDistributionPath"]

Il est également intégré à Docker. Ainsi, vous pouvez déclarer vos domaines dans les configurations de chaque application et faire en sorte qu'elles lisent ces configurations, génèrent les certificats HTTPS et servent via HTTPS à votre application automatiquement, sans nécessiter aucune modification de leurs configurations.

---

Avec ces informations et ces outils, passez à la section suivante pour tout combiner.

configurations.create("localLibsRepositoryElements") {
    attributes {
        attribute(Category.CATEGORY_ATTRIBUTE, objects.named("gradle-local-repository"))
    }
    isCanBeResolved = false
    isCanBeConsumed = true
    outgoing.artifact(localRepository) {
        builtBy(publishPluginsToTestRepository)
    }
}

configurations.create("futureVersion") {

        extendsFrom(currentClasspath)
    }
}

def currentClasspath = configurations.currentApiClasspath.incoming.artifactView { lenient(true) }.files
def currentDistroJars = currentClasspath.filter { it.name.startsWith('gradle-') && it.name.endsWith('.jar') }
def baselineJars = configurations.baselineJars
def baseVersion = gradleModule.identity.version.map { it.baseVersion.version }

dependencies {

        // use a separate configuration for the platform dependency that does not get published as part of 'apiElements' or 'runtimeElements'
        val platformImplementation by configurations.creating
        configurations["compileClasspath"].extendsFrom(platformImplementation)
        configurations["runtimeClasspath"].extendsFrom(platformImplementation)
        configurations["testCompileClasspath"].extendsFrom(platformImplementation)

 */

import gradlebuild.startscript.tasks.GradleStartScriptGenerator
import gradlebuild.configureAsRuntimeJarClasspath

plugins {
    java
}

val agentsClasspath = configurations.dependencyScope("agentsClasspath")
val resolveAgentsClasspath = configurations.resolvable("resolveAgentsClasspath") {
    extendsFrom(agentsClasspath.get())
    configureAsRuntimeJarClasspath(objects)
}

import gradlebuild.basics.buildCommitId
import gradlebuild.basics.capitalize
import gradlebuild.incubation.tasks.IncubatingApiAggregateReportTask

plugins {
    id("base")
}

val reports by configurations.creating {
    isCanBeResolved = false
    isCanBeConsumed = false
    description = "Dependencies to aggregate reports from"
}

val allIncubationReports = tasks.register<IncubatingApiAggregateReportTask>("allIncubationReports") {

    lateinit var selected: String

    private
    var upgrade: String? = null

    internal
    fun configure(components: ComponentMetadataHandler, configurations: ConfigurationContainer) {
        if (upgrade != null) {
            configurations.forceUpgrade(selected, upgrade!!)
        } else {
            providedBy.forEachIndexed { idx, provider ->
                if (provider != selected) {

 */

package common

import common.KillProcessMode.KILL_ALL_GRADLE_PROCESSES
import configurations.CompileAll
import configurations.FunctionalTest
import configurations.branchesFilterExcluding
import configurations.checkCleanDirUnixLike
import configurations.checkCleanDirWindows
import configurations.enablePullRequestFeature
import jetbrains.buildServer.configs.kotlin.AbsoluteId