# Module gradle

# Kotlin DSL Reference for Gradle

Gradle’s Kotlin DSL provides an enhanced editing experience in supported IDEs, with superior content assistance, refactoring, documentation, and more.
For an introduction see the <a href="../userguide/kotlin_dsl.html">Kotlin DSL Primer</a>.

The Kotlin DSL is implemented on top of Gradle’s Java API.

}

private inline fun buildDependentsMap(
    modules: List<KtModule>,
    getDependencies: (KtModule) -> Sequence<KtModule>,
): Map<KtModule, MutableSet<KtModule>> = buildMap<KtModule, MutableSet<KtModule>> {
    for (module in modules) {
        for (dependency in getDependencies(module)) {
            // `module` should not be part of its own dependents, per the contract of `KotlinModuleDependentsProvider`.

# main modules from the build list incorrectly, leading to the workspace
# modules being checked for correct sums. Specifically this would happen when
# the module name sorted after the virtual 'go' version module name because
# it could not get chopped off when we removed the MainModules.Len() modules
# at the beginning of the build list and we would remove the go module instead.

go mod verify

-- go.work --

source "${KUBE_ROOT}/hack/lib/init.sh"

# These are "internal" modules.  For various reasons, we want them to be
# decoupled from their parent modules.
MODULES=()                                                                                                                                                                   
kube::util::read-array MODULES < <(
    git ls-files -cmo --exclude-standard -- ':!:vendor/*' ':(glob)*/**/go.work' \

cp correct_modules.txt vendor/modules.txt
go build ./vendor/foo.com/internal/bar/a

# For go versions < 1.23, vendored packages that are missing in modules.txt should not result in an error.
cp 122go.mod go.mod

cp incorrect_modules.txt vendor/modules.txt

# go version < 1.23 and incorrect_modules is missing foo.com/internal/bar/b so the build should not fail

## Structure

Each platform and module has its own source directory under [platforms/](../platforms).
In these source directories, you will find the Gradle projects that make up the platform or module.

The platforms and modules are defined using a DSL in [settings.gradle.kts](../settings.gradle.kts)

    }

    private Set<Module> allRequiredModulesOf(String... names) {
        Set<Module> modules = new HashSet<>();
        for (String name : names) {
            modules.addAll(moduleRegistry.getModule(name).getAllRequiredModules());
        }
        return modules;
    }

    private Set<Module> allRequiredModulesOfOptional(String moduleName) {
        Module optionalModule = moduleRegistry.findModule(moduleName);

## Decision

Organize the Gradle code base into a set of coarse-grained "architecture modules".
An architecture module is responsible for providing a coherent set of features and:

- Provides a set of APIs and services for use from outside the module.
- Has a private implementation.
- Is owned by a single team. A team may own multiple architecture modules.

The modules are arranged into several different "Gradle platforms".

[short] skip

# 'go run pkg@version' works outside a module.
env GO111MODULE=auto
go run example.com/cmd/a@v1.0.0
stdout '^a@v1.0.0$'


# 'go run pkg@version' reports an error if modules are disabled.
env GO111MODULE=off
! go run example.com/cmd/a@v1.0.0
stderr '^go: modules disabled by GO111MODULE=off; see ''go help modules''$'
env GO111MODULE=on

    /**
     * Locates a module by name.
     *
     * @return the module. Does not return null.
     */
    Module getModule(String name) throws UnknownModuleException;

    /**
     * Tries to locate a module by name.
     *
     * @return the optional module, or {@literal null} if it cannot be found
     * @throws UnknownModuleException if the requested module is found but one of its dependencies is not
     */