implementation.forEach { file: File -> println(file.name) }
    }
}
// end::use-configuration[]

// tag::module-dependencies[]
dependencies {
    runtimeOnly(group = "org.springframework", name = "spring-core", version = "2.5")
    runtimeOnly("org.springframework:spring-aop:2.5")
    runtimeOnly("org.hibernate:hibernate:3.0.5") {
        isTransitive = true
    }

    }

    static class Versions implements Iterable<String> {
        static Versions of(String... versions) {
            new Versions(versions)
        }

        final List<String> versions

        private Versions(String... given) {
            versions = Arrays.asList(given)
        }

        @Override
        Iterator<String> iterator() {
            return versions.iterator()
        }

There are different ways to work with the sample:

- You may build or import the umbrella build in the root.
  There you can, for example, run the Spring Boot web application via `./gradlew :server-application:app:bootRun` or install the Android app using `./gradlew :android-app:app:installDebug`.
- You may only build or import one of the application builds directly.

<% if (binding.hasVariable("buildScanPluginVersion")) { %>
        classpath("com.gradle:build-scan-plugin:${buildScanPluginVersion}")
<% }%>
<% if(binding.hasVariable("springDmPluginVersion")) { %>
        classpath("io.spring.gradle:dependency-management-plugin:$springDmPluginVersion")
<% }%>
    }
}
<% if (binding.hasVariable("buildScanPluginVersion")) { %>
apply(plugin = "com.gradle.build-scan")
// TODO: fix buildScan configuration

	quarkus/test-framework/junit5-internal/pom.xml
	quarkus/test-framework/junit5-mockito/pom.xml
quarkus/integration-tests/spring-web/pom.xml
	quarkus/extensions/spring-web/core/runtime/pom.xml
	quarkus/extensions/spring-cache/runtime/pom.xml
	quarkus/extensions/spring-security/runtime/pom.xml
	quarkus/extensions/spring-scheduled/runtime/pom.xml
	quarkus/extensions/undertow/runtime/pom.xml

- runtime environment: a set of libraries known to work well together. e.g., the Spring Platform, recommending versions for both Spring and components that work well with Spring.
- deployment environment: Java runtime, application server, ...

In addition Gradle defines <<dependency_version_alignment.adoc#sec:virtual_platform,virtual platforms>>.

...
Type
     Jar (org.gradle.api.tasks.bundling.Jar)
----
--

Let's bring all this together by running through a quick worked example that configures the `bootJar` and `bootRun` tasks of a Spring Boot project:

.Configuring Spring Boot using type-safe accessors
====
include::sample[dir="snippets/kotlinDsl/configuring-tasks-spring-boot/kotlin",files="build.gradle.kts[tags=accessors]"]

* `*:guava`: will let all modules named `guava`, whatever their group, update
* `org.springframework.spring*:spring*`: will let all modules having their group starting with `org.springframework.spring` and name starting with `spring` update

NOTE: The resolution may cause other module versions to update, as dictated by the Gradle resolution rules.

== Disabling dependency locking

                }
            }
            mailingLists {
                mailingList {
                    name.set("Users")
                }
            }
            properties.put("spring-boot.version", "2.1.2.RELEASE")
            properties.put("hibernate.version", "5.4.1.Final")
        }

        expect:
        with (xml) {
            packaging == "pom"
            name == "my name"

Resolving dependencies::
A plugin uses configurations to find (and possibly download) inputs to the tasks it defines. For example Gradle needs to download Spring web framework JAR files from Maven Central.
Exposing artifacts for consumption::