build.gradle

plugins {
    id 'java-library'
    id "com.github.hierynomus.license" version "0.15.0"
    id "com.github.johnrengelman.shadow" version "5.0.0"
    id "net.researchgate.release" version "2.6.0"
    id "com.github.breadmoirai.github-release" version "2.2.11"
  	id 'io.codearte.nexus-staging' version '0.12.0'
}
project.ext {
    jUnitVersion = '5.5.0'
}

apply plugin:'java'
apply plugin:'maven'
apply plugin:'signing'
apply plugin:'com.github.hierynomus.license'
apply plugin:'com.github.johnrengelman.shadow'
apply plugin: 'net.researchgate.release'
apply plugin: "com.github.breadmoirai.github-release"
apply plugin: 'io.codearte.nexus-staging'

java {
    sourceCompatibility = JavaVersion.VERSION_11
    targetCompatibility = JavaVersion.VERSION_11
}

repositories {
	mavenCentral()
	jcenter()
}
 
dependencies {
	testImplementation group: 'org.junit.jupiter', name: 'junit-jupiter-api', version: jUnitVersion
  	testRuntimeOnly group: 'org.junit.jupiter', name: 'junit-jupiter-engine', version: jUnitVersion
  	implementation group: 'org.slf4j', name: 'slf4j-api', version: '1.7.30'
  	testImplementation group: 'org.slf4j', name: 'slf4j-simple', version: '1.7.30'
}
 
test {
	useJUnitPlatform()
	systemProperties['junit.jupiter.execution.parallel.enabled'] = true

	if (Runtime.runtime.availableProcessors()>=4){
		maxParallelForks = Runtime.runtime.availableProcessors()-2
	}	
	else{
		maxParallelForks = Runtime.runtime.availableProcessors()
	}
	minHeapSize = "4g"
	maxHeapSize = "8g"
}

license {
    header rootProject.file('src/main/resources/license.txt')
    strictCheck false
 	ext.year = Calendar.getInstance().get(Calendar.YEAR)
	include "**/*.java"
	exclude "**/*package-info.java"
}

sourceSets {
        main {
            java {srcDirs=["src/main/java"]}
            resources {srcDirs=["src/main/resources"]}
        }
        test {
            java {srcDirs=["src/test/java"]}
            resources {srcDirs=["src/test/resources"]}
        }
	}

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

task sourcesJar(type: Jar) {
	 classifier = 'sources'
	 from sourceSets.main.allSource
}


/*  Custom task to create a fat-jar containing all main and test
    sources as compiled class files and all necessary dependencies.
    The resulting fat-jar is necessary for running the PerformanceTester-Class 
    on the Linux shell where one can not use a developement environment like Eclipse.
*/
import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
task sourcesAndTestsJar(type: ShadowJar) {
    classifier = 'jar-with-tests-and-all-depedencies'
    project.configurations.implementation.canBeResolved = true
    configurations = [project.configurations.implementation]
    from sourceSets.main.output+sourceSets.test.allSource+sourceSets.test.output
}
	
shadowJar {
	classifier = 'jar-with-dependencies'
}
	
artifacts {
	archives javadocJar, sourcesJar, shadowJar
}
	
if(!project.hasProperty('signing.keyId') || !project.hasProperty('signing.password')|| !project.hasProperty('signing.secretKeyRingFile')){   
	println "WARNING: If you want to sign your archives please provide the 'signing.keyId' and 'signing.password' and 'signing.secretKeyRingFile' properties"
}
else{
	signing {
	    sign configurations.archives
	}
}
	
