build.gradle

plugins {
    id 'java-library'
    id "com.diffplug.gradle.spotless" version "3.24.3"
    id 'io.codearte.nexus-staging' version '0.21.2'
    id "de.marcphilipp.nexus-publish" version "0.3.0"
    id "com.github.johnrengelman.shadow" version "5.2.0"
}

version =  getGitVersion()

ext {
    releaseVersion = getReleaseVersion()
    javaDataLoader = "com.mongodb.jdbc.integration.testharness.DataLoader"
    javaTestGenerator = "com.mongodb.jdbc.integration.testharness.TestGenerator"
    aspectjVersion = '1.9.7'
}

spotless {
    java {
        googleJavaFormat('1.1').aosp()
        licenseHeaderFile('resources/license_header.txt')
    }
}

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

allprojects {
    apply plugin: 'idea'
    apply plugin: 'java'
    apply plugin: 'com.github.johnrengelman.shadow'

    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = sourceCompatibility

    repositories {
        mavenCentral()
    }

    configurations {
        ajc
        aspects
        compile {
            extendsFrom aspects
        }
    }

    dependencies {
        // MongoDB
        ajc "org.aspectj:aspectjtools:$aspectjVersion"
        implementation "org.aspectj:aspectjrt:$aspectjVersion"
        implementation group: 'org.mongodb', name: 'mongodb-driver-sync', version: mongodbDriverVersion
        implementation group: 'org.mongodb', name: 'mongodb-driver-core', version: mongodbDriverVersion
        implementation group: 'org.mongodb', name: 'mongodb-driver', version: mongodbDriverVersion
        implementation group: 'com.google.guava', name: 'guava', version: guavaVersion
        implementation group: 'org.apache.commons', name: 'commons-lang3', version: lang3Version
        ajc "org.aspectj:aspectjtools:$aspectjVersion"

        // Test
        testImplementation group: 'org.junit.jupiter', name: 'junit-jupiter-api', version: junitJupiterVersion
        testRuntimeOnly  group: 'org.junit.jupiter', name: 'junit-jupiter-engine', version: junitJupiterVersion
        testCompile  group: 'org.mockito', name: 'mockito-core', version: mockitoVersion
        testCompile  group: 'org.mockito', name: 'mockito-junit-jupiter', version: mockitoVersion
    }

    //ant.lifecycleLogLevel = AntBuilder.AntMessagePriority.VERBOSE

    compileJava {
        doLast {
            ant.taskdef(resource: "org/aspectj/tools/ant/taskdefs/aspectjTaskdefs.properties",
                    classpath: configurations.ajc.asPath)

            ant.iajc(
                    maxmem: "1024m", fork: "true", Xlint: "ignore",
                    destDir: project.sourceSets.main.output.classesDirs[0].absolutePath,
                    sourceroots: project.sourceSets.main.java.srcDirs[0].absolutePath,
                    classpath: project.sourceSets.main.runtimeClasspath.asPath,
                    source: project.sourceCompatibility,
                    target: project.targetCompatibility,
                    showWeaveInfo: true
            )
        }
    }

    test {
        useJUnitPlatform()
        failFast = true
    }

    task sourceJar(type: Jar) {
        from sourceSets.main.allJava
        classifier "sources"
    }

    task testJar(type: Jar) {
        from sourceSets.test.allJava
        classifier "test"
    }

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

    artifacts {
        sourceJar
        testJar
        javadocJar
    }
}

configurations {
    integrationTestImplementation.extendsFrom implementation
    integrationTestRuntimeOnly.extendsFrom runtimeOnly

    // Use the release version instead of gitVersion for the produced jar
    jar.archiveVersion = releaseVersion
    shadowJar.archiveVersion = releaseVersion
}

task integrationTest(type: Test) {
    useJUnitPlatform()
    description = 'Runs integration tests.'
    group = 'verification'

    testClassesDirs = sourceSets.integrationTest.output.classesDirs
    classpath = sourceSets.integrationTest.runtimeClasspath
    shouldRunAfter test
}

check.dependsOn integrationTest

task runTestGenerator(type: JavaExec) {
    group = "Execution"
    description = "Run the integration test baseline file generator."
    classpath = sourceSets.integrationTest.runtimeClasspath
    main = javaTestGenerator
}

task runDataLoader(type: JavaExec) {
    group = "Execution"
    description = "Run the data loader."
    classpath = sourceSets.integrationTest.runtimeClasspath
    main = javaDataLoader
}

jar {
    manifest {
        attributes('Implementation-Title': project.name,
                'Implementation-Version': project.version)
    }
}

dependencies {
    implementation "org.yaml:snakeyaml:$snakeYamlVersion"
    api "org.mongodb:mongodb-driver-sync:$mongodbDriverVersion"
    api "org.mongodb:mongodb-driver:$mongodbDriverVersion"
    integrationTestImplementation "org.junit.jupiter:junit-jupiter:$junitJupiterVersion"
    integrationTestImplementation group: 'org.junit.jupiter', name: 'junit-jupiter-api', version: junitJupiterVersion
}

def getReleaseVersion() {
	def snapshot = isDirtyVersion() || !isTaggedVersion()
	if (snapshot) {
		return getAbbreviatedGitVersion() + "-SNAPSHOT"
	} else {
		return getGitVersion()
	}
}

def isDirtyVersion() {
	getGitVersion().endsWith("dirty")
}

def isTaggedVersion() {
	def out = new ByteArrayOutputStream()
	def result = exec {
		commandLine 'git', 'describe', '--exact'
		ignoreExitValue true
		standardOutput out
		errorOutput out
	}
	if (result.getExitValue() == 0) {
		return true
	} else {
		return false
	}
}

def getGitVersion() {
    def out = new ByteArrayOutputStream()
    exec {
        commandLine 'git', 'describe', '--tags', '--always', '--dirty'
        standardOutput = out
    }
    out.toString().substring(1).trim()
}

def getAbbreviatedGitVersion() {
    def out = new ByteArrayOutputStream()
    exec {
        commandLine 'git', 'describe', '--abbrev=0'
        standardOutput = out
    }
    out.toString().substring(1).trim()
}

apply from: 'gradle/publish.gradle'
apply from: 'gradle/deploy.gradle'