build.gradle

import org.apache.tools.ant.filters.ReplaceTokens
import org.apache.tools.ant.filters.FixCrLfFilter

plugins {
    id 'application'
    id 'java-library'
    id 'maven-publish'
    id 'signing'
    id 'eclipse'
    id 'checkstyle'
    id 'jacoco'
    id 'com.github.spotbugs' version '4.7.10'
    id 'de.gliderpilot.jnlp' version '1.2.6'
    id 'org.hidetake.ssh' version '2.10.1'
    id 'com.diffplug.spotless' version '6.0.0'
    id 'com.github.ben-manes.versions' version '0.39.0'
}

apply from: 'gradle/utils.gradle'

applicationName = 'OmegaT'
mainClassName = 'org.omegat.Main'

ext {
    javaVersion = '1.8'
    omtVersion = loadProperties(file('src/org/omegat/Version.properties'))
    omtFlavor = omtVersion.beta.empty ? 'standard' : 'latest'
    omtWebsite = 'https://omegat.org'
    envIsCi = project.hasProperty('envIsCi')
    localPropsFile = file('local.properties')
    if (localPropsFile.file) {
        loadProperties(localPropsFile).each { k, v ->
            if (!findProperty(k)) {
                set(k, v)
            }
        }
    }
}

sourceCompatibility = javaVersion
targetCompatibility = javaVersion

version = omtVersion.version + getUpdateSuffix(omtVersion.update)

sourceSets {
    main {
        java {
            srcDir 'src'
        }
        resources {
            srcDir 'src'
        }
    }
    test {
        java {
            srcDir 'test/src'
        }
        resources {
            srcDir 'test/src'
            srcDir 'test/data'
        }
    }
    testIntegration {
        java {
            srcDir 'test-integration/src'
        }
    }
}

repositories {
    mavenCentral()
}

task webstartDocsJar(type: Jar) {
    description = 'Bundle documents for Java WebStart.'
    archiveBaseName = 'docs'
    from('release') {
        include 'changes.txt', 'OmegaT-license.txt'
        into 'docs'
    }
    from('docs') {
        include '**/instantStartGuideNoTOC.html', '**/OmegaT.css', '**/images/InstantGuide_*.png'
        into 'docs'
    }
}

configurations {
    all {
        // Temporary exclusion; see https://sourceforge.net/p/omegat/bugs/813/
        exclude group: 'org.apache.lucene', module: 'lucene-core'
    }
    [testRuntime, testCompile]*.exclude group: 'org.languagetool', module: 'language-all'

    testIntegrationImplementation.extendsFrom implementation

    jaxb
}

ext {
    providedLibsDir = file('lib/provided')
    languageToolVersion = '3.5'
    luceneVersion = '5.2.1'
}

