build.gradle

// Buildscript Dependencies
buildscript {
}

// Plugins
plugins {
	id 'com.palantir.git-version' version '0.7.1'
	id 'co.riiid.gradle' version '0.4.2'
	id 'com.jfrog.bintray' version '1.8.4'
	id 'com.matthewprenger.cursegradle' version '1.0.10'
}

// Configure Utility
allprojects {
	project.metaClass {
		isProperty = { propName ->
			return delegate.hasProperty(propName)&&!delegate.property(propName).empty
		}
	}
}

// Configure Variables
import org.apache.commons.lang.StringUtils

ext {
	mod_commonname = "${rootProject.name}-common"
	mod_build_prefix = 'b'

	assert project.isProperty('version_major'): 'missing property: version_major'
	assert project.isProperty('version_minor'): 'missing property: version_minor'
	assert project.isProperty('version_patch'): 'missing property: version_patch'

	mod_travis = System.getenv('TRAVIS') as boolean
	mod_buildnumber = System.getenv('TRAVIS_BUILD_NUMBER') as Integer
	mod_buildtag = System.getenv('TRAVIS_TAG')
	mod_prerelease = mod_autorelease = mod_travis && StringUtils.isEmpty(mod_buildtag)

	if (mod_buildtag!=null && mod_buildtag.startsWith(mod_build_prefix))
		throw new GradleException("Oops, circulated travis build. A push starting with the prefix '${mod_build_prefix}' was detected: ${mod_buildtag}")

	(mod_version_build, mod_version_meta) = ({
		if (mod_buildnumber)
			return [".${mod_buildnumber}", '']
		else
			return ({
				def buildnumberfile = file '.buildnumber/buildnum.properties'

				def version_build = ({
					def buildnumbermicro = 1
					def props = new Properties()
					if (buildnumberfile.exists())
						buildnumberfile.withInputStream { stream ->
							props.load stream
						}

					if (props.buildnumber &&
							props.version_major == project.version_major &&
							props.version_minor == project.version_minor &&
							props.version_patch == project.version_patch)
						buildnumbermicro = props.buildnumber as Integer
					return buildnumbermicro
				})()

				def buildtextmicro = String.format('%03d', version_build)
				def buildtext = "+${buildtextmicro}"

				task increment {
					doLast {
						def props = new Properties()
						props.version_major = project.version_major
						props.version_minor = project.version_minor
						props.version_patch = project.version_patch
						props.buildnumber = version_build+1 as String
						buildnumberfile.parentFile.mkdirs()
						buildnumberfile.withOutputStream { stream ->
							props.store stream, 'Build Number Property'
						}
					}
				}

				subprojects {
					afterEvaluate {
						tasks.build.dependsOn increment
					}
				}

				['', buildtext]
			})()
	})()

	mod_version_min = "${project.version_major}.${project.version_minor}.${project.version_patch}"
	mod_version = "${mod_version_min}${mod_version_build}"
	mod_version_full = "${mod_version}${mod_version_meta}"
	mod_artifacts_dir = file "artifacts/${mod_version_min}/${mod_version_full}"

	mod_git_repo = plugins.findPlugin('com.palantir.git-version').gitRepo(rootProject).repository
	mod_git_head = mod_git_repo.getRef('HEAD').objectId.name()

	// Parse Changelog
	def parseChangelog = { changelog ->
		def title = null
		def msg = null
		def releasetype = 'release'

		if (changelog!=null) {
			// Beta mode and Alpha mode
			if (StringUtils.contains(changelog, '[beta]')) {
				changelog = StringUtils.replace(changelog, '[beta]', '')
				releasetype = 'beta'
			} else if (StringUtils.contains(changelog, '[alpha]')) {
				changelog = StringUtils.replace(changelog, '[alpha]', '')
				releasetype = 'alpha'
			}

			// Split Title and Body
			def tagtitle = StringUtils.substringBefore(changelog, '\n')
			def tagmsg = StringUtils.stripStart(StringUtils.substringAfter(changelog, '\n'), '\n')
			if (!StringUtils.isEmpty(tagtitle))
				title = tagtitle
			if (!StringUtils.isEmpty(tagmsg))
				msg = tagmsg
		}
		return [title, msg, releasetype]
	}

	// Changelog Text
	(mod_changelog_title, mod_changelog, mod_releasetype) = ({
		// Get Changelog from Git Tag or File
		def (changelog_title, changelog, releasetype) = parseChangelog(({
			if (!StringUtils.isEmpty(mod_buildtag)) {
				def git_ref = mod_git_repo.getRef "refs/tags/${mod_buildtag}"

				if (git_ref!=null) {
					def git_revwalk = new org.eclipse.jgit.revwalk.RevWalk(mod_git_repo)
					try {
						return git_revwalk.parseTag(git_ref.getObjectId()).getFullMessage()
					} catch(org.eclipse.jgit.errors.IncorrectObjectTypeException e) {
					} finally {
						git_revwalk.dispose()
					}
				}
			} else {
				def fileChangelog = project.isProperty('extra_changelog_location') ? file(project.extra_changelog_location) : file('changelog.md')
				if (fileChangelog.exists())
					return fileChangelog.getText('UTF-8')
			}
			return null
		})())

		// Replace Version Text
		def convertChangelog = { str ->
			def str1 = str
				.replace('{version}', mod_version)
				.replace('{version_full}', mod_version_full)
			if (mod_buildnumber!=null)
				return str1
					.replace('{version_number}', "${mod_buildnumber}")
			return str1
		}

		// Generate Default Changelog
		def (n_changelog_title, n_changelog) = ({
			if (mod_buildnumber!=null)
				return ["v${mod_version}", "v${mod_version_min} Build${mod_buildnumber}"]
			else
				return ["v${mod_version_full}", "v${mod_version_full}"]
		})()

		if (changelog_title!=null)
			n_changelog_title = convertChangelog(changelog_title)
		if (changelog!=null)
			n_changelog = convertChangelog(changelog)
		return [n_changelog_title, n_changelog, releasetype]
	})()

	sec_curseforge_key = System.getenv('CURSEFORGE_TOKEN') ?: project.isProperty('api_key_curseforge') ? project.api_key_curseforge : null
	sec_github_key = System.getenv('GITHUB_TOKEN') ?: project.isProperty('api_key_github') ? project.api_key_github : null
	sec_bintray_user = System.getenv('BINTRAY_USER') ?: project.isProperty('api_user_bintray') ? project.api_user_bintray : null
	sec_bintray_key = System.getenv('BINTRAY_KEY') ?: project.isProperty('api_key_bintray') ? project.api_key_github : null
}

