Refactor/11-plugin-auto-apply-with-check-task

build-logic/src/main/kotlin/io/casper/build/TestClass.kt

@@ -5,10 +5,9 @@ package io.casper.build
  * 이제 올바른 KDoc 주석 형식을 사용합니다.
  */
 class TestClass {
+
     /**
-     * 이 함수는 KDoc 주석 검사 테스트를 위한 용도입니다.
-     *
-     * @return 항상 Unit을 반환합니다.
+     * 이 함수는 빌드 로직에서 사용하는 테스트 함수입니다.
      */
     fun testFunction() {
         println("이 함수는 문서화 검사를 테스트하기 위한 용도입니다.")

build.gradle.kts

@@ -1,21 +1,16 @@
 plugins {
     kotlin("jvm") version "1.9.23"
-    kotlin("plugin.spring") version "1.9.23"
-    id("org.springframework.boot") version "3.4.4"
-    id("io.spring.dependency-management") version "1.1.7"
     id("org.jlleitschuh.gradle.ktlint").version("12.1.1")
     id("io.gitlab.arturbosch.detekt") version "1.23.6"
     id("casper.documentation-convention")
 }
 
-// 모든 프로젝트(루트 및 서브프로젝트)에 공통 설정 적용
-allprojects {
+// 서브프로젝트 설정
+subprojects {
+    // 서브프로젝트에 공통 설정 적용
     repositories {
         mavenCentral()
     }
-
-    // 모든 프로젝트에 플러그인 적용
-    apply(plugin = "casper.documentation-convention")
 }
 
 tasks.register("checkAll") {
@@ -25,6 +20,11 @@ tasks.register("checkAll") {
     // 루트 프로젝트의 check 태스크에 의존
     dependsOn(tasks.named("check"))
 
+    // 모든 서브프로젝트의 check 태스크에 의존
+    subprojects.forEach { subproject ->
+        dependsOn(subproject.tasks.matching { it.name.startsWith("check") })
+    }
+
     // build-logic, convention 등 includeBuild 모듈의 check 태스크에 의존
     dependsOn(gradle.includedBuilds.map { it.task(":check") })
 }
@@ -38,20 +38,6 @@ java {
     }
 }
 
-dependencies {
-    implementation("org.springframework.boot:spring-boot-starter")
-    implementation("org.jetbrains.kotlin:kotlin-reflect")
-    testImplementation("org.springframework.boot:spring-boot-starter-test")
-    testImplementation("org.jetbrains.kotlin:kotlin-test-junit5")
-    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
-}
-
-kotlin {
-    compilerOptions {
-        freeCompilerArgs.addAll("-Xjsr305=strict")
-    }
-}
-
 tasks.withType<Test> {
     useJUnitPlatform()
 }

casper-application-domain/build.gradle.kts

@@ -0,0 +1,22 @@
+plugins {
+    kotlin("jvm")
+    id("casper.documentation-convention") // 명시적으로 플러그인 적용
+}
+
+group = "hs.kr.casper.entrydsm"
+version = "0.0.1-SNAPSHOT"
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    testImplementation(kotlin("test"))
+}
+
+tasks.test {
+    useJUnitPlatform()
+}
+kotlin {
+    jvmToolchain(17)
+}

casper-application-domain/src/main/kotlin/hs/kr/entrydsm/application/TestClass2.kt

@@ -0,0 +1,15 @@
+package hs.kr.entrydsm.application
+
+/**
+ * 이 클래스는 KDoc 주석 검사 테스트를 위한 용도입니다.
+ * 이제 올바른 KDoc 주석 형식을 사용합니다.
+ */
+class TestClass2 {
+
+    /**
+     * 이 함수는 문서화 검사를 테스트하기 위한 용도입니다.
+     */
+    fun testFunction() {
+        println("이 함수는 문서화 검사를 테스트하기 위한 용도입니다.")
+    }
+}

casper-application-infrastructure/build.gradle.kts

@@ -0,0 +1,41 @@
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+    kotlin("jvm")
+    kotlin("plugin.spring") version "1.9.23"
+    id("org.springframework.boot") version "3.4.4"
+    id("io.spring.dependency-management") version "1.1.7"
+    id("casper.documentation-convention")
+}
+
+group = "hs.kr.entrydsm"
+version = "0.0.1-SNAPSHOT"
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    // impl project
+    implementation(project(":casper-application-domain"))
+
+    implementation("org.springframework.boot:spring-boot-starter")
+    implementation("org.jetbrains.kotlin:kotlin-reflect")
+
+    testImplementation("org.springframework.boot:spring-boot-starter-test")
+    testImplementation(kotlin("test"))
+}
+
+tasks.withType<KotlinCompile> {
+    kotlinOptions {
+        freeCompilerArgs += "-Xjsr305=strict"
+    }
+}
+
+tasks.withType<Test> {
+    useJUnitPlatform()
+}
+
+kotlin {
+    jvmToolchain(17)
+}