dependencies {
    // Libs are provided in the "source" distribution only
    if (providedLibsDir.directory) {
        implementation fileTree(dir: providedLibsDir, include: '**/*.jar')
    } else {
        implementation 'commons-io:commons-io:2.11.0'
        implementation 'commons-lang:commons-lang:2.6'
        api 'org.slf4j:slf4j-api:1.7.32'
        implementation 'org.slf4j:slf4j-jdk14:1.7.32'

        // macOS integration
        implementation 'org.madlonkay:desktopsupport:0.6.0'

        api 'javax.xml.bind:jaxb-api:2.3.1'
        implementation 'com.sun.xml.bind:jaxb-impl:2.3.4'

        // Data: inline data URL handler
        implementation 'tokyo.northside:url-protocol-handler:0.1.4'

        // JSON parser
        implementation "com.fasterxml.jackson.core:jackson-core:2.12.3"
        implementation "com.fasterxml.jackson.core:jackson-databind:2.12.3"

        // PDF Filter
        implementation 'org.apache.pdfbox:pdfbox:2.0.24'

        // Aligner
        implementation 'net.loomchild:maligna:3.0.1'

        // Dictionary
        implementation 'io.github.dictzip:dictzip:0.12.2'
        implementation 'com.github.takawitter:trie4j:0.9.8'
        implementation 'io.github.eb4j:dsl4j:0.5.2'
        implementation 'io.github.eb4j:stardict4j:0.3.2'

        // Encoding dectection
        implementation 'com.github.albfernandez:juniversalchardet:2.4.0'

        // Legacy projects re-hosted on Maven Central
        api 'org.omegat:vldocking:3.0.5'
        implementation 'org.omegat:htmlparser:1.5'
        implementation 'org.omegat:gnudiff4j:1.15'
        implementation 'org.omegat:lib-mnemonics:1.0'
        implementation 'org.omegat:jmyspell-core:1.0.0-beta-2'

        // LanguageTool
        implementation "org.languagetool:languagetool-core:${languageToolVersion}"
        runtimeOnly("org.languagetool:language-all:${languageToolVersion}") {
            // Temporary exclusion; see https://sourceforge.net/p/omegat/bugs/814/
            exclude module: 'lucene-gosen-ipadic'
        }
        runtimeOnly 'org.omegat.lucene:lucene-gosen:5.0.0:ipadic'
        runtimeOnly 'org.languagetool:hunspell-native-libs:2.9'

        // Lucene for tokenizers
        // Temporary use of custom lucene-core; see https://sourceforge.net/p/omegat/bugs/813/
        implementation "org.omegat.lucene:lucene-core:${luceneVersion}-1"
        implementation "org.apache.lucene:lucene-analyzers-common:${luceneVersion}"
        implementation "org.apache.lucene:lucene-analyzers-kuromoji:${luceneVersion}"
        implementation "org.apache.lucene:lucene-analyzers-smartcn:${luceneVersion}"
        implementation "org.apache.lucene:lucene-analyzers-stempel:${luceneVersion}"

        // Team project server support
        implementation 'org.eclipse.jgit:org.eclipse.jgit:5.11.1.202105131744-r'
        implementation 'org.eclipse.jgit:org.eclipse.jgit.ssh.jsch:5.11.1.202105131744-r'
        implementation 'com.jcraft:jsch.agentproxy.jsch:0.0.9'
        // Specify the following two here just to make sure all jsch.agentproxy libs are the same version.
        implementation 'com.jcraft:jsch.agentproxy.connector-factory:0.0.9'
        implementation 'com.jcraft:jsch.agentproxy.svnkit-trilead-ssh2:0.0.9'
        // For gpg signing
        implementation 'org.eclipse.jgit:org.eclipse.jgit.gpg.bc:5.11.1.202105131744-r'
        implementation 'org.tmatesoft.svnkit:svnkit:1.8.14'

        // Team project conflict resolution
        implementation 'org.madlonkay:supertmxmerge:2.0.3'

        // Credentials encryption
        implementation 'org.jasypt:jasypt:1.9.3'

        // Groovy used for scripts - needed at implementation for GroovyClassLoader modifications
        // Ivy is needed to handle Grape/@Grab dependencies
        runtimeOnly('org.codehaus.groovy:groovy-all:3.0.9@pom') {
            transitive = true
        }
        runtimeOnly 'org.codehaus.groovy:groovy-dateutil:3.0.9'
        runtimeOnly 'org.apache.ivy:ivy:2.5.0'

        // Script editor
        implementation 'com.fifesoft:rsyntaxtextarea:3.0.8'
        implementation 'com.fifesoft:rstaui:3.0.4'
        implementation ('com.fifesoft:languagesupport:3.0.2') {
            exclude module: 'rhino'
        }
        implementation 'com.fifesoft:autocomplete:3.0.5'

        // Moses MT connector
        implementation 'org.apache.xmlrpc:xmlrpc-client:3.1.3'

        // JSON parser
        implementation "com.fasterxml.jackson.core:jackson-core:2.12.3"
        implementation "com.fasterxml.jackson.core:jackson-databind:2.12.3"
    }

    // Test dependencies
    testImplementation 'junit:junit:4.13.2'
    testImplementation 'org.xmlunit:xmlunit-legacy:2.8.3'
    testImplementation("org.languagetool:languagetool-server:${languageToolVersion}") {
        exclude group: 'org.slf4j'
    }
    // LanguageTool unit tests exercise these languages
    ['be', 'en', 'fr'].each {
        testImplementation "org.languagetool:language-${it}:${languageToolVersion}"
    }
    testRuntimeOnly "org.languagetool:language-pl:${languageToolVersion}"

    // WebStart-only
    jnlp webstartDocsJar.outputs.files

    // JAXB codegen only
    jaxb 'com.sun.xml.bind:jaxb-xjc:2.3.4'

    testIntegrationImplementation sourceSets.main.output, sourceSets.test.output
}

jar {
    def omtPlugins = loadProperties(file('Plugins.properties'))
    manifest {
        attributes('License': 'GNU Public License version 3 or later',
                   'Implementation-Version': project.version,
                   'Permissions': 'all-permissions',
                   'OmegaT-Plugins': omtPlugins.plugin,
                   'OmegaT-Plugin': 'true',
                   'Main-Class': mainClassName,
                   'Class-Path': configurations.runtimeClasspath.collect { "lib/${it.name}" }.join(' '))
        omtPlugins.each { key, val ->
            if (key != 'plugin') {
                val.tokenize().each { cls ->
                    attributes('OmegaT-Plugin': key, cls)
                }
            }
        }
    }
    // Don't include extra stuff like version number in JAR name
    archiveFileName = "${archiveBaseName.get()}.${archiveExtension.get()}"
}

ext {
    distsDir = file("${buildDir}/${distsDirName}")

    assetDir = findProperty('assetDir') ?: '../'

    macJRE = fileTree(dir: assetDir, include: '*-jre_x64_mac_*.tar.gz')

    linux64JRE = fileTree(dir: assetDir, include: '*-jre_x64_linux_*.tar.gz')

    windowsJRE = fileTree(dir: assetDir, include: '*-jre_x86-32_windows_*.zip')
    windowsJRE64 = fileTree(dir: assetDir, include: '*-jre_x64_windows_*.zip')
}

