build.gradle

group = "$groupPackage" as Object
version = "$projectVersion" as Object
description = "$rootProject.name"

buildscript {
    repositories {
        maven {
            url "https://plugins.gradle.org/m2/"
        }
    }
    dependencies {
        classpath "io.freefair.gradle:lombok-plugin:$gradlePluginLombokVersion"
        classpath "com.github.ben-manes:gradle-versions-plugin:$gradlePluginVersionsVersion"
        classpath "gradle.plugin.com.hierynomus.gradle.plugins:license-gradle-plugin:$licenseGradlePluginVersion"
        classpath "org.ajoberstar.grgit:grgit-gradle:$grgitGradlePluginVersion"
        classpath "com.diffplug.spotless:spotless-plugin-gradle:$spotlessGradlePluginVersion"
    }
}

apply plugin: "io.freefair.lombok"
apply plugin: "java"
apply plugin: "java-library"
apply plugin: "maven-publish"
apply plugin: "signing"
apply plugin: "com.github.ben-manes.versions"
apply plugin: "com.github.hierynomus.license"
apply plugin: "jacoco"
apply plugin: "org.ajoberstar.grgit"
apply plugin: "com.diffplug.spotless"

spotless {

    format "misc", {
        // define the files to apply `misc` to
        target "*.gradle", "*.md", ".gitignore"

        // define the steps to apply to those files
        trimTrailingWhitespace()
        indentWithSpaces() // or spaces. Takes an integer argument if you don"t like 4
        endWithNewline()
    }
    java {
        eclipse("4.19.0").configFile("src/test/resources/alpharo-formatter.xml")
    }
}

task tagRelease {
    description = "Tags the current head with the project\'s version."
    doLast {
        grgit.tag.add {
            name = "RELEASE-${project.version.toString()}"
            message = "New release in version ${version}"
        }
    }
}

sourceCompatibility = "$projectSourceCompatibility" as Object

repositories {
    mavenLocal()
    mavenCentral()
    maven {
        name "Sonatype Nexus Releases"
        url "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
        mavenContent {
            releasesOnly()
        }
    }
    maven {
        name "Sonatype Nexus Snapshots"
        url "https://oss.sonatype.org/content/repositories/snapshots"
        mavenContent {
            snapshotsOnly()
        }
    }
}

tasks.withType(JavaCompile) {
    options.encoding = "UTF-8"
    // uncomment the next line for build with compiler argument -Xlint:deprecation
    // options.compilerArgs << "-Xlint:deprecation"
    // uncomment the next line for build with compiler argument -Xlint:unchecked
    // options.compilerArgs << "-Xlint:unchecked"
}

task sourcesJar(type: Jar) {
    archiveClassifier.set("sources")
    from(sourceSets.main.allJava)
}

task javadocJar(type: Jar) {
    from javadoc
    archiveClassifier.set("javadoc")
    javadoc.properties.failOnError = true
}

javadoc {
    failOnError = false
    if(JavaVersion.current().isJava9Compatible()) {
        options.addBooleanOption("html5", true)
    }
}

def releaseVersion = !version.endsWith("SNAPSHOT")

publishing {
    publications {
        mavenJava(MavenPublication) {
            artifactId = "$rootProject.name"
            from components.java
            artifact sourcesJar
            artifact javadocJar
            pom {
                name = "$rootProject.name"
                description = "$projectDescription"
                url = "$projectScmProviderUrl"+"$projectHolderUsername"+"$slash"+"$rootProject.name"
                organization {
                    name = "$projectOrganizationName"
                    url = "$projectOrganizationUrl"
                }
                issueManagement {
                    system = "$projectIssueManagementSystem"
                    url = "$projectScmProviderUrl"+"$projectHolderUsername"+"$slash"+"$rootProject.name"+"$issuesPath"
                }
                licenses {
                    license {
                        name = "$projectLicenseName"
                        url = "$projectLicenseUrl"
                        distribution = "$projectLicenseDistribution"
                    }
                }
                developers {
                    developer {
                        id = "$projectHolderUsername"
                        name = "$projectLeaderName"
                    }
                }
                scm {
                    connection = "$projectScmGitUrlPrefix" + "$projectScmProviderDomain" + "$colon" + "$projectHolderUsername" + "$slash" + "$rootProject.name" + "$projectScmGitUrlSuffix"
                    developerConnection = "$projectScmGitUrlPrefix" + "$projectScmProviderDomain" + "$colon" + "$projectHolderUsername" + "$slash" + "$rootProject.name" + "$projectScmGitUrlSuffix"
                    url = "$projectScmGitUrlPrefix" + "$projectScmProviderDomain" + "$colon" + "$projectHolderUsername" + "$slash" + "$rootProject.name" + "$projectScmGitUrlSuffix"
                }
            }
        }
    }
    repositories {
        maven {
            credentials {
                username System.getenv("$projectRepositoriesUserNameKey") ?: project.property("$projectRepositoriesUserNameKey")
                password System.getenv("$projectRepositoriesPasswordKey") ?: project.property("$projectRepositoriesPasswordKey")
            }
            def releasesRepoUrl = "$projectRepositoriesReleasesRepoUrl" as Object
            def snapshotsRepoUrl = "$projectRepositoriesSnapshotsRepoUrl" as Object
            url = releaseVersion ? releasesRepoUrl : snapshotsRepoUrl
        }
    }
}

