build.gradle

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

plugins {
    id 'de.gliderpilot.jnlp' version '1.1.0'
    id 'com.jfrog.bintray' version '1.7.3'
}

apply plugin: 'application'
apply plugin: 'maven-publish'
apply plugin: 'eclipse'
apply plugin: 'de.gliderpilot.jnlp'


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

def javaVersion = '1.8'

sourceCompatibility = javaVersion
targetCompatibility = javaVersion

def omtVersion = loadProperties file('src/org/omegat/Version.properties')
version = omtVersion.version + getUpdateSuffix(omtVersion.update)

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

repositories {
    jcenter()
    maven {
        url 'http://dl.bintray.com/omegat-org/maven'
    }
}

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'
}

def depsProvided = file('lib/provided').directory
def languageToolVersion = '3.5'
def luceneVersion = '5.2.1'

dependencies {
    if (!depsProvided) {
        compile 'commons-io:commons-io:2.5'
        compile 'commons-lang:commons-lang:2.6'
        compile 'org.slf4j:slf4j-jdk14:1.7.22'

        // PDF Filter
        compile 'org.apache.pdfbox:pdfbox:2.0.4'

        // Aligner
        compile 'net.loomchild:maligna:3.0.0'

        // Dictionary
        compile 'org.dict.zip:dictzip-lib:0.8.2'
        compile 'com.github.takawitter:trie4j:0.9.5'

        // Legacy projects re-hosted on GitHub + Bintray
        compile 'org.omegat:vldocking:3.0.5'
        compile 'org.omegat:juniversalchardet:1.0.4'
        compile 'org.omegat:htmlparser:1.5'
        compile 'org.omegat:gnudiff4j:1.15'
        compile 'org.omegat:lib-mnemonics:1.0'
        compile 'org.omegat:jmyspell-core:1.0.0-beta-2'

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

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

        // Team project server support
        compile 'org.eclipse.jgit:org.eclipse.jgit:4.2.0.201601211800-r'
        compile '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.
        compile 'com.jcraft:jsch.agentproxy.connector-factory:0.0.9'
        compile 'com.jcraft:jsch.agentproxy.svnkit-trilead-ssh2:0.0.9'
        compile 'org.tmatesoft.svnkit:svnkit:1.8.12'

        // Team project conflict resolution
        compile 'org.madlonkay.supertmxmerge:supertmxmerge:2.0.1'

        // Credentials encryption
        compile 'org.jasypt:jasypt:1.9.2'

        // Groovy used for (runtime) scripts, tests only
        runtime 'org.codehaus.groovy:groovy-all:2.4.7'

        // Script editor
        compile 'com.fifesoft:rsyntaxtextarea:2.5.8'
        compile 'com.fifesoft:rstaui:2.5.7'
        compile ('com.fifesoft:languagesupport:2.5.8') {
            exclude module: 'rhino'
        }
        compile 'com.fifesoft:autocomplete:2.5.8'
    }

    compile fileTree(dir: 'lib', include: '**/*.jar')

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

    // WebStart-only
    jnlp project(path: ':release:WebStart-specific', configuration: 'docs')

    testIntegrationCompile sourceSets.main.output, sourceSets.test.output, configurations.compile
}

jar {
    // Set manifest entries at execution time because accessing configurations.runtime as an
    // instance forces configuration blocks to be evaluated and this causes problems like
    // introducing ordering dependencies on various definitions in this file.
    doFirst {
        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.runtime.collect { "lib/${it.name}" }.join(' '))
            omtPlugins.keys().each { key ->
                if (key != 'plugin') {
                    omtPlugins[key].tokenize().each { cls ->
                        attributes('OmegaT-Plugin': key, cls)
                    }
                }
            }
        }
    }
    // Don't include extra stuff like version number in JAR name
    archiveName = "${jar.baseName}.${jar.extension}"
}

def assetDir = System.getProperty('asset.dir', '../')

