Implement scripts as gradle plugin

This commit is contained in:
Johannes Frohnmeyer 2022-10-06 19:30:52 +02:00
parent c373dbee79
commit d567348fb3
Signed by: Johannes
GPG Key ID: E76429612C2929F4
29 changed files with 837 additions and 3 deletions

33
.gitignore vendored Normal file
View File

@ -0,0 +1,33 @@
.gradle
build/
!gradle/wrapper/gradle-wrapper.jar
!**/src/main/**/build/
!**/src/test/**/build/
### IntelliJ IDEA ###
.idea
### Eclipse ###
.apt_generated
.classpath
.factorypath
.project
.settings
.springBeans
.sts4-cache
bin/
!**/src/main/**/bin/
!**/src/test/**/bin/
### NetBeans ###
/nbproject/private/
/nbbuild/
/dist/
/nbdist/
/.nb-gradle/
### VS Code ###
.vscode/
### Mac OS ###
.DS_Store

View File

@ -1,9 +1,17 @@
variables:
GRADLE_OPTS: "-Dorg.gradle.daemon=false -Dorg.gradle.jvmargs=-Xmx2G"
before_script:
- export GRADLE_USER_HOME=`pwd`/.gradle
pages:
image: gradle:alpine
stage: deploy
script:
- shopt -s extglob
- gradle publish -Pmaven="$CI_API_V4_URL/projects/$CI_PROJECT_ID/packages/maven"
- mkdir public
- cp -r ./!(public) public
- cp ci/* public
- cp -r legacy/* public
artifacts:
paths:
- public

2
build.gradle.kts Normal file
View File

@ -0,0 +1,2 @@
group = "io.gitlab.jfronny"
version = "1.0-SNAPSHOT"

12
buildSrc/build.gradle.kts Normal file
View File

@ -0,0 +1,12 @@
plugins {
`kotlin-dsl`
}
repositories {
mavenCentral()
gradlePluginPortal()
}
dependencies {
implementation("org.gradle.kotlin:gradle-kotlin-dsl-plugins:2.3.3")
}

View File

@ -0,0 +1 @@
rootProject.name="scripts-conventions"

View File

@ -0,0 +1,40 @@
plugins {
`java-gradle-plugin`
id("org.gradle.kotlin.kotlin-dsl")
`maven-publish`
}
group = rootProject.group
version = rootProject.version
repositories {
mavenCentral()
gradlePluginPortal()
maven {
name = "Fabric"
url = uri("https://maven.fabricmc.net/")
}
maven {
name = "CurseGradle"
url = uri("https://gitlab.com/api/v4/projects/32776914/packages/maven")
}
}
publishing {
repositories {
if (project.hasProperty("maven")) {
maven(project.property("maven") as String) {
name = "dynamic"
credentials(HttpHeaderCredentials::class) {
name = "Job-Token"
value = System.getenv()["CI_JOB_TOKEN"]
}
authentication {
create<HttpHeaderAuthentication>("header")
}
}
}
mavenLocal()
}
}

View File

@ -0,0 +1,7 @@
plugins {
id("jf.plugin-conventions")
}
dependencies {
implementation("org.eclipse.jgit:org.eclipse.jgit:[6.0, 7.0)")
}

View File

@ -0,0 +1,7 @@
package io.gitlab.jfronny.convention
enum class VersionType(val displayName: String, val curseforgeName: String, val modrinthName: String) {
RELEASE("Release", "release", "release"),
BETA("Beta", "beta", "beta"),
ALPHA("Alpha", "alpha", "alpha");
}

View File

@ -0,0 +1,87 @@
package io.gitlab.jfronny.convention.ext
import org.eclipse.jgit.api.Git
import org.eclipse.jgit.errors.IncorrectObjectTypeException
import org.eclipse.jgit.lib.AnyObjectId
import org.eclipse.jgit.lib.Constants
import org.eclipse.jgit.lib.ObjectId
import org.eclipse.jgit.lib.PersonIdent
import org.eclipse.jgit.lib.Ref
import org.eclipse.jgit.lib.Repository
import org.eclipse.jgit.revwalk.RevCommit
import org.eclipse.jgit.revwalk.RevTag
import org.eclipse.jgit.revwalk.RevWalk
import java.time.Instant
import java.time.ZoneOffset
import java.time.ZonedDateTime
fun Git.log(since: AnyObjectId? = null, until: AnyObjectId? = null): List<Commit> {
var command = this.log()
if (since != null) command = command.not(since)
if (until != null) command = command.add(until)
return command.call().map { it.resolve(repository) }
}
fun Git.getTags(): List<Tag> = repository.refDatabase.getRefsByPrefix(Constants.R_TAGS)
.map { it.resolveTag(repository) }
.sortedByDescending { it.dateTime }
fun Ref.resolveTag(repo: Repository): Tag = RevWalk(repo).use { walk ->
val rev = try {
walk.parseTag(objectId)
} catch (e: IncorrectObjectTypeException) {
// Lightweight (unannotated) tag
// Copy information from commit
val target = walk.parseCommit(objectId).resolve(repo)
return Tag(objectId, null, name, target, target.author, target.fullMessage, target.shortMessage, target.dateTime)
}
walk.parseBody(rev)
walk.parseBody(rev.`object`)
val target = walk.peel(rev)
walk.parseBody(target)
return rev.resolve((target as RevCommit).resolve(repo))
}
fun RevTag.resolve(commit: Commit): Tag {
val ident = taggerIdent
return Tag(
id,
this,
name,
commit,
Person(ident, ident.name, ident.emailAddress),
fullMessage,
shortMessage,
ZonedDateTime.ofInstant(
ident.`when`.toInstant(),
ident.timeZone?.toZoneId() ?: ZoneOffset.UTC
)
)
}
fun RevCommit.resolve(repo: Repository): Commit = Commit(
this,
ObjectId.toString(this),
try {
repo.newObjectReader().use { reader -> reader.abbreviate(this).name() }
} catch (e: Exception) {
Exception("Could not abbreviate $name", e).printStackTrace()
null
},
Person(committerIdent, committerIdent.name, committerIdent.emailAddress),
Person(authorIdent, authorIdent.name, authorIdent.emailAddress),
ZonedDateTime.ofInstant(
Instant.ofEpochSecond(commitTime.toLong()),
committerIdent.timeZone?.toZoneId() ?: ZoneOffset.UTC
),
fullMessage,
shortMessage,
parents.map { ObjectId.toString(it) }
)
data class Tag(val id: ObjectId, val original: RevTag?, val fullName: String, val commit: Commit?, val tagger: Person?, val fullMessage: String?, val shortMessage: String?, val dateTime: ZonedDateTime?) {
val name: String
get() = Repository.shortenRefName(fullName)
}
data class Commit(val original: RevCommit, val id: String, val abbreviatedId: String?, val committer: Person, val author: Person, val dateTime: ZonedDateTime, val fullMessage: String, val shortMessage: String, val parentIds: List<String>)
data class Person(val original: PersonIdent, val name: String, val emailAddress: String)

View File

@ -0,0 +1,26 @@
package io.gitlab.jfronny.convention.ext
import io.gitlab.jfronny.convention.VersionType
import org.gradle.api.DefaultTask
import org.gradle.api.Project
import org.gradle.api.Task
import org.gradle.api.tasks.TaskContainer
import org.gradle.kotlin.dsl.extra
import org.gradle.kotlin.dsl.named
var Project.versionS: String
get() = version.toString()
set(value) {
version = value
}
var Project.versionType: VersionType
get() = if (extra.has("io.gitlab.jfronny.scripts.getVersionType")) extra["io.gitlab.jfronny.scripts.getVersionType"] as VersionType else VersionType.RELEASE
set(value) = extra.set("io.gitlab.jfronny.scripts.getVersionType", value)
var Project.changelog: String
get() = if (extra.has("io.gitlab.jfronny.scripts.getChangelog")) extra["io.gitlab.jfronny.scripts.getChangelog"].toString() else ""
set(value) = extra.set("io.gitlab.jfronny.scripts.getChangelog", value)
val TaskContainer.deployDebug: Task get() = findByName("deployDebug") ?: register("deployDebug").get().dependsOn(named<DefaultTask>("build").get())
val TaskContainer.deployRelease: Task get() = findByName("deployRelease") ?: register("deployRelease").get().dependsOn(deployDebug)

View File

@ -0,0 +1,45 @@
import io.gitlab.jfronny.convention.*
import io.gitlab.jfronny.convention.ext.*
import org.eclipse.jgit.api.Git
import java.awt.Toolkit
import java.awt.datatransfer.StringSelection
versionS = "0.0.0+nogit"
versionType = VersionType.ALPHA
if (File(projectDir, ".git").exists()) {
Git.open(projectDir).use { git ->
versionS = "0.0.0+notag"
val tags: List<Tag> = git.getTags()
if (tags.isNotEmpty()) {
if (tags[0].fullMessage != null) changelog += "${tags[0].fullMessage}\n"
versionS = tags[0].name
val vt = when(versionS[0]) {
'v' -> VersionType.RELEASE
'b' -> VersionType.BETA
'a' -> VersionType.ALPHA
else -> null
}
versionType = vt ?: VersionType.RELEASE
if (vt != null) versionS = versionS.substring(1)
changelog += "Commits in $versionType $versionS:\n"
changelog += git.log(if (tags.size >= 2) tags[1].id else null, tags[0].id)
.reversed()
.joinToString("\n") { "- ${it.shortMessage}" }
}
}
}
if (changelog == "") changelog = "No io.gitlab.jfronny.scripts.getChangelog"
val timestamp: Long = if (project.hasProperty("timestamp")) "${project.property("timestamp")}".toLong()
else (System.currentTimeMillis() / 1000L)
if (project.hasProperty("release")) versionS += "-$timestamp"
println(changelog)
tasks.register("copyVersionNumber") {
doLast {
Toolkit.getDefaultToolkit().systemClipboard.setContents(StringSelection(versionS), null)
println("Copied version number: $versionS")
}
}

View File

@ -0,0 +1,24 @@
plugins {
`maven-publish`
}
publishing {
repositories {
mavenLocal()
if (project.hasProperty("maven")) {
maven {
url = uri(project.property("maven").toString())
name = "dynamic"
credentials(HttpHeaderCredentials::class) {
name = "Job-Token"
value = System.getenv()["CI_JOB_TOKEN"]
}
authentication {
create<HttpHeaderAuthentication>("header")
}
}
}
}
}

9
jfmod/build.gradle.kts Normal file
View File

@ -0,0 +1,9 @@
plugins {
id("jf.plugin-conventions")
}
dependencies {
api(project(":lom"))
implementation("com.modrinth.minotaur:Minotaur:2.3.1")
implementation("io.gitlab.jfronny:CurseGradle:1.4.0-1642087331626")
}

View File

@ -0,0 +1,21 @@
package io.gitlab.jfronny.jfmod.ext
import com.matthewprenger.cursegradle.CurseExtension
import com.matthewprenger.cursegradle.CurseProject
import com.matthewprenger.cursegradle.CurseRelation
import com.matthewprenger.cursegradle.Options
import org.gradle.api.Action
import org.gradle.api.DefaultTask
import org.gradle.api.Project
import org.gradle.api.tasks.TaskContainer
import org.gradle.api.tasks.TaskProvider
import org.gradle.kotlin.dsl.closureOf
import org.gradle.kotlin.dsl.configure
import org.gradle.kotlin.dsl.named
val TaskContainer.curseforge: TaskProvider<DefaultTask> get() = named<DefaultTask>("curseforge")
fun Project.curseforge(configure: Action<CurseExtension>) = extensions.configure<CurseExtension> { configure.execute(this) }
fun CurseExtension.options(configure: Action<Options>) = options(closureOf<Options> { configure.execute(this) })
fun CurseExtension.project(configure: Action<CurseProject>) = project(closureOf<CurseProject> { configure.execute(this) })
fun CurseProject.relations(configure: Action<CurseRelation>) = relations(closureOf<CurseRelation> { configure.execute(this) })

View File

@ -0,0 +1,40 @@
import io.gitlab.jfronny.convention.ext.*
import io.gitlab.jfronny.jfmod.ext.*
import io.gitlab.jfronny.lom.ext.*
plugins {
id("jfmod")
id("com.matthewprenger.cursegradle")
}
curseforge {
if (System.getenv().containsKey("CURSEFORGE_API_TOKEN")) apiKey = System.getenv()["CURSEFORGE_API_TOKEN"]
else println("No CURSEFORGE_API_TOKEN specified")
project {
id = prop("curseforge_id")
releaseType = versionType.curseforgeName
addGameVersion("Fabric")
addGameVersion(lom.minecraftVersion.get())
changelog = project.changelog
mainArtifact(tasks.remapJar.get().archiveFile.get())
mainArtifact.displayName = "[${lom.minecraftVersion.get()}] $versionS"
relations {
prop("curseforge_required_dependencies", "")
.split(", ", ",")
.filter { it.isNotBlank() }
.forEach { requiredDependency(it) }
prop("curseforge_optional_dependencies", "")
.split(", ", ",")
.filter { it.isNotBlank() }
.forEach { optionalDependency(it) }
}
afterEvaluate {
uploadTask.dependsOn(tasks.build)
}
}
options {
forgeGradleIntegration = false
}
}
tasks.deployRelease.dependsOn(tasks.curseforge)

View File

@ -0,0 +1,103 @@
import io.gitlab.jfronny.convention.ext.*
import io.gitlab.jfronny.lom.ext.*
plugins {
id("jf.autoversion")
id("jf.maven-publish")
id("lom")
}
//TODO test libjf-config-compiler-plugin integration
if (project.hasProperty("libjf_version")) {
buildscript {
repositories {
maven {
name = "JF Commons"
url = uri("https://gitlab.com/api/v4/projects/35745143/packages/maven")
}
maven {
name = "LibJF"
url = uri("https://gitlab.com/api/v4/projects/25805200/packages/maven")
}
}
dependencies {
classpath("io.gitlab.jfronny.libjf:libjf-config-compiler-plugin:${prop("libjf_version")}")
}
}
}
val devOnlyModules by extra(prop("dev_only_module", "").split(", ", ",").filter { it.isNotBlank() })
val nonModSubprojects by extra(prop("non_mod_project", "").split(", ", ",").filter { it.isNotBlank() })
val self = project
allprojects {
if (name in nonModSubprojects) return@allprojects
group = self.group
version = self.version
apply(plugin = "jf.maven-publish")
apply(plugin = "lom")
if (self.hasProperty("libjf_version")) apply(plugin = "io.gitlab.jfronny.libjf.libjf-config-compiler-plugin")
base {
archivesName.set(prop("archives_base_name", archivesName.get()))
}
lom {
minecraftVersion.set(prop("minecraft_version"))
loaderVersion.set(prop("loader_version"))
if (hasProperty("yarn_mappings")) yarn(prop("yarn_mappings"))
else mojmap()
}
afterEvaluate {
self.allprojects.forEach { sub ->
if (sub != this && sub.name !in nonModSubprojects) {
loom {
mods {
register(sub.name) {
sourceSet(sub.sourceSets.main)
sourceSet(sub.sourceSets.client)
}
register("${sub.name}-testmod") {
sourceSet(sub.sourceSets.testmod)
}
}
}
}
}
}
}
subprojects {
if (name in nonModSubprojects) return@subprojects
self.tasks.deployDebug.dependsOn(tasks.deployDebug)
self.tasks.deployRelease.dependsOn(tasks.deployRelease)
tasks.named("javadoc").get().enabled = false
afterEvaluate {
dependencies {
testmodImplementation(sourceSets.main.output)
}
tasks.genClientOnlySources.enabled = false
tasks.genCommonSources.enabled = false
tasks.unpickClientOnlyJar.enabled = false
tasks.unpickCommonJar.enabled = false
rootProject.dependencies {
api(project(mapOf("path" to project.path, "configuration" to "shadow")))
clientImplementation(sourceSets.client.output)
testmodImplementation(sourceSets.testmod.output)
if (name !in devOnlyModules) include(project)
}
}
}
if (hasProperty("curseforge_id")) apply(plugin = "jfmod.curseforge")
if (hasProperty("modrinth_id")) apply(plugin = "jfmod.modrinth")

View File

@ -0,0 +1,40 @@
import io.gitlab.jfronny.convention.ext.*
import io.gitlab.jfronny.lom.ext.*
plugins {
id("jfmod")
id("com.modrinth.minotaur")
}
val readmeFile = file("README.md")
modrinth {
token.set(System.getenv()["MODRINTH_API_TOKEN"])
projectId.set(prop("modrinth_id"))
versionName.set("[${lom.minecraftVersion.get()}] $versionS")
versionType.set(project.versionType.modrinthName)
changelog.set(project.changelog)
uploadFile.set(tasks.remapJar.get())
gameVersions.add(lom.minecraftVersion.get())
loaders.add("fabric")
prop("modrinth_required_dependencies", "")
.split(", ", ",")
.filter { it.isNotBlank() }
.forEach { required.project(it) }
prop("modrinth_optional_dependencies", "")
.split(", ", ",")
.filter { it.isNotBlank() }
.forEach { optional.project(it) }
if (readmeFile.exists()) {
syncBodyFrom.set(
"""${readmeFile.readText()}
[![Contact](https://img.shields.io/badge/-Contact-informational)](https://jfronny.gitlab.io/contact.html)"""
)
}
}
tasks.deployRelease.dependsOn(tasks.modrinth)
if (readmeFile.exists()) {
tasks.deployRelease.dependsOn(tasks.modrinthSyncBody)
}

View File

@ -243,7 +243,7 @@ allprojects {
}
build.dependsOn remapMavenJar
task testmodJar(type: Jar) { //TODO include deps
task testmodJar(type: Jar) {
from sourceSets.testmod.output
destinationDirectory = new File(project.buildDir, "devlibs")
archiveClassifier = "testmod"

19
lom/build.gradle.kts Normal file
View File

@ -0,0 +1,19 @@
plugins {
id("jf.plugin-conventions")
}
gradlePlugin {
// Define the plugin
plugins {
create("lom") {
id = "lom"
implementationClass = "io.gitlab.jfronny.lom.LomPlugin"
}
}
}
dependencies {
api(project(":convention"))
api("net.fabricmc:fabric-loom:1.0-SNAPSHOT")
api("gradle.plugin.com.github.johnrengelman:shadow:7.1.2")
}

View File

@ -0,0 +1,27 @@
package io.gitlab.jfronny.lom
import net.fabricmc.loom.LoomGradleExtension
import org.gradle.api.Project
import org.gradle.api.provider.Property
import java.util.*
interface LomExtension {
var yarnBuild: String?
fun yarn(yarnBuild: String) {
this.yarnBuild = Objects.requireNonNull(yarnBuild)
}
fun mojmap() {
yarnBuild = null
}
val minecraftVersion: Property<String>
val loaderVersion: Property<String>
companion object {
operator fun get(project: Project): LoomGradleExtension {
return project.extensions.getByName("lom") as LoomGradleExtension
}
}
}

View File

@ -0,0 +1,187 @@
package io.gitlab.jfronny.lom
import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
import io.gitlab.jfronny.convention.ext.deployDebug
import io.gitlab.jfronny.convention.ext.versionS
import io.gitlab.jfronny.lom.ext.*
import io.gitlab.jfronny.lom.ext.registering
import net.fabricmc.loom.task.RemapJarTask
import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.api.publish.maven.MavenPublication
import org.gradle.api.tasks.bundling.AbstractArchiveTask
import org.gradle.api.tasks.bundling.Jar
import org.gradle.api.tasks.compile.JavaCompile
import org.gradle.kotlin.dsl.*
import java.io.File
class LomPlugin : Plugin<Project> {
override fun apply(target: Project) {
target.applyLom()
}
private fun Project.applyLom() {
val devlibs = File(project.buildDir, "devlibs")
val args = AfterEvaluateArgs(extensions.create("lom"), null, null)
afterEvaluate { lomAfterEvaluate(args) } // Needs to be registered before loom to properly set things up
apply(plugin = "idea")
apply(plugin = "java-library")
apply(plugin = "fabric-loom")
apply(plugin = "maven-publish")
apply(plugin = "com.github.johnrengelman.shadow")
loom {
runtimeOnlyLog4j.set(true)
splitEnvironmentSourceSets()
mods {
register(name) {
sourceSet(sourceSets.main)
sourceSet(sourceSets.client)
}
register("$name-testmod") {
sourceSet(sourceSets.testmod)
}
}
}
sourceSets {
create("testmod") {
compileClasspath += sourceSets.main.compileClasspath
runtimeClasspath += sourceSets.main.runtimeClasspath
compileClasspath += sourceSets.client.compileClasspath
runtimeClasspath += sourceSets.client.runtimeClasspath
}
}
repositories {
maven {
name = "TerraformersMC"
url = uri("https://maven.terraformersmc.com/")
}
maven {
name = "LibJF"
url = uri("https://gitlab.com/api/v4/projects/25805200/packages/maven")
}
maven {
name = "JF Gson"
url = uri("https://gitlab.com/api/v4/projects/35030495/packages/maven")
}
maven {
name = "JF Commons"
url = uri("https://gitlab.com/api/v4/projects/35745143/packages/maven")
}
maven {
name = "JF FLoader"
url = uri("https://gitlab.com/api/v4/projects/36014652/packages/maven")
}
mavenCentral()
mavenLocal()
}
configurations.create("dev")
tasks.jar.archiveClassifier.set("dev")
val inputTask: Jar = tasks.findByName("injectCompiledConfig") as Jar? ?: tasks.jar
val completeJar by tasks.registering(ShadowJar::class) {
dependsOn(inputTask)
configurations.clear()
configurations.add(project.configurations.shadow)
archiveClassifier.set("shadow")
destinationDirectory.set(devlibs)
}
args.completeJar = completeJar
artifacts.add("dev", tasks.jar.archiveFile.get().asFile) {
type = "jar"
builtBy(tasks.jar)
}
java {
withSourcesJar()
}
tasks.withType<AbstractArchiveTask>() {
isPreserveFileTimestamps = false
isReproducibleFileOrder = false
}
val remapMavenJar by tasks.registering(RemapJarTask::class) {
dependsOn(completeJar)
archiveFileName.set("$archiveBaseName-${project.versionS}-maven.jar")
addNestedDependencies.set(false)
}
args.remapMavenJar = remapMavenJar
tasks.assemble.dependsOn(remapMavenJar)
val testmodJar by tasks.registering(Jar::class) { //TODO include deps
from(sourceSets.testmod.output)
destinationDirectory.set(devlibs)
archiveClassifier.set("testmod")
}
val remapTestmodJar by tasks.registering(RemapJarTask::class) {
dependsOn(testmodJar)
inputFile.set(testmodJar.archiveFile)
archiveClassifier.set("testmod")
addNestedDependencies.set(false)
}
tasks.assemble.dependsOn(remapTestmodJar)
}
private fun Project.lomAfterEvaluate(args: AfterEvaluateArgs) {
val extension = args.extension
val completeJar = args.completeJar!!
val remapMavenJar = args.remapMavenJar!!
tasks.withType<JavaCompile>().configureEach {
options.encoding = "UTF-8"
options.release.set(17)
}
dependencies {
minecraft("com.mojang:minecraft:${extension.minecraftVersion.get()}")
if (extension.yarnBuild != null) mappings("net.fabricmc:yarn:${extension.minecraftVersion.get()}+${extension.yarnBuild}:v2")
else loom.officialMojangMappings()
modImplementation("net.fabricmc:fabric-loader:${extension.loaderVersion.get()}")
testmodImplementation(sourceSets.main.output)
testmodImplementation(sourceSets.client.output)
}
tasks.remapJar {
dependsOn(completeJar)
inputFile.set(completeJar.archiveFile)
archiveFileName.set("$archiveBaseName-${project.versionS}.jar")
}
tasks.processResources {
filesMatching("fabric.mod.json") {
expand(mapOf("version" to project.versionS))
}
}
publishing {
publications {
create<MavenPublication>("mavenJava") {
artifact(remapMavenJar) {
builtBy(remapMavenJar)
}
artifact(tasks.sourcesJar) {
builtBy(tasks.remapSourcesJar)
}
}
}
}
tasks.publish.dependsOn(tasks.build)
tasks.deployDebug.dependsOn(tasks.publish)
}
private data class AfterEvaluateArgs(val extension: LomExtension, var completeJar: ShadowJar?, var remapMavenJar: RemapJarTask?)
}

View File

@ -0,0 +1,47 @@
package io.gitlab.jfronny.lom.ext
import org.gradle.api.Action
import org.gradle.api.DefaultTask
import org.gradle.api.PolymorphicDomainObjectContainer
import org.gradle.api.Project
import org.gradle.api.Task
import org.gradle.api.plugins.JavaPluginExtension
import org.gradle.api.publish.PublishingExtension
import org.gradle.api.tasks.SourceSetContainer
import org.gradle.api.tasks.TaskContainer
import org.gradle.api.tasks.bundling.Jar
import org.gradle.kotlin.dsl.named
import org.gradle.kotlin.dsl.support.delegates.ProjectDelegate
import org.gradle.language.jvm.tasks.ProcessResources
import kotlin.reflect.KClass
import kotlin.reflect.KProperty
val Project.java: JavaPluginExtension get() = extensions.getByName("java") as JavaPluginExtension
fun Project.java(configure: Action<JavaPluginExtension>) = extensions.configure("java", configure)
val Project.publishing: PublishingExtension get() = extensions.getByName("publishing") as PublishingExtension
fun Project.publishing(configure: Action<PublishingExtension>) = extensions.configure("publishing", configure)
val Project.sourceSets: SourceSetContainer get() = extensions.getByName("sourceSets") as SourceSetContainer
fun Project.sourceSets(configure: Action<SourceSetContainer>) = extensions.configure("sourceSets", configure)
val TaskContainer.assemble: DefaultTask get() = named<DefaultTask>("assemble").get()
val TaskContainer.build: DefaultTask get() = named<DefaultTask>("build").get()
val TaskContainer.jar: Jar get() = named<Jar>("jar").get()
val TaskContainer.sourcesJar: Jar get() = named<Jar>("sourcesJar").get()
val TaskContainer.publish: Task get() = named("publish").get()
fun TaskContainer.processResources(configure: ProcessResources.() -> Unit) = named<ProcessResources>("processResources").configure(configure)
fun <T : Any, C : PolymorphicDomainObjectContainer<T>, U : T> C.registering(type: KClass<U>, action: U.() -> Unit): PDelegate<T, C, U> = PDelegate(this, type.java, action)
class PDelegate<T : Any, C : PolymorphicDomainObjectContainer<T>, U : T>(private val container: C, private val type: Class<U>, private val action: U.() -> Unit) {
operator fun provideDelegate(thisRef: Any?, property: KProperty<*>): SDelegate<U> = SDelegate(container.register(property.name, type, action).get())
}
class SDelegate<T>(private val delegate: T) {
operator fun getValue(thisRef: Any?, property: KProperty<*>): T = delegate
}
fun Project.prop(name: String, default: String? = null): String {
return if (default == null || hasProperty(name)) property(name).toString()
else default
}

View File

@ -0,0 +1,38 @@
package io.gitlab.jfronny.lom.ext
import net.fabricmc.loom.api.LoomGradleExtensionAPI
import net.fabricmc.loom.task.GenerateSourcesTask
import net.fabricmc.loom.task.RemapJarTask
import net.fabricmc.loom.task.RemapSourcesJarTask
import net.fabricmc.loom.task.UnpickJarTask
import org.gradle.api.Action
import org.gradle.api.DefaultTask
import org.gradle.api.Project
import org.gradle.api.artifacts.dsl.DependencyHandler
import org.gradle.api.tasks.SourceSet
import org.gradle.api.tasks.SourceSetContainer
import org.gradle.api.tasks.TaskContainer
import org.gradle.kotlin.dsl.named
val Project.loom: LoomGradleExtensionAPI get() = extensions.getByName("loom") as LoomGradleExtensionAPI
fun Project.loom(configure: Action<LoomGradleExtensionAPI>) = extensions.configure("loom", configure)
fun DependencyHandler.minecraft(dependencyNotation: Any) = add("minecraft", dependencyNotation)
fun DependencyHandler.mappings(dependencyNotation: Any) = add("mappings", dependencyNotation)
fun DependencyHandler.modImplementation(dependencyNotation: Any) = add("modImplementation", dependencyNotation)
fun DependencyHandler.testmodImplementation(dependencyNotation: Any) = add("testmodImplementation", dependencyNotation)
fun DependencyHandler.clientImplementation(dependencyNotation: Any) = add("clientImplementation", dependencyNotation)
val SourceSetContainer.main: SourceSet get() = named("main").get()
fun SourceSetContainer.main(configure: Action<SourceSet>) = configure.execute(this.main)
val SourceSetContainer.client: SourceSet get() = named("client").get()
fun SourceSetContainer.client(configure: Action<SourceSet>) = configure.execute(this.client)
val SourceSetContainer.testmod: SourceSet get() = named("testmod").get()
fun SourceSetContainer.testmod(configure: Action<SourceSet>) = configure.execute(this.testmod)
fun TaskContainer.remapJar(configure: RemapJarTask.() -> Unit) = named<RemapJarTask>("remapJar").configure(configure)
val TaskContainer.remapSourcesJar: RemapSourcesJarTask get() = named<RemapSourcesJarTask>("remapSourcesJar").get()
val TaskContainer.genClientOnlySources: DefaultTask get() = named<DefaultTask>("genClientOnlySources").get()
val TaskContainer.genCommonSources: DefaultTask get() = named<DefaultTask>("genCommonSources").get()
val TaskContainer.unpickClientOnlyJar: UnpickJarTask get() = named<UnpickJarTask>("unpickClientOnlyJar").get()
val TaskContainer.unpickCommonJar: UnpickJarTask get() = named<UnpickJarTask>("unpickCommonJar").get()

View File

@ -0,0 +1,6 @@
package io.gitlab.jfronny.lom.ext
import org.gradle.api.artifacts.Configuration
import org.gradle.api.artifacts.ConfigurationContainer
val ConfigurationContainer.shadow: Configuration get() = named("shadow").get()

5
settings.gradle.kts Normal file
View File

@ -0,0 +1,5 @@
rootProject.name = "scripts"
include("lom")
include("convention")
include("jfmod")