// Configure Subprojects
evaluationDependsOnChildren()

// Plugins
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'idea'
apply plugin: 'maven-publish'

// Configure Source Sets
sourceSets {
	delegate.each { s ->
		s.java {
			srcDirs = []
		}
		s.resources {
			srcDirs = []
		}
	}
}

// Auto-Generated Directory
task setupSourceSets {
	doLast {
		sourceSets*.java.srcDirs*.each { it.mkdirs() }
		sourceSets*.resources.srcDirs*.each { it.mkdirs() }
	}
	[tasks.eclipseClasspath, tasks.ideaModule]*.dependsOn 'setupSourceSets'
}

// Configure Version
version = "${mod_version}"

// Universal Jar
jar {
	subprojects.each { p ->
		if (p.name==mod_commonname) {
			manifest p.commonManifest
			p.tasks.shadowJar.outputs.files.each { f ->
				from zipTree(f)
			}
		} else {
			p.tasks.jar.outputs.files.each { f ->
				from(f) {
					rename '.*', p.version_minecraft+'.jar'
				}
			}
		}
		dependsOn p.tasks.build
	}
	classifier = 'universal'
	destinationDir = mod_artifacts_dir
}

// Output Jar
artifacts {
    archives jar
}

// Release GitHub
gradle.taskGraph.whenReady {taskGraph ->
	if (taskGraph.hasTask(tasks.githubRelease)) {
		assert sec_github_key!=null, 'missing sec_github_key'
		assert project.isProperty('extra_github_owner'), 'missing extra_github_owner'
		assert project.isProperty('extra_github_repo'), 'missing extra_github_repo'
	}
}
if (sec_github_key!=null&&project.isProperty('extra_github_owner')&&project.isProperty('extra_github_repo')) {
	github {
		tasks.githubRelease.dependsOn 'build'
		prerelease = mod_prerelease
		owner = project.extra_github_owner
		repo = project.extra_github_repo
		token = sec_github_key
		tagName = mod_travis ? (mod_autorelease ? "${mod_build_prefix}${mod_buildnumber}" : mod_buildtag) : mod_version_full
		targetCommitish = mod_git_head
		name = mod_changelog_title
		body = mod_changelog
		draft = false
		def allassets = [jar]
		subprojects.each { p ->
			allassets.addAll([p.tasks.shadowJar, p.tasks.jar, p.tasks.devJar, p.tasks.sourceJar, p.tasks.apiJar])
		}
		assets = allassets*.outputs*.files*.asPath*.tr('\\','/')
	}
}