task genDocIndex(type: Copy) {
    description = 'Generate the docs index file'
    def docPropsFiles = fileTree(dir: 'docs', include: '*/version*.properties').findAll {
        file("${it.parent}/index.html").file
    }
    inputs.files docPropsFiles
    from('doc_src') {
        include 'index_template.html'
    }
    into 'docs'
    rename('index_template.html', 'index.html')
    doFirst {
        def langNameExceptions = loadProperties(file('doc_src/lang_exceptions.properties'))
        def langInfos = docPropsFiles.collect { props ->
            def code = props.parentFile.name
            def locale = Locale.forLanguageTag(code.replace('_', '-'))
            def name = langNameExceptions[code] ?: locale.getDisplayName(locale)
            def docVersion = loadProperties(props).version
            def status = docVersion == omtVersion.version ? 'up-to-date' : 'out-of-date'
            ['code': code, 'name': name, 'version': docVersion, 'status': status]
        }.sort { it.code }
        expand('languages': langInfos)
        filteringCharset = 'UTF-8'
    }
}

task webManual(type: Sync) {
    description = 'Generate the HTML manual'
    dependsOn genDocIndex
    destinationDir = file("${buildDir}/docs/manual")
    from 'docs'
    from('release') {
        include 'doc-license.txt'
    }
}

distributions {
    main {
        contents {
            from('docs') {
                into 'docs'
                exclude 'index.html'
            }
            from(genDocIndex.outputs) {
                into 'docs'
                include 'index.html'
            }
            from('release') {
                into 'docs'
                include 'changes.txt', 'doc-license.txt', 'OmegaT-license.txt', 'contributors.txt'
                filter(FixCrLfFilter, eol: FixCrLfFilter.CrLf.newInstance('crlf'))
            }
            from('scripts') {
                into 'scripts'
            }
            from('images') {
                into 'images'
            }
            from('release') {
                include '*.txt', '*.html'
                filter(ReplaceTokens, tokens: [TRANSLATION_NOTICE: ''])
                filter(FixCrLfFilter, eol: FixCrLfFilter.CrLf.newInstance('crlf'))
            }
            from('release/plugins-specific') {
                into 'plugins'
            }
            from('release/linux-specific') {
                filter(ReplaceTokens, tokens:
                    [VERSION_NUMBER_SUBST: project.version,
                     JAR_SUBST: jar.archiveName])
                fileMode 0755
            }
            from('release/win32-specific') {
                include 'OmegaT.bat'
                filter(ReplaceTokens, tokens: [JAR_SUBST: jar.archiveName])
            }
            from('lib/licenses') {
                into 'lib'
            }
            eachFile {
                // Move main JAR up one level from lib.
                if (it.name == jar.archiveName) {
                    it.relativePath = it.relativePath.parent.parent.append(true, jar.archiveName)
                }
            }
        }
        distZip.archiveFileName = "${applicationName}_${version}${omtVersion.beta}_Without_JRE.zip"
    }

    source {
        contents {
            from(rootDir) {
                include 'config/**', 'docs/**', 'images/**', 'lib/**', 'release/**',
                    'src/**', 'test/**', 'doc_src/**', 'docs_devel/**', 'scripts/**',
                    'gradle/**', 'gradlew*', '*.gradle', 'README.md', '*.properties'
                exclude '**/build/**', 'doc_src/**/pdf/**', 'local.properties'
            }
            into('lib/provided') {
                from configurations.runtimeClasspath
            }
        }
        sourceDistZip.archiveFileName = "${applicationName}_${version}${omtVersion.beta}_Source.zip"
    }

    mac {
        contents {
            from('release/mac-specific') {
                exclude '**/MacOS/OmegaT', '**/Info.plist', '**/java.entitlements'
            }
            from('release/mac-specific') {
                include '**/MacOS/OmegaT'
                fileMode 0755
            }
            from('release/mac-specific') {
                include '**/Info.plist'
                expand(version: project.version,
                       // $APP_ROOT is expanded at runtime by the launcher binary
                       configfile: '$APP_ROOT/Contents/Resources/Configuration.properties')
            }
            into('OmegaT.app/Contents/Java') {
                with main.contents
                exclude '*.sh', '*.kaptn', 'OmegaT', 'OmegaT.bat'
            }
            if (!macJRE.empty) {
                from(tarTree(macJRE.singleFile)) {
                    into 'OmegaT.app/Contents/PlugIns'
                    includeEmptyDirs = false
                    eachFile {
                        replaceRelativePathSegment(it, /jdk.*-jre/, 'jre.bundle')
                    }
                }
            }
        }
    }

    linux64 {
        contents {
            with main.contents
            exclude 'OmegaT.bat'
            if (!linux64JRE.empty) {
                from(tarTree(linux64JRE.singleFile)) {
                    includeEmptyDirs = false
                    eachFile {
                        replaceRelativePathSegment(it, /jdk.*-jre/, 'jre')
                    }
                }
            }
        }
    }

    l10nMinimal {
        contents {
            from 'release/l10n-project'
            from('doc_src') {
                include 'en/InstantStartGuide.xml',
                    'en/images/InstantGuide_1.png',
                    'en/images/InstantGuide_2.png'
                into 'source/doc_src'
            }
            from('src') {
                include 'org/omegat/Bundle.properties'
                into 'source/src'
            }
            from('release') {
                include 'win32-specific/CustomMessages.ini'
                into 'source/release'
            }
            from('scripts') {
                include 'properties/check_rules.properties',
                    'properties/spellcheck.properties',
                    'properties/svn_cleanup_selected.properties',
                    'properties/search_replace.properties',
                    'properties/replace_strip_tags.properties',
                    'properties/strip_bidi_marks.properties',
                    'properties/nbsp.properties',
                    'extract_text_content.properties'
                into 'source/scripts'
            }
            from('release') {
                include 'mac-specific/OmegaT.app/Contents/Resources/en.lproj/Localizable.strings'
                into 'source/release'
            }
            from('release') {
                include 'readme.txt'
                into 'source'
                filter(ReplaceTokens, tokens: [TRANSLATION_NOTICE: 'This translation is the work of [insert your name], copyright\u00a9 [insert year].'])
                filter(FixCrLfFilter,  eol: FixCrLfFilter.CrLf.newInstance('crlf'))
                rename '.txt$', '.utf8'
                filteringCharset = 'UTF-8'
            }
        }
        l10nMinimalDistZip.archiveFileName = "${applicationName}_${project.version}${omtVersion.beta}_L10N_Minimal.zip"
    }

    l10nFull {
        contents {
            with l10nMinimal.contents
            from('doc_src') {
                include 'en/**'
                exclude 'en/html/**', 'en/pdf/**'
                into 'source/doc_src'
            }
        }
        l10nFullDistZip.archiveFileName = "${applicationName}_${version}${omtVersion.beta}_L10N_Full.zip"
    }
}

