val aggregate by configurations.creating {
    isVisible = false
    isCanBeResolved = false
    isCanBeConsumed = false
}

// Resolvable configuration to resolve the classes of all dependencies
val classesPath by configurations.creating {
    isVisible = false
    isCanBeConsumed = false
    extendsFrom(aggregate)
    attributes {
        attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.JAVA_RUNTIME))

import gradlebuild.incubation.tasks.IncubatingApiAggregateReportTask

plugins {
    id("base")
}

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

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

repositories {
    mavenCentral()
}

val myPlugin by configurations.creating {
    isCanBeConsumed = false
    isCanBeResolved = false
}
val myPluginClasspath by configurations.creating {
    extendsFrom(myPlugin)
    isCanBeConsumed = false
}

dependencies {
    myPlugin("org.apache.commons:commons-lang3:3.3.1")
}

// tag::disabling-one-configuration[]
configurations {
    "myPluginClasspath" {

}
// end::consumer_dependencies[]

val functionalTest by configurations.creating {
    isCanBeConsumed = false
    isCanBeResolved = false
}
val functionalTestClasspath by configurations.creating {
    extendsFrom(functionalTest)
    isCanBeConsumed = false
    attributes {
        attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage::class.java, Usage.JAVA_API))
    }
}

plugins {
    `java-library`
}

// tag::resolvable-configuration[]
val instrumentedClasspath by configurations.creating {
    isCanBeConsumed = false
}
// end::resolvable-configuration[]

// tag::explicit-configuration-dependency[]
dependencies {
    instrumentedClasspath(project(mapOf(
        "path" to ":producer",
        "configuration" to "instrumentedJars")))
}
// end::explicit-configuration-dependency[]

    val shadedImplementation by configurations.creating {
        isCanBeResolved = false
        isCanBeConsumed = false
    }
    implementation.extendsFrom(shadedImplementation)

    val shadedRuntimeElements by configurations.creating {
        isCanBeResolved = false
        isCanBeConsumed = true
        attributes {
            attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.JAVA_RUNTIME))

plugins {
    `java-library`
}

// tag::declare-outgoing-configuration[]
val instrumentedJars by configurations.creating {
    isCanBeConsumed = true
    isCanBeResolved = false
    // If you want this configuration to share the same dependencies, otherwise omit this line
    extendsFrom(configurations["implementation"], configurations["runtimeOnly"])
}
// end::declare-outgoing-configuration[]

        // As an outgoing configuration, explain that consumers may want to consume it
        assert(isCanBeConsumed)
    }
    // A configuration meant for consumers that need the implementation of this component
    create("exposedRuntime") {
        isCanBeResolved = false
        assert(isCanBeConsumed)
    }
}
// end::setup-configurations[]

// tag::define_attribute[]
// An attribute of type `String`

fun generatedJsonFileFor(name: String) =
    layout.buildDirectory.file("generated-resources/$name/$name.json")

fun bucket() =
    configurations.creating {
        isCanBeResolved = false
        isCanBeConsumed = false
        isVisible = false
    }

fun libraryResolver(extends: List<Configuration>) =
    configurations.creating {
        attributes {

repositories {
    mavenCentral() // <1>
}

val codec = configurations.create("codec") { // <2>
    attributes {
        attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.JAVA_RUNTIME))
    }
    isVisible = false
    isCanBeConsumed = false
}

dependencies {
    codec("commons-codec:commons-codec:1.10") // <3>
}

tasks.register<CreateMD5>("md5") {
    codecClasspath.from(codec) // <4>