Release/v1.0.1

.github/workflows/deploy_maven_central.yml

@@ -1,16 +1,30 @@
 
 name: deploy maven central
 
+# This workflow handles deployment to Maven Central
+# Deployment occurs automatically in two scenarios:
+# 1. When code is merged to the main branch
+# 2. When a PR is opened or updated to merge to the main branch
+# For releases, use branch naming convention: release/vx.x.x (e.g., release/v1.0.0)
+# The version number will be extracted from the branch name
+
 on:
   push:
+    branches:
+      - main
+  pull_request:
+    types: [opened, synchronize]
+    branches:
+      - main
   workflow_dispatch:
 
 jobs:
   test:
     if: github.ref != 'refs/heads/main'
     uses: ./.github/workflows/test.yml
   cd:
-    if: github.ref == 'refs/heads/main'
+    # Run on main branch or when a PR is targeting the main branch
+    if: github.ref == 'refs/heads/main' || (github.event_name == 'pull_request' && github.event.pull_request.base.ref == 'main')
     runs-on: ubuntu-latest
 
     steps:
@@ -29,6 +43,11 @@ jobs:
         run: chmod +x ./gradlew
       - name: Validate Gradle wrapper
         uses: gradle/wrapper-validation-action@v1
+      - name: Display version info
+        run: |
+          echo "Branch name from GITHUB_REF_NAME: $GITHUB_REF_NAME"
+          echo "Branch name from GITHUB_HEAD_REF: $GITHUB_HEAD_REF"
+          ./gradlew -q printVersion
       - name: Publish package
         uses: gradle/gradle-build-action@v2
         with:

.run/renlin_sample [allTests].run.xml

@@ -0,0 +1,24 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="renlin:sample [allTests]" type="GradleRunConfiguration" factoryName="Gradle">
+    <ExternalSystemSettings>
+      <option name="executionName" />
+      <option name="externalProjectPath" value="$PROJECT_DIR$/sample" />
+      <option name="externalSystemIdString" value="GRADLE" />
+      <option name="scriptParameters" value="" />
+      <option name="taskDescriptions">
+        <list />
+      </option>
+      <option name="taskNames">
+        <list>
+          <option value="allTests" />
+        </list>
+      </option>
+      <option name="vmOptions" />
+    </ExternalSystemSettings>
+    <ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>
+    <ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
+    <DebugAllEnabled>false</DebugAllEnabled>
+    <RunAsTest>false</RunAsTest>
+    <method v="2" />
+  </configuration>
+</component>

.run/renlin_sample [jsBrowserDevelopmentRun].run.xml

@@ -0,0 +1,24 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="renlin:sample [jsBrowserDevelopmentRun]" type="GradleRunConfiguration" factoryName="Gradle">
+    <ExternalSystemSettings>
+      <option name="executionName" />
+      <option name="externalProjectPath" value="$PROJECT_DIR$/sample" />
+      <option name="externalSystemIdString" value="GRADLE" />
+      <option name="scriptParameters" value="-t" />
+      <option name="taskDescriptions">
+        <list />
+      </option>
+      <option name="taskNames">
+        <list>
+          <option value="jsBrowserDevelopmentRun" />
+        </list>
+      </option>
+      <option name="vmOptions" />
+    </ExternalSystemSettings>
+    <ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>
+    <ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
+    <DebugAllEnabled>false</DebugAllEnabled>
+    <RunAsTest>false</RunAsTest>
+    <method v="2" />
+  </configuration>
+</component>

convention-plugins/build.gradle.kts

@@ -1,7 +1,9 @@
 plugins {
     `kotlin-dsl`
 }
+fun pluginId(pluginName: String, version: String) = "$pluginName:$pluginName.gradle.plugin:$version"
 
 dependencies {
     implementation(libs.nexus.publish)
+    implementation(pluginId("org.jetbrains.kotlin.multiplatform", "2.1.0"))
 }

convention-plugins/src/main/kotlin/renlin.common.gradle.kts