installMacDist {
    doFirst {
        delete "$destinationDir/OmegaT.app/Contents/PlugIns/jre.bundle"
    }
}

def hunspellJar = configurations.runtimeClasspath.files.find {
    it.name.startsWith('hunspell-native-libs')
}

task hunspellJarSignedContents(type: Sync) {
    onlyIf {
        // Set this in e.g. local.properties
        condition(project.hasProperty('macCodesignIdentity'), 'Code signing property not set')
    }
    from zipTree(hunspellJar)
    destinationDir = file("$buildDir/hunspell")
    doLast {
        def jnilibs = fileTree(dir: destinationDir, include: '**/*.jnilib').files
        exec {
            commandLine('codesign', '--deep', '--force',
                        '--sign', project.property('macCodesignIdentity'),
                        '--timestamp',
                        '--options', 'runtime',
                        '--entitlements', file('release/mac-specific/java.entitlements'),
                        *jnilibs.toList())
        }
    }
}

task hunspellSignedJar(type: Jar) {
    from hunspellJarSignedContents.outputs
    archiveFileName = hunspellJar.name
}

task installMacSignedDist(type: Sync) {
    description = 'Build the signed Mac distribution. Requires an Apple Developer Account.'
    onlyIf {
        // Set this in e.g. local.properties
        condition(project.hasProperty('macCodesignIdentity'), 'Code signing property not set')
    }
    with distributions.mac.contents
    duplicatesStrategy = DuplicatesStrategy.INCLUDE
    from(hunspellSignedJar.outputs) {
        into 'OmegaT.app/Contents/Java/lib'
    }
    destinationDir = file("${buildDir}/install/${applicationName}-macSigned")
    doFirst {
        delete "$destinationDir/OmegaT.app/Contents/PlugIns/jre.bundle"
    }
    doLast {
        exec {
            commandLine 'codesign', '--deep', '--force',
                '--sign', project.property('macCodesignIdentity'),
                '--timestamp',
                '--options', 'runtime',
                '--entitlements', file('release/mac-specific/java.entitlements'),
                file("${destinationDir}/OmegaT.app")
        }
    }
}

macDistZip {
    onlyIf {
        condition(!macJRE.empty, 'JRE not found')
    }
    archiveFileName = "${applicationName}_${project.version}${omtVersion.beta}_Mac.zip"
}

task macSignedDistZip(type: Zip) {
    def zipRoot = "${applicationName}_${project.version}${omtVersion.beta}_Mac_Signed"
    from(installMacSignedDist.outputs) {
        into zipRoot
    }
    archiveFileName = "${zipRoot}.zip"
}

task macNotarize {
    onlyIf {
        condition(project.hasProperty('macNotarizationUsername'),
                  'Username for notarization not set')
    }
    inputs.files macSignedDistZip.outputs.files
    doLast {
        exec {
            // Assuming setup per instructions at
            // https://developer.apple.com/documentation/security/notarizing_your_app_before_distribution/customizing_the_notarization_workflow#3087734
            commandLine 'xcrun', 'altool', '--notarize-app',
                '--primary-bundle-id', "org.omegat.$version",
                '--username', project.property('macNotarizationUsername'),
                '--password', '@keychain:AC_PASSWORD',
                '--file', inputs.files.singleFile
        }
    }
}

task macStapledNotarizedDistZip(type: Zip) {
    def zipRoot = "${applicationName}_${project.version}${omtVersion.beta}_Mac_Notarized"
    from(installMacSignedDist.outputs) {
        into zipRoot
    }
    doFirst {
        def app = "${installMacSignedDist.destinationDir}/OmegaT.app"
        exec {
            commandLine 'xcrun', 'stapler', 'staple', app
        }
    }
    archiveFileName = "${zipRoot}.zip"
}

