String originalUrl
        String mirrorUrl
        String type

        private MirroredRepository(String originalUrl, String mirrorUrl, String type) {
            this.originalUrl = originalUrl
            this.mirrorUrl = mirrorUrl ?: originalUrl
            this.type = type
        }

        String getRepositoryDefinition(GradleDsl dsl = GROOVY) {

                }
                dependsOn('spring', 'bom', '2.0') {
                    endorseStrictVersions = true
                    attribute(Category.CATEGORY_ATTRIBUTE.name, Category.REGULAR_PLATFORM)
                }
            }.publish()
        def depSpring2 = mavenHttpRepo.module('spring', 'core', '2.0').publish()

@startuml

skinparam monochrome true
skinparam component {
    BackgroundColor white
    BorderColor Black
	ArrowColor Black
}

database "External Repository" {
  [Spring Boot\nFramework] as SpringBoot
  [Android\nFramework] as Android
}

package "Application Layer" {
  [server-application]
  [android-app]
}

package "Business Logic Layer" {
  [user-feature]
  [admin-feature]
}

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