build.gradle

buildscript {
    repositories {
        maven { url 'http://jcenter.bintray.com' }
    }

    dependencies {
        classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.8.0'
        classpath 'org.ajoberstar:gradle-git-publish:0.3.2'
    }
}

apply plugin: 'maven-publish'
apply plugin: 'com.jfrog.bintray'
apply plugin: 'org.ajoberstar.git-publish'

allprojects {
    apply plugin: 'groovy'
    apply plugin: 'idea'
    group = 'com.bmuschko'
    version = '2.4.2'
    defaultTasks 'clean', 'build', 'createAllDeliverables'
}

subprojects {
    apply plugin: 'jacoco'
    apply from: "$rootProject.projectDir/gradle/integration-test.gradle"
    apply from: "$rootProject.projectDir/gradle/functional-test.gradle"

    def compatibilityVersion = 1.6
    sourceCompatibility = compatibilityVersion
    targetCompatibility = compatibilityVersion

    repositories {
        mavenCentral()
    }

    dependencies {
        compile localGroovy()
        testCompile('org.spockframework:spock-core:1.0-groovy-2.4') {
            exclude group: 'org.codehaus.groovy'
        }
        testCompile 'org.apache.commons:commons-lang3:3.3'
    }

    task jacocoIntegrationTestReport(type: JacocoReport) {
        sourceSets sourceSets.main
        executionData integrationTest
    }

    task jacocoFunctionalTestReport(type: JacocoReport) {
        sourceSets sourceSets.main
        executionData functionalTest
    }
}

task uberJar(type: Jar, dependsOn: subprojects.assemble) {
    description = 'Creates Uberjar.'

    subprojects.each { project ->
        from project.configurations.archives.allArtifacts.files.collect { zipTree(it) }
    }

    manifest {
        attributes 'Implementation-Title': 'Gradle Tomcat plugin',
                   'Implementation-Version': version,
                   'Built-By': System.getProperty('user.name'),
                   'Built-Date': new Date(),
                   'Built-JDK': System.getProperty('java.version'),
                   'Built-Gradle': gradle.gradleVersion
    }
}

task sourcesJar(type: Jar) {
    description = 'Creates sources JAR.'
    classifier = 'sources'

    subprojects.each { project ->
        from project.sourceSets.main.allSource
    }
}

ext.groovyDocsDir = 'build/docs/groovydoc'

task aggregateGroovydocs(type: Groovydoc, dependsOn: subprojects.groovydoc) {
    description = 'Creates Groovydocs.'

    ext.title = "Gradle Tomcat plugin ($version)"
    docTitle title
    windowTitle title
    source subprojects.groovydoc.source
    destinationDir file(groovyDocsDir)
    classpath = files(subprojects.groovydoc.classpath)
    groovyClasspath = project(':plugin').groovydoc.groovyClasspath
}

task groovydocJar(type: Jar, dependsOn: aggregateGroovydocs) {
    description = 'Creates GroovyDocs JAR.'
    classifier = 'javadoc'

    from groovyDocsDir
}

task createAllDeliverables(dependsOn: [uberJar, sourcesJar, groovydocJar]) {
    description = 'Creates all deliverables including plugin JAR, sources JAR and Groovydoc JAR.'
}

task aggregateTestReports(type: TestReport) {
    destinationDir = file("$buildDir/reports/all-tests")
    reportOn subprojects*.test, subprojects*.integrationTest
}

check.dependsOn aggregateTestReports

artifacts {
    archives uberJar
    archives sourcesJar
    archives groovydocJar
}

publishing {
    publications {
        mavenJava(MavenPublication) {
            artifact uberJar
            artifact sourcesJar
            artifact groovydocJar

            pom.withXml {
                def root = asNode()
                root.appendNode('name', 'Gradle Tomcat plugin')
                root.appendNode('description', 'Gradle plugin supporting deployment of your web application to an embedded Tomcat web container.')
                root.appendNode('url', 'https://github.com/bmuschko/gradle-tomcat-plugin')
                root.appendNode('inceptionYear', '2010')

                def scm = root.appendNode('scm')
                scm.appendNode('url', 'https://github.com/bmuschko/gradle-tomcat-plugin')
                scm.appendNode('connection', 'scm:https://bmuschko@github.com/bmuschko/gradle-tomcat-plugin.git')
                scm.appendNode('developerConnection', 'scm:git://github.com/bmuschko/gradle-tomcat-plugin.git')

                def license = root.appendNode('licenses').appendNode('license')
                license.appendNode('name', 'The Apache Software License, Version 2.0')
                license.appendNode('url', 'http://www.apache.org/licenses/LICENSE-2.0.txt')
                license.appendNode('distribution', 'repo')

                def developers = root.appendNode('developers')
                def bmuschko = developers.appendNode('developer')
                bmuschko.appendNode('id', 'bmuschko')
                bmuschko.appendNode('name', 'Benjamin Muschko')
                bmuschko.appendNode('email', 'benjamin.muschko@gmail.com')
            }
        }
    }
}

bintray {
    user = project.hasProperty('bintrayUser') ? project.getProperty('bintrayUser') : null
    key =  project.hasProperty('bintrayKey') ? project.getProperty('bintrayKey') : null
    publications = ['mavenJava']
    publish = true

    pkg {
        repo = 'gradle-plugins'
        name = 'com.bmuschko:gradle-tomcat-plugin'
        desc = 'Gradle plugin supporting deployment of your web application to an embedded Tomcat web container.'
        websiteUrl = "https://github.com/bmuschko/${project.name}"
        issueTrackerUrl = "https://github.com/bmuschko/${project.name}/issues"
        vcsUrl = "https://github.com/bmuschko/${project.name}.git"
        licenses = ['Apache-2.0']
        labels = ['gradle', 'tomcat', 'web', 'container', 'embedded']
        publicDownloadNumbers = true

        version {
            vcsTag = "v$project.version"
            attributes = ['gradle-plugin': ["com.bmuschko.tomcat:${project.group}:${project.name}",
                                            "com.bmuschko.tomcat-base:${project.group}:${project.name}"]]

            gpg {
                sign = true
                passphrase = project.hasProperty('gpgPassphrase') ? project.getProperty('gpgPassphrase') : null
            }

            mavenCentralSync {
                sync = true
                user = project.hasProperty('mavenCentralUserToken') ? project.getProperty('mavenCentralUserToken') : null
                password = project.hasProperty('mavenCentralPassword') ? project.getProperty('mavenCentralPassword') : null
                close = '1'
            }
        }
    }
}

gitPublish {
    repoUri = 'git@github.com:bmuschko/gradle-tomcat-plugin.git'
    branch = 'gh-pages'

    contents {
        from(aggregateGroovydocs.outputs.files) {
            into 'docs/groovydoc'
        }
    }
}


idea.project {
    jdkName = '1.8'

    ipr.withXml { provider ->
        def node = provider.asNode()

        // Use GIT
        def vcsConfig = node.component.find { it.'@name' == 'VcsDirectoryMappings' }
        vcsConfig.mapping[0].'@vcs' = 'Git'

        // Set Gradle home
        def gradleSettings = node.appendNode('component', [name: 'GradleSettings'])
        gradleSettings.appendNode('option', [name: 'SDK_HOME', value: gradle.gradleHomeDir])
    }
}