## 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".

  <modelVersion>4.0.0</modelVersion>
  <groupId>test.readparent</groupId>
  <artifactId>local-parent</artifactId>
  <packaging>pom</packaging>
  <version>1.0</version>

  <modules>
    <module>module</module>
  </modules>

_Gradle Module Metadata 1.1 is supported in Gradle 6._

Gradle publishes Gradle Module Metadata along with traditional metadata. Gradle Module Metadata is automatically consumed when available.

## Goal

{
    "formatVersion": "1.0",
    "component": {
        "group": "org.gradle.test",
        "module": "publishTest",
        "version": "1.9",
        "attributes": {
            "org.gradle.status": "milestone"
        }
    }

root modules by the go command for builds and related operations.  A
workspace that does not specify modules to be used cannot be used to do
builds from local modules.

go.work files are line-oriented. Each line holds a single directive,
made up of a keyword followed by arguments. For example:

	go 1.18

	use ../foo/bar
	use ./baz

	replace example.com/foo v1.2.3 => example.com/bar v1.4.5

<project-modules id="moduleCoreId" project-version="1.5.0">
	<wb-module deploy-name="api">
		<wb-resource deploy-path="/" source-path="src/main/java"/>
		<wb-resource deploy-path="/" source-path="src/main/resources"/>
		<wb-resource deploy-path="/" source-path="src/main/testbutnottest"/>
	</wb-module>

var CmdMod = &base.Command{
	UsageLine: "go mod",
	Short:     "module maintenance",
	Long: `Go mod provides access to operations on modules.

Note that support for modules is built into all the go commands,
not just 'go mod'. For example, day-to-day adding, removing, upgrading,
and downgrading of dependencies should be done using 'go get'.
See 'go help modules' for an overview of module functionality.
	`,

	Commands: []*base.Command{

module example.net/m

go 1.16
-- m2/README.txt --
Package p has been moved to module …/m/p.
Module …/m/p does not require any version of module …/m.

-- p0/go.mod --
module example.net/m/p

go 1.16
-- p0/p.go --