def macExecutable = file("${assetDir}/JavaAppLauncher")
def macJRE = file("${assetDir}/jre-mac-root")
def macDistEnabled = macExecutable.file && macJRE.directory

def linuxJRE = file("${assetDir}/jre-linux")
def linux64JRE = file("${assetDir}/jre-linux-64")

def windowsJRE = file("${assetDir}/jre")
def windowsJRE64 = file("${assetDir}/jre-64")

distributions {
    main {
        contents {
            from('docs') {
                into 'docs'
            }
            from('release') {
                into 'docs'
                include 'changes.txt', 'doc-license.txt', 'OmegaT-license.txt', 'contributors.txt'
            }
            from('scripts') {
                into 'scripts'
            }
            from('images') {
                into 'images'
            }
            from('release') {
                include '*.txt', '*.html'
                exclude 'readme.txt'
            }
            from('release') {
                include 'readme.txt'
                expand(translationNotice: '')
            }
            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.archiveName = "${applicationName}_${version}${omtVersion.beta}_Without_JRE.zip"
    }

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

    if (macDistEnabled) {
        mac {
            contents {
                from('release/mac-specific') {
                    include '**/Info.plist'
                    expand(version: project.version,
                        configfile: '$APP_ROOT/Contents/Resources/Configuration.properties')
                }
                from('release/mac-specific') {
                    exclude '**/Info.plist'
                }
                into('OmegaT.app/Contents/Java') {
                    with main.contents
                    exclude '*.sh', '*.kaptn', 'OmegaT', 'OmegaT.bat'
                }
                from(macExecutable) {
                    into 'OmegaT.app/Contents/MacOS'
                    fileMode 0755
                }
                from(macJRE) {
                    into 'OmegaT.app/Contents/PlugIns/jre.bundle'
                    fileMode 0755
                }
            }
            macDistZip.archiveName = "${applicationName}_${version}${omtVersion.beta}_Mac.zip"
        }
    }

    [linux: linuxJRE, linux64: linux64JRE].each { distName, jrePath ->
        create(distName) {
            contents {
                with main.contents
                exclude 'OmegaT.bat'
                from(jrePath) {
                    into 'jre'
                    fileMode 0755
                }
            }
        }
    }

    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'
                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'
                expand(translationNotice: 'This translation is the work of [insert your name], copyright© [insert year].')
                rename '.txt$', '.utf8'
            }
        }
        l10nMinimalDistZip.archiveName = "${applicationName}_${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.archiveName = "${applicationName}_${version}${omtVersion.beta}_L10N_Full.zip"
    }
}

if (macDistEnabled) {
    task installMacSignedDist(type: Sync) {
        onlyIf {
            // Set this in e.g. gradle.properties
            project.hasProperty('codesignIdentity')
        }
        with distributions.mac.contents
        destinationDir = file("${buildDir}/install/${applicationName}-macSigned")
        doLast {
            exec {
               commandLine 'codesign', '--deep', '-s', project.property('codesignIdentity'), file("${destinationDir}/OmegaT.app")
            }
        }
    }
    
    task macSignedDistZip(type: Zip) {
        from installMacSignedDist.outputs
        archiveName = "${applicationName}_${version}${omtVersion.beta}_Mac_Signed.zip"
    }
    
    task mac(dependsOn: [macDistZip, macSignedDistZip]) {
        description = 'Build the Mac distributions.'
    }
}

task linux(dependsOn: [linuxDistTar, linux64DistTar]) {
    description = 'Build the Linux distributions.'
}
[(linuxDistTar): linuxJRE, (linux64DistTar): linux64JRE].each { task, requirement ->
    task.onlyIf {
        requirement.directory
    }
    def suffix = task.name.contains('64') ? 'Linux_64' : 'Linux'
    task.archiveName = "${applicationName}_${version}${omtVersion.beta}_${suffix}.tar.bz2"
    task.compression = Compression.BZIP2
    task.extension = '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) {
        file("${destinationDir}/bin").mkdirs()
    }
}
// Delete dummy afterwards.
installDist.doLast {
    delete "${destinationDir}/bin"
    delete startScripts.outputDir
}

