* under the License.
 */
package org.apache.maven.toolchain.building;

/**
 * Builds the effective toolchains from a user toolchains file and/or a global toolchains file.
 *
 * @since 3.3.0
 */
public interface ToolchainsBuilder {

    /**
     * Builds the effective toolchains of the specified toolchains files.
     *

        compile.dependencies.is(compile.dependencies)
    }

    def "builds and caches the configuration meta-data from the module descriptor"() {
        when:
        configuration("conf")

        then:
        metadata.getConfiguration("conf").transitive
        metadata.getConfiguration("conf").visible
    }

    def "builds and caches hierarchy for a configuration"() {
        given:
        configuration("a")

* Share build configuration logic between subprojects using convention plugins in `buildSrc`
* Run similar named tasks in all subprojects
* Run a task in a specific subproject
* Build, bundle and run the application

== Next steps

When your project grows, you might be interested in more details how to configure JVM projects, structuring multi-project builds and dependency management:

#### JVM platform

This is a platform that builds on the core and software platforms to add support for developing software that runs on the JVM.
This includes software that is implemented using Java, Kotlin or some other JVM language.

This platform provides specific support for Java, Groovy and Scala, and includes the foojay toolchain plugin. 

#### Extensibility platform

[[sec:build_cache_enable]]
== Enable the Build Cache

By default, the build cache is not enabled. You can enable the build cache in a couple of ways:

Run with `--build-cache` on the command-line::
Gradle will use the build cache for this build only.
Put `org.gradle.caching=true` in your `gradle.properties`::
Gradle will try to reuse outputs from previous builds for all builds, unless explicitly disabled with `--no-build-cache`.

    @ToBeFixedForConfigurationCache
    def "builds IDE metadata artifacts in parallel"() {
        given:
        server.start()
        buildTestFixture.withBuildInSubDir()
        def buildA = singleProjectBuild("buildA") {
            buildFile << """
                apply plugin: 'java'
                apply plugin: 'idea'
            """
        }

        def included = ['buildB', 'buildC', 'buildD']

Shared build caches can decrease build times for both CI and developer builds.

For more information about the build cache, check out the
<<build_cache_use_cases.adoc#use_cases_cache,build cache documentation>>.

=== Visualize the build cache with build scans

Build scans can help you investigate build cache effectiveness.
In the performance screen, the _"Build cache"_ tab shows you statistics about:

(we highly recommend to name this branch without prefix and hyphen (`-`) because it's used to generate build type ID) and want to
test these changes without affecting `master`/`release` pipeline. Here are the instructions.

image::gradle-basic-3.png[]

The primary purpose of the _settings file_ is to add subprojects to your build.

Gradle supports single and multi-project builds.

- For single-project builds, the settings file is optional.
- For multi-project builds, the settings file is mandatory and declares all subprojects.

[[sec:settings_file_script]]
== Settings script

The settings file is a script.

== Suggestions for authoring your build

[[custom_actions]]
=== Review usages of `doFirst` and `doLast`

Using `doFirst` and `doLast` from a build script on a cacheable task ties you to build script changes since the implementation of the closure comes from the build script.