build.gradle

/*
 * mrd: build.gradle
 * Copyright (c) 2022, Physikalisch-Technische Bundesanstalt
 * All Rights Reserved
 *
 * Released under Apache 2.0
 */

buildscript {
    ext {
        vXnat = "1.8.3"
    }
}

// This is the minimum set of Gradle plugins required to build most XNAT plugins.
plugins {
    id "jacoco"
    id "java"
    id "com.palantir.git-version" version "0.12.1"
    id "io.franzbecker.gradle-lombok" version "4.0.0"
    id "io.spring.dependency-management" version "1.0.11.RELEASE"
    id "org.nrg.xnat.build.xnat-data-builder" version "1.8.3"
}

group "gov.ptb.qmri.xnat"
version "1.0.0-SNAPSHOT"
description "XNAT plugin to support ISMRMRD raw data"

// This provides access to all of these repositories for dependency resolution.
repositories {
    mavenLocal()
    maven { url "https://nrgxnat.jfrog.io/nrgxnat/libs-release" }
    maven { url "https://nrgxnat.jfrog.io/nrgxnat/libs-snapshot" }
    mavenCentral()
}

// This defines a dependency package, specifically the XNAT NRG parent pom, which specifies
// versions for all of XNAT's dependencies. This helps ensure that plugins are building
// against the same versions of various libraries as XNAT itself.
dependencyManagement.imports {
    mavenBom "org.nrg:parent:${vXnat}"
}

// This is a pretty minimal set of dependencies, so don't worry if you need to add more.
dependencies {
    implementation enforcedPlatform("org.nrg:parent:${vXnat}")

    implementation("org.nrg.xnat:web") {
        transitive = false
    }
    implementation("org.nrg:dicom-xnat-mx") {
        transitive = false
    }
    implementation("org.nrg.xnat:xnat-data-models") {
        transitive = false
    }
    implementation "org.nrg.xdat:core"
    implementation "org.nrg:dicom-xnat-util"
    implementation "org.nrg:prefs"
    implementation "org.nrg:framework"
    implementation "dcm4che:dcm4che-core"
    implementation "io.springfox:springfox-swagger2"
    implementation "io.springfox:springfox-swagger-ui"

    implementation  "org.slf4j:slf4j-simple:1.7.30"

    compileOnly "log4j:log4j"

    testImplementation "org.junit.jupiter:junit-jupiter-api"
    testImplementation "org.springframework:spring-test"
    testImplementation "com.github.sbrannen:spring-test-junit5"
    testImplementation "org.mockito:mockito-core"
    testImplementation "org.assertj:assertj-core"
    testImplementation "com.h2database:h2"

    testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine"
    testRuntimeOnly "ch.qos.logback:logback-classic"
}

// Pulls in the Jenkins BUILD_NUMBER environment variable if available.
def buildDate = new Date()
def buildNumber = System.getenv().BUILD_NUMBER?.toInteger() ?: "Manual"
def isDirty, branchName, gitHash, gitHashFull, commitDistance, lastTag, isCleanTag

try {
    def gitDetails = versionDetails()
    isDirty = gitVersion().endsWith ".dirty"
    branchName = gitDetails.branchName ?: "Unknown"
    gitHash = gitDetails.gitHash
    gitHashFull = gitDetails.gitHashFull
    commitDistance = gitDetails.commitDistance
    lastTag = gitDetails.lastTag
    isCleanTag = gitDetails.isCleanTag
} catch (IllegalArgumentException e) {
    logger.info "Got an error trying to read VCS metadata from git. It's possible this project is not under VCS control. Using placeholder values for manifest entries."
    isDirty = true
    branchName = "Unknown"
    gitHash = "None"
    gitHashFull = "None"
    commitDistance = 0
    lastTag = "None"
    isCleanTag = false
}

ext.gitManifest = manifest {
    attributes "Application-Name": project.description,
            "Build-Date": buildDate,
            "Build-Number": buildNumber,
            "Implementation-Version": project.version,
            "Implementation-Sha": gitHash,
            "Implementation-Sha-Full": gitHashFull,
            "Implementation-Commit": commitDistance,
            "Implementation-LastTag": lastTag,
            "Implementation-Branch": branchName,
            "Implementation-CleanTag": isCleanTag,
            "Implementation-Dirty": isDirty
}