task mac(dependsOn: [macDistZip, macNotarize]) {
    description = 'Build the Mac distributions.'
}

task linux(dependsOn: [linux64DistTar]) {
    description = 'Build the Linux distributions.'
}

linux64DistTar {
    onlyIf {
        condition(!linux64JRE.empty, 'JRE not found')
    }
    doFirst {
        delete "$destinationDirectory/jre"
    }
    archiveFileName = "${applicationName}_${project.version}${omtVersion.beta}_Linux_64.tar.bz2"
    compression = Compression.BZIP2
    archiveExtension = 'tar.bz2'
}

task l10n(dependsOn: [l10nMinimalDistZip, l10nFullDistZip]) {
    description = 'Build the L10N distributions.'
}

// We bundle our startup scripts separately, so disable startScripts.
startScripts.enabled = false

// installDist insists on installing a script. Trick it with a dummy script.
installDist.doFirst {
    startScripts.outputDir.mkdirs()
    file("${startScripts.outputDir}/${applicationName}").createNewFile()
    if (destinationDir.directory) {
        // As of Gradle 4.4(?) the application plugin expects `lib` as well
        ['lib', 'bin'].each { file("${destinationDir}/${it}").mkdirs() }
    }
}
// Delete dummy afterwards.
installDist.doLast {
    delete "${destinationDir}/bin"
    delete startScripts.outputDir
}

// Read in all our custom messages and massage them for inclusion in the .iss
ext.getInnoSetupCustomMessages = {
    // Don't include languages that InnoSetup doesn't have strings for
    def blacklist = ['cy', 'ia', 'mfe']
    // Sort files to ensure English comes first, to set fallback
    fileTree(dir: 'release/win32-specific', include: 'CustomMessages*.ini')
        .sort()
        .collect { file ->
            def match = file.name =~ /CustomMessages_?([^\.]*).ini/
            if (match) {
                def capture = match.group(1)
                def lang = capture.empty ? 'en' : capture
                if (!blacklist.contains(lang)) {
                    file.text.replaceAll(/(?m)^([^=]+)/) { "$lang.${it[0]}" }
                }
            }
        }.findAll()
        .join(System.lineSeparator())
}

task win {
    description = 'Build the Windows distributions.'
}

ext.makeWinTask = { args ->
    def fullVersion = project.version + omtVersion.beta
    def installerBasename = "OmegaT_${fullVersion}_${args.suffix}"
    def installerExe = "${distsDir}/${installerBasename}.exe"
    task(type: Sync, args.name) {
        description = "Create a Windows installer for ${args.name} distro. " +
            'Requires Inno Setup (http://www.jrsoftware.org/isinfo.php).'
        with distributions.main.contents
        from ('release/win32-specific') {
            include 'OmegaT.exe', 'OmegaT.l4J.ini'
        }
        if (args.jrePath && !args.jrePath.empty) {
            from (zipTree(args.jrePath.singleFile)) {
                includeEmptyDirs = false
                eachFile {
                    replaceRelativePathSegment(it, /jdk.*-jre/, 'jre')
                }
            }
        }
        destinationDir = file("${buildDir}/innosetup/${args.name}")
        outputs.file installerExe
        onlyIf {
            conditions([!args.jrePath || !args.jrePath.empty, 'JRE not found'],
                       [exePresent('iscc') || exePresent('docker'),
                        'InnoSetup or Docker not installed'])
        }
        doFirst {
            delete "$destinationDir/jre"
        }
        doLast {
            project.copy {
                from('release/win32-specific') {
                    include 'OmegaT.iss'
                }
                into(destinationDir)
                filter(ReplaceTokens, tokens: [
                    VERSION_NUMBER_SUBST: fullVersion,
                    OUTPUT_BASENAME_SUBST: installerBasename.toString(),
                    CUSTOM_MESSAGES_SUBST: getInnoSetupCustomMessages(),
                    ARCHITECTURE_SUBST: args.arch ?: ''
                ])
                filter(FixCrLfFilter,  eol: FixCrLfFilter.CrLf.newInstance('crlf'))
                filteringCharset = 'UTF-8'
            }
            exec {
                // You'd think we could just set the PATH, but there be dragons here
                // https://github.com/palantir/gradle-docker/issues/162
                def exe = exePresent('iscc') ?  'iscc' : file('release/ci/iscc')
                commandLine exe, "${destinationDir}/OmegaT.iss"
            }
            ant.move file: "${destinationDir}/${installerBasename}.exe",
                todir: distsDir
        }
    }
    def signedTaskName = "${args.name}Signed"
    task(signedTaskName) {
        onlyIf {
            // Set these in e.g. local.properties
            def props = ['winCodesignFile', 'winCodesignPassword', 'winCodesignTimestampUrl']
            conditions([props.every { project.hasProperty(it) }, 'Code signing properties not set'],
                       [file(installerExe).file, 'Unsigned installer not built'],
                       [exePresent('osslsigncode') || exePresent('docker'),
                        'osslsigncode or Docker not installed'])
        }
        def signedExe = "${distsDir}/${installerBasename}_Signed.exe"
        inputs.file installerExe
        outputs.file signedExe
        doLast {
            exec {
                // You'd think we could just set the PATH, but there be dragons here
                // https://github.com/palantir/gradle-docker/issues/162
                def exe = exePresent('osslsigncode') ? 'osslsigncode' : file('release/ci/osslsigncode')
                commandLine exe, 'sign',
                    '-pkcs12', project.property('winCodesignFile'),
                    '-pass', project.property('winCodesignPassword'),
                    '-n', applicationName,
                    '-i', omtWebsite,
                    '-t', project.property('winCodesignTimestampUrl'),
                    '-h', 'sha2',
                    '-in', installerExe,
                    '-out', signedExe
            }
        }
        dependsOn args.name
    }
    assemble.dependsOn args.name, signedTaskName
    win.dependsOn args.name, signedTaskName
}
makeWinTask(name: 'winNoJRE', suffix: 'Windows_without_JRE')
makeWinTask(name: 'winJRE', suffix: 'Windows', jrePath: windowsJRE)
makeWinTask(name: 'winJRE64', suffix: 'Windows_64', jrePath: windowsJRE64, arch: 'x64')

