package org.gradle.smoketests

class KotlinCompilerPluginsSmokeTest extends AbstractPluginValidatingSmokeTest {
    @Override
    Map<String, Versions> getPluginsToValidate() {
        [
            'org.jetbrains.kotlin.plugin.allopen': TestedVersions.kotlin,
            'org.jetbrains.kotlin.plugin.spring': TestedVersions.kotlin
        ]
    }

public class ProfileUtil {
    private static final String SPRING_PROFILES_ACTIVE = "spring.profiles.active";

    public static void setup() {
        final List<String> list = new ArrayList<String>();

        final String values = System.getProperty(SPRING_PROFILES_ACTIVE);
        if (values != null) {
            for (final String value : values.split(",")) {
                list.add(value);
            }

        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