build.gradle

plugins {
    id 'base'
    id 'java-library'
    id 'maven-publish'
    id 'signing'
    alias(libs.plugins.nexus.publish)
    id 'idea'
}

repositories {
    mavenCentral()
}

group 'org.omegat.lucene.lucene-gosen'
description 'Japanese analysis for Apache Lucene'

version = "8.11.0"

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(8)
    }
    withSourcesJar()
    withJavadocJar()
}

dependencies {
    implementation(libs.lucene.core)
    implementation(libs.lucene.analyzers.common)
    implementation(libs.lucene.codecs)
    implementation(libs.icu4j)
    testImplementation(libs.junit)
    testImplementation(libs.lucene.test.framework)
    testImplementation(libs.randomizedtesting)
}

javadoc {
    options.locale = 'en_US'
}

// Re-build dictionary with user custom dictionaries, without copy
tasks.register('rebuildNaistChasenDic') {
    doLast {
        println "rebuilding dictionary"
    }
    dependsOn(compileJava, ":dictionary:cleanCompiledNaistChasen", ":dictionary:compileNaistChasen")
}

tasks.register('rebuildIpadicDic') {
    doLast {
        println "rebuilding dictionary"
    }
    dependsOn(compileJava, ":dictionary:cleanCompiledIpadic", ":dictionary:compileIpadic")
}

// Create Jar library without dictionary
tasks.register('jarWithNaistChasen', Jar) {
    archiveClassifier = naistDictype
    from files(sourceSets.main.output,
            fileTree("dictionary" + File.separator
                    + naistDictype + File.separator + compiledDicDir).include('**/*.sen')
    )
    dependsOn(compileJava, ":dictionary:compileNaistChasen")
}

tasks.register('jarWithIpadic', Jar) {
    archiveClassifier = ipadicDictype
    from files(sourceSets.main.output,
            fileTree("dictionary" + File.separator
                    + ipadicDictype + File.separator + compiledDicDir).include('**/*.sen')
    )
    dependsOn(compileJava, ":dictionary:compileIpadic")
}

// Make packages for distribution
tasks.build.dependsOn(jarWithIpadic, jarWithNaistChasen)
tasks.classes.dependsOn(":dictionary:compileNaistChasen", ":dictionary:compileIpadic")

configurations {
    conf
}
def ipadicArtifact = artifacts.add('conf', jarWithIpadic.archiveFile.get().asFile) {
    type ipadicDictype
    builtBy jarWithIpadic
}
def naistArtifact = artifacts.add('conf', jarWithNaistChasen.archiveFile.get().asFile) {
    type naistDictype
    builtBy jarWithNaistChasen
}
artifacts {
    archives jar, sourcesJar, javadocJar
    archives file: jarWithIpadic.archivePath, name: ipadicDictype, builtBy: jarWithIpadic
    archives file: jarWithNaistChasen.archivePath, name: naistDictype, builtBy: jarWithNaistChasen
}

javadoc {
    failOnError = false
    options {
        jFlags('-Duser.language=en')
        addStringOption('locale', 'en_US')
        addStringOption('bottom', '<span>Copyright 2000-2024, OmegaT project and contributors</span>')
        addStringOption('encoding', 'UTF-8')
        addBooleanOption("Xdoclint:none", true)
        addBooleanOption('frames', false)
        addBooleanOption('public', true)
    }
}

tasks.withType(JavaCompile).configureEach {
    options.encoding = "UTF-8"
}

publishing {
    publications {
        mavenJava(MavenPublication) { publication ->
            groupId = 'org.omegat.lucene'
            artifactId = 'lucene-gosen'
            from components.java
            artifact ipadicArtifact
            artifact naistArtifact

            pom {
                name = 'Lucene-Gosen'
                description = 'Lucene-Gosen'
                url = 'https://omegat.org'
                scm {
                    connection = "scm:git:https://github.com/omegat-org/lucene-gosen"
                    developerConnection = "scm:git:https://github.com/omegat-org/lucene-gosen"
                    url = "https://github.com/omegat-org/lucene-gosen"
                }
                licenses {
                    license {
                        name = 'The GNU Lesser General Public License, Version 2.1'
                        url = 'https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html'
                    }
                }
                developers {
                    developer {
                        id = 'omegat'
                        name = 'OmegaT Developers'
                        email = 'info@omegat.org'
                    }
                }
            }
        }
    }
}

nexusPublishing {
    repositories.sonatype {
        // stagingProfileId = '15818299f2c2bb'
        nexusUrl.set(uri("https://s01.oss.sonatype.org/service/local/"))
        snapshotRepositoryUrl.set(uri("https://s01.oss.sonatype.org/content/repositories/snapshots/"))
        username = findProperty('ossrhUsername')
        password = findProperty('ossrhPassword')
    }
}

signing {
    if (project.hasProperty("signingKey")) {
        def signingKey = findProperty("signingKey").toString()
        def signingPassword = findProperty("signingPassword").toString()
        useInMemoryPgpKeys(signingKey, signingPassword)
    } else {
        useGpgCmd()
    }
    sign publishing.publications.mavenJava
}

tasks.withType(Sign).configureEach {
    def hasKey = project.hasProperty("signingKey") || project.hasProperty("signing.gnupg.keyName")
    onlyIf { hasKey && !project.version.toString().endsWith("-SNAPSHOT") }
}