build.gradle

/*
 * Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License").
 * You may not use this file except in compliance with the License.
 * A copy of the License is located at
 *
 *  http://aws.amazon.com/apache2.0
 *
 * or in the "license" file accompanying this file. This file 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 org.gradle.api.tasks.testing.logging.TestExceptionFormat
import org.gradle.api.tasks.testing.logging.TestLogEvent

import java.util.regex.Pattern

buildscript {
  repositories {
    maven { url "https://plugins.gradle.org/m2/" }
    mavenLocal()
  }
}


plugins {
    // Apply the java plugin to add support for Java
    id "java"

    // Apply the application plugin to add support for building a CLI application.
    id "application"

    id "maven-publish"
    id "com.palantir.git-version" version "0.12.3"
    id "checkstyle"
    id "org.jreleaser" version "1.13.0"

    // Fork of runtime plugin with java 21 support, until https://github.com/beryx/badass-runtime-plugin/issues/153
    // is resolved.
    id "com.dua3.gradle.runtime" version "1.13.1-patch-1"
}


version gitVersion().replaceFirst("v", "")

// Reusable license copySpec for building JARs
def licenseSpec = copySpec {
    from "${project.rootDir}/LICENSE"
    from "${project.rootDir}/NOTICE"
}

// Set up tasks that build source and javadoc jars.
task sourcesJar(type: Jar) {
    metaInf.with(licenseSpec)
    from {
        sourceSets.main.allJava
    }
    archiveClassifier = "sources"
}

// Build a javadoc JAR too.
task javadocJar(type: Jar) {
    metaInf.with(licenseSpec)
    from {
        tasks.javadoc
    }
    archiveClassifier = "javadoc"
}

ext {
    // Load the Smithy Language Server version from VERSION.
    libraryVersion = project.file("VERSION").getText('UTF-8').replace(System.lineSeparator(), "")
    imageJreVersion = "21"
    correttoRoot = "https://corretto.aws/downloads/latest/amazon-corretto-${imageJreVersion}"
}

println "Smithy Language Server version: '${libraryVersion}'"

def stagingDirectory = rootProject.layout.buildDirectory.dir("staging")

allprojects {
    apply plugin: "java"
    apply plugin: "maven-publish"
    group = "software.amazon.smithy"
    version = libraryVersion
    description = "Language Server Protocol implementation for Smithy"
}

repositories {
    mavenLocal()
    mavenCentral()
}

publishing {
    repositories {
        maven {
            name = "localStaging"
            url = stagingDirectory
        }
    }

    publications {
        mavenJava(MavenPublication) {
            groupId = project.group
            artifactId = "smithy-language-server"

            from components.java

            jar

            // Ship the source and javadoc jars.
            artifact(tasks["sourcesJar"])
            artifact(tasks["javadocJar"])

            // Include extra information in the POMs.
            project.afterEvaluate {
                pom {
                    name.set("Smithy Language Server")
                    description.set(project.description)
                    url.set("https://github.com/smithy-lang/smithy-language-server")
                    licenses {
                        license {
                            name.set("Apache License 2.0")
                            url.set("http://www.apache.org/licenses/LICENSE-2.0.txt")
                            distribution.set("repo")
                        }
                    }
                    developers {
                        developer {
                            id.set("smithy")
                            name.set("Smithy")
                            organization.set("Amazon Web Services")
                            organizationUrl.set("https://aws.amazon.com")
                            roles.add("developer")
                        }
                    }
                    scm {
                        url.set("https://github.com/smithy-lang/smithy-language-server.git")
                    }
                }
            }
        }
    }
}

checkstyle {
    toolVersion = "10.12.4"
}

dependencies {
    implementation "org.eclipse.lsp4j:org.eclipse.lsp4j:0.23.1"
    implementation "software.amazon.smithy:smithy-build:[smithyVersion, 2.0["
    implementation "software.amazon.smithy:smithy-cli:[smithyVersion, 2.0["
    implementation "software.amazon.smithy:smithy-model:[smithyVersion, 2.0["
    implementation "software.amazon.smithy:smithy-syntax:[smithyVersion, 2.0["

    testImplementation "org.junit.jupiter:junit-jupiter:5.10.0"
    testImplementation "org.hamcrest:hamcrest:2.2"

    testRuntimeOnly "org.junit.platform:junit-platform-launcher"

    checkstyle "com.puppycrawl.tools:checkstyle:${checkstyle.toolVersion}"
}

tasks.withType(Javadoc).all {
    options.addStringOption('Xdoclint:none', '-quiet')
}

tasks.withType(Test).configureEach {
    useJUnitPlatform()

    testLogging {
        events TestLogEvent.PASSED, TestLogEvent.SKIPPED, TestLogEvent.FAILED, TestLogEvent.STANDARD_OUT, TestLogEvent.STANDARD_ERROR
        exceptionFormat TestExceptionFormat.FULL
        showExceptions true
        showCauses true
        showStackTraces true
    }
}

tasks.register('createProperties') {
    dependsOn processResources
    doLast {
        new File("$buildDir/resources/main/version.properties").withWriter { w ->
            Properties p = new Properties()
            p['version'] = project.version.toString()
            p.store w, null
        }
    }
}

classes {
    dependsOn createProperties
}

application {
    // Define the main class for the application.
    mainClass = "software.amazon.smithy.lsp.Main"
}

// ==== CheckStyle ====
// https://docs.gradle.org/current/userguide/checkstyle_plugin.html
apply plugin: "checkstyle"
tasks.named("checkstyleTest") {
    enabled = false
}

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(21)
    }
}

jar {
    from (configurations.compileClasspath.collect { entry -> zipTree(entry) }) {
        exclude "about.html"
        exclude "META-INF/LICENSE"
        exclude "META-INF/LICENSE.txt"
        exclude "META-INF/NOTICE"
        exclude "META-INF/MANIFEST.MF"
        exclude "META-INF/*.SF"
        exclude "META-INF/*.DSA"
        exclude "META-INF/*.RSA"
        exclude "reflect.properties"
        // Included by dependencies in later versions of java, causes duplicate entries in the output jar
        exclude "**/module-info.class"
    }
    manifest {
        attributes("Main-Class": "software.amazon.smithy.lsp.Main")
    }
}