def haveInnoSetup = {
    try {
        def findIscc = 'where iscc'.execute()
        findIscc.waitForProcessOutput()
        return findIscc.exitValue() == 0
    } catch (any) {
        return false
    }
}

// Read in all our custom messages and massage them for inclusion in the .iss
def getInnoSetupCustomMessages = {
    // Don't include languages that InnoSetup doesn't have strings for
    def blacklist = ['cy', 'ia']
    def iniFiles = fileTree(dir: 'release/win32-specific', include: 'CustomMessages*.ini')
    def result = new StringBuilder()
    iniFiles.each { f ->
        def match = f.name =~ /CustomMessages_?([^\.]*).ini/
        if (match) {
            def lang = match.group(1)
            if (!blacklist.contains(lang)) {
                result << f.text.replaceAll(/(?m)^([^=]+)/) {
                    lang.empty ? it[0] : "${lang}.${it[0]}"
                }
                result << System.lineSeparator()
            }
        }
    }
    return result.toString()
}

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

def makeWinTask = { args ->
    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'
        }
        destinationDir = file("${buildDir}/innosetup/${args.name}")
        def fullVersion = project.version + omtVersion.beta
        def installerBasename = "OmegaT_${fullVersion}_${args.suffix}"
        def hasJRE = args.jrePath != null
        outputs.file "${distsDir}/${installerBasename}.exe"
        onlyIf {
            (!hasJRE || args.jrePath.directory) && haveInnoSetup()
        }
        doLast {
            project.copy {
                from('release/win32-specific') {
                    include 'OmegaT.iss'
                }
                into(destinationDir)
                filter(ReplaceTokens, tokens: [VERSION_NUMBER_SUBST: fullVersion,
                         OUTPUT_DIR_SUBST: distsDir.path,
                         OUTPUT_BASENAME_SUBST: installerBasename.toString(),
                         JRE_COMMENT_SUBST: hasJRE ? '' : ';',
                         JRE_PATH_SUBST: hasJRE ? args.jrePath.path : '',
                         CUSTOM_MESSAGES_SUBST: getInnoSetupCustomMessages(),
                         ARCHITECTURE_SUBST: args.get('arch', '')])
                filteringCharset = 'UTF-8'
            }
            exec {
                commandLine 'iscc', "${destinationDir}/OmegaT.iss"
            }
        }
    }
    assemble.dependsOn args.name
    win.dependsOn args.name
}
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 }

def webstartProps = loadProperties file("${assetDir}/webstart.properties")

jnlp {
    href "${applicationName}.jnlp"
    if (webstartProps.codebase) {
        codebase webstartProps.codebase
    }
    withXml {
        information {
            title applicationName
            vendor "${applicationName} Development Team"
            homepage href: 'http://www.omegat.org'
            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
        }
    }
    if (webstartProps.keystore) {
        signJarAddedManifestEntries = ['Codebase': webstartProps.codebase,
            'Permissions': 'all-permissions',
            'Application-Name': applicationName]
        signJarRemovedManifestEntries = '(?:Trusted-Only|Trusted-Library|.*-Digest)'
        signJarParams = ['keystore', 'alias', 'storepass', 'keypass', 'tsaurl'].collectEntries {
            [(it): webstartProps[it]]
        }.findAll { k, v -> v != null }
    }
}

