build.gradle

/*
 * Copyright 2020 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import com.google.accompanist.buildsrc.Libs
import com.google.accompanist.buildsrc.Versions

buildscript {
    repositories {
        google()
        mavenCentral()
        jcenter()
    }

    dependencies {
        classpath Libs.androidGradlePlugin
        classpath Libs.Kotlin.gradlePlugin

        classpath Libs.gradleMavenPublishPlugin

        classpath Libs.Dokka.gradlePlugin
        classpath Libs.Kotlin.binaryCompatibility
    }
}

plugins {
    id "com.diffplug.spotless" version "5.9.0"
}

apply plugin: 'org.jetbrains.dokka'

apply plugin: 'binary-compatibility-validator'
apiValidation {
    // Ignore the sample from API tracking/checking
    ignoredProjects += ["sample", "imageloading-testutils"]
}

tasks.withType(org.jetbrains.dokka.gradle.DokkaMultiModuleTask).configureEach {
    outputDirectory = rootProject.file('docs/api')
    failOnWarning = true
}

allprojects {
    repositories {
        google()
        mavenCentral()
        jcenter()

        if (!Libs.AndroidX.Compose.snapshot.isEmpty()) {
            maven { url Libs.AndroidX.Compose.snapshotUrl }
        }
    }
}

subprojects {
    apply plugin: 'com.diffplug.spotless'
    spotless {
        kotlin {
            target "**/*.kt"
            ktlint(Versions.ktlint)
            licenseHeaderFile rootProject.file('spotless/copyright.txt')
        }

        groovyGradle {
            target '**/*.gradle'
            greclipse().configFile(rootProject.file('spotless/greclipse.properties'))
            licenseHeaderFile rootProject.file('spotless/copyright.txt'),
                    '(buildscript|apply|import)'
        }
    }

    tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach { compile ->
        kotlinOptions {
            // Treat all Kotlin warnings as errors
            allWarningsAsErrors = true

            // Set JVM target to 1.8
            jvmTarget = "1.8"

            // Allow use of @OptIn
            freeCompilerArgs += "-Xopt-in=kotlin.RequiresOptIn"

            // FIXME figure out why this is needed
            freeCompilerArgs += "-Xallow-unstable-dependencies"
        }
    }

    // Read in the signing.properties file if it is exists
    def signingPropsFile = rootProject.file('release/signing.properties')
    if (signingPropsFile.exists()) {
        def localProperties = new Properties()
        signingPropsFile.withInputStream { is -> localProperties.load(is) }
        localProperties.each { prop ->
            if (prop.key == "signing.secretKeyRingFile") {
                // If this is the key ring, treat it as a relative path
                project.ext.set(prop.key, rootProject.file(prop.value).absolutePath)
            } else {
                project.ext.set(prop.key, prop.value)
            }
        }
    }

    // Must be afterEvaluate or else com.vanniktech.maven.publish will overwrite our
    // dokka and version configuration.
    afterEvaluate {
        tasks.withType(org.jetbrains.dokka.gradle.DokkaTask).configureEach {
            dokkaSourceSets.configureEach {
                reportUndocumented.set(true)
                skipEmptyPackages.set(true)
                skipDeprecated.set(true)
                jdkVersion.set(8)

                // Add Android SDK packages
                noAndroidSdkLink.set(false)

                // Add samples from :sample module
                samples.from(rootProject.file("sample/src/main/java/"))

                // AndroidX + Compose docs
                externalDocumentationLink {
                    url.set(new URL("https://developer.android.com/reference/"))
                    packageListUrl.set(new URL("https://developer.android.com/reference/androidx/package-list"))
                }
                externalDocumentationLink {
                    url.set(new URL("https://developer.android.com/reference/kotlin/"))
                    packageListUrl.set(new URL("https://developer.android.com/reference/kotlin/androidx/package-list"))
                }

                // Coil docs
                if (rootProject.file('package-list-coil-base').exists()) {
                    externalDocumentationLink {
                        url.set(new URL("https://coil-kt.github.io/coil/api/coil-base/"))
                        packageListUrl.set(new URL("file://$rootDir/package-list-coil-base"))
                    }
                }

                // Glide docs
                externalDocumentationLink {
                    url.set(new URL("https://bumptech.github.io/glide/javadocs/4110/"))
                }

                sourceLink {
                    localDirectory.set(project.file("src/main/java"))
                    // URL showing where the source code can be accessed through the web browser
                    remoteUrl.set(new URL("https://github.com/google/accompanist/blob/main/${project.name}/src/main/java"))
                    // Suffix which is used to append the line number to the URL. Use #L for GitHub
                    remoteLineSuffix.set("#L")
                }
            }
        }

        if (!Libs.AndroidX.Compose.snapshot.isEmpty()) {
            // We're depending on a Jetpack Compose snapshot, update the library version name
            // to indicate it's from a Compose snapshot
            def versionName = project.properties.get('VERSION_NAME')
            if (versionName.contains("SNAPSHOT")) {
                version = versionName.replace(
                        '-SNAPSHOT',
                        ".compose-${Libs.AndroidX.Compose.snapshot}-SNAPSHOT"
                )
            }
        }

        if (!version.endsWith('SNAPSHOT')) {
            // If we're not a SNAPSHOT library version, we fail the build if we're relying on
            // any snapshot dependencies
            configurations.configureEach { configuration ->
                configuration.dependencies.configureEach { dependency ->
                    if (dependency instanceof ProjectDependency) {
                        // We don't care about internal project dependencies
                        return
                    }

                    def depVersion = dependency.version
                    if (depVersion != null && depVersion.endsWith('SNAPSHOT')) {
                        throw new IllegalArgumentException(
                                "Using SNAPSHOT dependency with non-SNAPSHOT library version: $dependency"
                        )
                    }
                }
            }
        }
    }
}