build.gradle

buildscript {
    repositories { jcenter() }
    dependencies {
        classpath 'com.github.jengelman.gradle.plugins:shadow:+'
    }
}

apply plugin: 'java'
apply plugin: 'application'
apply plugin: 'maven'
apply plugin: 'maven-publish'
apply plugin: 'signing'
apply plugin: 'idea'
apply plugin: 'com.github.johnrengelman.shadow'

group = 'io.honeybadger'
version = '1.0.9'
sourceCompatibility = 1.7
targetCompatibility = 1.7
archivesBaseName = rootProject.name
mainClassName = "io.honeybadger.reporter.HoneybadgerCLI"

task wrapper(type: Wrapper) {
    gradleVersion = '2.4'
    distributionUrl = "https://services.gradle.org/distributions/gradle-$gradleVersion-all.zip"
}

run {
    standardInput = System.in
}

repositories {
    mavenCentral()
    mavenLocal()
}

configurations {
    providedCompile
    providedCompile.extendsFrom(compile)
}

javadoc {
    classpath = sourceSets.main.output + sourceSets.main.compileClasspath +
            configurations.providedCompile
}

sourceSets {
    main {
        compileClasspath += configurations.providedCompile
    }
    test {
        compileClasspath += configurations.providedCompile
        runtimeClasspath += configurations.providedCompile
    }

    integration {
        java.srcDir file('src/integration/java')
        resources.srcDir file('src/main/resources')
        compileClasspath = sourceSets.main.output +
                           sourceSets.test.output +
                           configurations.testRuntime +
                           configurations.providedCompile
        runtimeClasspath = output + compileClasspath
    }
}

dependencies {
    // We compile against the servlet API, but we don't bring it into the dependency graph
    // because the implementation is typically provided by the application server
    providedCompile 'javax.servlet:javax.servlet-api:3.1.0'

    providedCompile 'com.typesafe.play:play_2.10:2.4.2'

    // logging facade that allows users of the library to use their own logging implementations
    // This is the one unshadowed dependency
    compile 'org.slf4j:slf4j-api:1.7.12'

    // ==========================================================================
    // NOTE: If you are adding a dependency, be sure to shadow it in the settings
    // below the dependencies section.
    // ==========================================================================

    // JSON processing
    compile 'com.google.code.gson:gson:2.3.1'

    // HTTP requesting library - used to talk to the Honeybadger API
    compile('org.apache.httpcomponents:fluent-hc:4.5') {
        // we exclude commons logging because we replace it with a shadowed
        // jcl-over-slf4j in order to redirect all logging messages over
        // the slf4j interface
        exclude group: 'commons-logging'
    }

    // Used so we don't have to pull in commons-logging as a dependency
    compile 'org.slf4j:jcl-over-slf4j:1.7.12'

    // Used to get the Honeybadger library version from the JAR manifest
    compile 'com.jcabi:jcabi-manifests:1.1'

    // Used for rendering HTML error page templates
    compile 'com.github.spullara.mustache.java:compiler:0.8.18'

    // Utilities for testing below

    testCompile ('com.google.guava:guava:18.0') {
        exclude group: 'org.slf4j'
    }

    testCompile 'junit:junit:4.12'
    testCompile 'ch.qos.logback:logback-classic:1.1.3'
    testCompile 'org.mockito:mockito-all:1.10.19'
    testCompile 'com.github.fge:json-schema-validator:2.2.6'
}

// We don't generate an unshadowed jar
jar {
    onlyIf { false }
    doFirst {
        manifest {
            attributes("Honeybadger-Java-Version": version)
        }
    }
}

// By default we include all (but one) dependencies and remap their packge names
// so that they won't conflict with other dependencies in the graph.
shadowJar {
    baseName = "${rootProject.name}"
    classifier = ''

    doFirst {
        // We set the version of the library here so that we can get at it
        // at runtime and send it to the Honeybadger API as part of its
        //  diagnostic data.
        manifest {
            attributes("Honeybadger-Java-Version": version)
        }
    }

    relocate 'com.google', 'io.honeybadger.com.google'
    relocate 'org.apache', 'io.honeybadger.org.apache'
    relocate 'com.jcabi', 'io.honeybadger.com.jcabi'
    relocate 'com.github', 'io.honeybadger.com.github'
    exclude  'org/slf4j/**'
}

def installer = install.repositories.mavenInstaller

// Remove everything but slf4j
[installer]*.pom*.whenConfigured {pom ->
    pom.dependencies.retainAll {
        (it.artifactId == 'slf4j-api' && it.groupId == 'org.slf4j') ||
            it.scope != "compile"
    }
}