@@ -0,0 +1,45 @@
+import org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi
+
+plugins {
+    kotlin("multiplatform")
+
+}
+
+
+kotlin {
+    jvm {
+        @OptIn(ExperimentalKotlinGradlePluginApi::class)
+        compilerOptions {
+            freeCompilerArgs = listOf("-Xjsr305=strict")
+        }
+    }
+    js {
+        browser {
+            testTask {
+                useKarma {
+                    useChromeHeadless()
+                }
+            }
+        }
+    }
+    sourceSets["commonMain"].dependencies {
+        implementation("net.kigawa:hakate:3.3.2")
+    }
+    sourceSets["commonTest"].dependencies {
+
+
+    }
+    sourceSets["jvmMain"].dependencies {
+
+    }
+    sourceSets["jvmTest"].dependencies {
+
+    }
+
+    sourceSets["jsMain"].dependencies {
+
+    }
+    sourceSets["jsTest"].dependencies {
+    }
+}
+

convention-plugins/src/main/kotlin/root.publication.gradle.kts

@@ -3,14 +3,67 @@ plugins {
 }
 object Conf {
     const val GROUP = "net.kigawa"
-    const val VERSION = "1.0.0"
+    // Base version - will be modified based on branch name if available
+    const val BASE_VERSION = "1.0.1"
 }
 
+// Determine version based on branch name
+// Branch naming convention for releases: release/vx.x.x (e.g., release/v1.0.0)
+fun determineVersion(): String {
+    // Try to get branch name from different environment variables
+    // For pull requests, GITHUB_HEAD_REF contains the source branch name
+    // For direct pushes, GITHUB_REF_NAME contains the branch name
+    val branchName = System.getenv("GITHUB_HEAD_REF") 
+        ?: System.getenv("GITHUB_REF_NAME") 
+        ?: return Conf.BASE_VERSION
+
+    // For main branch, use the base version
+    if (branchName == "main") {
+        return Conf.BASE_VERSION
+    }
+
+    // For release branches in format 'release/vx.x.x', use the version from the branch name
+    val releasePattern = Regex("^release/v(\\d+\\.\\d+\\.\\d+)$")
+    val matchResult = releasePattern.find(branchName)
+    if (matchResult != null) {
+        // Extract version number from branch name
+        val versionFromBranch = matchResult.groupValues[1]
+        return versionFromBranch
+    }
+
+    // For other branches, use format: baseVersion-branchName-SNAPSHOT
+    // Replace any non-alphanumeric characters with dashes for Maven compatibility
+    val sanitizedBranchName = branchName.replace(Regex("[^a-zA-Z0-9]"), "-")
+    return "${Conf.BASE_VERSION}-${sanitizedBranchName}-SNAPSHOT"
+}
+
+val projectVersion = determineVersion()
+
 group = Conf.GROUP
-version = Conf.VERSION
+version = projectVersion
 allprojects {
+    apply(plugin = "renlin.common")
     group = Conf.GROUP
-    version = Conf.VERSION
+    version = projectVersion
+}
+
+// Add a task to print the version (useful for debugging)
+tasks.register("printVersion") {
+    doLast {
+        val branchName = System.getenv("GITHUB_HEAD_REF") ?: System.getenv("GITHUB_REF_NAME") ?: "unknown"
+        println("Project version: $version")
+        println("Determined from branch: $branchName")
+
+        // Check if it's a release branch
+        val releasePattern = Regex("^release/v(\\d+\\.\\d+\\.\\d+)$")
+        val isReleaseBranch = releasePattern.matches(branchName)
+        println("Is release branch format (release/vx.x.x): $isReleaseBranch")
+
+        if (isReleaseBranch) {
+            val versionFromBranch = releasePattern.find(branchName)?.groupValues?.get(1)
+            println("Version extracted from branch name: $versionFromBranch")
+        }
+    }
 }
 
 nexusPublishing {

generate/build.gradle.kts

@@ -0,0 +1,28 @@
+import org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi
+
+plugins {
+    alias(libs.plugins.kotlinMultiplatform)
+}
+
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+}
+
+kotlin {
+    jvm {
+        @OptIn(ExperimentalKotlinGradlePluginApi::class)
+        compilerOptions {
+            freeCompilerArgs = listOf("-Xjsr305=strict")
+        }
+    }
+    js {
+        browser {
+            binaries.executable()
+        }
+    }
+
+}

generate/src/jvmMain/kotlin/_Tag_generate.kt

