build.gradle

buildscript {
    ext {
        esVersion = '7.17.0'
        luceneVersion = '8.11.1'
        elastic4sVersion = '7.16.3'
        circeVersion= '0.14.1'
        circeGenericExtrasVersion= '0.14.1'
        scalaShortVersion = '2.13'
        scalaFullVersion = '2.13.6'
        zioVersion = '1.0.1'
    }
    repositories {
        maven {
            url "https://plugins.gradle.org/m2/"
        }
    }
    dependencies {
        classpath 'com.github.jengelman.gradle.plugins:shadow:6.1.0'
        classpath 'gradle.plugin.com.github.maiflai:gradle-scalatest:0.31'
        classpath "org.elasticsearch.gradle:build-tools:${esVersion}"
    }
}

allprojects {

    setGroup('com.klibisz.elastiknn')

    // Use -Pversion=foo123 to override the version. Otherwise uses the version file.
    if (version != 'unspecified') setVersion(version)
    else setVersion(rootProject.file('version').getText().strip())

    repositories {
        mavenCentral()
        mavenLocal()
    }
}

subprojects {
    // apply plugin: 'java'
    apply plugin: 'java-library'
    java {
        sourceCompatibility = JavaVersion.VERSION_1_8
        targetCompatibility = JavaVersion.VERSION_1_8
    }
}

// Make sub-projects easy to reference.
Project api4s = project(':api4s')
Project benchmarks = project(':benchmarks')
Project clientElastic4s = project(':client-elastic4s')
Project clientJava = project(':client-java')
Project lucene = project(':lucene')
Project models = project(':models')
Project plugin = project(':plugin')
Project testing = project(':testing')

// Utility to apply multiple configuration closures to a single project.
// TODO: Why can't you just chain .configure(closure1).configure(closure2)...?
def configure(Project p, List<Closure> configClosures) {
    configClosures.forEach { configure(p, it) }
}

def scalaProjectConfig = {
    apply plugin: 'scala'
    tasks.withType(ScalaCompile) {
        scalaCompileOptions.setAdditionalParameters(List.of("-Xfatal-warnings", "-Ywarn-unused:imports"))
    }
    task unifiedScaladocs(type: ScalaDoc, description: 'Generate unified scaladocs', group: 'Documentation') {
        Set docProjects = subprojects.findAll { it.plugins.hasPlugin('scala') }
        destinationDir = file("${rootProject.buildDir}/docs/scaladoc")
        title = "$project.name $version"
        scalaDocOptions = new ScalaDocOptions()
        subprojects.each { proj ->
            if (docProjects.contains(proj.name)) {
                proj.tasks.withType(ScalaDoc).each {
                    source += proj.sourceSets.main.allJava
                    source += proj.sourceSets.main.allScala
                    classpath += proj.sourceSets.main.compileClasspath
                    excludes += scaladoc.excludes
                    includes += scaladoc.includes
                }
            }
        }
    }
}

def publishConfig(String projectDescription, boolean isScala = false) {
    return {

        // Have to do it this way because gradle.properties doesn't expand `~`, `$HOME`, etc.
        ext."signing.secretKeyRingFile" = "${System.getProperty("user.home")}/.gnupg/secring.gpg"

        apply plugin: 'maven-publish'
        apply plugin: 'signing'
        task sourceJar(type: Jar) {
            classifier 'sources'
            from sourceSets.main.allSource
        }
        task javadocJar(type: Jar) {
            classifier 'javadoc'
            from javadoc.destinationDir
        }
        publishing {
            publications {
                maven(MavenPublication) {
                    artifactId = isScala ? "${project.name}_${scalaShortVersion}" : project.name
                    from components.java
                    artifact tasks.sourceJar
                    artifact tasks.javadocJar
                    pom {
                        groupId = "com.klibisz.elastiknn"
                        name = "${rootProject.group}:${artifactId}"
                        description = projectDescription
                        url = 'https://github.com/alexklibisz/elastiknn'
                        licenses {
                            license {
                                name = 'Apache 2.0'
                                url = 'https://choosealicense.com/licenses/apache-2.0/'
                            }
                        }
                        developers {
                            developer {
                                id = 'alexklibisz'
                                name = 'Alex Klibisz'
                                email = 'aklibisz@gmail.com'
                            }
                        }
                        scm {
                            connection = 'scm:git:git://github.com/alexklibisz/elastiknn.git'
                            developerConnection = 'scm:git:ssh://github.com/alexklibisz/elastiknn.git'
                            url = 'https://github.com/alexklibisz/elastiknn'
                        }
                    }

                }
            }
            repositories {
                maven {
                    url = version.contains('SNAPSHOT') ? "https://oss.sonatype.org/content/repositories/snapshots/" : "https://oss.sonatype.org/service/local/staging/deploy/maven2"
                    credentials {
                        username = project.properties.getOrDefault('sonatypeUsername', 'wrong')
                        password = project.properties.getOrDefault('sonatypePassword', 'wrong')
                    }
                }
            }
        }
        signing {
            sign publishing.publications
        }
    }
}

configure(api4s, List.of(
        scalaProjectConfig,
        publishConfig("Scala case classes and JSON codecs for the Elastiknn JSON API", true),
        {
            dependencies {
                implementation "org.elasticsearch:elasticsearch-x-content:${esVersion}"
                implementation "org.scala-lang:scala-library:${scalaFullVersion}"
            }
        }
))