uploadArchives {
		repositories {
			mavenDeployer {
				if(!project.hasProperty('nexusUsername') || !project.hasProperty('nexusPassword')){   
	            	println "WARNING: If you want to release to Sonatype please provide the 'nexusUsername' and 'nexusPassword' properties"
				}
				else{
				beforeDeployment { 
						MavenDeployment deployment -> signing.signPom(deployment) 
					}
					repository(url: "https://oss.sonatype.org/service/local/staging/deploy/maven2/") {
						authentication(userName: nexusUsername, password: nexusPassword)
						if(project.hasProperty('systemProp.https.proxyHost') && project.hasProperty('systemProp.https.proxyPort')){
							println "INFO: Using system proxy for upload : "+System.properties['https.proxyHost']+":"+System.properties['https.proxyPort']
							proxy(host: System.properties['https.proxyHost'], port: System.properties['https.proxyPort'] as Integer, type: 'http')
						}
					}
					snapshotRepository(url: "https://oss.sonatype.org/content/repositories/snapshots/") {
						authentication(userName: nexusUsername, password: nexusPassword)
						if(project.hasProperty('systemProp.https.proxyHost') && project.hasProperty('systemProp.https.proxyPort')){
							println "INFO: Using system proxy for upload : "+System.properties['https.proxyHost']+":"+System.properties['https.proxyPort']
							proxy(host: System.properties['https.proxyHost'], port: System.properties['https.proxyPort'] as Integer, type: 'http')
						}					
					}
				}
				pom.project {
		        name = projectname
		        packaging = 'jar'
		        artifactId = projectname
		        description = projectdescription
		        url = projecturl
	
		        scm {
		          	connection 'scm:git:https://github.com/IPK-BIT/isa4j.git'
		          	developerConnection 'scm:git:https://github.com/IPK-BIT/isa4j.git'
		          	url 'https://github.com/IPK-BIT/isa4j.git'
		        }
	
		        licenses {
		          	license {
		            	name 'MIT License'
		            	url 'https://spdx.org/licenses/MIT.html'
		          	}
		        }
	
		        developers {
		         	developer {
			            name 'Dennis Psaroudakis'
			            email 'psaroudakis@ipk-gatersleben.de'
			            organization = 'IPK Gatersleben'
			            organizationUrl 'http://www.ipk.gatersleben.de'
			          }
			          developer {
			            name 'Dr. Daniel Arend'
			            email 'arendd@ipk-gatersleben.de'
			            organization = 'IPK Gatersleben'
			            organizationUrl 'http://www.ipk.gatersleben.de'
			          }
		        }
	      	}
			}
		}	
}
uploadArchives.dependsOn test	

nexusStaging {
	if(project.hasProperty('nexusUsername') && project.hasProperty('nexusPassword')){
		stagingProfileId  = "isa4j_ipk_gatersleben_de"	
		username = nexusUsername
		password = nexusPassword
	}
}

release {
    failOnCommitNeeded = false
    failOnPublishNeeded = true
    failOnSnapshotDependencies = true
    failOnUnversionedFiles = true
    failOnUpdateNeeded = true
    revertOnFail = true

  	preCommitText = ''
  	preTagCommitMessage = '[gradle-release-plugin] - prepare release '
    tagCommitMessage = '[gradle-release-plugin] - creating tag: '
    newVersionCommitMessage = '[gradle-release-plugin] - prepare for next development iteration '
    
    tagTemplate = "isa4j-"+'$version'
    versionPropertyFile = 'gradle.properties'
    versionProperties = []
    buildTasks = []
   
    scmAdapters = [
        net.researchgate.release.GitAdapter
    ]

    git {
        requireBranch = 'master'
        pushToRemote = 'origin'
        pushToBranchPrefix = ''
        commitVersionFileOnly = false
        signTag = false
    }
}

//skip the task to tag this relsase because it is done by the githubRelease task
createReleaseTag.enabled = false

//project.tasks.afterReleaseBuild.dependsOn project.collect({it.getTasks().getByName("githubRelease")})
project.tasks.afterReleaseBuild.dependsOn project.collect({it.getTasks().getByName("uploadArchives")})

githubRelease {
	// This is your personal access token with Repo permissions
	// You get this from your user settings > developer settings > Personal Access Tokens
	if(project.hasProperty('githubtoken')){
    	token githubtoken
    }
    owner "IPK-BIT" 			
    repo "isa4j" 						
    tagName "isa4j-"+ "${project.version}" 		
    targetCommitish "master" 			
    releaseName "isa4j-"+ "${project.version}"				
    body "" 							
    draft false 						
    prerelease false 					
  	// releaseAssets jar.destinationDir 		// this points to which files you want to upload as assets with your release
   	releaseAssets.from("build/libs/isa4j-${project.version}-jar-with-dependencies.jar","build/libs/isa4j-${project.version}.jar","build/libs/isa4j-${project.version}-sources.jar","build/libs/isa4j-${project.version}-javadoc.jar")
    overwrite false
    dryRun false
    apiEndpoint "https://api.github.com" 			
}

afterReleaseBuild.finalizedBy('githubRelease')


task copyJavaDocs(type: Copy) {
     from 'build/docs/javadoc'
     into 'docs/javadoc'
}

copyJavaDocs.dependsOn(javadoc)
javadocJar.finalizedBy(copyJavaDocs)