runtime {
    addOptions("--compress", "2", "--strip-debug", "--no-header-files", "--no-man-pages")
    addModules("java.logging")

    launcher {
        jvmArgs = [
                '-XX:-UsePerfData',
                '-Xshare:auto',
                '-XX:SharedArchiveFile={{BIN_DIR}}/../lib/smithy.jsa'
        ]
    }

    targetPlatform("linux-x86_64") {
        jdkHome = jdkDownload("${correttoRoot}-x64-linux-jdk.tar.gz")
    }

    targetPlatform("linux-aarch64") {
        jdkHome = jdkDownload("${correttoRoot}-aarch64-linux-jdk.tar.gz")
    }

    targetPlatform("darwin-x86_64") {
        jdkHome = jdkDownload("${correttoRoot}-x64-macos-jdk.tar.gz")
    }

    targetPlatform("darwin-aarch64") {
        jdkHome = jdkDownload("${correttoRoot}-aarch64-macos-jdk.tar.gz")
    }

    targetPlatform("windows-x64") {
        jdkHome = jdkDownload("${correttoRoot}-x64-windows-jdk.zip")
    }

    // Because we're using target-platforms, it will use this property as a prefix for each target zip
    imageZip = layout.buildDirectory.file("image/smithy-language-server.zip")
}

tasks["assembleDist"].dependsOn("publish")
tasks["assembleDist"].dependsOn("runtimeZip")

// Generate a changelog that only includes the changes for the latest version
// which Jreleaser will add to the release notes of the github release.
def releaseChangelogFile = project.layout.buildDirectory.file("resources/RELEASE_CHANGELOG.md").get().asFile
tasks.register("createReleaseChangelog") {
    dependsOn processResources

    doLast {
        def changelog = project.file("CHANGELOG.md").text
        // Copy the text in between the first two version headers
        def matcher = Pattern.compile("^## \\d+\\.\\d+\\.\\d+", Pattern.MULTILINE).matcher(changelog)
        def getIndex = {
            matcher.find()
            return matcher.start()
        }
        def result = changelog.substring(getIndex(), getIndex()).trim()
        releaseChangelogFile.write(result)
    }
}

tasks.jreleaserRelease.dependsOn(tasks.createReleaseChangelog)

jreleaser {
    dryrun = false

    project {
        website = 'https://smithy.io'
        authors = ['Smithy']
        vendor = "Smithy"
        license = 'Apache-2.0'
        description = "Smithy Language Server - A Language Server Protocol implementation for the Smithy IDL."
        copyright = "2019"
    }

    release {
        github {
            overwrite = true
            tagName = '{{projectVersion}}'
            releaseName = 'Smithy Language Server v{{{projectVersion}}}'
            changelog {
                external = releaseChangelogFile.absolutePath
            }
            commitAuthor {
                name = "smithy-automation"
                email = "github-smithy-automation@amazon.com"
            }
        }
    }

    files {
        active = "ALWAYS"
        artifact {
            // We'll include the VERSION file in the release artifacts so that the version can be easily
            // retrieving by hitting the GitHub `releases/latest` url
            path = "VERSION"
            extraProperties.put('skipSigning', true)
        }
    }

    platform {
        // These replacements are for the names of files that are released, *not* for names within this build config
        replacements = [
                'osx': 'darwin',
                'aarch_64': 'aarch64',
                'windows_x86_64': 'windows_x64'
        ]
    }

    distributions {
        'smithy-language-server' {
            distributionType = 'JLINK'
            stereotype = 'CLI'

            artifact {
                path = "build/image/smithy-language-server-linux-x86_64.zip"
                platform = "linux-x86_64"
            }

            artifact {
                path = "build/image/smithy-language-server-linux-aarch64.zip"
                platform = "linux-aarch_64"
            }

            artifact {
                path = "build/image/smithy-language-server-darwin-x86_64.zip"
                platform = "osx-x86_64"
            }

            artifact {
                path = "build/image/smithy-language-server-darwin-aarch64.zip"
                platform = "osx-aarch_64"
            }

            artifact {
                path = "build/image/smithy-language-server-windows-x64.zip"
                platform = "windows-x86_64"
            }
        }
    }

    checksum {
        individual = true
        files = false
    }

    signing {
        active = "RELEASE"
        armored = true
        verify = true
    }

    // Configuration for deploying to Maven Central.
    // https://jreleaser.org/guide/latest/examples/maven/maven-central.html#_gradle
    deploy {
        maven {
            nexus2 {
                "maven-central" {
                    active = "ALWAYS"
                    url = "https://aws.oss.sonatype.org/service/local"
                    snapshotUrl = "https://aws.oss.sonatype.org/content/repositories/snapshots"
                    closeRepository = true
                    releaseRepository = true
                    stagingRepository(stagingDirectory.get().toString())
                }
            }
        }
    }
}