build.gradle

description = "Apereo Central Authentication Service $version"

defaultTasks "clean", "build"

ext {
    publishSnapshots = Boolean.getBoolean("publishSnapshots")
    publishReleases = Boolean.getBoolean("publishReleases")
    sonatypeUsername = System.getProperty("sonatypeUsername")
    sonatypePassword = System.getProperty("sonatypePassword")
}

def isArtifactSigningRequired = {
    if (publishReleases && sonatypeUsername != null && sonatypePassword != null) {
        return true
    }
    return false
}

apply from: rootProject.file("gradle/dependencies.gradle")
apply plugin: "com.gradle.build-scan"

buildScan {
    licenseAgreementUrl = "https://gradle.com/terms-of-service"
    licenseAgree = "yes"
}

buildscript {
    repositories {
        mavenLocal()
        mavenCentral()
        jcenter()
        maven { url "https://maven.eveoh.nl/content/repositories/releases" }
        maven { url "https://plugins.gradle.org/m2/" }
        maven { url "http://repo.spring.io/plugins-release" }
        maven { url "https://repo.spring.io/milestone" }
        maven { url "https://repo.spring.io/snapshot" }
    }

    dependencies {
        classpath "org.springframework.boot:spring-boot-gradle-plugin:$springBootVersion"
        classpath "com.netflix.nebula:gradle-lint-plugin:5.0.0"
        classpath "org.standardout:gradle-versioneye-plugin:1.4.0"
        classpath "org.springframework.build.gradle:propdeps-plugin:0.0.7"
        classpath "com.gradle:build-scan-plugin:1.0"
    }
}

allprojects {
    apply plugin: "idea"
    apply plugin: "eclipse"
    apply plugin: "maven"
    apply plugin: "signing"
    apply plugin: "org.standardout.versioneye"
    apply plugin: "nebula.lint"

    if (project.name == "cas-server-support-bom") {
        println "Skipping pom generation for [$project.name], letting it create <dependency-management> entries."
    } else {
        apply from: rootProject.file("gradle/maven.gradle")
    }
    
    gradleLint.rules = ["dependency-parentheses", "dependency-tuple"]

    signing {
        required = isArtifactSigningRequired
        sign configurations.archives
    }

    idea {
        module {
            downloadSources = false
            downloadJavadoc = false
        }
    }

    signArchives.enabled = rootProject.publishReleases || rootProject.publishSnapshots

    /*
    Do NOT publish test dependencies into the final POM.
    */
    conf2ScopeMappings.mappings.remove(configurations.findByName("testCompile"))
    conf2ScopeMappings.mappings.remove(configurations.findByName("testRuntime"))
}