// Disable .tar distributions for everyone but Linux
tasks.findAll { it.name =~ /[dD]istTar$/ && !it.name.contains('linux') }.each { it.enabled = false }
// Disable .zip distributions for Linux
tasks.findAll { it.name =~ /[dD]istZip$/ && it.name.contains('linux') }.each { it.enabled = false }

jnlp {
    href "${applicationName}.jnlp"
    codebase findProperty('jwsCodebase')
    withXml {
        information {
            title applicationName
            vendor "${applicationName} Development Team"
            homepage href: omtWebsite
            shortcut(online: false) {
                desktop()
                menu submenu: "${applicationName} from WebStart"
            }
        }
        'offline-allowed'()
        association 'mime-type': 'application/x-omegat-project', extensions: 'project'
        security {
            'all-permissions'()
        }
        resources {
            property name: 'javaws.cfg.jauthenticator', value: true
        }
    }
    signJarAddedManifestEntries = [
        'Codebase': findProperty('jwsCodebase'),
        'Permissions': 'all-permissions',
        'Application-Name': applicationName
    ]
    signJarParams = ['keystore', 'storetype', 'alias', 'storepass', 'keypass', 'tsaurl'].collectEntries {
        [it, findProperty("jws${it.capitalize()}")]
    }
}

[webstartDistZip, signJars, generateJnlp].each { task ->
    task.configure {
        def requiredProps = ['jwsCodebase', 'jwsKeystore', 'jwsAlias']
        onlyIf {
            condition(requiredProps.every { project.hasProperty(it) },
                      'Java Web Start properties not set')
        }
        requiredProps.each {
            inputs.property it, findProperty(it)
        }
    }
}

processResources {
    def revision = detectRevision()
    inputs.property 'revision', revision
    doLast {
        logger.lifecycle("Detected revision ${revision}")
        def versionFile = file("${sourceSets.main.output.resourcesDir}/org/omegat/Version.properties")
        ant.propertyfile(file: versionFile) {
            entry(key: 'revision', value: revision)
        }
    }
}

task checksums {
    def algos = ['SHA-512', 'MD5']
    description = "Generate ${algos.join(', ')} checksums for distribution files"
    inputs.files fileTree(dir: distsDir, exclude: 'checksums')
    def checksumsDir = file("${distsDir}/checksums")
    outputs.dir checksumsDir
    onlyIf {
        condition(distsDir.directory, 'Distfiles not found')
    }
    doLast {
        distsDir.listFiles().findAll { it.file }.each { f ->
            algos.each { algo ->
                ant.checksum file: f, algorithm: algo, todir: checksumsDir
            }
        }
    }
}

task genJAXB {
    description = 'Generate classes for loading and manipulating XML formats'
}

ext.makeJaxbTask = { args ->
    def taskName = "gen${args.name.capitalize()}"
    task(type: JavaExec, taskName) {
        classpath = configurations.jaxb
        mainClass = 'com.sun.tools.xjc.XJCFacade'
        delegate.args args.args
        outputs.dir args.outdir
    }
    genJAXB.dependsOn taskName
}

makeJaxbTask(name: 'segmentation', outdir: 'src/gen/core/segmentation',
             args: ['-no-header', '-d', 'src', '-p', 'gen.core.segmentation', 'src/schemas/srx20.xsd'])
makeJaxbTask(name: 'filters', outdir: 'src/gen/core/filters',
             args: ['-no-header', '-d', 'src', '-p', 'gen.core.filters', 'src/schemas/filters.xsd'])
makeJaxbTask(name: 'tbx', outdir: 'src/gen/core/tbx',
             args: ['-no-header', '-d', 'src', '-p', 'gen.core.tbx', 'src/schemas/tbx.xsd'])
makeJaxbTask(name: 'project', outdir: 'src/gen/core/project',
             args: ['-no-header', '-d', 'src', '-p', 'gen.core.project', 'src/schemas/project_properties.xsd'])
makeJaxbTask(name: 'tmx14', outdir: 'src/gen/core/tmx14',
             args: ['-no-header', '-d', 'src', '-p', 'gen.core.tmx14', '-b', 'src/schemas/tmx14.xjb', 'src/schemas/tmx14.xsd'])