casper-application-infrastructure/src/main/kotlin/hs/kr/entrydsm/application/TestClass3.kt

@@ -0,0 +1,8 @@
+package hs.kr.entrydsm.application
+
+/**
+ * test
+ */
+class TestClass3 {
+
+}

src/test/kotlin/hs/kr/entrydsm/application/CasperApplicationTests.kt → casper-application-infrastructure/src/test/kotlin/hs/kr/entrydsm/application/CasperApplicationTests.kt

@@ -3,13 +3,10 @@ package hs.kr.entrydsm.application
 import org.junit.jupiter.api.Test
 import org.springframework.boot.test.context.SpringBootTest
 
-/**
- * asdf
- *
- */
 @SpringBootTest
 class CasperApplicationTests {
+
     @Test
     fun contextLoads() {
     }
-}
+}

casper-convention/src/main/kotlin/io/casper/convention/plugins/DocumentationConventionPlugin.kt

@@ -11,47 +11,94 @@ import org.gradle.kotlin.dsl.register
 
 /**
  * Casper 프로젝트의 KDoc 문서화 규칙을 정의하는 Gradle 플러그인입니다.
+ * 코드 요소(클래스, 함수, 프로퍼티 등)에 KDoc 주석이 있는지 확인하는 태스크를 제공합니다.
  */
 class DocumentationConventionPlugin : Plugin<Project> {
+    /**
+     * 플러그인을 프로젝트에 적용합니다.
+     * 각 코드 요소별 문서화 확인 태스크와 통합 태스크를 등록하고, 빌드 라이프사이클에 연결합니다.
+     *
+     * @param project 플러그인이 적용될 프로젝트
+     */
     override fun apply(project: Project) {
-        with(project) {
-            // 현재 프로젝트에 태스크 등록
-            registerDocTasks(this)
-
-            // 모든 서브프로젝트에도 태스크 등록
-            subprojects {
-                registerDocTasks(this)
-            }
-        }
+        project.logger.lifecycle("문서화 규칙 플러그인을 적용합니다: ${project.name}")
+        val registeredTasks = registerIndividualDocCheckTasks(project)
+        registerAggregateTask(project, registeredTasks)
+        connectToCheckLifecycle(project)
     }
 
+    /**
+     * 각 코드 요소(클래스, 함수, 프로퍼티 등)별로 개별 문서화 확인 태스크를 등록합니다.
+     * DocCheckTaskType에 정의된 각 유형에 대해 DocCheckTask를 생성합니다.
+     *
+     * @param project 태스크가 등록될 프로젝트
+     * @return 등록된 태스크 프로바이더 목록
+     */
+    private fun registerIndividualDocCheckTasks(project: Project): List<TaskProvider<out Task>> {
+        val registeredTasks = mutableListOf<TaskProvider<out Task>>()
 
-    private fun Project.registerDocTasks(project: Project) {
-        with(project) {
-            val registeredTasks = mutableListOf<TaskProvider<out Task>>()
+        DocCheckTaskType.values().forEach { taskType ->
+            val taskName = taskType.taskName
 
-            DocCheckTaskType.values().forEach { taskType ->
-                val task = tasks.register<DocCheckTask>(taskType.taskName) {
+            // 이미 같은 이름의 태스크가 있는지 확인
+            if (project.tasks.findByName(taskName) == null) {
+                val task = project.tasks.register<DocCheckTask>(taskName) {
                     group = DocConstants.DOC_GROUP
                     description = taskType.description
                     codeElement.set(taskType.codeElement)
                 }
                 registeredTasks.add(task)
+                project.logger.lifecycle("${project.name}에 ${taskName} 태스크를 등록했습니다.")
+            } else {
+                project.logger.lifecycle("${project.name}에 이미 ${taskName} 태스크가 있습니다.")
+                registeredTasks.add(project.tasks.named(taskName))
             }
+        }
+        return registeredTasks
+    }
 
-            // 모든 문서화 검사를 한 번에 실행하는 태스크
-    tasks.register("checkAllDocs") {
-        group = DocConstants.CHECK_GROUP
-        description = "모든 코드 요소의 KDoc 주석 여부를 확인합니다"
+    /**
+     * 모든 개별 문서화 확인 태스크를 한 번에 실행하는 통합 태스크를 등록합니다.
+     * 이 태스크는 모든 개별 태스크에 의존하므로, 하나의 명령으로 모든 확인을 실행할 수 있습니다.
+     *
+     * @param project 태스크가 등록될 프로젝트
+     * @param individualTasks 의존할 개별 태스크 목록
+     */
+    private fun registerAggregateTask(project: Project, individualTasks: List<TaskProvider<out Task>>) {
+        // 모든 문서화 검사를 한 번에 실행하는 태스크
+        if (project.tasks.findByName(CHECK_ALL_DOCS_TASK) == null) {
+            project.tasks.register(CHECK_ALL_DOCS_TASK) {
+                group = DocConstants.CHECK_GROUP
+                description = "모든 코드 요소의 KDoc 주석 여부를 확인합니다"
 
-        // 등록된 모든 검사 태스크에 의존
-        dependsOn(registeredTasks)
+                // 등록된 모든 검사 태스크에 의존
+                dependsOn(individualTasks)
+            }
+            project.logger.lifecycle("${project.name}에 ${CHECK_ALL_DOCS_TASK} 태스크를 등록했습니다.")
+        }
+    }
+
+    /**
+     * 문서화 확인 태스크를 프로젝트의 기본 check 태스크에 연결합니다.
+     * 이를 통해 일반적인 빌드 라이프사이클에 문서화 확인이 포함됩니다.
+     *
+     * @param project 연결될 프로젝트
+     */
+    private fun connectToCheckLifecycle(project: Project) {
+        // 프로젝트 평가 후에 check 태스크가 있으면 checkAllDocs를 의존성으로 추가
+        project.afterEvaluate {
+            project.tasks.findByName("check")?.dependsOn(CHECK_ALL_DOCS_TASK)
+            project.logger.lifecycle("${project.name}의 check 태스크에 ${CHECK_ALL_DOCS_TASK} 의존성을 추가했습니다.")
+        }
     }
 
-    // 빌드 검증 과정에 문서화 검사 포함
-    tasks.named("check") {
-        dependsOn("checkAllDocs")
+    /**
+     * 플러그인 내에서 사용되는 상수 값들을 정의합니다.
+     */
+    companion object {
+        /**
+         * 모든 문서화 확인 태스크를 실행하는 통합 태스크의 이름입니다.
+         */
+        const val CHECK_ALL_DOCS_TASK = "checkAllDocs"
     }
-}
-}
 }

settings.gradle.kts

@@ -14,3 +14,7 @@ dependencyResolutionManagement {
         mavenCentral()
     }
 }
+
+include(":casper-application-domain")
+
+include("casper-application-infrastructure")