Quelle  build.gradle   Sprache: unbekannt

// Top-level build file where you can add configuration options common to all sub-projects/modules.

import io.gitlab.arturbosch.detekt.Detekt
import io.gitlab.arturbosch.detekt.DetektCreateBaselineTask
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
import java.nio.file.Files
import java.nio.file.Paths
import java.nio.file.StandardCopyOption

buildscript {
    // This logic is duplicated in the allprojects block: I don't know how to fix that.
    repositories {
        gradle.mozconfig.substs.GRADLE_MAVEN_REPOSITORIES.each { repository ->
            maven {
                url repository
                if (gradle.mozconfig.substs.ALLOW_INSECURE_GRADLE_REPOSITORIES) {
                    allowInsecureProtocol = true
                }
            }
        }
    }

    dependencies {
        classpath ComponentsDependencies.tools_androidgradle
        classpath ComponentsDependencies.tools_benchmarkgradle
        classpath ComponentsDependencies.tools_kotlingradle
        classpath ComponentsDependencies.androidx_navigation_safeargs
        classpath ComponentsDependencies.osslicenses_plugin
        classpath "org.mozilla.telemetry:glean-gradle-plugin:${Versions.mozilla_glean}"
        classpath "${ApplicationServicesConfig.groupId}:tooling-nimbus-gradle:${ApplicationServicesConfig.version}"

        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }

    // Variables in plugins {} aren't directly supported. Hack around it by setting an
    // intermediate variable which can pull from FenixDependenciesPlugin.kt and be used later.
    ext {
        detekt_plugin = Versions.detekt
        ksp_plugin = Versions.ksp_plugin
        protobuf_plugin = Versions.protobuf_plugin
        python_envs_plugin = Versions.python_envs_plugin
    }
}

plugins {
    id("io.gitlab.arturbosch.detekt").version("$detekt_plugin")
    id("com.google.devtools.ksp").version("$ksp_plugin")
}

allprojects {
    // This logic is duplicated in the buildscript block: I don't know how to fix that.
    repositories {
        gradle.mozconfig.substs.GRADLE_MAVEN_REPOSITORIES.each { repository ->
            maven {
                url repository
                if (gradle.mozconfig.substs.ALLOW_INSECURE_GRADLE_REPOSITORIES) {
                    allowInsecureProtocol = true
                }
            }
        }

        maven {
            url "${gradle.mozconfig.topobjdir}/gradle/maven"
        }
    }

    tasks.withType(KotlinCompile).configureEach {
        kotlinOptions.allWarningsAsErrors = true
        kotlinOptions.freeCompilerArgs += [
                "-opt-in=kotlin.RequiresOptIn", "-Xjvm-default=all-compatibility"
        ]
    }
}