subprojects {
    task allDependenciesInsight(type: DependencyInsightReportTask, description: "Produce insight information for all dependencies") << {}
    task allDependencies(type: DependencyReportTask, description: "Display a graph of all project dependencies") {}

    apply plugin: "java"
    apply plugin: "checkstyle"
    apply plugin: "findbugs"
    apply plugin: "project-report"
    apply plugin: "propdeps"
    apply plugin: "propdeps-maven"
    apply plugin: "propdeps-idea"
    apply plugin: "propdeps-eclipse"


    apply from: rootProject.file("gradle/tasks.gradle")

    ext.libraries = rootProject.ext.libraries;

    repositories {
        mavenLocal()
        mavenCentral()
        jcenter()

        maven { url "https://raw.github.com/vt-middleware/maven-repo/master" }
        maven { url "https://oss.sonatype.org/content/repositories/snapshots" }
        maven { url "https://oss.sonatype.org/content/repositories/releases" }
        maven { url "http://repo.maven.apache.org/maven2" }
        maven { url "https://jitpack.io" }
        maven { url "http://developer.jasig.org/repo/content/groups/m2-legacy/" }
        maven { url "https://build.shibboleth.net/nexus/content/repositories/releases" }
        maven { url "http://files.couchbase.com/maven2" }
        maven { url "https://repo.spring.io/milestone" }
        maven { url "https://repo.spring.io/snapshot" }
        maven { url "https://repo.spring.io/libs-snapshot" }
        maven { url "https://dl.bintray.com/uniconiam/maven" }
    }

    test {
        enabled = !Boolean.getBoolean("skipTests")
        useJUnit()
        scanForTestClasses = false

        ignoreFailures = Boolean.getBoolean("ignoreTestFailures")
        include "**/*Tests.*"
        exclude "**/*Abstract*.*"
        classpath = it.classpath + files("${projectDir}/src/main/resources") +
                files("${projectDir}/src/test/resources")
        testLogging {
            events = ["FAILED", "STANDARD_OUT"]
            exceptionFormat = "full"
            showStandardStreams = Boolean.getBoolean("showStandardStreams")
            showExceptions = true
            showCauses = true
        }
    }

    configurations {
        tests
    }

    configurations.all {
        resolutionStrategy {
            if (!Boolean.getBoolean("skipVersionConflict")) {
                failOnVersionConflict()
            }
            cacheDynamicVersionsFor 24, 'hours'
            cacheChangingModulesFor 24, 'hours'
        }
        exclude(group: "ch.qos.logback", module: "logback-core")
        exclude(group: "ch.qos.logback", module: "logback-classic")
        exclude(group: "cglib", module: "cglib")
        exclude(group: "cglib", module: "cglib-full")
    }

    artifacts {
        tests testJar

        archives sourcesJar
        archives javadocJar
        archives resourcesJar
        archives testJar
    }


    sourceSets {
        test.resources.srcDirs = ["${projectDir}/src/test/resources", "${projectDir}/src/test/java"]
    }

    ext.buildDate = null
    ext.buildJarFile = new File(project.buildDir, "libs/${project.name}-${project.version}.jar")
    
    compileJava.options.fork = true 

    def currentTime = java.time.ZonedDateTime.now()
    compileJava.doLast {
        buildDate = currentTime
        jar.manifest {
            attributes("Implementation-Date": project.buildDate)
        }
    }

    tasks.jar.onlyIf {
        project.buildDate != null || !project.buildJarFile.exists()
    }

    jar {
        manifest {
            attributes("Implementation-Title": project.name,
                       "Implementation-Vendor": project.group,
                       "Created-By": project.group,
                       "Implementation-Version": project.version)
        }
    }

    checkstyle {
        configFile new File(rootDir, "checkstyle-rules.xml")
        configProperties = ["checkstyle.suppressions.file": new File(rootDir, "checkstyle-suppressions.xml")]
        ignoreFailures false
        showViolations true
        toolVersion "${checkstyleVersion}"
    }

    checkstyleTest {
        enabled = !Boolean.getBoolean("skipCheckstyle")
    }

    checkstyleMain {
        enabled = !Boolean.getBoolean("skipCheckstyle")
    }

    versioneye {
        includePlugins = false
        includeSubProjects = true
    }
    
    findbugs {
        toolVersion = "${findbugsVersion}"
        sourceSets = [sourceSets.main]
        ignoreFailures = false
        reportsDir = file("$project.buildDir/findbugsReports")
        effort = "max"
        reportLevel = "low"
        includeFilter = file("$rootProject.projectDir/findbugs-rules.xml")
    }

    findbugsMain {
        enabled = !Boolean.getBoolean("skipFindbugs")
        reports {
            xml.enabled = false
            html.enabled = true
        }
    }

    findbugsTest {
        enabled = !Boolean.getBoolean("skipFindbugs")
    }

    dependencies {
        compile libraries.aspectj
        compile libraries.validationapi
        compile libraries.log4j
        compile libraries.guava
        compile libraries.commons
        compile libraries.jodatime
        compile libraries.inspektr

        compileOnly libraries.javax

        if (Boolean.getBoolean("genConfigMetadata")) {
            optional libraries.springbootconfigmetadata
        }

        if (!Boolean.getBoolean("skipFindbugs")) {
            findbugs libraries.findbugs
            findbugs configurations.findbugsPlugins.dependencies
            findbugsPlugins libraries.findbugscontrib
            findbugsPlugins libraries.findbugssec
        }

        testCompile libraries.tests
        runtime libraries.javaximpl
    }
    
    if (Boolean.getBoolean("genConfigMetadata")) {
        compileJava.dependsOn(processResources)
    }
}

task wrapper(type: Wrapper, description: "Gradle wrapper") {
    gradleVersion = project.gradleVersion
}

task javadoc(type: Javadoc, description: "Aggregate all Javadocs into a single directory") {
    source subprojects.collect { project -> project.sourceSets.main.allJava }
    destinationDir = new File(buildDir, "javadoc")
    classpath = files(subprojects.collect { project -> project.sourceSets.main.compileClasspath })
}

task aggregateJavadocsIntoJar(type: Jar, dependsOn: javadoc,
        description: "Aggregate all Javadocs into a single directory") {
    classifier = "javadoc"
    from javadoc
}

task rootSourcesJar(type: Jar, description: "Build JAR for the root CAS module") {
    baseName = "${project.archivesBaseName}"
    from rootProject.file("src")
}

artifacts {
    archives aggregateJavadocsIntoJar
    archives rootSourcesJar
}