build.gradle

import marytts.modules.phonemiser.AllophoneSet

plugins {
    id 'de.dfki.mary.lexicon-compiler' version '0.3.0'
    id 'maven-publish'
    id 'signing'
}

group 'de.dfki.mary'
version '0.2.0-SNAPSHOT'
description 'US English lexicon for MaryTTS'

ext {
    url = 'https://github.com/marytts/marytts-lexicon-en_US-cmudict'
    isReleaseVersion = !version.endsWith("SNAPSHOT")
}

repositories {
    exclusiveContent {
        forRepositories(
                ivy {
                    url 'http://festvox.org/packed/festival/2.4/'
                    allowInsecureProtocol = true
                    patternLayout {
                        artifact '[module]_[classifier].[ext]'
                    }
                    metadataSources {
                        artifact()
                    }
                },
                ivy {
                    url 'https://www.cstr.ed.ac.uk/downloads/festival/2.4/'
                    patternLayout {
                        artifact '[module]_[classifier].[ext]'
                    }
                    metadataSources {
                        artifact()
                    }
                }
        )
        filter {
            includeModule 'org.festvox', 'festlex'
        }
    }
}

configurations {
    cmudict
}

dependencies {
    cmudict group: 'org.festvox', name: 'festlex', version: '0.4', classifier: 'CMU', ext: 'tar.gz'
}

def unpackCmuDictTask = tasks.register('unpackCmuDict') {
    def config = configurations.named('cmudict')
    ext.destDir = objects.directoryProperty()
            .convention(layout.buildDirectory.dir('cmudict'))

    inputs.property 'config', config
    outputs.dir destDir

    doLast {
        copy {
            into destDir
            from config
            filesMatching '*.tar.gz', { tarDetails ->
                copy {
                    into destDir
                    from tarTree(tarDetails.file)
                    include '**/cmudict-0.4.scm',
                            '**/cmudict_extensions.scm',
                            '**/COPYING'
                    eachFile {
                        it.path = it.name
                    }
                }
                tarDetails.exclude()
            }
        }
    }
}

def allophoneSetFile = objects.fileProperty()
        .convention(layout.projectDirectory.dir('modules/en/us/lexicon').file('allophones.en_US.xml'))

def processCmuDictTask = tasks.register('processCmuDict') {
    def srcDir = objects.directoryProperty()
            .convention(unpackCmuDictTask.get().destDir)
    def mappingFile = objects.fileProperty()
            .convention(layout.projectDirectory.dir('modules/en/synthesis').file('sampa2mrpa_en.map'))
    ext.destFile = objects.fileProperty()
            .convention(layout.buildDirectory.file('cmudict.txt'))

    inputs.dir srcDir
    inputs.file mappingFile
    inputs.file allophoneSetFile
    outputs.file destFile

    doLast {
        def phoneMapping = [:]
        mappingFile.get().asFile.eachLine { line ->
            (line =~ /(.+)<->(.+)/).each { match, sampa, mrpa ->
                phoneMapping[mrpa] = sampa
            }
        }
        def stressMapping = [
                '1': "'",
                '2': ','
        ]
        def allophoneSet = AllophoneSet.getAllophoneSet(allophoneSetFile.get().asFile.path)
        destFile.get().asFile.withWriter { dest ->
            fileTree(srcDir).include('*.scm').each { scmFile ->
                scmFile.eachLine('UTF-8') { line ->
                    (line =~ /\("(\w+)" (\w+) \((.+)\)\)/).each { match, lemma, pos, transcription ->
                        def transcriptionMapped = transcription.replaceAll(~/\b(\S+?)([0-2])?\b/, { all, phone, stress ->
                            def mappedPhone = phoneMapping[phone] ?: phone
                            def mappedStress = stressMapping[stress] ?: ''
                            mappedStress + mappedPhone
                        })
                        def transcriptionSyllabified = allophoneSet.syllabify(transcriptionMapped)
                        def transcriptionNoSpaces = transcriptionSyllabified.replaceAll(' ', '')
                        dest.writeLine("$lemma $transcriptionNoSpaces")
                    }
                }
            }
        }
    }
}

tasks.named('compileLexicon').configure {
    allophonesFile.set allophoneSetFile
    lexiconFile.set processCmuDictTask.get().destFile
}

tasks.named('processResources').configure {
    from unpackCmuDictTask, {
        include 'COPYING'
    }
}

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

publishing {
    publications {
        mavenJava(MavenPublication) {
            from components.java
            pom {
                name = project.name
                description = project.description
                url = project.url
                licenses {
                    license {
                        name = 'GNU Lesser General Public License v3.0 only'
                        url = 'https://spdx.org/licenses/LGPL-3.0-only.html'
                    }
                }
                developers {
                    developer {
                        name = 'Ingmar Steiner'
                        id = 'psibre'
                    }
                    developer {
                        name = 'Marc Schröder'
                        id = 'marc1s'
                    }
                    developer {
                        name = 'Marcela Charfuelan'
                        id = 'marcelach1'
                    }
                }
                scm {
                    connection = "scm:git:${project.url}.git"
                    developerConnection = "scm:git:ssh://git@github.com:marytts/${project.name}.git"
                    url = project.url
                }
            }
        }
    }
    repositories {
        maven {
            name 'OSSRH'
            url isReleaseVersion ? 'https://oss.sonatype.org/service/local/staging/deploy/maven2/'
                    : 'https://oss.sonatype.org/content/repositories/snapshots'
            credentials(PasswordCredentials)
        }
    }
}

signing {
    required { isReleaseVersion }
    sign publishing.publications.mavenJava
}

tasks.withType(Sign).configureEach {
    onlyIf { isReleaseVersion }
}