WilderWorkspace/replaceTokenScript.gradle at master · WilderForge/WilderWorkspace · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
import org.apache.tools.ant.filters.ReplaceTokens

// Define file extensions for token replacement. You can add additional file types to replace tokens in.
def tokenReplaceExtensions = ['.java', '.json']

// Define all tokens and their replacements as a map
def replacementTokens = [
	workspaceVersion: project.version,
    providerVersion: libs.versions.provider.version.get(),
    fabricLoaderVersion: libs.versions.fabric.loader.version.get(),
    asmVersion: libs.versions.asm.version.get(),

    mixinVersion: libs.versions.mixin.version.get(),
    guavaVersion: libs.versions.guava.version.get(),

    //dependencies for building and running WilderWorkspace gradle plugin itself
    commonsIOVersion: libs.versions.commons.io.version.get(),
    commonsLangVersion: libs.versions.commons.Lang.version.get(),
    commonsTextVersion: libs.versions.commons.Text.version.get(),
    vineFlowerVersion: libs.versions.vineflower.version.get(),
    loomVersion: libs.versions.fabric.Loom.version.get(),
    gsonVersion: libs.versions.gson.version.get(),
    thrixlvaultVersion: libs.versions.thrixlvault.version.get(),

    gdxVersion: libs.versions.libgdx.version.get(),

    //transitive dependencies
    log4jVersion: libs.versions.log4j.version.get()
]

task replaceTokensInResources(type: Copy) {
    doFirst {
        delete "$buildDir/processedResources"
    }
    from(sourceSets.main.resources.srcDirs) {
        // Only include files matching the defined extensions
        include { file -> tokenReplaceExtensions.any { file.name.endsWith(it) } }
        // Apply token replacement using the predefined variable
        filter(ReplaceTokens, tokens: replacementTokens)
    }
    from(sourceSets.main.resources.srcDirs) {
        // Ensure non-text files are passed through untouched
        exclude { file -> tokenReplaceExtensions.any { file.name.endsWith(it) } }
    }
    into("$buildDir/processedResources")

    outputs.upToDateWhen { false }
    outputs.cacheIf { false }

    inputs.files(sourceSets.main.resources.srcDirs)
    outputs.dir("$buildDir/processedResources")
}

task replaceTokensInSource(type: Copy) {
    def processedDir = "$buildDir/processedSrc"
    doFirst {
    	delete processedDir
        project.logger.lifecycle("Starting file iteration in source files")
        project.logger.lifecycle("Source directories being used: ${sourceSets.main.java.srcDirs}")
    }

    from(sourceSets.main.java.srcDirs) {
        include '**/*'

        eachFile { file ->
            def matchesExtension = tokenReplaceExtensions.any { file.name.endsWith(it) }
            project.logger.lifecycle("found file " + file)
        }

        filter(ReplaceTokens, tokens: replacementTokens)
    }

    into(processedDir)

    inputs.files(sourceSets.main.java.srcDirs)
    outputs.dir(processedDir)

    // Ensure Gradle sees the task as out-of-date by overriding the up-to-date check
    outputs.upToDateWhen { false }
    outputs.cacheIf { false }

    doLast {
        project.logger.lifecycle("File iteration and token replacement complete")
    }
}

gradle.taskGraph.whenReady { taskGraph ->
    replaceTokensInSource.outputs.upToDateWhen { false }
    replaceTokensInResources.outputs.upToDateWhen { false }
}


sourceSets {
    processed {
    	resources.srcDirs = ["$buildDir/processedResources"]
        java.srcDirs = ["$buildDir/processedSrc"]
    }
    build {
    	java.srcDirs = sourceSets.main.java.srcDirs + sourceSets.processed.java.srcDirs
        resources.srcDirs = sourceSets.main.resources.srcDirs + sourceSets.processed.resources.srcDirs
    }
}

configurations {
    resolvedCompileOnly {
        extendsFrom compileOnly
    }
}

processResources {
    dependsOn replaceTokensInResources
    from(sourceSets.processed.resources)
    duplicatesStrategy = DuplicatesStrategy.INCLUDE
}

compileJava {
	dependsOn replaceTokensInResources
    source = replaceTokensInSource.outputs
    classpath -= sourceSets.main.resources
    classpath += sourceSets.processed.resources
}

task sourceJar(type: Jar) {
    from sourceSets.processed.allSource
    archiveClassifier.set('sources')
    destinationDirectory.set(file("$buildDir/libs"))
    dependsOn replaceTokensInSource, replaceTokensInResources
}
build.dependsOn(sourceJar)

eclipse {
    classpath {
    	sourceSets -= [sourceSets.processed, sourceSets.build]
    }
}