publishing {
    publications {
        shadow(MavenPublication) {
            from components.shadow
            artifactId = "${rootProject.name}"
        }
    }
}

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

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

task integration(type: Test) {
    group = 'Verification'
    description = 'Runs the integration tests.'
    testClassesDir = sourceSets.integration.output.classesDir
    classpath = sourceSets.integration.runtimeClasspath
}

// Dumps system properties to STDOUT
task showSystemProperties << {
    System.properties.each { k, v -> println "${k}:${v}" }
}

tasks.withType(Test) {
    def apiKeyProp = "honeybadger.api_key"
    def readApiKeyProp = "honeybadger.read_api_key"

    if (!System.getProperty(apiKeyProp) && !System.getenv("HONEYBADGER_API_KEY")) {
        println 'No API key'
        def msg = "${apiKeyProp} system property must be specified"
        throw new org.gradle.api.InvalidUserDataException(msg)
    }

    // Assume a default environment of test if it isn't specified
    systemProperty 'ENV', System.getProperty('ENV', 'TEST')
    systemProperty 'honeybadger.version', version
    systemProperty 'honeybadger.application_package', 'io.honeybadger'

    def passSysProp = { String prop ->
        systemProperty prop, System.getProperty(prop)
    }

    // White-listed system properties that can be passed from gradle.properties
    passSysProp(apiKeyProp)
    passSysProp(readApiKeyProp)
    passSysProp('honeybadger.url')
    passSysProp('http.proxyHost')
    passSysProp('http.proxyPort')
    passSysProp('honeybadger.excluded_exception_classes')
    passSysProp('honeybadger.excluded_sys_props')
}

//  Task dependency definitions
jar.dependsOn(shadowJar)

check.dependsOn(integration)
integration.mustRunAfter test

artifacts {
    archives javadocJar, sourcesJar, shadowJar
}

signing {
    sign configurations.archives
}

publishing {
    publications {
        mavenJava(MavenPublication) {
            from components.java

            artifact sourcesJar {
                classifier "sources"
            }

            // This messy thing is here to add proper exclusions to
            // generated POMs
            project.configurations[JavaPlugin.RUNTIME_CONFIGURATION_NAME].allDependencies.findAll {
                it instanceof ModuleDependency && !it.excludeRules.isEmpty()
            }.each { ModuleDependency dep ->
                pom.withXml {
                    def xmlDep = asNode().dependencies.dependency.find {
                        it.groupId[0].text() == dep.group && it.artifactId[0].text() == dep.name
                    }
                    def xmlExclusions = xmlDep.exclusions[0]
                    if (!xmlExclusions) xmlExclusions = xmlDep.appendNode('exclusions')

                    dep.excludeRules.each { ExcludeRule rule ->
                        def xmlExclusion = xmlExclusions.appendNode('exclusion')
                        xmlExclusion.appendNode('groupId', rule.group)
                        xmlExclusion.appendNode('artifactId', rule.module)
                    }
                }
            }
        }
    }
}

uploadArchives {
    repositories {
        mavenDeployer {
            beforeDeployment { MavenDeployment deployment -> signing.signPom(deployment) }

            repository(url: "https://oss.sonatype.org/service/local/staging/deploy/maven2/") {
                authentication(userName: ossrhUsername, password: ossrhPassword)
            }

            snapshotRepository(url: "https://oss.sonatype.org/content/repositories/snapshots/") {
                authentication(userName: ossrhUsername, password: ossrhPassword)
            }

            pom.project {
                name 'Honeybadger Java Client'
                packaging 'jar'
                description 'Library that sends exceptions to the online error management service Honeybadger.'
                url 'https://github.com/honeybadger-io/honeybadger-java'

                scm {
                    connection 'scm:git:git@github.com:honeybadger-io/honeybadger-jvm-client-v2.git'
                    developerConnection 'scm:git:git@github.com:honeybadger-io/honeybadger-java.git'
                    url 'git@github.com:honeybadger-io/honeybadger-java.git'
                }

                licenses {
                    license {
                        name 'MIT License'
                        url 'https://raw.githubusercontent.com/honeybadger-io/honeybadger-java/master/LICENSE'
                    }
                }

                developers {
                    developer {
                        id 'elijah'
                        name 'Elijah Zupancic'
                        email 'elijah@zupancic.name'
                        organizationUrl 'https://github.com/dekobon'
                    }
                }
            }
        }
    }
}

idea {
    module {
        scopes.PROVIDED.plus += [configurations.providedCompile]
    }
}