Paste #9Cbepp8dn0pHrlvjmBL9 at spacepaste

import com.github.jengelman.gradle.plugins.shadow.ShadowPlugin
import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
import net.minecraftforge.gradle.user.IReobfuscator
import net.minecraftforge.gradle.user.ReobfMappingType
import net.minecraftforge.gradle.user.ReobfTaskFactory
import net.minecraftforge.gradle.user.patcherUser.forge.ForgeExtension
import net.minecraftforge.gradle.user.patcherUser.forge.ForgePlugin
import nl.javadude.gradle.plugins.license.LicenseExtension
import nl.javadude.gradle.plugins.license.LicensePlugin
import org.ajoberstar.grgit.Grgit
import org.gradle.api.internal.HasConvention
import org.spongepowered.asm.gradle.plugins.MixinExtension
import org.spongepowered.asm.gradle.plugins.MixinGradlePlugin
import java.util.regex.Pattern
// Gradle repositories and dependencies
buildscript {
repositories {
mavenCentral()
jcenter()
maven {
setUrl("http://files.minecraftforge.net/maven")
}
maven {
setUrl("http://repo.spongepowered.org/maven")
}
maven {
setUrl("https://plugins.gradle.org/m2/")
}
}
}
plugins {
base
java
maven
id("net.minecraftforge.gradle.forge").version("2.3-SNAPSHOT")
id("org.spongepowered.mixin").version("0.5-SNAPSHOT")
id("com.github.johnrengelman.shadow").version("2.0.4")
id("com.github.hierynomus.license").version("0.14.0")
id("org.ajoberstar.grgit").version("3.0.0-beta.1")
}
// TODO: Reduce duplication of buildscript code between CC projects?
group = "io.github.opencubicchunks"
version = getModVersion()
val theForgeVersion: String by project
val versionSuffix: String by project
val versionMinorFreeze: String by project
val theMappingsVersion: String by project
val licenseYear: String by project
val projectName: String by project
val malisisCoreVersion: String by project
val malisisCoreMinVersion: String by project
val sourceSets = the<JavaPluginConvention>().sourceSets
val mainSourceSet = sourceSets["main"]
val minecraft = the<ForgeExtension>()
base {
archivesBaseName = "CubicWorldGen"
}
java {
sourceCompatibility = JavaVersion.VERSION_1_8
}
minecraft {
version = theForgeVersion
runDir = "run"
mappings = theMappingsVersion
isUseDepAts = true
replace("@@MALISIS_VERSION@@", malisisCoreMinVersion)
replaceIn("io/github/opencubicchunks/cubicchunks/cubicgen/CustomCubicMod.java")
}
license {
val ext = (this as HasConvention).convention.extraProperties
ext["project"] = projectName
ext["year"] = licenseYear
exclude("**/*.info")
exclude("**/package-info.java")
exclude("**/*.json")
exclude("**/*.xml")
exclude("assets/*")
header = file("HEADER.txt")
ignoreFailures = false
strictCheck = true
mapping(mapOf("java" to "SLASHSTAR_STYLE"))
}
mixin {
add(sourceSets["main"], "cubicgen.refmap.json")
}
repositories {
mavenCentral()
maven { setUrl("https://oss.sonatype.org/content/repositories/public/") }
// Note: sponge repository needs to be the second one because flow-noise is both in sponge and sonatype repository
// but sponge has older one, and we need the newer one from sonatype
// currently gradle seems to resolve dependencies from repositories in the order they are defined here
maven { setUrl("http://repo.spongepowered.org/maven") }
}
val deobfCompile by configurations
val compile by configurations
val testCompile by configurations
val forgeGradleGradleStart by configurations
val forgeGradleMcDeps by configurations
val shade by configurations.creating
compile.extendsFrom(shade)
// needed for tests to work
testCompile.extendsFrom(forgeGradleGradleStart)
testCompile.extendsFrom(forgeGradleMcDeps)
dependencies {
deobfCompile("net.malisis:malisiscore:$malisisCoreVersion") {
isTransitive = false
}
shade("com.flowpowered:flow-noise:1.0.1-SNAPSHOT")
deobfCompile("io.github.opencubicchunks:cubicchunks-api:1.12.2-0.0-SNAPSHOT")
deobfCompile("io.github.opencubicchunks:cubicchunks:1.12.2-0.0-SNAPSHOT")
// provided by cubicchunks implementation
shade("org.spongepowered:mixin:0.7.10-SNAPSHOT") {
isTransitive = false
}
testCompile("junit:junit:4.11")
testCompile("org.hamcrest:hamcrest-junit:2.0.0.0")
testCompile("it.ozimov:java7-hamcrest-matchers:0.7.0")
testCompile("org.mockito:mockito-core:2.1.0-RC.2")
testCompile("org.spongepowered:launchwrappertestsuite:1.0-SNAPSHOT")
}
fun Jar.setupManifest() {
manifest {
attributes["FMLAT"] = "cubicchunks_cubicgen_at.cfg"
attributes["FMLCorePluginContainsFMLMod"] = "true"
attributes["FMLCorePlugin"] = "io.github.opencubicchunks.cubicchunks.cubicgen.asm.CubicGenCoreMod"
attributes["TweakClass"] = "org.spongepowered.asm.launch.MixinTweaker"
attributes["TweakOrder"] = "0"
attributes["ForceLoadAsMod"] = "true"
attributes["Maven-Version"] = "${project.group}:${project.base.archivesBaseName}:${project.version}:core"
}
}
tasks {
val shadeJar by tasks.creating(ShadowJar::class) {
from(sourceSets["main"].output)
configurations = listOf(shade)
setupManifest()
classifier = "all"
}
configure<NamedDomainObjectContainer<IReobfuscator>> {
create("shadeJar").apply {
mappingType = ReobfMappingType.SEARGE
}
}
tasks["assemble"].dependsOn("reobfShadeJar")
"test"(Test::class) {
systemProperty("lwts.tweaker", "io.github.opencubicchunks.cubicchunks.tweaker.MixinTweakerServer")
jvmArgs("-Dmixin.debug.verbose=true", //verbose mixin output for easier debugging of mixins
"-Dmixin.checks.interfaces=true", //check if all interface methods are overriden in mixin
"-Dmixin.env.remapRefMap=true")
testLogging {
showStandardStreams = true
}
}
"processResources"(ProcessResources::class) {
// this will ensure that this task is redone when the versions change.
inputs.property("version", project.version.toString())
inputs.property("mcversion", minecraft.version)
// replace stuff in mcmod.info, nothing else
from(mainSourceSet.resources.srcDirs) {
include("mcmod.info")
// replace version and mcversion
expand(mapOf("version" to project.version.toString(), "mcversion" to minecraft.version))
}
// copy everything else, thats not the mcmod.info
from(mainSourceSet.resources.srcDirs) {
exclude("mcmod.info")
}
}
/*
// based on:
// https://github.com/Ordinastie/MalisisCore/blob/30d8efcfd047ac9e9bc75dfb76642bd5977f0305/build.gradle#L204-L256
// https://github.com/gradle/kotlin-dsl/blob/201534f53d93660c273e09f768557220d33810a9/samples/maven-plugin/build.gradle.kts#L10-L44
val uploadArchives by tasks.creating(Upload::class) {
repositories {
withConvention(MavenRepositoryHandlerConvention::class) {
mavenDeployer {
// Sign Maven POM
//beforeDeployment {
// signing.signPom(this)
//}
val username = if (project.hasProperty("sonatypeUsername")) project.properties["sonatypeUsername"] else System.getenv("sonatypeUsername")
val password = if (project.hasProperty("sonatypePassword")) project.properties["sonatypePassword"] else System.getenv("sonatypePassword")
withGroovyBuilder {
"snapshotRepository"("url" to "https://oss.sonatype.org/content/repositories/snapshots") {
"authentication"("userName" to username, "password" to password)
}
"repository"("url" to "https://oss.sonatype.org/service/local/staging/deploy/maven2") {
"authentication"("userName" to username, "password" to password)
}
}
// Maven POM generation
pom.project {
withGroovyBuilder {
"name"(projectName)
"artifactId"(base.archivesBaseName.toLowerCase())
"packaging"("jar")
"url"("https://github.com/OpenCubicChunks/CubicChunks")
"description"("Unlimited world height mod for Minecraft")
"scm" {
"connection"("scm:git:git://github.com/OpenCubicChunks/CubicChunks.git")
"developerConnection"("scm:git:ssh://git@github.com:OpenCubicChunks/CubicChunks.git")
"url"("https://github.com/OpenCubicChunks/RegionLib")
}
"licenses" {
"license" {
"name"("The MIT License")
"url"("http://www.tldrlegal.com/license/mit-license")
"distribution"("repo")
}
}
"developers" {
"developer" {
"id"("Barteks2x")
"name"("Barteks2x")
}
// TODO: add more developers
}
"issueManagement" {
"system"("github")
"url"("https://github.com/OpenCubicChunks/CubicChunks/issues")
}
}
}
}
}
}
}*/
}
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// !!!!!!!!!!!VERSIONS!!!!!!!!!!!!!
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
fun getMcVersion(): String {
return theForgeVersion.split("-")[0]
}
//returns version string according to this: http://mcforge.readthedocs.org/en/latest/conventions/versioning/
//format: MCVERSION-MAJORMOD.MAJORAPI.MINOR.PATCH(-final/rcX/betaX)
//rcX and betaX are not implemented yet
fun getModVersion(): Any {
return object {
val v: String by lazy {
try {
val git = Grgit.open()
val describe = org.ajoberstar.grgit.operation.DescribeOp(git.repository).call()
val branch = getGitBranch(git)
val snapshotSuffix = if (project.hasProperty("doRelease")) "" else "-SNAPSHOT"
getModVersion(describe, branch) + snapshotSuffix;
} catch (ex: RuntimeException) {
logger.error("Unknown error when accessing git repository! Are you sure the git repository exists?", ex)
String.format("%s-%s.%s.%s%s%s", getMcVersion(), "9999", "9999", "9999", "", "NOVERSION")
}
}
override fun toString() = v
}
}
fun getGitBranch(git: org.ajoberstar.grgit.Grgit): String {
var branch: String = git.branch.current.name
if (branch.equals("HEAD")) {
branch = when {
System.getenv("TRAVIS_BRANCH")?.isEmpty() == false -> // travis
System.getenv("TRAVIS_BRANCH")
System.getenv("GIT_BRANCH")?.isEmpty() == false -> // jenkins
System.getenv("GIT_BRANCH")
System.getenv("BRANCH_NAME")?.isEmpty() == false -> // ??? another jenkins alternative?
System.getenv("BRANCH_NAME")
else -> throw RuntimeException("Found HEAD branch! This is most likely caused by detached head state! Will assume unknown version!")
}
}
if (branch.startsWith("origin/")) {
branch = branch.substring("origin/".length)
}
return branch
}
fun getModVersion(describe: String, branch: String): String {
if (branch.startsWith("MC_")) {
val branchMcVersion = branch.substring("MC_".length)
if (branchMcVersion != getMcVersion()) {
logger.warn("Branch version different than project MC version! MC version: " +
getMcVersion() + ", branch: " + branch + ", branch version: " + branchMcVersion)
}
}
//branches "master" and "MC_something" are not appended to version sreing, everything else is
//only builds from "master" and "MC_version" branches will actually use the correct versioning
//but it allows to distinguish between builds from different branches even if version number is the same
val branchSuffix = if (branch == "master" || branch.startsWith("MC_")) "" else ("-" + branch.replace("[^a-zA-Z0-9.-]", "_"))
val baseVersionRegex = "v[0-9]+\\.[0-9]+"
val unknownVersion = String.format("%s-UNKNOWN_VERSION%s%s", getMcVersion(), versionSuffix, branchSuffix)
if (!describe.contains('-')) {
//is it the "vX.Y" format?
if (describe.matches(Regex(baseVersionRegex))) {
return String.format("%s-%s.0.0%s%s", getMcVersion(), describe, versionSuffix, branchSuffix)
}
logger.error("Git describe information: \"$describe\" in unknown/incorrect format")
return unknownVersion
}
//Describe format: vX.Y-build-hash
val parts = describe.split("-")
if (!parts[0].matches(Regex(baseVersionRegex))) {
logger.error("Git describe information: \"$describe\" in unknown/incorrect format")
return unknownVersion
}
if (!parts[1].matches(Regex("[0-9]+"))) {
logger.error("Git describe information: \"$describe\" in unknown/incorrect format")
return unknownVersion
}
val mcVersion = getMcVersion()
val modAndApiVersion = parts[0].substring(1)
//next we have commit-since-tag
val commitSinceTag = Integer.parseInt(parts[1])
val minorFreeze = if (versionMinorFreeze.isEmpty()) -1 else Integer.parseInt(versionMinorFreeze as String)
val minor = if (minorFreeze < 0) commitSinceTag else minorFreeze
val patch = if (minorFreeze < 0) 0 else (commitSinceTag - minorFreeze)
return String.format("%s-%s.%d.%d%s%s", mcVersion, modAndApiVersion, minor, patch, versionSuffix, branchSuffix)
}
fun extractForgeMinorVersion(): String {
// version format: MC_VERSION-MAJOR.MINOR.?.BUILD
return theForgeVersion.split(Regex("-")).getOrNull(1)?.split(Regex("\\."))?.getOrNull(1)
?: throw RuntimeException("Invalid forge version format: $theForgeVersion")
}

spacepaste

Paste details