registerTransform(Unzip) {
        from.attribute(artifactType, 'jar')
        to.attribute(artifactType, 'java-classes-directory')
    }
}
// end::artifact-transform-registration[]

dependencies {
    attributesSchema {
        attribute(usage)
    }
}
configurations.create("compile") {
    attributes.attribute usage, 'api'

        parameters {
            externalClasspath.from(configurations.getByName("externalClasspath"))
            excludedPackage = "org.gradle.api"
        }
    }
}

dependencies {
    attributesSchema {
        attribute(usage)
    }
}
configurations.create("compile") {
    attributes.attribute(usage, "api")

        from.attribute(artifactType, "jar")
        to.attribute(artifactType, "java-classes-directory")
    }
}
// end::artifact-transform-registration[]

dependencies {
    attributesSchema {
        attribute(usage)
    }
}
configurations.create("compile") {
    attributes.attribute(usage, "api")

    def setup() {
        project.pluginManager.apply(JvmEcosystemPlugin)
    }

    def "configures the attributes schema"() {
        when:
        def attrs = project.dependencies.attributesSchema.attributes

        then:
        attrs.containsAll(
            Usage.USAGE_ATTRIBUTE,
            Category.CATEGORY_ATTRIBUTE,
            Bundling.BUNDLING_ATTRIBUTE,

"""
        buildFile << """
def usage = Attribute.of('usage', String)
def flavor = Attribute.of('flavor', String)
def buildType = Attribute.of('buildType', String)

allprojects {
    dependencies {
       attributesSchema {
          attribute(usage)
          attribute(flavor)
          attribute(buildType)
       }
    }
    configurations {
        compile
        create("default") {
            extendsFrom compile

                void execute(CompatibilityCheckDetails<String> details) {
                    details.compatible()
                }
            }

            dependencies.attributesSchema {
                attribute(flavor) {
                    compatibilityRules.add(CategoryCompatibilityRule)
                }
            }
        """.stripIndent()

        when:

// An attribute of type `Usage`
val myUsage = Attribute.of("my.usage.attribute", Usage::class.java)
// end::define_attribute[]

// tag::register-attributes[]
dependencies.attributesSchema {
    // registers this attribute to the attributes schema
    attribute(myAttribute)
    attribute(myUsage)
}
// end::register-attributes[]

// tag::attributes-on-configurations[]
configurations {

        given:
        buildFile << '''
             def usage = Attribute.of('usage', String)
             allprojects {

                dependencies {
                    attributesSchema {
                        attribute(usage)
                    }
                }
                configurations {
                    compile {
                        attributes { attribute usage, 'api' }

import org.gradle.api.artifacts.result.UnresolvedComponentResult
import org.gradle.api.artifacts.type.ArtifactTypeContainer
import org.gradle.api.attributes.AttributeMatchingStrategy
import org.gradle.api.attributes.AttributesSchema
import org.gradle.api.attributes.CompatibilityRuleChain
import org.gradle.api.attributes.DisambiguationRuleChain
import org.gradle.api.initialization.Settings
import org.gradle.api.invocation.Gradle

        parameters {
            externalClasspath.from(configurations.externalClasspath)
            excludedPackage = "org.gradle.api"
        }
    }
}

dependencies {
    attributesSchema {
        attribute(usage)
    }
}
configurations.create("compile") {
    attributes.attribute usage, 'api'