logger.info """
Building artifacts with manifest attributes:

 * Build-Date:              ${buildDate}
 * Build-Number:            ${buildNumber}
 * Implementation-Version:  ${version}
 * Implementation-Sha-Full: ${gitHashFull}
 * Implementation-Sha:      ${gitHash}
 * Implementation-Commit:   ${commitDistance}
 * Implementation-LastTag:  ${lastTag}
 * Implementation-Branch:   ${branchName}
 * Implementation-CleanTag: ${isCleanTag}
 * Implementation-Dirty:    ${isDirty}
"""

// TODO: This configures the compileJava task to call the xnatDataBuilder task before
//       trying to compile any Java code in the plugin. If your plugin includes one or
//       more custom data types, you'll need to generate source code for those datatypes
//       before you can use them in your Java code.
compileJava.dependsOn project.tasks["xnatDataBuilder"]

configurations {
    all {
        exclude group: "junit"
        exclude group: "net.logstash.logback"
        exclude group: "org.nrg.xnat.pipeline"
        exclude group: "org.slf4j", module: "jcl-over-slf4j"
        exclude group: "org.slf4j", module: "log4j-over-slf4j"
        exclude group: "org.slf4j", module: "slf4j-log4j12"
        exclude group: "org.slf4j", module: "slf4j-simple"
    }
    implementation.extendsFrom(implementAndInclude)
}

lombok {
    version = dependencyManagement.importedProperties["lombok.version"] as String
    sha256 = dependencyManagement.importedProperties["lombok.checksum"] as String
}

jacocoTestReport {
    dependsOn test
    reports {
        xml.required = false
        csv.required = true
        html.required = true
    }
}

java {
    // As of the 1.8.x release, XNAT is built as a Java 8-compatible (i.e. JDK 1.8)
    // application. All plugins must be 1.8 compatible as well. This does NOT mean
    // the code must be compiled with Java 8, just that the compiled byte code must
    // be compatible with running in a Java 8 environment.
    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = JavaVersion.VERSION_1_8
}

sourceSets {
    main {
        java {
            srcDir "build/xnat-generated/src/main/java"
        }
        resources {
            srcDir "build/xnat-generated/src/main/resources"
        }
    }
}

tasks.withType(Jar) {
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
}

// This builds a sources jar that pulls in the manifest with VCS info from above.
task sourcesJar(type: Jar, dependsOn: classes) {
    classifier "sources"
    manifest {
        from gitManifest
    }
    from sourceSets.main.allSource
}

// This builds a javadoc jar that pulls in the manifest with VCS info from above.
task javadocJar(type: Jar) {
    classifier "javadoc"
    manifest {
        from gitManifest
    }
    from javadoc.destinationDir
}

// This builds a regular classes jar that pulls in the manifest with VCS info from above.
// For the most part this jar isn't necessary: what you really want is the plugin jar.
jar {
    dependsOn test, sourcesJar, javadocJar
    enabled = true
    manifest {
        from gitManifest
    }
}

// This builds the XNAT plugin jar that pulls in the manifest with VCS info from above.
// This includes all compiled Java classes (including generated classes), any schema
// files, JavaScript and Velocity template resources, and the XNAT plugin identifier
// properties file, in this case named META-INF/xnat/templatePlugin-plugin.properties.
task xnatPluginJar(type: Jar) {
    dependsOn test, sourcesJar, javadocJar
    zip64 true
    archiveClassifier.set "xpl"
    manifest {
        from gitManifest
    }

    // files and folders with "-dev" or "--xx" in their name
    // will not be in the compiled jar
    exclude "**/resources/**/*-dev**"
    exclude "**/resources/**/*--xx**"
    from {
        configurations.implementAndInclude.collect { it.isDirectory() ? it : zipTree(it) }
    } {
        exclude "META-INF/*.SF"
        exclude "META-INF/*.DSA"
        exclude "META-INF/*.RSA"
    }
    with jar
}