makeJaxbTask(name: 'taas', outdir: 'src/gen/taas',
             args: ['-no-header', '-d', 'src', '-p', 'gen.taas', '-b', 'src/schemas/taas.xjb', 'src/schemas/taas.xsd'])

task genMac {
    description = 'Generate the Mac .app skeleton. Requires AppBundler (https://bitbucket.org/infinitekind/appbundler) ' +
        'to be available in ~/.ant/lib'
    outputs.dir file('release/mac-specific')
    def appbundlerJar = file("${System.getProperty('user.home')}/.ant/lib/appbundler-1.0ea.jar")
    onlyIf {
        condition(appbundlerJar.file, 'AppBundler not found')
    }
    doLast {
        ant.taskdef(name: 'appbundler',
                    classname: 'com.oracle.appbundler.AppBundlerTask',
                    classpath: appbundlerJar)
        ant.appbundler(outputdirectory: 'release/mac-specific',
                       name: applicationName,
                       displayname: applicationName,
                       executablename: applicationName,
                       identifier: 'org.omegat.OmegaT',
                       icon: 'images/OmegaT.icns',
                       version: '${version}',
                       jvmrequired: javaVersion,
                       shortversion: '${version}',
                       mainclassname: mainClassName) {
            option(value: "-Xdock:name=${applicationName}")
            argument(value: '--config-file=${configfile}')
            bundledocument(extensions: 'project',
                           name: "${applicationName} Project",
                           role: 'editor',
                           icon: 'images/OmegaT.icns')
            bundledocument(extensions: '*',
                           name: 'All Files',
                           role: 'none')
            plistentry(key: 'JVMRuntime', value: 'jre.bundle')
        }
    }
}

allprojects {
    javadoc {
        failOnError = false
    }
    tasks.withType(JavaCompile) {
       options.compilerArgs.addAll '-Xlint', '-Werror'
    }
}

spotbugs {
    reportLevel = 'high'
}

tasks.findAll { it.name =~ /^spotbugs.*/ }.each {
    it.reports {
        xml.enabled = envIsCi
        html.enabled = !envIsCi
    }
}

checkstyle {
    toolVersion = '8.8'
}
checkstyleMain.exclude '**/gen/**'

spotless {
    enforceCheck false
    java {
        targetExclude 'src/gen/**'
        eclipse().configFile 'docs_devel/eclipse-formatting.xml'
        removeUnusedImports()
    }
}

task changedOnBranch {
    description = 'List files that have been modified on this git branch.'
    doLast {
        ext.files = project.files(gitModifiedFiles())
        ext.files.each { println(it) }
    }
}

task spotlessChangedApply {
    description = 'Apply code formatting to files that have been changed on the current branch.'
    finalizedBy 'spotlessApply'
    dependsOn changedOnBranch
    doFirst {
        spotlessJava.target = changedOnBranch.files.findAll {
            it.path.endsWith('.java')
        }
    }
}

jacoco {
    toolVersion="0.8.6"
}

tasks.jacocoTestReport {
    dependsOn(tasks.test) // tests are required to run before generating the report
    reports {
        xml.required = true  // coveralls plugin depends on xml format report
        html.required = true
    }
}

task manualPdfs {
    description = 'Build PDF manuals for all languages. Requires Docker.'
}

task manualHtmls {
    description = 'Build HTML manuals for all languages. Requires Docker.'
}

ext.manualIndexXmls = fileTree(dir: 'doc_src', include: '**/OmegaTUsersManual_xinclude full.xml')
manualIndexXmls.each { xml ->
    def lang = xml.parentFile.name
    def pdfTaskName = "manualPdf${lang.capitalize()}"
    task(pdfTaskName) {
        inputs.files fileTree(dir: "doc_src/${lang}", include: '**/*.xml')
        outputs.file "${distsDir}/OmegaT_documentation_${lang}.PDF"
        doLast {
            exec {
                workingDir = 'doc_src'
                commandLine './docgen', "-Dlanguage=${lang}", 'pdf'
            }
            copy {
                from fileTree(dir: "doc_src/${lang}/pdf", include: '*.PDF')
                into distsDir
            }
            delete fileTree(dir: "doc_src/${lang}", includes: ['pdf/*', 'index.xml'])
        }
    }
    manualPdfs.dependsOn pdfTaskName

    def htmlTaskName = "manualHtml${lang.capitalize()}"
    task(htmlTaskName) {
        inputs.files fileTree(dir: "doc_src/${lang}", include: '**/*.xml')
        doLast {
            exec {
                workingDir = 'doc_src'
                commandLine './docgen', "-Dlanguage=${lang}", 'html5'
            }
            delete fileTree(dir: "doc_src/${lang}", includes: ['xhtml5/**/*', 'index.xml'])
        }
    }
    manualHtmls.dependsOn htmlTaskName
}

task instantStartGuides {
    description = 'Build Instant Start guides for all languages. Requires Docker.'
}

task updateManuals {
    description = 'Update Instant Start guides and HTML manuals.'
    dependsOn manualHtmls, instantStartGuides
    finalizedBy genDocIndex
}