signing {
    if (releaseVersion) {
        sign publishing.publications.mavenJava
    }
}

jar {
    manifest {
        attributes(
                "Name"                  : project.name,
                "Manifest-Version"      : project.version,
                "Implementation-Title"  : "$groupPackage" + "." + "$rootProject.name",
                "Implementation-Version": project.version,
                "Implementation-Vendor" : "$projectLeaderName",
                "Created-By"            : "Gradle ${gradle.gradleVersion}",
                "Built-By"              : "$projectLeaderName",
                "Build-Timestamp"       : new java.text.SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ").format(new Date()),
                "Build-Jdk"             : "${System.properties['java.version']} (${System.properties['java.vendor']} ${System.properties['java.vm.version']})",
                "Build-OS"              : "${System.properties['os.name']} ${System.properties['os.arch']} ${System.properties['os.version']}")
    }
}

license {
    ext.year="$projectInceptionYear"
    ext.owner="$projectLeaderName"
    ignoreFailures = true
    header rootProject.file("src/main/resources/LICENSE.txt")
    excludes(["**/README",
              "**/README.md",
              "**/LICENSE",
              "**/NOTICE",
              "**/*.xml",
              "**/*.xsl",
              "**/*.xsd",
              "**/*.dtd",
              "**/*.html",
              "**/*.jsp",
              "**/*.jpa",
              "**/*.sql",
              "**/*.properties",
              "**/*.bat",
              "**/*.gradle",
              "**/*.MF",
              "**/*.txt",
              "**/*.vm",
              "**/*.log",
              "**/*.map",
              "**/*.js.map",
              "**/*.tmpl",
              "**/*.js.tmpl",
              "**/*.editorconfig",
              "src/test/resources/**",
              "src/main/resources/**",
              "out/**",
              "build/**"])
}
// workhack for license issue #76
gradle.startParameter.excludedTaskNames += "licenseMain"
gradle.startParameter.excludedTaskNames += "licenseTest"

test {
    useJUnitPlatform()
}

jacocoTestReport {
    reports {
        xml.enabled true
        html.enabled true
    }
}

check.dependsOn jacocoTestReport

dependencies {
    compileOnly("org.projectlombok:lombok:$lombokVersion")
    annotationProcessor("org.projectlombok:lombok:$lombokVersion")
    testCompileOnly("org.projectlombok:lombok:$lombokVersion")
    testAnnotationProcessor("org.projectlombok:lombok:$lombokVersion")
    implementation("io.github.astrapi69:resourcebundle-core:$resourcebundleCoreVersion")
    implementation("javax.mail:mail:$mailVersion")
    implementation("eu.medsea.mimeutil:mime-util:$mimeUtilVersion")
    implementation("com.thoughtworks.xstream:xstream:$xstreamVersion")
    implementation("io.github.astrapi69:silly-collections:$sillyCollectionsVersion")
    implementation("io.github.astrapi69:file-worker:$fileWorkerVersion")
    implementation("io.github.astrapi69:net-extensions:$netExtensionsVersion")
    implementation("io.github.astrapi69:silly-strings:$sillyStringsVersion")
    testImplementation("io.github.astrapi69:jobj-core:$jobjCoreVersion")
    testImplementation("io.github.astrapi69:test-objects:$testObjectsVersion")
    testImplementation("commons-codec:commons-codec:$commonsCodecVersion")
    testImplementation("org.meanbean:meanbean:$meanbeanVersion")
    testImplementation("org.junit.jupiter:junit-jupiter-api:$junitJupiterVersion")
    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:$junitJupiterVersion")
}