MassHash/replaceTokenScript.gradle at master · WilderForge/MassHash · 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
import org.apache.tools.ant.filters.ReplaceTokens

// Define file extensions for token replacement
def tokenReplaceExtensions = ['.java', '.json']

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
        filter(ReplaceTokens, tokens: [
            massHashVersion: project.version
        ])
    }
    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 // Ensure the directory is deleted before processing
        project.logger.lifecycle("Starting replaceTokensInSource task execution...")
        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: [
            massHashVersion: project.version
        ])
    }

    into(processedDir)

    // Properly set inputs and outputs
    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")
    }
}


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]
    }
}