build.gradle

import org.gradle.internal.jvm.Jvm

plugins {
    id 'java-library'
    id 'c'
    id 'cpp'
    id 'maven-publish'
    id 'signing'
}

group "cloud.unum"
version = file("VERSION").text.trim()

java {
    sourceCompatibility = JavaVersion.VERSION_18
    targetCompatibility = JavaVersion.VERSION_18
}

repositories {
    mavenCentral()
}

sourceSets {
    main {
        java {
            srcDir "java/"
            exclude "test/"
        }
        // Ensure native libraries are included in the main source set
        resources {
            srcDirs "$buildDir/libs"
            include "usearch/**"
        }
    }
    test {
        java {
            srcDir "java/test"
        }
    }
}

task sourcesJar(type: Jar, dependsOn: classes) {
    archiveClassifier.set('sources')
    from sourceSets.main.allSource
}

task javadocJar(type: Jar, dependsOn: javadoc) {
    archiveClassifier.set('javadoc')
    from javadoc.destinationDir
}

dependencies {
    testImplementation('junit:junit:4.13.2')
}

model {

    components {
        usearch(NativeLibrarySpec) {
            sources {
                cpp {
                    source {
                        srcDirs "java/cloud/unum/usearch"
                        include "**/*.cpp"
                    }
                    exportedHeaders {
                        srcDirs "include", "fp16/include", "simsimd/include", "${Jvm.current().javaHome}/include"
                    }
                }
                c {
                    source {
                        srcDirs "simsimd/c/"
                        include "**/*.c"
                    }
                    exportedHeaders {
                        srcDirs "simsimd/include"
                    }
                }
            }
            binaries.withType(StaticLibraryBinarySpec) {
                buildable = false
            }
            binaries.withType(SharedLibraryBinarySpec) {
                if (targetPlatform.operatingSystem.linux) {
                    cppCompiler.args '-I', "${Jvm.current().javaHome}/include/linux"
                    cppCompiler.args '-D_FILE_OFFSET_BITS=64'
                    cppCompiler.args '-std=c++11'
                } else if (targetPlatform.operatingSystem.macOsX) {
                    cppCompiler.args '-I', "${Jvm.current().javaHome}/include/darwin"
                    cppCompiler.args '-D_FILE_OFFSET_BITS=64'
                    cppCompiler.args '-std=c++11'
                } else if (targetPlatform.operatingSystem.windows){
                    cppCompiler.args "-I${Jvm.current().javaHome}/include/win32"
                    cppCompiler.args '/std:c++11'
                }
                cppCompiler.args '-DUSEARCH_USE_FP16LIB=1'
                cppCompiler.args '-DUSEARCH_USE_SIMSIMD=1'
                cppCompiler.args '-DSIMSIMD_DYNAMIC_DISPATCH=1'
                cppCompiler.args '-DSIMSIMD_NATIVE_BF16=0'
                cppCompiler.args '-DSIMSIMD_NATIVE_F16=0'
            }
        }
    }

    toolChains {
        clang(Clang)
        gcc(Gcc) {
            target("linux_aarch64") {
                cppCompiler.withArguments { args ->
                    args << "-march=armv8-a"
                }
            }
        }
    }    
}

test {
    forkEvery 1

    dependsOn jar

    // Rearrange test classpath, add compiled JAR instead of main classes
    classpath = project.sourceSets.test.output + configurations.testRuntimeClasspath + files(jar.archiveFile)

    // Enable detailed test logging
    testLogging {
        // Ensure that we get output from all tests, not just failing ones
        showStandardStreams = true
        exceptionFormat = 'full' // Can be 'short', 'full', or 'summary'

        // More detailed test result logging
        events "passed", "skipped", "failed"
    }
}

jar {
    dependsOn("usearchSharedLibrary")
    from("$buildDir/libs/usearch/shared") {
        include "libusearch.so", "libusearch.dylib", "libusearch.dll"
        into "usearch"
    }
    from sourceSets.main.output
}

signing {
    def signingKey = findProperty("signingKey")
    def signingPassword = findProperty("signingPassword")
    useInMemoryPgpKeys(signingKey, signingPassword)
    sign publishing.publications
}

publishing {
    publications {
        library(MavenPublication) {
            from components.java
            
            artifact sourcesJar
            artifact javadocJar

            signing {
                sign publishing.publications.library
            }

            pom {
                name = "USearch"
                description = "Smaller & Faster Single-File Vector Search Engine from Unum"
                url = "https://github.com/unum-cloud/usearch"

                licenses {
                    license {
                        name = 'The Apache License, Version 2.0'
                        url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                    }
                }

                scm {
                    connection = 'scm:git:git://github.com/unum-cloud/usearch.git'
                    developerConnection = 'scm:git:ssh://github.com/unum-cloud/usearch.git'
                    url = 'https://github.com/unum-cloud/usearch'
                }

                developers {
                    developer {
                        id = 'ashvardanian'
                        name = 'Ash Vardanian'
                        email = 'ash.vardanian@unum.cloud'
                    }
                }
            }
        }
    }


    // Publishing to GitHub is much easier ;)
    repositories {
        maven {
            name = "OSSRH"
            url = "https://s01.oss.sonatype.org/service/local/staging/deploy/maven2/"
            credentials {
                username = System.getenv("MAVEN_USERNAME")
                password = System.getenv("MAVEN_PASSWORD")
            }
        }
    }

    repositories {
        maven {
            name = "GitHubPackages"
            url = "https://maven.pkg.github.com/unum-cloud/usearch"
            credentials {
                username = System.getenv("GITHUB_ACTOR")
                password = System.getenv("GITHUB_TOKEN")
            }
        }
    }
}

// Ensure that the native library is built before the Java code
compileJava.dependsOn tasks.withType(SharedLibraryBinarySpec)
tasks.named("processResources").configure {
    dependsOn tasks.named("linkUsearchSharedLibrary")
}