378 lines
12 KiB
Groovy
378 lines
12 KiB
Groovy
buildscript {
|
|
repositories {
|
|
maven {
|
|
name = 'Fabric'
|
|
url = 'https://maven.fabricmc.net/'
|
|
}
|
|
gradlePluginPortal()
|
|
}
|
|
|
|
dependencies {
|
|
classpath "gradle.plugin.com.matthewprenger:CurseGradle:1.4.0"
|
|
classpath "gradle.plugin.com.modrinth.minotaur:Minotaur:1.2.1"
|
|
classpath "net.fabricmc:fabric-loom:0.10-SNAPSHOT"
|
|
classpath "org.ajoberstar.grgit:grgit-gradle:3.1.0"
|
|
}
|
|
}
|
|
|
|
ext.curseforgeAvailable = project.hasProperty("curseforge_id")
|
|
ext.modrinthAvailable = project.hasProperty("modrinth_id")
|
|
|
|
apply plugin: 'idea'
|
|
apply plugin: 'java-library'
|
|
apply plugin: 'maven-publish'
|
|
if (ext.curseforgeAvailable) apply plugin: com.matthewprenger.cursegradle.CurseGradlePlugin
|
|
apply plugin: com.modrinth.minotaur.Minotaur
|
|
apply plugin: org.ajoberstar.grgit.gradle.GrgitPlugin
|
|
|
|
import com.modrinth.minotaur.request.VersionType
|
|
|
|
static Node getOrCreateNode(Node node, String name) {
|
|
Node dependencies = null
|
|
for(Node n : node) {
|
|
if(name == n.name()) {
|
|
dependencies = n
|
|
break
|
|
}
|
|
}
|
|
if(dependencies == null) {
|
|
dependencies = node.appendNode(name)
|
|
}
|
|
return dependencies
|
|
}
|
|
|
|
ext.moduleDependencies = { Project project, List<String> depNames ->
|
|
def deps = depNames.iterator().collect { project.dependencies.project(path: ":$it", configuration: 'dev') }
|
|
project.dependencies {
|
|
deps.each {
|
|
api it
|
|
}
|
|
}
|
|
project.publishing {
|
|
publications {
|
|
mavenJava(MavenPublication) {
|
|
pom.withXml {
|
|
def depsNode = getOrCreateNode(asNode(), "dependencies")
|
|
deps.each {
|
|
def depNode = depsNode.appendNode("dependency")
|
|
depNode.appendNode("groupId", it.group)
|
|
depNode.appendNode("artifactId", it.name)
|
|
depNode.appendNode("version", it.version)
|
|
depNode.appendNode("scope", "compile")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Fetch changelog
|
|
def changelogStr = ""
|
|
ext.currentVer = "0.0.0+nogit"
|
|
ext.currentType = VersionType.ALPHA
|
|
if (grgit != null) {
|
|
ext.currentVer = "0.0.0+notag"
|
|
grgit.open(dir: project.projectDir.toString())
|
|
def tagList = grgit.tag.list()
|
|
tagList.sort((left, right) -> right.commit.dateTime.compareTo(left.commit.dateTime))
|
|
if (tagList.size() >= 1) {
|
|
if (tagList.get(0).fullMessage != null) {
|
|
changelogStr += tagList.get(0).fullMessage + "\n"
|
|
}
|
|
ext.currentType = VersionType.RELEASE
|
|
ext.currentVer = tagList.get(0).getName()
|
|
switch (ext.currentVer[0]) {
|
|
case 'v':
|
|
ext.currentVer = ext.currentVer.substring(1)
|
|
break
|
|
case 'b':
|
|
ext.currentVer = ext.currentVer.substring(1)
|
|
ext.currentType = VersionType.BETA
|
|
break
|
|
case 'a':
|
|
ext.currentVer = ext.currentVer.substring(1)
|
|
ext.currentType = VersionType.ALPHA
|
|
break
|
|
}
|
|
def commits = new ArrayList<>(tagList.size() >= 2
|
|
? grgit.log{range(tagList.get(1).fullName, tagList.get(0).fullName)}
|
|
: grgit.log(includes: [grgit.tag.list().get(0).fullName]))
|
|
Collections.reverse(commits)
|
|
changelogStr += "Commits in " + ext.currentType.toString().toLowerCase() + " " + ext.currentVer + ":\n"
|
|
for (def commit : commits) {
|
|
changelogStr += "- " + commit.shortMessage + "\n"
|
|
}
|
|
}
|
|
}
|
|
if (changelogStr == "") {
|
|
changelogStr = "No changelog"
|
|
}
|
|
if (!project.hasProperty("release")) {
|
|
ext.currentVer += "-" + Instant.now().getEpochSecond()
|
|
}
|
|
println(changelogStr)
|
|
|
|
if (!project.hasProperty("modrinth_required_dependencies"))
|
|
project.ext.modrinth_required_dependencies = ""
|
|
else
|
|
project.ext.modrinth_required_dependencies = project.modrinth_required_dependencies
|
|
if (!project.hasProperty("modrinth_optional_dependencies"))
|
|
project.ext.modrinth_optional_dependencies = ""
|
|
else
|
|
project.ext.modrinth_optional_dependencies = project.modrinth_optional_dependencies
|
|
if (!project.hasProperty("curseforge_required_dependencies"))
|
|
project.ext.curseforge_required_dependencies = ""
|
|
else
|
|
project.ext.curseforge_required_dependencies = project.curseforge_required_dependencies
|
|
if (!project.hasProperty("curseforge_optional_dependencies"))
|
|
project.ext.curseforge_optional_dependencies = ""
|
|
else
|
|
project.ext.curseforge_optional_dependencies = project.curseforge_optional_dependencies
|
|
|
|
allprojects {
|
|
apply plugin: "java-library"
|
|
apply plugin: "maven-publish"
|
|
apply plugin: net.fabricmc.loom.bootstrap.LoomGradlePluginBootstrap
|
|
|
|
tasks.withType(JavaCompile).configureEach {
|
|
it.options.encoding = "UTF-8"
|
|
it.options.release = 17
|
|
}
|
|
|
|
if (project.hasProperty("archives_base_name"))
|
|
archivesBaseName = project.archives_base_name
|
|
group = project.maven_group
|
|
version = "$rootProject.ext.currentVer"
|
|
|
|
dependencies {
|
|
minecraft "com.mojang:minecraft:${project.minecraft_version}"
|
|
mappings "net.fabricmc:yarn:${project.minecraft_version}+${project.yarn_mappings}:v2"
|
|
modImplementation "net.fabricmc:fabric-loader:${project.loader_version}"
|
|
}
|
|
|
|
//loom {
|
|
// shareRemapCaches = true
|
|
//}
|
|
|
|
repositories {
|
|
maven {
|
|
name = 'TerraformersMC'
|
|
url = 'https://maven.terraformersmc.com/'
|
|
}
|
|
maven {
|
|
name = 'LibJF'
|
|
url = 'https://gitlab.com/api/v4/projects/25805200/packages/maven'
|
|
}
|
|
mavenLocal()
|
|
mavenCentral()
|
|
}
|
|
|
|
configurations {
|
|
dev
|
|
}
|
|
|
|
jar {
|
|
archiveClassifier = "dev"
|
|
}
|
|
|
|
afterEvaluate {
|
|
remapJar {
|
|
input = file("${project.buildDir}/libs/$archivesBaseName-${project.version}-dev.jar")
|
|
archiveFileName = "${archivesBaseName}-${project.version}.jar"
|
|
}
|
|
|
|
artifacts {
|
|
dev file: file("${project.buildDir}/libs/$archivesBaseName-${project.version}-dev.jar"), type: "jar", builtBy: jar
|
|
}
|
|
|
|
processResources {
|
|
inputs.property "version", project.version
|
|
|
|
filesMatching("fabric.mod.json") {
|
|
expand "version": project.version
|
|
}
|
|
}
|
|
}
|
|
|
|
java {
|
|
withSourcesJar()
|
|
}
|
|
|
|
tasks.withType(AbstractArchiveTask) {
|
|
preserveFileTimestamps = false
|
|
reproducibleFileOrder = true
|
|
}
|
|
}
|
|
|
|
subprojects {
|
|
publishing {
|
|
publications {
|
|
mavenJava(MavenPublication) {
|
|
afterEvaluate {
|
|
artifact(remapJar) {
|
|
builtBy remapJar
|
|
}
|
|
|
|
artifact(sourcesJar) {
|
|
builtBy remapSourcesJar
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
setupRepositories(repositories)
|
|
}
|
|
|
|
loom.disableDeprecatedPomGeneration(publishing.publications.mavenJava)
|
|
|
|
javadoc.enabled = false
|
|
|
|
afterEvaluate {
|
|
genSources.enabled = false
|
|
unpickJar.enabled = false
|
|
}
|
|
}
|
|
|
|
task remapMavenJar(type: net.fabricmc.loom.task.RemapJarTask, dependsOn: jar) {
|
|
input = jar.archiveFile
|
|
archiveFileName = "${archivesBaseName}-${project.version}-maven.jar"
|
|
addNestedDependencies = false
|
|
}
|
|
build.dependsOn remapMavenJar
|
|
|
|
publishing {
|
|
publications {
|
|
mavenJava(MavenPublication) {
|
|
artifact(remapMavenJar) {
|
|
builtBy remapMavenJar
|
|
}
|
|
|
|
artifact(sourcesJar) {
|
|
builtBy remapSourcesJar
|
|
}
|
|
|
|
pom.withXml {
|
|
def depsNode = getOrCreateNode(asNode(), "dependencies")
|
|
subprojects.each {
|
|
def depNode = depsNode.appendNode("dependency")
|
|
depNode.appendNode("groupId", it.group)
|
|
depNode.appendNode("artifactId", it.name)
|
|
depNode.appendNode("version", it.version)
|
|
depNode.appendNode("scope", "compile")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
setupRepositories(repositories)
|
|
}
|
|
|
|
loom.disableDeprecatedPomGeneration(publishing.publications.mavenJava)
|
|
|
|
void setupRepositories(RepositoryHandler repositories) {
|
|
def ENV = System.getenv()
|
|
if (project.hasProperty("maven")) {
|
|
repositories.maven {
|
|
url = project.getProperty("maven")
|
|
name = "dynamic"
|
|
|
|
credentials(HttpHeaderCredentials) {
|
|
name = "Job-Token"
|
|
value = ENV.CI_JOB_TOKEN
|
|
}
|
|
authentication {
|
|
header(HttpHeaderAuthentication)
|
|
}
|
|
}
|
|
}
|
|
repositories.mavenLocal()
|
|
}
|
|
|
|
subprojects.each { remapJar.dependsOn("${it.path}:remapJar") }
|
|
|
|
dependencies {
|
|
afterEvaluate {
|
|
subprojects.each {
|
|
api project(path: ":${it.name}", configuration: "dev")
|
|
|
|
if (!project.hasProperty("dev_only_module") || !(it.name in project.getProperty("dev_only_module").split(", "))) {
|
|
include it
|
|
}
|
|
|
|
testmodImplementation it.sourceSets.testmod.output
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ext.modrinthAvailable) {
|
|
task modrinth(type: com.modrinth.minotaur.TaskModrinthUpload, dependsOn: build) {
|
|
token = System.getenv().MODRINTH_API_TOKEN
|
|
projectId = project.modrinth_id
|
|
versionNumber = version
|
|
versionName = "[${project.minecraft_version}] ${version}"
|
|
versionType = project.ext.currentType
|
|
changelog = changelogStr
|
|
uploadFile = file("${project.buildDir}/libs/${archivesBaseName}-${version}.jar")
|
|
addGameVersion("${project.minecraft_version}")
|
|
addLoader('fabric')
|
|
if (!project.ext.modrinth_required_dependencies.isEmpty()) {
|
|
project.ext.modrinth_required_dependencies.split(", ").each {
|
|
String dep -> addDependency(dep, com.modrinth.minotaur.request.Dependency.DependencyType.REQUIRED)
|
|
}
|
|
}
|
|
if (!project.ext.modrinth_optional_dependencies.isEmpty()) {
|
|
project.ext.modrinth_optional_dependencies.split(", ").each {
|
|
String dep -> addDependency(dep, com.modrinth.minotaur.request.Dependency.DependencyType.OPTIONAL)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
task modrinth() {
|
|
}
|
|
}
|
|
|
|
if (ext.curseforgeAvailable) {
|
|
curseforge {
|
|
if (System.getenv().CURSEFORGE_API_TOKEN) {
|
|
apiKey = System.getenv().CURSEFORGE_API_TOKEN
|
|
} else {
|
|
println "No CURSEFORGE_API_TOKEN specified"
|
|
}
|
|
project {
|
|
id = project.curseforge_id
|
|
releaseType = 'release'
|
|
addGameVersion "Fabric"
|
|
addGameVersion "${project.minecraft_version}"
|
|
changelog = changelogStr
|
|
mainArtifact(file("${project.buildDir}/libs/${archivesBaseName}-${version}.jar"))
|
|
mainArtifact.displayName = "[${project.minecraft_version}] ${version}"
|
|
if (!project.ext.curseforge_required_dependencies.isEmpty() || !project.ext.curseforge_optional_dependencies.isEmpty()) {
|
|
relations {
|
|
if (!project.ext.curseforge_required_dependencies.isEmpty()) {
|
|
project.ext.curseforge_required_dependencies.split(", ").each {
|
|
String dep -> requiredDependency dep
|
|
}
|
|
}
|
|
if (!project.ext.curseforge_optional_dependencies.isEmpty()) {
|
|
project.ext.curseforge_optional_dependencies.split(", ").each {
|
|
String dep -> optionalDependency dep
|
|
}
|
|
}
|
|
}
|
|
}
|
|
releaseType = project.ext.currentType.toString().toLowerCase()
|
|
afterEvaluate {
|
|
uploadTask.dependsOn(build)
|
|
}
|
|
}
|
|
options {
|
|
forgeGradleIntegration = false
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
task curseforge() {
|
|
}
|
|
}
|