## Composition by architecture modules

Each [architecture module and platform](platforms.md) can contribute code to any of the runtimes.
Not every module contributes to every runtime.

The core-runtime module defines each runtime:

- The target JVM for the runtime. Each runtime has its own JVM compatibility constraints.

dependencies {
    api("me.champeau.gradle:japicmp-gradle-plugin")

    implementation("gradlebuild:basics")
    implementation("gradlebuild:module-identity")

    implementation("com.google.code.gson:gson")
    implementation("com.google.guava:guava")
    implementation("org.javassist:javassist")
    implementation("com.github.javaparser:javaparser-core")

include("basics")

// Platform: defines shared dependency versions
include("build-platform")

// Compute the identity/version we are building and related details (like current git commit)
include("module-identity")

// Code quality rules common to :build-logic and the root build
include("code-quality-rules")

// Plugins to build :build-logic plugins
include("gradle-plugin")

/**
 * @module byPlatform
 * @description Groups the PR's files by platform based on the file's path.
 * @param {string[]} files - the gitStream's files context variable
 * @returns {Map} - Map from platform to list of files in this PR in it
 * @example {{ owners | byPlatform }}
 */
function byPlatform(files) {
    const result = new Map();
    files.forEach(file => {
        const platform = getPlatform(file);
        if (!result.has(platform)) {

        configurations.all {
            if (isCanBeResolved && !isCanBeConsumed) {
                resolutionStrategy.dependencySubstitution {
                    substitute(module("it.unimi.dsi:fastutil")).using(variant(module("it.unimi.dsi:fastutil:8.5.2")) {
                        attributes {
                            attribute(minified, true)
                        }
                    })
                }

    skip()
}
javaComponent.withVariantsFromConfiguration(testFixturesApiElements) {
    skip()
}

plugins.withType<IdeaPlugin> {
    configure<IdeaModel> {
        module {
            val testFixtures = sourceSets.testFixtures.get()
            testSources.from(testFixtures.java.srcDirs)
            testSources.from(testFixtures.groovy.srcDirs)

/**
 * @module readField
 * @description Returns one field for a particular named object in a list of objects.
 * @param {[Object]} objects - The objects to search
 * @param {String} objectName - The name of the particular object to find
 * @param {String} fieldName - The name of the field for the group to return
 * @returns String - The specified value
 * @example {{ files | byPlatform | categorize(branch.diff.files_metadata) | readField('jvm', 'name') }}
 */

/**
 * @module byCodeowner
 * @description Groups the PR's files' by owner based on the CODEOWNERs file.
 * @param {string[]} files - the gitStream's files context variable
 * @param {Object} pr - the gitStream's pr context variable
 * @param {string} token - access token with repo:read scope, used to read the CODEOWNERS file
 * @param {string} pathToCodeOwners - path from repo root to CODEOWNERS file
 * @returns {Map} - Map from owner name to list of files they own

}

if (idea.project != null) { // may be null during script compilation
    idea {
        module {
            // We exclude some top-level directories, so their content is not indexed
            // and does not appear in search results by default
            excludeDirs = listOf(".gradle", "build", "intTestHomeDir")

description = "Provides plugins to configure conventions used by Kotlin, Java and Groovy projects to build Gradle"

dependencies {
    implementation("gradlebuild:basics")
    implementation("gradlebuild:module-identity")

    implementation(project(":dependency-modules"))

    implementation("org.eclipse.jgit:org.eclipse.jgit")
    implementation("org.jsoup:jsoup")
    implementation("com.google.guava:guava")
    implementation("org.ow2.asm:asm")