ext.instantStartXmls = fileTree(dir: 'doc_src', include: '**/InstantStartGuide.xml')
instantStartXmls.each { xml ->
    def lang = xml.parentFile.name
    def taskName = "instantStartGuide${lang.capitalize()}"
    task(taskName) {
        inputs.files fileTree(dir: "doc_src/${lang}", include: '**/*.xml')
        doLast {
            exec {
                workingDir = 'doc_src'
                commandLine './docgen', "-Dlanguage=${lang}", 'instant-start'
            }
        }
    }
    instantStartGuides.dependsOn taskName
}

task debug(type: JavaExec) {
    description = 'Launch app for debugging.' // Special debug task for NetBeans
    mainClass = mainClassName
    classpath = sourceSets.main.runtimeClasspath
    debug true
}

// E.g. when doing `build`, run checks before making distfiles
assemble.mustRunAfter check

test {
    // Test in headless mode with ./gradlew test -Pheadless
    if (project.hasProperty('headless')) {
        systemProperty 'java.awt.headless', 'true'
    }
}

task testIntegration(type: JavaExec) {
    description = 'Run integration tests. Pass repo URL as -Domegat.test.repo=<repo>'
    mainClass = 'org.omegat.core.data.TestTeamIntegration'
    classpath = sourceSets.testIntegration.runtimeClasspath
    systemProperties = System.properties
}

task sourceJar(type: Jar) {
    from sourceSets.main.allJava
    classifier = 'sources'
}

task javadocJar(type: Jar) {
    from javadoc.outputs
    classifier = 'javadoc'
}

ext.mavenStyleVersion = version.replace('_', '-')

publishing {
    publications {
        mavenJava(MavenPublication) { publication ->
            groupId = 'org.omegat'
            artifactId = 'omegat'
            version = mavenStyleVersion
            artifact sourceJar
            artifact javadocJar

            from components.java

            pom {
                name = 'OmegaT'
                description = 'The free translation memory tool'
                url = 'https://omegat.org'
                scm {
                    connection = "scm:git:https://git.code.sf.net/p/omegat/code"
                    developerConnection = "scm:git:https://git.code.sf.net/p/omegat/code"
                    url = "https://sourceforge.net/p/omegat/code/"
                }
                licenses {
                    license {
                        name = 'The GNU General Public License, Version 3.0'
                        url = 'https://www.gnu.org/licenses/licenses/gpl-3.0.html'
                    }
                }
                developers {
                    developer {
                        id = 'omegat'
                        name = 'OmegaT Developers'
                        email = 'info@omegat.org'
                    }
                }
            }
        }
    }
    repositories {
        maven {
            url = 'https://s01.oss.sonatype.org/service/local/staging/deploy/maven2/'
            credentials(PasswordCredentials) {
                username findProperty('ossrhUsername')
                password findProperty('ossrhPassword')
            }
        }
    }
}

signing {
    sign publishing.publications.mavenJava
    if (!findProperty("signing.keyId")) {
        useGpgCmd()
    }
}

remotes {
    sourceforgeWeb {
        host = 'web.sourceforge.net'
        user = findProperty('sourceforgeWebUser')
        password = findProperty('sourceforgeWebPassword')
        agent = true
    }
}

ext.htdocs = '/home/project-web/omegat/htdocs'

ext.publishAtomically = { args ->
    task("publish${args.name.capitalize()}") {
        description = "Copy ${args.name} to SourceForge web."
        dependsOn args.sourceTask
        doLast {
            ssh.run {
                session(remotes.sourceforgeWeb) {
                    def timestamp = new Date().format('yyyyMMddHHmmss')
                    def targetDir = args.targetDir ?: "${args.name}-${omtFlavor}"
                    def tempDir = "${targetDir}-temp-${timestamp}"
                    sftp {
                        cd htdocs
                        mkdir tempDir
                    }
                    put from: args.sourceTask.outputs.files, into: "${htdocs}/${tempDir}"
                    sftp {
                        cd htdocs
                        try { rename targetDir, "${targetDir}-old-${timestamp}" }
                        catch (ignored) {}
                        rename "${tempDir}/${args.sourceTask.destinationDir.name}", targetDir
                        rmdir tempDir
                    }
                }
            }
        }
    }
}

publishAtomically(name: 'manual', sourceTask: webManual)
publishAtomically(name: 'javadoc', sourceTask: javadoc)

ext {
    codebasePattern = /^https:\/\/omegat\.sourceforge\.io\/([^\/]+)\/$/
    def matcher = findProperty('jwsCodebase') =~ codebasePattern
    jwsTargetDir = matcher ? matcher[0][1] : null
}
if (jwsTargetDir) {
    publishAtomically(name: camelCase(jwsTargetDir),
                      sourceTask: installWebstartDist,
                      targetDir: jwsTargetDir)
}

task publishVersion {
    description = 'Update the version considered current by the version check.'
    doLast {
        ssh.run {
            session(remotes.sourceforgeWeb) {
                def target = "${htdocs}/Version-${omtFlavor}.properties"
                put from: file('src/org/omegat/Version.properties'), into: target
            }
        }
    }
}

// Allow setting the max heap size for the run task from the command line, e.g.
// `gradle -PrunMaxHeapSize=1024M run`
run.maxHeapSize = findProperty('runMaxHeapSize')