@@ -0,0 +1,43 @@
+import generator.DslGenerator
+import generator.IntegrationGenerator
+import generator.NativeGenerator
+import generator.TagGenerator
+import generator.UnionGenerator
+import java.io.File
+
+fun main() {
+    // 出力先ディレクトリ
+    val outputDir = "../renlin/src/commonMain/kotlin/net/kigawa/renlin/tag"
+    val categoryOutputDir = "../renlin/src/commonMain/kotlin/net/kigawa/renlin/w3c/category"
+    val categoryUnionOutputDir = "$categoryOutputDir/native"
+    val categoryIntegrationOutputDir = "$categoryOutputDir/integration"
+    val categoryDslOutputDir = "$categoryOutputDir/dsl"
+    val categoryNativeOutputDir = "$categoryOutputDir/native"
+    File(outputDir).mkdirs()
+    File(categoryOutputDir).mkdirs()
+    File(categoryUnionOutputDir).mkdirs()
+    File(categoryIntegrationOutputDir).mkdirs()
+    File(categoryDslOutputDir).mkdirs()
+    File(categoryNativeOutputDir).mkdirs()
+
+    val tagGenerator = TagGenerator(outputDir).also {
+        it.generate()
+    }
+    val unionGenerator = UnionGenerator(categoryUnionOutputDir).also {
+        it.generate()
+    }
+    val integrationGenerator = IntegrationGenerator(categoryIntegrationOutputDir).also {
+        it.generate()
+    }
+    val dslGenerator = DslGenerator(categoryDslOutputDir).also {
+        it.generate()
+    }
+    val nativeGenerator = NativeGenerator(categoryNativeOutputDir).also {
+        it.generate(unionGenerator.nativeCategories)
+    }
+
+    println("タグのコード生成が完了しました。")
+    println("生成されたUnionクラス: ${unionGenerator.processedUnions.size}")
+    println("生成されたIntegrationクラス: ${integrationGenerator.processedIntegrations.size}")
+    println("生成されたDSLクラス: ${dslGenerator.processedDsls.size}")
+}

generate/src/jvmMain/kotlin/generator/DslGenerator.kt

@@ -0,0 +1,57 @@
+package generator
+
+import model.AllowedCategories
+import tagCategories
+import java.io.File
+
+class DslGenerator(
+    val categoryDslOutputDir: String,
+) {
+    val processedDsls = mutableSetOf<String>()
+    fun generate() {
+        // DSLクラスの生成
+        (tagCategories.map { it.allowedCategories } +
+                tagCategories.flatMap { it.allowedCategories.categories }.map { AllowedCategories(it) })
+            .filter { it.categories.isNotEmpty() }
+            .forEach { allowedCategories ->
+                val dslName = allowedCategories.connectedStr() + "Dsl"
+                if (!processedDsls.contains(dslName)) {
+                    processedDsls.add(dslName)
+                    val categories = allowedCategories.categories
+
+
+                    val imports = mutableListOf<String>()
+
+                    val fileContent = """
+                package net.kigawa.renlin.w3c.category.dsl
+
+                ${imports.distinct().joinToString("\n                ")}
+                ${
+                        if (allowedCategories.categories.size > 1)
+                            "import net.kigawa.renlin.w3c.category.integration.${
+                                allowedCategories.connectedStr("Integration")
+                            }"
+                        else "import net.kigawa.renlin.w3c.category.native.${
+                            allowedCategories.connectedStr("Integration")
+                        }"
+                    }
+
+
+                /**
+                 * DSL for ${categories.joinToString(", ")}
+                 */
+                interface ${dslName}<CATEGORY_DSL : ${allowedCategories.connectedStr("Integration")}>${
+                        if (categories.size <= 1) ""
+                        else (categories.filter { it.trim() != dslName.trim() }
+                            .joinToString(separator = ",", prefix = ":")
+                            { "\n                    ${it}Dsl<CATEGORY_DSL>" })
+                    }
+            """.trimIndent()
+
+                    val file = File("$categoryDslOutputDir/${dslName}.kt")
+                    file.writeText(fileContent)
+                    println("Generated DSL: ${dslName}.kt")
+                }
+            }
+    }
+}