subprojects {
    afterEvaluate {
        kotlin {
            jvmToolchain(config.jvmTargetCompatibility)
        }

        if (it.hasProperty('android')) {
            android {
                buildToolsVersion gradle.mozconfig.substs.ANDROID_BUILD_TOOLS_VERSION
            }
        }
    }

    project.configurations.configureEach {
        // Dependencies can't depend on a different major version of Glean than A-C itself.
        resolutionStrategy.eachDependency { details ->
            if (details.requested.group == 'org.mozilla.telemetry'
                    && details.requested.name.contains('glean') ) {
                def requested = details.requested.version.tokenize(".")
                    def defined = Versions.mozilla_glean.tokenize(".")
                    // Check the major version
                    if (requested[0] != defined[0]) {
                        throw new AssertionError("Cannot resolve to a single Glean version. Requested: ${details.requested.version}, A-C uses: ${Versions.mozilla_glean}")
                    } else {
                        // Enforce that all (transitive) dependencies are using the defined Glean version
                        details.useVersion Versions.mozilla_glean
                    }
            }
        }

        resolutionStrategy.capabilitiesResolution.withCapability("org.mozilla.telemetry:glean-native") {
            def toBeSelected = candidates.find { it.id instanceof ModuleComponentIdentifier && it.id.module.contains('geckoview') }
            if (toBeSelected != null) {
                select(toBeSelected)
            }
            because 'use GeckoView Glean instead of standalone Glean'
        }
    }

    tasks.withType(KotlinCompile).configureEach { task ->
        // Translate Kotlin messages like "w: ..." and "e: ..." into
        // "...: warning: ..." and "...: error: ...", to make Treeherder understand.
        def listener = {

            if (it.startsWith("e: warnings found")) {
                return
            }

            if (it.startsWith('w: ') || it.startsWith('e: ')) {
                def matches = (it =~ /([ew]): (.+):(\d+):(\d+) (.*)/)
                if (!matches) {
                    logger.quiet "kotlinc message format has changed!"
                    if (it.startsWith('w: ')) {
                        // For warnings, don't continue because we don't want to throw an
                        // exception. For errors, we want the exception so that the new error
                        // message format gets translated properly.
                        return
                    }
                }
                def (_, type, file, line, column, message) = matches[0]
                type = (type == 'w') ? 'warning' : 'error'
                // Use logger.lifecycle, which does not go through stderr again.
                logger.lifecycle "$file:$line:$column: $type: $message"
            }
        } as StandardOutputListener

        doFirst {
            logging.addStandardErrorListener(listener)
        }
        doLast {
            logging.removeStandardErrorListener(listener)
        }
    }
}

tasks.register('clean', Delete) {
    delete rootProject.layout.buildDirectory
}

detekt {
    input = files("$projectDir/app/src")
    config = files("$projectDir/config/detekt.yml")
    baseline = file("$projectDir/config/detekt-baseline.xml")

    reports {
        html {
            enabled = true
            destination = file("$projectDir/build/reports/detekt.html")
        }
        xml {
            enabled = false
        }
        txt {
            enabled = false
        }
    }
}

tasks.withType(Detekt).configureEach() {
    autoCorrect = true

    exclude "**/test/**"
    exclude "**/androidTest/**"
    exclude "**/build/**"
    exclude "**/resources/**"
    exclude "**/tmp/**"
}

// Apply same path exclusions as for the main task
tasks.withType(DetektCreateBaselineTask).configureEach() {
    exclude "**/test/**"
    exclude "**/androidTest/**"
    exclude "**/build/**"
    exclude "**/resources/**"
    exclude "**/tmp/**"
}

configurations {
    ktlint
}

dependencies {
    ktlint("com.pinterest:ktlint:${Versions.ktlint}") {
        attributes {
            attribute(Bundling.BUNDLING_ATTRIBUTE, getObjects().named(Bundling, Bundling.EXTERNAL))
        }
    }

    detekt project(":mozilla-detekt-rules")
    detekt "io.gitlab.arturbosch.detekt:detekt-cli:${Versions.detekt}"
}

tasks.register('ktlint', JavaExec) {
    group = "verification"
    description = "Check Kotlin code style."
    classpath = configurations.ktlint
    mainClass.set("com.pinterest.ktlint.Main")
    args "app/src/**/*.kt"
    args "!**/build/**/*.kt"
    args "--baseline=ktlint-baseline.xml"
    args "--reporter=json,output=build/reports/ktlint/ktlint.json"
    args "--reporter=plain"
}

tasks.register('ktlintFormat', JavaExec) {
    description = "Fix Kotlin code style deviations."
    classpath = configurations.ktlint
    mainClass.set("com.pinterest.ktlint.Main")
    args "-F"
    args "app/src/**/*.kt"
    args "!**/build/**/*.kt"
    args "--baseline=ktlint-baseline.xml"
    args "--reporter=json,output=build/reports/ktlint/ktlintFormat.json"
    args "--reporter=plain"
    jvmArgs("--add-opens", "java.base/java.lang=ALL-UNNAMED")
}

tasks.withType(Detekt.class).configureEach {
    exclude("**/resources/**")
    exclude("**/tmp/**")
}

tasks.register("listRepositories") {
    doLast {
        println "Repositories:"
        project.repositories.each { println "Name: " + it.name + "; url: " + it.url }
    }
}