Hideout/hideout-core/build.gradle.kts

351 lines
11 KiB
Plaintext
Raw Normal View History

import com.github.jk1.license.filter.DependencyFilter
import com.github.jk1.license.filter.LicenseBundleNormalizer
import com.github.jk1.license.importer.DependencyDataImporter
import com.github.jk1.license.importer.XmlReportImporter
import com.github.jk1.license.render.*
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
2023-08-18 06:25:42 +00:00
import org.openapitools.generator.gradle.plugin.tasks.GenerateTask
2023-03-24 03:58:12 +00:00
plugins {
alias(libs.plugins.kotlin.jvm)
alias(libs.plugins.detekt)
alias(libs.plugins.spring.boot)
alias(libs.plugins.kotlin.spring)
alias(libs.plugins.openapi.generator)
alias(libs.plugins.kover)
alias(libs.plugins.license.report)
2023-03-24 03:58:12 +00:00
}
apply {
plugin("io.spring.dependency-management")
}
2023-03-24 03:58:12 +00:00
group = "dev.usbharu"
version = "0.0.1"
sourceSets {
create("intTest") {
2024-05-18 07:18:54 +00:00
compileClasspath += sourceSets.main.get().output
runtimeClasspath += sourceSets.main.get().output
}
2023-11-30 14:01:18 +00:00
create("e2eTest") {
2024-05-18 07:18:54 +00:00
compileClasspath += sourceSets.main.get().output
runtimeClasspath += sourceSets.main.get().output
2023-11-30 14:01:18 +00:00
}
}
val intTestImplementation by configurations.getting {
extendsFrom(configurations.implementation.get())
}
val intTestRuntimeOnly by configurations.getting {
extendsFrom(configurations.runtimeOnly.get())
}
2023-11-30 14:01:18 +00:00
val e2eTestImplementation by configurations.getting {
extendsFrom(configurations.implementation.get())
}
val e2eTestRuntimeOnly by configurations.getting {
extendsFrom(configurations.runtimeOnly.get())
}
val integrationTest = task<Test>("integrationTest") {
description = "Runs integration tests."
group = "verification"
testClassesDirs = sourceSets["intTest"].output.classesDirs
classpath = sourceSets["intTest"].runtimeClasspath
shouldRunAfter("test")
useJUnitPlatform()
}
2023-11-30 14:01:18 +00:00
val e2eTest = task<Test>("e2eTest") {
description = "Runs e2e tests."
group = "verification"
testClassesDirs = sourceSets["e2eTest"].output.classesDirs
classpath = sourceSets["e2eTest"].runtimeClasspath
shouldRunAfter("test")
useJUnitPlatform()
}
tasks.check {
dependsOn(integrationTest)
dependsOn(e2eTest)
}
tasks.withType<Test> {
useJUnitPlatform()
doFirst {
jvmArgs = arrayOf(
2023-12-14 05:37:36 +00:00
"--add-opens", "java.base/java.lang=ALL-UNNAMED",
"--add-opens", "java.base/java.util=ALL-UNNAMED",
"--add-opens", "java.naming/javax.naming=ALL-UNNAMED",
).toMutableList()
}
}
tasks.withType<KotlinCompile> {
kotlinOptions {
freeCompilerArgs += "-Xjsr305=strict"
}
2023-09-20 05:53:23 +00:00
dependsOn("openApiGenerateMastodonCompatibleApi")
mustRunAfter("openApiGenerateMastodonCompatibleApi")
}
tasks.clean {
delete += listOf("$rootDir/src/main/resources/static")
}
tasks.create<GenerateTask>("openApiGenerateMastodonCompatibleApi", GenerateTask::class) {
generatorName.set("kotlin-spring")
inputSpec.set("$rootDir/src/main/resources/openapi/mastodon.yaml")
outputDir.set("$buildDir/generated/sources/mastodon")
apiPackage.set("dev.usbharu.hideout.controller.mastodon.generated")
modelPackage.set("dev.usbharu.hideout.domain.mastodon.model.generated")
configOptions.put("interfaceOnly", "true")
configOptions.put("useSpringBoot3", "true")
2023-10-15 01:40:26 +00:00
configOptions.put("reactive", "true")
additionalProperties.put("useTags", "true")
importMappings.put("org.springframework.core.io.Resource", "org.springframework.web.multipart.MultipartFile")
typeMappings.put("org.springframework.core.io.Resource", "org.springframework.web.multipart.MultipartFile")
schemaMappings.put(
"StatusesRequest",
"dev.usbharu.hideout.mastodon.interfaces.api.status.StatusesRequest"
)
2023-10-10 02:32:35 +00:00
templateDir.set("$rootDir/templates")
}
2023-03-24 03:58:12 +00:00
repositories {
mavenCentral()
maven {
url = uri("https://git.usbharu.dev/api/packages/usbharu/maven")
}
maven {
name = "GitHubPackages"
url = uri("https://maven.pkg.github.com/usbharu/http-signature")
credentials {
username = project.findProperty("gpr.user") as String? ?: System.getenv("USERNAME")
password = project.findProperty("gpr.key") as String? ?: System.getenv("TOKEN")
}
}
2024-01-07 03:55:52 +00:00
maven {
name = "GitHubPackages2"
url = uri("https://maven.pkg.github.com/multim-dev/emoji-kt")
credentials {
username = project.findProperty("gpr.user") as String? ?: System.getenv("USERNAME")
password = project.findProperty("gpr.key") as String? ?: System.getenv("TOKEN")
}
}
2023-03-24 03:58:12 +00:00
}
2023-04-05 07:59:16 +00:00
kotlin {
target {
compilations.all {
kotlinOptions.jvmTarget = JavaVersion.VERSION_21.toString()
2023-04-05 07:59:16 +00:00
}
}
}
sourceSets.main {
kotlin.srcDirs(
"$buildDir/generated/ksp/main",
"$buildDir/generated/sources/openapi/src/main/kotlin",
"$buildDir/generated/sources/mastodon/src/main/kotlin"
)
}
val os = org.gradle.nativeplatform.platform.internal
.DefaultNativePlatform.getCurrentOperatingSystem()
2023-03-24 03:58:12 +00:00
dependencies {
2024-05-20 06:53:47 +00:00
developmentOnly(libs.h2db)
detektPlugins(libs.detekt.formatting)
implementation(libs.bundles.exposed)
implementation(libs.bundles.coroutines)
implementation(libs.bundles.ktor.client)
implementation(libs.bundles.apache.tika)
implementation(libs.bundles.openapi)
implementation(libs.bundles.owl.producer)
implementation(libs.bundles.owl.broker)
implementation(libs.bundles.spring.boot.oauth2)
implementation(libs.bundles.spring.boot.data.mongodb)
implementation(libs.bundles.spring.boot.data.mongodb)
implementation("org.springframework.boot:spring-boot-starter-actuator")
implementation("org.springframework.boot:spring-boot-starter-web")
2023-08-28 12:05:34 +00:00
implementation("org.springframework.boot:spring-boot-starter-security")
implementation("org.springframework.boot:spring-boot-starter-thymeleaf")
implementation("org.springframework.boot:spring-boot-starter-log4j2")
2024-02-21 02:08:36 +00:00
implementation("org.springframework.boot:spring-boot-starter-validation")
2024-05-20 06:53:47 +00:00
implementation(libs.blurhash)
implementation(libs.aws.s3)
implementation(libs.jsoup)
implementation(libs.owasp.java.html.sanitizer)
implementation(libs.postgresql)
implementation(libs.imageio.webp)
implementation(libs.thumbnailator)
implementation(libs.flyway.core)
implementation("dev.usbharu:owl-common-serialize-jackson:0.0.1")
implementation(libs.javacv) {
exclude(module = "opencv")
exclude(module = "flycapture")
exclude(module = "artoolkitplus")
exclude(module = "libdc1394")
exclude(module = "librealsense")
exclude(module = "librealsense2")
exclude(module = "tesseract")
exclude(module = "libfreenect")
exclude(module = "libfreenect2")
}
if (os.isWindows) {
implementation(variantOf(libs.javacv.ffmpeg) { classifier("windows-x86_64") })
} else {
implementation(variantOf(libs.javacv.ffmpeg) { classifier("linux-x86_64") })
}
2023-11-02 02:56:03 +00:00
implementation("dev.usbharu:http-signature:1.0.0")
2024-01-07 03:55:52 +00:00
implementation("dev.usbharu:emoji-kt:2.0.0")
2024-01-07 03:55:52 +00:00
2023-03-24 03:58:12 +00:00
testImplementation("org.springframework.boot:spring-boot-starter-test")
2024-05-20 06:53:47 +00:00
implementation(libs.kotlin.junit)
implementation(libs.coroutines.test)
2024-05-20 06:53:47 +00:00
testImplementation(libs.ktor.client.mock)
testImplementation(libs.h2db)
2023-03-31 03:23:58 +00:00
testImplementation("org.mockito.kotlin:mockito-kotlin:5.3.1")
testImplementation("org.mockito:mockito-inline:5.2.0")
testImplementation("nl.jqno.equalsverifier:equalsverifier:3.16.1")
testImplementation("com.jparams:to-string-verifier:1.4.8")
2023-04-05 07:59:16 +00:00
intTestImplementation("org.springframework.boot:spring-boot-starter-test")
intTestImplementation("org.springframework.security:spring-security-test")
2024-05-20 06:53:47 +00:00
intTestImplementation(libs.kotlin.junit)
intTestImplementation(libs.coroutines.test)
intTestImplementation("org.mockito.kotlin:mockito-kotlin:5.3.1")
2024-05-20 06:53:47 +00:00
intTestImplementation(libs.h2db)
2023-11-30 14:01:18 +00:00
e2eTestImplementation("org.springframework.boot:spring-boot-starter-test")
e2eTestImplementation("org.springframework.security:spring-security-test")
e2eTestImplementation("org.springframework.boot:spring-boot-starter-webflux")
2023-12-01 08:32:10 +00:00
e2eTestImplementation("com.intuit.karate:karate-junit5:1.4.1")
2024-05-20 06:53:47 +00:00
e2eTestImplementation(libs.h2db)
2023-11-30 14:01:18 +00:00
2023-03-24 03:58:12 +00:00
}
2023-03-24 04:09:43 +00:00
2023-04-29 14:57:25 +00:00
detekt {
parallel = true
config = files("../detekt.yml")
2023-04-29 14:57:25 +00:00
buildUponDefaultConfig = true
basePath = "${rootDir.absolutePath}/src/main/kotlin"
2023-04-29 16:25:54 +00:00
autoCorrect = true
2023-04-29 14:57:25 +00:00
}
configurations.matching { it.name == "detekt" }.all {
resolutionStrategy.eachDependency {
if (requested.group == "org.jetbrains.kotlin") {
useVersion(io.gitlab.arturbosch.detekt.getSupportedKotlinVersion())
}
}
}
tasks.withType<io.gitlab.arturbosch.detekt.Detekt> {
exclude("**/generated/**")
doFirst {
}
setSource("src/main/kotlin")
exclude("build/")
}
tasks.withType<io.gitlab.arturbosch.detekt.Detekt>().configureEach {
2023-09-19 07:21:35 +00:00
exclude("**/org/koin/ksp/generated/**", "**/generated/**")
}
tasks.withType<io.gitlab.arturbosch.detekt.DetektCreateBaselineTask>().configureEach {
2023-09-19 07:21:35 +00:00
exclude("**/org/koin/ksp/generated/**", "**/generated/**")
}
configurations {
all {
exclude("org.springframework.boot", "spring-boot-starter-logging")
exclude("ch.qos.logback", "logback-classic")
}
}
project.gradle.taskGraph.whenReady {
println(this.allTasks)
this.allTasks.map { println(it.name) }
if (this.hasTask(":koverGenerateArtifact")) {
println("has task")
val task = this.allTasks.find { it.name == "test" }
val verificationTask = task as VerificationTask
verificationTask.ignoreFailures = true
}
}
kover {
2024-05-18 07:18:54 +00:00
currentProject {
sources {
excludedSourceSets.addAll(
"aot", "e2eTest", "intTest"
)
}
}
2024-05-18 07:18:54 +00:00
reports {
filters {
excludes {
packages(
"dev.usbharu.hideout.activitypub.domain.exception",
"dev.usbharu.hideout.core.domain.exception",
"dev.usbharu.hideout.core.domain.exception.media",
"dev.usbharu.hideout.core.domain.exception.resource",
"dev.usbharu.hideout.core.domain.exception.resource.local"
)
annotatedBy("org.springframework.context.annotation.Configuration")
annotatedBy("org.springframework.boot.context.properties.ConfigurationProperties")
packages(
"dev.usbharu.hideout.controller.mastodon.generated",
"dev.usbharu.hideout.domain.mastodon.model.generated"
)
packages("org.springframework")
packages("org.jetbrains")
}
}
}
}
springBoot {
buildInfo()
}
licenseReport {
excludeOwnGroup = true
importers = arrayOf<DependencyDataImporter>(XmlReportImporter("hideout", File("$projectDir/license-list.xml")))
renderers = arrayOf<ReportRenderer>(
InventoryHtmlReportRenderer(),
CsvReportRenderer(),
JsonReportRenderer(),
XmlReportRenderer()
)
filters = arrayOf<DependencyFilter>(LicenseBundleNormalizer("$projectDir/license-normalizer-bundle.json", true))
allowedLicensesFile = File("$projectDir/allowed-licenses.json")
configurations = arrayOf("productionRuntimeClasspath")
}