build.gradle

/*
 * Copyright (c) 2024 Snowflake Computing Inc.
 *
 * 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
 *
 *      http://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.
 */

buildscript {
    repositories {
        maven {
            url "https://plugins.gradle.org/m2/"
        }
    }
    dependencies {
        classpath "com.diffplug.spotless:spotless-plugin-gradle:${libs.plugins.spotless.get().version}"
    }
}

plugins {
    id "idea"
    id "eclipse"
    id "org.jetbrains.gradle.plugin.idea-ext" version "1.1.8"
}

allprojects {
    repositories {
        mavenLocal()
        mavenCentral()
    }
    idea {
        module {
            downloadJavadoc = true
            downloadSources = true
        }
    }
}

subprojects {
    apply plugin: "jacoco"
    apply plugin: "java"
    apply plugin: "com.diffplug.spotless"
    apply plugin: "jacoco-report-aggregation"
    apply plugin: "groovy"

    tasks.withType(JavaCompile) {
        options.compilerArgs << "-Xlint:unchecked"
        options.compilerArgs << "-Xlint:deprecation"
    }

    project(":polaris-service") {
        apply plugin: "application"
    }

    project(":polaris-core") {
        apply plugin: "java-library"
    }

    dependencies {
        implementation(platform(libs.jackson.bom))
        implementation("com.fasterxml.jackson.core:jackson-annotations")
        implementation(libs.guava)
        implementation(libs.slf4j.api)
        compileOnly(libs.jetbrains.annotations)
        compileOnly(libs.spotbugs.annotations)

        testImplementation(platform(libs.junit.bom))
        testImplementation("org.junit.jupiter:junit-jupiter")
        testImplementation(libs.assertj.core)
        testImplementation(libs.mockito.core)

        testRuntimeOnly("org.junit.platform:junit-platform-launcher")
    }

    task format {
        dependsOn "spotlessApply"
    }

    test {
        useJUnitPlatform()
        jvmArgs += [ '-Duser.language=en' ]
    }

    spotless {
        def disallowWildcardImports = {
            String text = it
            def regex = ~/import .*\.\*;/
            def m = regex.matcher(text)
            if (m.find()) {
                throw new AssertionError("Wildcard imports disallowed - ${m.findAll()}")
            }
        }
        format("xml") {
            target("src/**/*.xml", "src/**/*.xsd")
            targetExclude("codestyle/copyright-header.xml")
            eclipseWtp(com.diffplug.spotless.extra.wtp.EclipseWtpFormatterStep.XML)
                    .configFile(rootProject.file("codestyle/org.eclipse.wst.xml.core.prefs"))
            // getting the license-header delimiter right is a bit tricky.
            //licenseHeaderFile(rootProject.file("codestyle/copyright-header.xml"), '<^[!?].*$')
        }
        if (project.plugins.hasPlugin("java-base")) {
            java {
                target "src/*/java/**/*.java"
                targetExclude "build/**"
                licenseHeaderFile(rootProject.file("codestyle/copyright-header-java.txt"))
                googleJavaFormat()
                endWithNewline()
                custom "disallowWildcardImports", disallowWildcardImports
            }
        }
    }
}

def projectName = rootProject.file("ide-name.txt").text.trim()
def ideName = "$projectName ${rootProject.version.toString().replace("^([0-9.]+).*", "\1")}"

if (System.getProperty("idea.sync.active").asBoolean()) {
    // There's no proper way to set the name of the IDEA project (when "just importing" or
    // syncing the Gradle project)
    def ideaDir = rootProject.layout.projectDirectory.dir(".idea")
    ideaDir.asFile.mkdirs()
    ideaDir.file(".name").asFile.text = ideName
    def icon = ideaDir.file("icon.png").asFile
    if (!icon.exists()) {
        def img = new URI("https://raw.githubusercontent.com/polaris-catalog/polaris/main/docs/img/logos/polaris-brandmark.png").toURL().openConnection().getInputStream().bytes
        ideaDir.file("icon.png").asFile.newOutputStream().with { out -> out.write(img) }
    }

    idea {
        module {
            name = ideName
            downloadSources = true // this is the default BTW
            inheritOutputDirs = true
        }
    }

    idea.project.settings {
        copyright {
            useDefault = "ApacheLicense-v2"
            profiles.create("ApacheLicense-v2") {
                // strip trailing LF
                def copyrightText = rootProject.file("codestyle/copyright-header.txt").text
                notice = copyrightText
            }
        }

        encodings.encoding = "UTF-8"
        encodings.properties.encoding = "UTF-8"
    }
}

eclipse { project { name = ideName } }