build.gradle

import static java.util.stream.Collectors.toList

ext.rootConfig = new File(rootDir, 'config')
ext.git = find('git')
ext.majorVersion = major(version)

ext.latest = gitVersion() == 'master' ? version : latest_release

if (JavaVersion.current().isJava8Compatible()) {
    allprojects {
        tasks.withType(Javadoc) {
            options.addStringOption('Xdoclint:none', '-quiet')
        }
    }
}

buildscript {
    repositories {
        mavenLocal()
        mavenCentral()
        jcenter()
        maven { url 'https://oss.sonatype.org/content/repositories/snapshots' }
    }

    dependencies {
        classpath 'com.netflix.nebula:gradle-extra-configurations-plugin:1.12.+'
    }
}

task wrapper(type: Wrapper) {
    gradleVersion = '4.2.1'
}

configure(subprojects.findAll { it.name != 'util' }) {
    apply plugin: 'java'
    apply plugin: 'idea'
    apply plugin: 'eclipse'
    apply plugin: 'checkstyle'
    apply plugin: 'findbugs'
    apply plugin: 'jacoco'
    apply plugin: 'optional-base'

    group = 'org.mongodb.morphia'
    sourceCompatibility = JavaVersion.VERSION_1_6
    targetCompatibility = JavaVersion.VERSION_1_6

    evaluationDependsOn(':util')

    repositories {
        mavenCentral()
        maven { url 'https://oss.sonatype.org/content/repositories/snapshots' }
        mavenLocal()
    }

    dependencies {
        testCompile 'junit:junit:4.12'
    }

    project.archivesBaseName = "morphia-${project.name}"

    task testCoverage(dependsOn: check)

    checkstyle {
        configDir = rootConfig
    }

    findbugs {
        excludeFilter = new File("$rootConfig/findbugs-exclude.xml")
        sourceSets = [sourceSets.main]
    }

    tasks.withType(FindBugs) {
        reports {
            xml.enabled = project.buildingWith('xmlReports.enabled')
            html.enabled = !project.buildingWith('xmlReports.enabled')
        }
    }

    /*
    For security we allow the signing-related project properties to be passed in as environment variables, which
    Gradle enables if they are prefixed with "ORG_GRADLE_PROJECT_".  But since environment variables can not contain
    the '.' character and the signing-related properties contain '.', here we map signing-related project properties with '_'
    to ones with '.' that are expected by the signing plugin.
 */
    gradle.taskGraph.whenReady { taskGraph ->
        if (taskGraph.allTasks.any { it instanceof Sign }) {
            if (project.hasProperty("signing_keyId")) {
                allprojects { ext."signing.keyId" = project.property("signing_keyId") }
            }
            if (project.hasProperty("signing_secretKeyRingFile")) {
                allprojects { ext."signing.secretKeyRingFile" = project.property("signing_secretKeyRingFile") }
            }
            if (project.hasProperty("signing_password")) {
                allprojects { ext."signing.password" = project.property("signing_password") }
            }
        }
    }

    tasks.withType(AbstractCompile) {
        options.encoding = 'ISO-8859-1'
        options.fork = true
        options.debug = true
        options.compilerArgs = ['-Xlint:unchecked', '-Xlint:deprecation', '-Xlint:-options']
    }

    tasks.withType(Test) {
        if (System.getenv()['RS_ENABLED'] == "true") {
            systemProperty 'MONGO_URI', 'mongodb://localhost:27017,localhost:27018,localhost:27019'
        }


        useJUnit {
        }

        if (!JavaVersion.current().isJava8Compatible()) {
            exclude 'org/mongodb/morphia/converters/LocalDate*', 'org/mongodb/morphia/converters/LocalTime*',
                    'org/mongodb/morphia/converters/Instant*', 'org/mongodb/morphia/converters/Java8*'
        }

        jacoco { enabled = false }

        beforeTest { descr ->
            logger.info("[Test ${descr.className} > ${descr.name}]")
        }
    }


    test {
        // set heap size for the test JVM(s)
        minHeapSize = "256m"
        maxHeapSize = "512m"
    }

    task quickCheck(dependsOn: ['checkstyleMain', 'checkstyleTest', 'findbugsMain']) {}

    javadoc {
        exclude "**/internal/**"

        dependsOn project.project(':util').compileJava //We need taglets to be compiled

        options.author = true
        options.version = true
        options.tagletPath project.project(":util").sourceSets.main.output.files
                                   .stream()
                                   .map { file(it) }
                                   .collect(toList())
        options.setTaglets(['taglets.ManualTaglet', 'taglets.ServerReleaseTaglet'])
        options.links 'http://docs.oracle.com/javase/6/docs/api/'
        options.links 'http://api.mongodb.org/java/3.0/'
        title "Morphia ${majorVersion} API"
        options.encoding = 'UTF-8'
        options.charSet 'UTF-8'
        options.docEncoding 'UTF-8'
    }
}

def buildingWith(n) {
    project.hasProperty(n)
}

def major(fullVersion) {
    fullVersion.split('\\.').dropRight(1).join('.') +
        (gitVersion() == 'master' && fullVersion.contains('-SNAPSHOT') ? '-SNAPSHOT' : '')
}

def gitVersion() {
    def stdOut = new ByteArrayOutputStream()
    exec {
        commandLine git, "rev-parse", "--abbrev-ref", "HEAD"
        standardOutput = stdOut
        ignoreExitValue = true
    }

    return stdOut.toString().trim()
}

def find(executable) {
    def list = ['/usr/local/bin/', '/usr/bin/']
    list.findResult {
        def exec = file(it + executable)
        if(exec.exists()) {
            exec.absolutePath
        }
    } ?: executable
}

apply from: 'gradle/osgi-compatibility.gradle'
apply from: 'gradle/release-process.gradle'
apply from: 'gradle/docs.gradle'