asynchronizer

1
@file:Suppress("UnstableApiUsage")
2

3
import org.jreleaser.model.Active
4

5
plugins {
6
    `java-library`
7
    `maven-publish`
8
    alias(libs.plugins.jreleaser)
9
}
10

11
allprojects {
12

13
    group = properties["PROJECT_GROUP"].toString()
14
    version = properties[project.name + "-version"].toString()
15
    description = properties[project.name + "-description"].toString()
16

17
    repositories {
18
        mavenCentral()
19
    }
20

21
}
22

23
subprojects {
24

25
    apply(plugin = "java-library")
26
    apply(plugin = "maven-publish")
27
    apply(plugin = rootProject.libs.plugins.jreleaser.get().pluginId)
28

29
    configure<JavaPluginExtension> {
30
        sourceCompatibility = JavaVersion.VERSION_17
31
        targetCompatibility = JavaVersion.VERSION_17
32
    }
33

34
    tasks.withType<JavaCompile> {
35
        options.encoding = "UTF-8"
36
        options.compilerArgs.add("-parameters")
37
    }
38

39
    tasks.withType<Jar> {
40
        isPreserveFileTimestamps = false
41
        isReproducibleFileOrder = true
42
    }
43

44
    java {
45
        withJavadocJar()
46
        withSourcesJar()
47
    }
48

49
    dependencies {
50
        compileOnly(rootProject.libs.lombok)
51
        annotationProcessor(rootProject.libs.lombok)
52

53
        testCompileOnly(rootProject.libs.lombok)
54
        testAnnotationProcessor(rootProject.libs.lombok)
55
    }
56

57
    testing {
58
        suites {
59
            val test by getting(JvmTestSuite::class) {
60
                testType.set(TestSuiteType.UNIT_TEST)
61

62
                useJUnitJupiter()
63

64
                dependencies {
65
                    implementation.bundle(rootProject.testLibs.bundles.junitAndMockito)
66
                }
67
            }
68
        }
69
    }
70

71
    publishing {
72

73
        publications {
74
            create<MavenPublication>("release") {
75
                from(components["java"])
76

77
                artifactId = project.name
78

79
                pom {
80
                    inceptionYear = "2024"
81
                    name.set(project.name)
82
                    description.set(project.description)
83
                    url.set(project.properties["PROJECT_URL"].toString())
84

85
                    issueManagement {
86
                        url.set(project.properties["PROJECT_ISSUES_URL"].toString())
87
                    }
88

89
                    scm {
90
                        url.set(project.properties["PROJECT_REPO_URL"].toString())
91
                        connection.set(project.properties["PROJECT_GIT_URL"].toString())
92
                        developerConnection.set(project.properties["PROJECT_GIT_URL"].toString())
93
                    }
94

95
                    licenses {
96
                        license {
97
                            name.set(project.properties["PROJECT_LICENSE_NAME"].toString())
98
                            url.set(project.properties["PROJECT_LICENSE_URL"].toString())
99
                            distribution.set("repo")
100
                        }
101
                    }
102

103
                    developers {
104
                        developer {
105
                            id.set(project.properties["AUTHOR_ID"].toString())
106
                            name.set(project.properties["AUTHOR_NAME"].toString())
107
                            email.set(project.properties["AUTHOR_EMAIL"].toString())
108
                            url.set(project.properties["AUTHOR_URL"].toString())
109
                        }
110
                    }
111
                }
112
            }
113
        }
114

115
        repositories {
116
            maven {
117
                setUrl(layout.buildDirectory.dir("staging-deploy"))
118
            }
119
        }
120

121
    }
122

123
    jreleaser {
124
        beforeEvaluate {
125
            mkdir(layout.buildDirectory.dir("jreleaser"))
126
        }
127
        gitRootSearch = true
128
        project {
129
            inceptionYear = "2024"
130
            author(properties["AUTHOR_NAME"].toString())
131
        }
132
        signing {
133
            active = Active.ALWAYS
134
            armored = true
135
            verify = true
136
        }
137
        release {
138
            github {
139
                overwrite = true
140
                sign = true
141
                branch = properties["RELEASE_BRANCH"].toString()
142
                branchPush = properties["RELEASE_BRANCH"].toString()
143
                changelog {
144
                    formatted = Active.ALWAYS
145
                    format = "- {{commitShortHash}} {{commitTitle}}"
146
                    contributors {
147
                        enabled = false
148
                    }
149
                    labeler {
150
                        label = "feature"
151
                        title = "feat:"
152
                    }
153
                    labeler {
154
                        label = "bug"
155
                        title = "fix:"
156
                    }
157
                    labeler {
158
                        label = "task"
159
                        title = "chore:"
160
                    }
161
                    labeler {
162
                        label = "task"
163
                        title = "ci:"
164
                    }
165
                    labeler {
166
                        label = "doc"
167
                        title = "docs:"
168
                    }
169
                    category {
170
                        title = "🚀 New Features"
171
                        key = "feature"
172
                        labels = setOf("feature")
173
                        order = 1
174
                    }
175
                    category {
176
                        title = "🐞 Bug Fixes"
177
                        key = "bug"
178
                        labels = setOf("bug")
179
                        order = 2
180
                    }
181
                    category {
182
                        title = "🔨 Tasks"
183
                        key = "task"
184
                        labels = setOf("task")
185
                        order = 3
186
                    }
187
                    category {
188
                        title = "📔 Docs"
189
                        key = "doc"
190
                        labels = setOf("doc")
191
                        order = 4
192
                    }
193
                    replacer {
194
                        search = "feat: "
195
                        replace = ""
196
                    }
197
                    replacer {
198
                        search = "fix: "
199
                        replace = ""
200
                    }
201
                    replacer {
202
                        search = "chore: "
203
                        replace = ""
204
                    }
205
                    replacer {
206
                        search = "ci: "
207
                        replace = ""
208
                    }
209
                    replacer {
210
                        search = "docs: "
211
                        replace = ""
212
                    }
213
                }
214
            }
215
        }
216
        deploy {
217
            maven {
218
                mavenCentral.create(properties["RELEASE_DEPLOYER_NAME"].toString()) {
219
                    active = Active.ALWAYS
220
                    url = properties["RELEASE_DEPLOYER_URL"].toString()
221
                    stagingRepository(layout.buildDirectory.dir("staging-deploy").get().toString())
222
                    setAuthorization("Basic")
223
                    retryDelay = 60
224
                }
225
            }
226
        }
227
    }
228

229
}
230