processResources.doLast {
    /* Set the revision number included in version strings. The value is chosen from the first valid value in:
    1. src/org/omegat/Version.properties (only if not "dev", i.e. this is a source package not under VCS)
    2. This svn checkout's revision
    3. This git clone's SHA-1
    4. If none of the above, the value "unknown"
     */
    def provided = System.getProperty('repo.revision', '')
    def git = file('.git').directory ? doCmd('git rev-parse --short HEAD') : ''
    def svn = file('.svn').directory ? doCmd('svnversion') : ''
    def revision = [provided, omtVersion.revision, git, svn, 'unknown'].find {
        it != 'dev' && !it.empty
    }
    println "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 {
        checksumsDir.directory
    }
    doLast {
        distsDir.listFiles().findAll { it.file }.each { f ->
            algos.each { algo ->
                ant.checksum file: f, algorithm: algo, todir: checksumsDir
            }
        }
    }
}

task genDocIndex(type: JavaExec) {
    description = 'Regenerate the docs index file'
    main = 'util.CreateDocIndexUtil'
    classpath = sourceSets.main.runtimeClasspath
    inputs.files fileTree(dir: 'docs', include: '**/version.properties')
    outputs.file 'docs/index.html'
}
jar.finalizedBy genDocIndex

task genJAXB {
    description = 'Generate classes for loading and manipulating XML formats'
    outputs.dir 'src/gen'
    doLast {
        ['gen.core.segmentation': 'src/schemas/srx20.xsd',
         'gen.core.filters': 'src/schemas/filters.xsd',
         'gen.core.tbx': 'src/schemas/tbx.xsd',
         'gen.core.project': 'src/schemas/project_properties.xsd'].each { pkg, xsd ->
            exec {
                commandLine 'xjc', '-no-header', '-d', 'src', '-p', pkg, xsd
            }
        }
        [[p: 'gen.core.tmx14', b: 'src/schemas/tmx14.xjb', xsd: 'src/schemas/tmx14.xsd'],
            [p: 'gen.taas', b: 'src/schemas/taas.xjb', xsd: 'src/schemas/taas.xsd']].each { cfg ->
            exec {
                commandLine 'xjc', '-no-header', '-d', 'src', '-p', cfg.p, '-b', cfg.b, cfg.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 {
        appbundlerJar.file
    }
    doLast {
        ant.taskdef(name: 'appbundler', classname: 'com.oracle.appbundler.AppBundlerTask',
            classpath: appbundlerJar)
        ant.appbundler(outputdirectory: 'release/mac-specific',
            name: applicationName,
            displayname: 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
    }
}

task jar2(type: Sync) {
    description = 'Create minimal executable output for debugging.'
    destinationDir = file("${buildDir}/install/jar2")
    from jar
    from(configurations.runtime) {
        into 'lib'
    }
    from('scripts') {
        into 'scripts'
    }
}

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

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

task sourceJar(type: Jar) {
    from sourceSets.main.allJava
}

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

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

publishing {
    publications {
        forBintray(MavenPublication) {
            groupId 'org.omegat'
            artifactId 'omegat'
            version mavenStyleVersion
    
            from components.java
            artifact sourceJar {
                classifier 'sources'
            }
            artifact javadocJar {
                classifier 'javadoc'
            }
        }
    }
}

bintray {
    user = findProperty('bintrayUser')
    key = findProperty('bintrayKey')
    pkg {
        repo = 'maven'
        name = 'OmegaT'
        userOrg = 'omegat-org'
        licenses = ['GPL-3.0']
        vcsUrl = 'https://svn.code.sf.net/p/omegat/svn/'
        version {
            name = mavenStyleVersion
        }
    }
    publications = ['forBintray']
}

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

def Properties loadProperties(File propFile) {
    def config = new Properties()
    if (propFile.canRead()) {
        config.load(new FileInputStream(propFile))
    }
    return config
}

def doCmd(String cmd) {
    StringBuilder output = new StringBuilder()
    cmd.execute().waitForProcessOutput(output, null)
    return output.toString().trim()
}

def getUpdateSuffix(String update) {
    if (!update || update == '0') {
        return ''
    }
    if (update.length() == 1) {
        return "_0${update}"
    }
    return "_${update}"
}

eclipse {
    classpath {
        plusConfigurations << configurations.runtime
    }
}