configure(benchmarks, List.of(
        scalaProjectConfig,
        {
            apply plugin: 'application'
            apply plugin: 'com.github.johnrengelman.shadow'

            application {
                mainClassName = project.hasProperty("mainClass") ? project.getProperty("mainClass") : 'com.klibisz.elastiknn.benchmarks.Enqueue'
            }

            shadowJar {
                // This is needed to preserve the META-INF directory from lucene-core.
                mergeServiceFiles()
            }

            dependencies {
                implementation clientElastic4s
                implementation lucene
                implementation models
                implementation plugin
                implementation "ch.qos.logback:logback-classic:1.2.3"
                implementation "com.amazonaws:aws-java-sdk-s3:1.11.781"
                implementation "com.github.scopt:scopt_${scalaShortVersion}:4.0.0-RC2"
                implementation "com.nrinaudo:kantan.csv-generic_${scalaShortVersion}:0.6.1"
                implementation "dev.zio:zio_${scalaShortVersion}:${zioVersion}"
                implementation "dev.zio:zio-logging-slf4j_${scalaShortVersion}:0.4.0"
                implementation "dev.zio:zio-streams_${scalaShortVersion}:${zioVersion}"
                implementation "io.circe:circe-generic-extras_${scalaShortVersion}:${circeGenericExtrasVersion}"
                implementation "io.circe:circe-parser_${scalaShortVersion}:${circeVersion}"

                // Without this you get a warning: WARNING: JAXB is unavailable. Will fallback to SDK implementation which may be
                // less performant.If you are using Java 9+, you will need to include javax.xml.bind:jaxb-api as a dependency.
                implementation 'javax.xml:jaxb-api:2.1'
                implementation "org.scala-lang:scala-library:${scalaFullVersion}"
            }
        }))

configure(clientElastic4s, List.of(
        scalaProjectConfig,
        publishConfig("Scala client for Elastiknn, based on elastic4s", true),
        {
            dependencies {
                api api4s
                api "com.sksamuel.elastic4s:elastic4s-client-esjava_${scalaShortVersion}:${elastic4sVersion}"
                implementation "org.scala-lang:scala-library:${scalaFullVersion}"
            }
        }))

configure(clientJava, List.of(
        publishConfig("Java APIs for Elastiknn, intended for use with Elasticsearch REST clients", false),
        {
            dependencies {
                implementation "org.elasticsearch:elasticsearch:${esVersion}"
            }
        }
))


configure(models, List.of(
        publishConfig("Exact and approximate similarity models used in Elastiknn", false)))

configure(lucene, List.of(
        publishConfig("Custom Lucene queries used in Elastiknn"),
        {
            dependencies {
                implementation models
                implementation "org.apache.lucene:lucene-core:${luceneVersion}"
            }
        }))

configure(plugin, List.of(scalaProjectConfig, {

    apply plugin: 'elasticsearch.esplugin'

    configurations {
        all {
            // Needed to resolve scala minor version conflicts.
            resolutionStrategy.preferProjectModules()
        }
    }

    esplugin {
        name 'elastiknn'
        description 'Elasticsearch plugin for exact and approximate nearest neighbors search on sparse and dense vectors.'
        classname 'com.klibisz.elastiknn.ElastiknnPlugin'
        licenseFile rootProject.file('LICENSE.txt')
        noticeFile rootProject.file('NOTICE.txt')
    }

    dependencies {
        // TODO: a couple of the deps need both runtime _and_ implementation dependencies to run?
        implementation api4s
        implementation lucene
        implementation models
        implementation "com.google.guava:guava:28.1-jre"
        implementation "org.scala-lang:scala-library:${scalaFullVersion}"
        runtimeOnly "com.google.guava:failureaccess:1.0.1"
        runtimeOnly "org.scala-lang:scala-library:${scalaFullVersion}"
    }
}))

configure(testing, List.of(scalaProjectConfig, {

    apply plugin: 'com.github.maiflai.scalatest'

    test {
        outputs.upToDateWhen { false }
        testLogging {
            showStandardStreams = true
            exceptionFormat = 'full'
            events "standardOut", "started", "passed", "skipped", "failed"
        }
        maxParallelForks = 1
    }

    dependencies {
        implementation benchmarks
        implementation clientElastic4s
        implementation clientJava
        implementation lucene
        implementation models
        implementation plugin
        implementation "ch.qos.logback:logback-classic:1.2.3"
        implementation "com.klibisz.futil:futil_${scalaShortVersion}:0.1.2"
        implementation "com.storm-enroute:scalameter_${scalaShortVersion}:0.19"
        implementation 'com.typesafe:config:1.4.0'
        implementation "com.typesafe.scala-logging:scala-logging_${scalaShortVersion}:3.9.2"
        implementation 'com.vladsch.flexmark:flexmark-all:0.35.10'
        implementation "io.circe:circe-generic-extras_${scalaShortVersion}:${circeGenericExtrasVersion}"
        implementation "io.circe:circe-parser_${scalaShortVersion}:${circeVersion}"
        implementation 'org.apache.commons:commons-math3:3.6.1'
        implementation "org.apache.lucene:lucene-analyzers-common:${luceneVersion}"
        implementation "org.apache.lucene:lucene-codecs:${luceneVersion}"
        implementation "org.elasticsearch.client:elasticsearch-rest-high-level-client:${esVersion}"
        implementation "org.elasticsearch:elasticsearch:${esVersion}"
        implementation 'org.pegdown:pegdown:1.4.2'
        implementation "org.scala-lang:scala-library:${scalaFullVersion}"
        implementation "org.scalanlp:breeze_${scalaShortVersion}:1.3"
        implementation "org.scalatest:scalatest_${scalaShortVersion}:3.2.0"
    }
}))