plugins {
    `java-library`
}
repositories {
    mavenCentral()
}

tasks.test {
    useJUnitPlatform()
}

// tag::patchArgs[]
val moduleName = "org.gradle.sample"
val patchArgs = listOf("--patch-module", "$moduleName=${tasks.compileJava.get().destinationDirectory.asFile.get().path}")
tasks.compileTestJava {
    options.compilerArgs.addAll(patchArgs)
}
tasks.test {
    jvmArgs(patchArgs)
}
// end::patchArgs[]

                library("commons-lang3", "org.apache.commons", "commons-lang3").version {
                    strictly("[3.8, 4.0[")
                    prefer("3.9")
                }
                bundle("groovy", listOf("groovy-core", "groovy-json", "groovy-nio"))
            }
        }
    }
    // end::catalog_with_bundle[]
}

if (providers.systemProperty("create4").getOrNull() != null) {
    // tag::catalog_with_plugin[]

  val conscrypt =
    if (includeConscrypt) {
      Security.addProvider(Conscrypt.newProvider())
      conscrypt(ianaSuitesNew)
    } else {
      Client("Conscrypt", "Disabled", null, listOf())
    }

  val clients =
    listOf(
      okhttp,
      chrome80,
      firefox73,
      android9,
      safari12iOS,
      conscrypt,
      currentVm,
      okHttp_3_9,
      okHttp_3_11,
      okHttp_3_13,

@MyComposable
fun Scaffold(bars: List<@MyComposable () -> Unit>) {
}

// MODULE: main(lib)
// FILE: main.kt
import org.jetbrains.kotlin.fir.plugin.MyComposable
import p3.Scaffold

@MyComposable
private fun TopAppBar(title: String) {
}

@MyComposable
private fun ArticleScreenContent(title: String, bottomBarContent: @MyComposable () -> Unit = { }) {
    Scaffold(listOf({ TopAppBar(title) }, bottomBarContent))

// tag::declare-dependency[]
}
// end::declare-dependency[]

// tag::generate-grammar-settings[]
tasks.generateGrammarSource {
    maxHeapSize = "64m"
    arguments = arguments + listOf("-visitor", "-long-messages")
}

import org.gradle.docs.samples.Dsl

plugins {
    id("org.gradle.samples")
}

val singleProjectSampleLanguages = listOf(JAVA, GROOVY, SCALA, KOTLIN, SWIFT, CPP)
val multiProjectApplicationSampleLanguages = listOf(JAVA, GROOVY, SCALA, KOTLIN)

singleProjectSampleLanguages.forEach { language ->
    setupGeneratorTask(language, "library", ModularizationOption.SINGLE_PROJECT)

            key.contains("Class(") -> listOf("type")
            key.contains("Classes(") -> listOf("types")
            else -> null
        }

        key.startsWith("${GroovyNamedArguments::class.qualifiedName}.") -> when {
            key.contains("Map(") -> listOf("args")
            key.contains("Parameters(") -> listOf("args", "foo", "bar")
            else -> null
        }

    extraParameters: String = "",
    os: Os = Os.LINUX,
    arch: Arch = Arch.AMD64,
    testJavaVersion: String = os.perfTestJavaVersion.major.toString(),
    testJavaVendor: String = os.perfTestJavaVendor.toString(),
) = listOf(
    "$task${if (extraParameters.isEmpty()) "" else " $extraParameters"}",
    "-PperformanceBaselines=$baselines",
    "-PtestJavaVersion=$testJavaVersion",
    "-PtestJavaVendor=$testJavaVendor",

            val value = result.value
            check(value is Syntactic<T>)
            return value.value
        }

        fun <T> checked(results: List<CheckedResult<SyntacticResult<T>>>): List<T> =
            results.map {
                val syntacticResult = it.value
                check(syntacticResult is Syntactic<T>)
                syntacticResult.value
            }.toList()
    }

        type.name
    }
    // When no product flavors defined, use empty
    val productFlavors = android.productFlavors.map { flavor -> flavor.name }
        .takeIf { it.isNotEmpty() }
        ?: listOf("")
    productFlavors.forEach { productFlavorName ->
        buildTypes.forEach { buildTypeName ->
            lateinit var sourceName: String
            lateinit var sourcePath: String