build.gradle

import com.yandex.div.gradle.FileExtensions
import com.yandex.div.gradle.PublicationType

apply from: "$projectDir/version.gradle"
apply from: "$projectDir/dependencies.gradle"

def publicationType = PublicationType.fromString(project.findProperty("publicationType"))

ext {
    minSdkVersion = 21
    compileSdkVersion = 34
    targetSdkVersion = 34
    buildToolsVersion = "34.0.0"

    divkitVersionName = "${divkitVersion.versionName}${publicationType.getVersionSuffix()}"
}

buildscript {
    apply from: "$projectDir/dependencies.gradle"

    FileExtensions.ifExists("${project.projectDir}/bootstrap.internal.gradle") {
        apply from: it
    }

    repositories {
        gradlePluginPortal()
        google()
        mavenCentral()
    }

    dependencies {
        classpath "com.android.tools.build:gradle:$versions.gradlePlugin"
        classpath "com.yandex.android:appmetrica-build-plugin:$versions.metricaCrashPlugin"
        classpath "com.yandex.test:screenshot-test-plugin:1.0.0"
        classpath "io.github.gradle-nexus:publish-plugin:1.1.0"
        classpath "org.jetbrains.dokka:dokka-gradle-plugin:$versions.dokka"
        classpath "org.jetbrains.kotlin:kotlin-allopen:$versions.kotlin"
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$versions.kotlin"
        classpath "org.jetbrains.kotlin:kotlin-serialization:$versions.kotlin"
        classpath "org.jetbrains.kotlinx:binary-compatibility-validator:0.11.1"
    }
}

apply plugin: "org.jetbrains.kotlinx.binary-compatibility-validator"

allprojects {
    repositories {
        google()
        mavenCentral()
    }

    configurations.all {
        resolutionStrategy {
            eachDependency { details ->
                if (details.requested.group == 'com.christophsturm' &&  details.requested.name == 'filepeek') {
                    details.useVersion '0.1.3'
                }
            }
        }
    }

    tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
        kotlinOptions {
            freeCompilerArgs = ['-Xjvm-default=all', '-opt-in=com.yandex.div.data.DivModelInternalApi']
            languageVersion = "1.5"
            apiVersion = "1.5"
            jvmTarget = "1.8"
        }
    }
}

subprojects {
    tasks.withType(Test) {
        // Do not use parallel forks, because profit from parallel execution is eaten by Robolectric initialization in every test process
        maxParallelForks = 1
        maxHeapSize = "4g"
    }

    configurations.all {
        exclude group: 'com.intellij', module: 'annotations'
    }

    afterEvaluate {
        if (plugins.hasPlugin("jacoco")) {
            project.tasks.named("jacocoTestReport") { task ->
                unitTests.dependsOn(task)
            }
        }

        project.tasks.withType(PublishToMavenRepository) { task ->
            task.finalizedBy(reportBuildNumber)
        }

        project.tasks.withType(PublishToMavenLocal) { task ->
            task.finalizedBy(reportVersion)
        }
    }
}

wrapper {
    gradleVersion "8.3"
    distributionType = Wrapper.DistributionType.ALL
    distributionUrl "https://services.gradle.org/distributions/gradle-$gradleVersion-all.zip"
}

apiValidation {
    ignoredProjects += [
        "api-generator-test",
        "divkit-demo-app",
        "divkit-perftests",
        "divkit-regression-testing",
        "sample",
        "screenshot-test-runtime",
        "ui-test-common",
        "unit-test-common"
    ]
    ignoredPackages += ["com.yandex.div.internal"]
    nonPublicMarkers += ["dagger.internal.DaggerGenerated"]
}

task reportVersion {
    doLast {
        println "DivKit version ${rootProject.property('divkitVersionName')}"
    }
}

task reportBuildNumber {
    doLast {
        println "buildNumber ${rootProject.property('divkitVersionName')}"
    }
}

task assembleDemoDebug {
    dependsOn ':divkit-demo-app:assembleDebug'
}

task assembleDemoDebugBundle {
    dependsOn ':divkit-demo-app:bundleDebug'
}

task assembleDemoRelease {
    dependsOn ':divkit-demo-app:assembleRelease'
}

task assembleDemoReleaseBundle {
    dependsOn ':divkit-demo-app:bundleRelease'
}

task unitTests

task finalVerification {
    dependsOn unitTests
}

FileExtensions.ifExists("${project.projectDir}/build.internal.gradle") {
    apply from: it
}