build.gradle

import groovy.json.JsonBuilder
import groovy.json.JsonSlurper
import org.gradle.api.artifacts.DependencyResolveDetails
import org.gradle.api.tasks.bundling.Jar

import java.util.regex.Matcher
import java.util.regex.Pattern

buildscript {
    ext {
        kotlinVersion = "1.3.41"
    }
    repositories {
        mavenCentral()
    }

    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"
        classpath "org.jetbrains.kotlin:kotlin-allopen:$kotlinVersion"
        classpath "org.jetbrains.dokka:dokka-gradle-plugin:0.9.17"
        classpath "io.codearte.gradle.nexus:gradle-nexus-staging-plugin:0.30.0"
    }
}

apply plugin: "antlr"
apply plugin: "kotlin"

apply plugin: "org.jetbrains.dokka"
apply plugin: "maven-publish"
apply plugin: "signing"
apply plugin: "io.codearte.nexus-staging"

nexusStaging {
    packageGroup = "one.leftshift"
    serverUrl = "https://s01.oss.sonatype.org/service/local/"
    stagingProfileId = System.getenv("OSSRH_STAGING_PROFILE_ID")
    username = System.getenv("OSSRH_LOGIN_NAME")
    password = System.getenv("OSSRH_LOGIN_PASSWORD")
}


allprojects {
    repositories {
        mavenCentral()
    }

    configurations.all {
        resolutionStrategy.eachDependency { DependencyResolveDetails details ->
            def requested = details.requested
            if (requested.group == "org.jetbrains.kotlin") {
                details.useVersion kotlinVersion
            }
        }
    }

    if (System.getenv("CI")) {
        afterEvaluate { rootProject.tasks.postRelease.finalizedBy rootProject.tasks.sendReleaseEmail }
        if (tasks.findByName("publish")) {
            afterEvaluate { rootProject.tasks.postRelease.dependsOn tasks.publish }
        }
    }
}

repositories {
    maven {
        credentials(AwsCredentials) {
            accessKey gradle.awsAccessKey
            secretKey gradle.awsSecretKey
        }
        url gradle.releasesRepositoryUrl
    }
    maven {
        credentials(AwsCredentials) {
            accessKey gradle.awsAccessKey
            secretKey gradle.awsSecretKey
        }
        url gradle.snapshotsRepositoryUrl
    }
}


dependencies {
    antlr "org.antlr:antlr4:4.7.2" // use ANTLR version 4

    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
    implementation "org.jetbrains.kotlin:kotlin-reflect"
    implementation "org.apache.velocity:velocity-engine-core:2.1"

    testImplementation "org.junit.jupiter:junit-jupiter:5.6.2"
    testImplementation "org.assertj:assertj-core:3.13.2"
}

test {
    useJUnitPlatform()
}

sourceSets.main.java.srcDirs += new File(buildDir, "generated-src/antlr")
generateGrammarSource {
    outputDirectory = new File(project.rootDir, "build/generated-src/antlr/gaia/sdk/antlr")
    arguments += ["-visitor", "-package", "gaia.sdk.antlr"]
}
compileKotlin.dependsOn generateGrammarSource

task generateSource(type: Test) {
    useJUnitPlatform()
    filter {
        includeTestsMatching "gaia.sdk.codegen.KotlinCodegenTest"
    }
}
generateSource.dependsOn generateGrammarSource


task setVersionJavascript() {
    doLast {
        String packageJsonPath = project(":gaia-sdk-javascript").projectDir.toString() + "/package.json"
        File packageJsonFile = file(packageJsonPath)
        def parsedJson = new JsonSlurper().parseText(packageJsonFile.text)
        parsedJson.version = version.toString()
        packageJsonFile.text = new JsonBuilder(parsedJson).toPrettyString()
        logger.quiet("Updated version in ${packageJsonPath} to ${version.toString()}")
    }
}
task setVersionPython() {
    doLast {
        String pyprojectTomlPath = project(":gaia-sdk-python").projectDir.toString() + "/pyproject.toml"
        File pyprojectTomlFile = file(pyprojectTomlPath)
        String pyprojectTomlContent = pyprojectTomlFile.text

        Pattern regex = Pattern.compile("^version\\s?=\\s?[\"'].*[\"']\\s?\$", Pattern.MULTILINE)
        Matcher matcher = regex.matcher(pyprojectTomlContent)
        List<String> matches = []
        while (matcher.find()) {
            matches.add(matcher.group(0))
        }
        if (matches.size() > 1)
            throw new RuntimeException("More than one version found in ${pyprojectTomlPath}")
        if (matches.isEmpty() || matches.first().trim().isEmpty())
            throw new RuntimeException("No version found in ${pyprojectTomlPath}")
        pyprojectTomlFile.text = pyprojectTomlContent.replaceAll(matches.first(), "version = \"${version.toString()}\"")
        logger.quiet("Updated version in ${pyprojectTomlPath} to ${version.toString()}")
    }
}