// Release Bintray - Maven Publishing
publishing.publications {
	ModPublication(MavenPublication) {
		groupId = project.group
		artifactId = project.modid
		version = "${mod_version}"
		artifact jar
	}

	subprojects.each { p ->
		if (p.name!=mod_commonname) {
			"ModPublication-${p.version_minecraft}"(MavenPublication) {
				groupId = p.group
				artifactId = p.modid
				version = "${p.version_minecraft}-${p.mod_version}"
				artifact p.shadowJar
				//artifact p.jar
				artifact p.devJar
				artifact p.sourceJar
				artifact p.apiJar
			}
		}
	}
}

// Release Bintray
gradle.taskGraph.whenReady {taskGraph ->
	if (taskGraph.hasTask(tasks.bintrayUpload)) {
		assert sec_bintray_user!=null, 'missing sec_bintray_user'
		assert sec_bintray_key!=null, 'missing sec_bintray_key'
		assert project.isProperty('extra_bintray_repo'), 'missing extra_bintray_repo'
		assert project.isProperty('extra_bintray_name'), 'missing extra_bintray_name'
	}
}
if (sec_bintray_user!=null&&sec_bintray_key!=null&&project.isProperty('extra_bintray_repo')&&project.isProperty('extra_bintray_name')) {
	bintray {
		tasks.bintrayUpload.enabled = !mod_autorelease
		user = sec_bintray_user
		key = sec_bintray_key
		def pubs = ['ModPublication']
		subprojects.each { p ->
			if (p.name!=mod_commonname)
				pubs += "ModPublication-${p.version_minecraft}"
		}
		publications = pubs

		publish = true
		pkg {
			userOrg = project.extra_bintray_org
			repo = project.extra_bintray_repo
			name = project.extra_bintray_name
			version {
				name = "${mod_version}"
				released = new Date()
				desc = "${mod_changelog_title}"+(StringUtils.isEmpty(mod_changelog)?'':"\n\n${mod_changelog}")
				vcsTag = mod_buildtag
			}
		}
	}
} else
	tasks.bintrayUpload.enabled = false

// Release CurseForge
if (sec_curseforge_key!=null&&project.isProperty('extra_curseforge_id')) {
	curseforge {
		tasks.curseforge.enabled = !mod_autorelease

		tasks.curseforge.dependsOn 'build'
		apiKey = sec_curseforge_key
		project {
			id = project.extra_curseforge_id

			changelogType = 'markdown'
			changelog = mod_changelog

			releaseType = mod_releasetype

			mainArtifact(jar) {
				displayName = "${jar.baseName}-${jar.version} Universal"
			}

			subprojects.each { p ->
				addGameVersion p.version_minecraft
			}

			/*
			relations {
			}
			*/
		}
	}
} else
	tasks.curseforge.enabled = false