logger.lifecycle("Removing old cache directory : $stateDir")
                    delete { delete(stateDir) }
                }
            }
        }
    }
}


/**
 * Clean up daemon log files produced in integration tests.
 */
fun FileSystemOperations.removeDaemonLogFiles(dir: Directory) {
    if (dir.asFile.isDirectory) {

fun Project.repoRoot(): Directory = getBuildEnvironmentExtension()?.repoRoot?.get() ?: layout.projectDirectory.parentOrRoot()


fun Directory.parentOrRoot(): Directory = if (this.file("version.txt").asFile.exists()) {
    this
} else {
    val parent = dir("..")
    when {

The build process state also includes state that is tied to a particular Gradle user home directory.
When that directory changes between Gradle invocations, the state is discarded and recreated.
Typically, the Gradle user home directory does not change for a given process, so this is effectively process state.

            } else {
                throw GradleException(errorMessage)
            }
        }
    }

    /**
     * Returns non-empty directories: the mapping of directory to at most 4 leftover files' relative path in the directory.
     */
    private
    fun TestFilesCleanupProjectState.tmpTestFiles(): LeftoverFiles = projectBuildDir.get().asFile.resolve("tmp/teŝt files")
        .listFiles()

     *
     * The fixture build supports both Java and Kotlin sources.
     *
     * @param v1 sources producer for V1, receiver is the `src/main` directory
     * @param v2 sources producer for V2, receiver is the `src/main` directory
     * @param block convenience block invoked on the result
     * @return the check result
     */
    private

    }

    private
    fun someClasses(): Sequence<Path> {
        val directory = projectDir.resolve("classes")

        touchFile(directory.resolve("com/acme/Foo.class"))
        touchFile(directory.resolve("com/acme/internal/FooInternal.class"))
        touchFile(directory.resolve("com/foo/internal/FooInternal.class"))
        touchFile(directory.resolve("javax/servlet/http/HttpServletRequest.class"))

# Gradle architecture documentation

This directory contains documentation that describes Gradle's architecture and how the various pieces fit together and work.

## Architecture decision records (ADRs)

The Gradle team uses ADRs to record architectural decisions that the team has made.

See [Architecture decisions records](standards) for the list of ADRs.

import java.util.stream.Collectors


object SamplesGenerator {

    fun generate(type: String, modularization: ModularizationOption, templateFolder: Directory, target: Directory, projectLayoutSetupRegistry: ProjectLayoutSetupRegistry) {
        val descriptor = projectLayoutSetupRegistry[type] as CompositeProjectInitDescriptor
        val projectName = "demo"

platforms/documentation/docs/src/docs/userguide/jvm/                                          @gradle/bt-devrel-education @gradle/bt-jvm
platforms/documentation/docs/src/docs/userguide/reference/directory_layout.adoc               @gradle/bt-devrel-education @gradle/bt-jvm

import org.gradle.api.attributes.Category
import org.gradle.api.attributes.LibraryElements
import org.gradle.api.attributes.Usage
import org.gradle.api.file.ConfigurableFileCollection
import org.gradle.api.file.Directory
import org.gradle.api.tasks.GroovySourceDirectorySet
import org.gradle.api.tasks.InputDirectory
import org.gradle.api.tasks.InputFiles
import org.gradle.api.tasks.PathSensitive
import org.gradle.api.tasks.PathSensitivity