Merge branch 'master' of https://github.com/eclipse-thingweb/kotlin-wot into master

RobWin · RobWin · commit 9c212ecd9a36 · 2025-04-11T21:54:20.000+02:00
# Conflicts:
#	build.gradle.kts
diff --git a/.github/workflows/gradle-pr.yml b/.github/workflows/gradle-pr.yml
@@ -0,0 +1,12 @@
+name: build-pr
+
+on:
+  push:
+    branches-ignore:
+      - 'master'
+
+jobs:
+  CI:
+    uses: eclipse-lmos/.github/.github/workflows/gradle-ci.yml@main
+    permissions:
+      contents: read
diff --git a/.github/workflows/gradle.yml b/.github/workflows/gradle.yml
@@ -9,53 +9,21 @@
 # This workflow will build a Java project with Gradle and cache/restore any dependencies to improve the workflow execution time
 # For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-java-with-gradle
 
-name: Java CI with Gradle
+name: build-publish
 
 on:
   push:
-    branches: [ "master" ]
-  pull_request:
-    branches: [ "master" ]
+    branches: [ master ]
 
 jobs:
-  validation:
-    name: "Gradle wrapper validation"
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4.1.7
-      - uses: gradle/actions/wrapper-validation@v4.1.0
-  build:
-
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-
-    steps:
-      - uses: actions/checkout@v4
-      - name: Set up JDK 21
-        uses: actions/setup-java@v4
-        with:
-          java-version: '21'
-          distribution: 'temurin'
-      - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@0d30c9111cf47a838eb69c06d13f3f51ab2ed76f # v3.1.0
-      - name: Build with Gradle Wrapper
-        run: ./gradlew build
-
-  dependency-submission:
-    runs-on: ubuntu-latest
+  build-publish:
+    uses: eclipse-lmos/.github/.github/workflows/gradle-ci-main.yml@main
     permissions:
       contents: write
-    steps:
-      - uses: actions/checkout@v4
-      - name: Set up JDK 21
-        uses: actions/setup-java@v4
-        with:
-          java-version: '21'
-          distribution: 'temurin'
-
-      # Generates and submits a dependency graph, enabling Dependabot Alerts for all project dependencies.
-      # See: https://github.com/gradle/actions/blob/main/dependency-submission/README.md
-      - name: Generate and submit dependency graph
-        if: github.event_name == 'push' && github.ref == 'refs/heads/main'
-        uses: gradle/actions/dependency-submission@0d30c9111cf47a838eb69c06d13f3f51ab2ed76f # v3.1.0
+      packages: write
+    secrets:
+      oss-username: ${{ secrets.OSSRH_USERNAME }}
+      oss-password: ${{ secrets.OSSRH_PASSWORD }}
+      signing-key-id: ${{ secrets.GPG_SUBKEY_ID }}
+      signing-key: ${{ secrets.GPG_PRIVATE_KEY }}
+      signing-key-password: ${{ secrets.GPG_PASSPHRASE }}
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
@@ -0,0 +1,120 @@
+name: release
+
+on:
+  workflow_dispatch:
+    inputs:
+      release-type:
+        type: choice
+        description: What do you want to release?
+        options: 
+        - Milestone
+        - Release
+  workflow_call:
+    inputs:
+      release-type:
+        default: "Milestone"
+        required: true
+        type: string
+      registry-name:
+        default: eclipse-lmos
+        type: string
+        required: false
+    secrets:
+      oss-username:
+        required: true
+      oss-password:
+        required: true
+      signing-key-id:
+        required: true
+      signing-key:
+        required: true
+      signing-key-password:
+        required: true
+      bot-token:
+        required: true
+      registry-username:
+        required: false
+      registry-password:
+        required: false
+    outputs:
+      version:
+       value: ${{ jobs.build-and-release.outputs.version }}
+
+jobs:
+  build-and-release:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      packages: write
+    outputs:
+      version: ${{ steps.Publish.outputs.version }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4.2.2
+        with:
+          ref: master
+          token: ${{ secrets.bot-token }}
+      - name: REUSE Compliance Check
+        uses: fsfe/reuse-action@v5.0.0
+      - name: Set up JDK 21
+        uses: actions/setup-java@v4.7.0
+        with:
+          java-version: '21'
+          distribution: 'temurin'
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4.3.0
+      - name: Publish
+        id: Publish
+        env:
+          ORG_GRADLE_PROJECT_mavenCentralUsername: ${{ secrets.oss-username }}
+          ORG_GRADLE_PROJECT_mavenCentralPassword: ${{ secrets.oss-password }}
+          ORG_GRADLE_PROJECT_signingInMemoryKeyId: ${{ secrets.signing-key-id }}
+          ORG_GRADLE_PROJECT_signingInMemoryKey: ${{ secrets.signing-key }}
+          ORG_GRADLE_PROJECT_signingInMemoryKeyPassword: ${{ secrets.signing-key-password }}
+          REGISTRY_URL: ghcr.io
+          REGISTRY_USERNAME: ${{ secrets.registry-username }}
+          REGISTRY_PASSWORD: ${{ secrets.registry-password }}
+          REGISTRY_NAMESPACE: ${{ inputs.registry-name }}
+          GH_TOKEN: ${{ secrets.bot-token }}
+        run: |
+          git config --global user.email "cicd@ancf.ai"
+          git config --global user.name "CICD"
+          git fetch -t -q
+
+          # Extract version without -SNAPSHOT suffix from gradle.properties
+          version=$(sed -n -E 's/^version[[:blank:]]*=[[:blank:]]*(.*)-SNAPSHOT$/\1/p' gradle.properties)
+          oldSnapshotVersion="${version}-SNAPSHOT"
+
+          # In case of milestone release, set milestone release version based on previous milestone release versions
+          if [ "${{ github.event.inputs.release-type }}" == "Milestone" ]; then
+            oldMilestone=$(git tag -l "${version}-M*" --sort=v:refname | tail -n 1)
+            if [ "${oldMilestone}" == "" ]; then
+              version=${version}-M1
+            else
+              version=${version}-M$((10#${oldMilestone##*-M}+1))
+            fi
+          fi
+
+          # In case of non-milestone releses, increase the snapshot version in master branch
+          if [ "${{ github.event.inputs.release-type }}" == "Milestone" ]; then
+            nextSnapshotVersion="${oldSnapshotVersion}"
+          else
+            major=$(echo $version | cut -d. -f1)
+            minor=$(echo $version | cut -d. -f2)
+            nextSnapshotVersion="${major}.$((minor+1)).0-SNAPSHOT"
+          fi
+
+          echo "Releasing ${version}"
+          echo "version=${version}" >> $GITHUB_OUTPUT
+          
+          # Update version, build, publish release jars and (optionally) docker image and helm chart
+          ./gradlew :release -Prelease.useAutomaticVersion=true "-Prelease.releaseVersion=${version}" "-Prelease.newVersion=${nextSnapshotVersion}" --no-parallel
+          git checkout "${version}"
+          ./gradlew publish --no-configuration-cache
+
+          # Generate release notes
+          if [ "${{ github.event.inputs.release-type }}" == "Milestone" ]; then
+            gh release create "${version}" --generate-notes --prerelease
+          else
+            gh release create "${version}" --generate-notes --latest
+          fi
diff --git a/build.gradle.kts b/build.gradle.kts
@@ -1,20 +1,23 @@
+import com.vanniktech.maven.publish.SonatypeHost
+
 plugins {
     kotlin("jvm") version "2.0.20"
     id("org.jetbrains.kotlinx.kover") version "0.8.3"
     id("org.cadixdev.licenser") version "0.6.1"
-    id("com.jaredsburrows.license") version "0.9.8"
-    `maven-publish`
+    id("com.vanniktech.maven.publish") version "0.31.0"
+    id("org.cyclonedx.bom") version "2.2.0" apply false
 }
 
 subprojects {
     apply(plugin = "org.jetbrains.kotlin.jvm")
     apply(plugin = "org.jetbrains.kotlinx.kover")
     apply(plugin = "maven-publish")
     apply(plugin = "org.cadixdev.licenser")
-    apply(plugin = "com.jaredsburrows.license")
+    apply(plugin = "com.vanniktech.maven.publish")
+    apply(plugin = "org.cyclonedx.bom")
 
     group = "org.eclipse.thingweb"
-    version = "0.1.3-SNAPSHOT"
+    version = "0.1.0-SNAPSHOT"
 
     license {
         header(rootProject.file("LICENSE"))
@@ -48,21 +51,34 @@ subprojects {
         add("archives", tasks["javadocJar"])
     }
 
-    publishing {
-        publications {
-            create<MavenPublication>("mavenKotlin") {
-                from(components["java"])
-                artifact(tasks["sourcesJar"])
-                artifact(tasks["javadocJar"])
-                artifactId = project.name
+    mavenPublishing {
+        publishToMavenCentral(SonatypeHost.DEFAULT, automaticRelease = true)
+        signAllPublications()
+
+        pom {
+            name = "kotlin-wot"
+            description = "A Framework for implementing Web of Things in Kotlin."
+            url = "https://github.com/eclipse-thingweb/kotlin-wot"
+            licenses {
+                license {
+                    name = "Apache-2.0"
+                    distribution = "repo"
+                    url = "https://github.com/eclipse-thingweb/kotlin-wot/blob/master/LICENSES/Apache-2.0.txt"
+                }
+            }
+            developers {
+                developer {
+                    id = "robwin"
+                    name = "Robert Winkler"
+                    email = "opensource@telekom.de"
+                }
+            }
+            scm {
+                url = "https://github.com/eclipse-thingweb/kotlin-wot.git"
             }
-        }
-        repositories {
-            mavenLocal()
         }
     }
 
-
     tasks.test {
         useJUnitPlatform()
 
diff --git a/kotlin-wot-reflection/src/main/kotlin/reflection/ExposedThingBuilder.kt b/kotlin-wot-reflection/src/main/kotlin/reflection/ExposedThingBuilder.kt
@@ -73,10 +73,10 @@ object ExposedThingBuilder {
                 title = thingAnnotation.title
                 objectType = Type(thingAnnotation.type)
                 val contexts = clazz.findAnnotations<Context>()
-                if(contexts.isNotEmpty()){
+                if (contexts.isNotEmpty()) {
                     val context = org.eclipse.thingweb.thing.schema.Context(DEFAULT_CONTEXT)
                     contexts.forEach {
-                        context.addContext(it.prefix, it.url)
+                        if (it.prefix.isEmpty()) context.addContext(it.url) else context.addContext(it.prefix, it.url)
                     }
                     objectContext = context
                 }
diff --git a/kotlin-wot-reflection/src/main/kotlin/reflection/annotations/Annotations.kt b/kotlin-wot-reflection/src/main/kotlin/reflection/annotations/Annotations.kt
@@ -15,7 +15,7 @@ annotation class Thing(val id: String, val title: String, val description: Strin
 @Target(AnnotationTarget.CLASS)
 @Retention(AnnotationRetention.RUNTIME)
 @Repeatable
-annotation class Context(val prefix: String, val url : String)
+annotation class Context(val prefix: String = "", val url : String)
 
 @Target(AnnotationTarget.CLASS)
 @Retention(AnnotationRetention.RUNTIME)
diff --git a/kotlin-wot/src/main/kotlin/thing/ContextSerializer.kt b/kotlin-wot/src/main/kotlin/thing/ContextSerializer.kt
@@ -23,20 +23,20 @@ internal class ContextSerializer : JsonSerializer<Context>() {
         gen: JsonGenerator,
         serializers: SerializerProvider
     ) {
-        val defaultUrl: String? = context.defaultUrl
+        val defaultUrls: List<String> = context.defaultUrls
         val prefixedUrls: Map<String, String> = context.prefixedUrls
-        val hasDefaultUrl = defaultUrl != null
+        val hasMoreThanOneDefaultUrl = defaultUrls.size > 1
         val hasPrefixedUrls = prefixedUrls.isNotEmpty()
-        if (hasDefaultUrl && hasPrefixedUrls) {
+        if (hasMoreThanOneDefaultUrl || hasPrefixedUrls) {
             gen.writeStartArray()
         }
-        if (hasDefaultUrl) {
-            gen.writeString(defaultUrl)
+        defaultUrls.forEach {
+            gen.writeString(it)
         }
         if (hasPrefixedUrls) {
             gen.writeObject(prefixedUrls)
         }
-        if (hasDefaultUrl && hasPrefixedUrls) {
+        if (hasMoreThanOneDefaultUrl || hasPrefixedUrls) {
             gen.writeEndArray()
         }
     }
diff --git a/kotlin-wot/src/main/kotlin/thing/ThingDescription.kt b/kotlin-wot/src/main/kotlin/thing/ThingDescription.kt
@@ -126,25 +126,6 @@ data class ThingDescription @JsonCreator constructor(
         securityDefinitions[name] = securityScheme
     }
 
-    fun getPropertiesByObjectType(objectType: String): Map<String, PropertyAffordance<*>> {
-        return getPropertiesByExpandedObjectType(getExpandedObjectType(objectType))
-    }
-
-    private fun getPropertiesByExpandedObjectType(objectType: String): Map<String, PropertyAffordance<*>> {
-        return properties.filter { (_, property) ->
-            property.objectType?.defaultType?.let { getExpandedObjectType(it) } == objectType
-        }.toMap()
-    }
-
-    fun getExpandedObjectType(objectType: String): String {
-
-        val parts = objectType.split(":", limit = 2)
-        val prefix = if (parts.size == 2) parts[0] else null
-        val suffix = parts.last()
-
-        return objectContext?.getUrl(prefix)?.let { "$it#$suffix" } ?: objectType
-    }
-
     fun toJson() : String{
         return try {
             JsonMapper.instance.writeValueAsString(this)
diff --git a/kotlin-wot/src/main/kotlin/thing/schema/Context.kt b/kotlin-wot/src/main/kotlin/thing/schema/Context.kt
@@ -16,35 +16,28 @@ import com.fasterxml.jackson.databind.annotation.JsonSerialize
  */
 @JsonDeserialize(using = ContextDeserializer::class)
 @JsonSerialize(using = ContextSerializer::class)
-//@Serializable(with = ContextSerializer::class)
-data class Context(private val urls: MutableMap<String?, String> = HashMap()) {
+data class Context(val defaultUrls: MutableList<String> = mutableListOf(), private val prefixeUrls: MutableMap<String, String> = HashMap()) {
 
     constructor(url: String) : this() {
         addContext(url)
     }
 
-    constructor(prefix: String?, url: String) : this() {
+    constructor(prefix: String, url: String) : this() {
         addContext(prefix, url)
     }
 
     fun addContext(url: String): Context {
-        return addContext(null, url)
-    }
-
-    fun getUrl(prefix: String?): String? {
-        return urls[prefix]
+        defaultUrls.add(url)
+        return this
     }
 
-    fun addContext(prefix: String?, url: String): Context {
-        urls[prefix] = url
+    fun addContext(prefix: String, url: String): Context {
+        prefixeUrls[prefix] = url
         return this
     }
 
-    val defaultUrl: String?
-        get() = urls[null] // Directly accessing the map
-
     val prefixedUrls: Map<String, String>
-        get() = urls.entries
+        get() = prefixeUrls.entries
             .filter { (key, _) -> key != null }
             .associate { (key, value) -> key!! to value }
 }

Original file line number	Diff line number	Diff line change
`@@ -73,10 +73,10 @@ object ExposedThingBuilder {`
`73`	`73`	`title = thingAnnotation.title`
`74`	`74`	`objectType = Type(thingAnnotation.type)`
`75`	`75`	`val contexts = clazz.findAnnotations<Context>()`
`76`		`- if(contexts.isNotEmpty()){`
	`76`	`+ if (contexts.isNotEmpty()) {`
`77`	`77`	`val context = org.eclipse.thingweb.thing.schema.Context(DEFAULT_CONTEXT)`
`78`	`78`	`contexts.forEach {`
`79`		`- context.addContext(it.prefix, it.url)`
	`79`	`+ if (it.prefix.isEmpty()) context.addContext(it.url) else context.addContext(it.prefix, it.url)`
`80`	`80`	`}`
`81`	`81`	`objectContext = context`
`82`	`82`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,20 +23,20 @@ internal class ContextSerializer : JsonSerializer<Context>() {`
`23`	`23`	`gen: JsonGenerator,`
`24`	`24`	`serializers: SerializerProvider`
`25`	`25`	`) {`
`26`		`- val defaultUrl: String? = context.defaultUrl`
	`26`	`+ val defaultUrls: List<String> = context.defaultUrls`
`27`	`27`	`val prefixedUrls: Map<String, String> = context.prefixedUrls`
`28`		`- val hasDefaultUrl = defaultUrl != null`
	`28`	`+ val hasMoreThanOneDefaultUrl = defaultUrls.size > 1`
`29`	`29`	`val hasPrefixedUrls = prefixedUrls.isNotEmpty()`
`30`		`- if (hasDefaultUrl && hasPrefixedUrls) {`
	`30`	`+ if (hasMoreThanOneDefaultUrl \|\| hasPrefixedUrls) {`
`31`	`31`	`gen.writeStartArray()`
`32`	`32`	`}`
`33`		`- if (hasDefaultUrl) {`
`34`		`- gen.writeString(defaultUrl)`
	`33`	`+ defaultUrls.forEach {`
	`34`	`+ gen.writeString(it)`
`35`	`35`	`}`
`36`	`36`	`if (hasPrefixedUrls) {`
`37`	`37`	`gen.writeObject(prefixedUrls)`
`38`	`38`	`}`
`39`		`- if (hasDefaultUrl && hasPrefixedUrls) {`
	`39`	`+ if (hasMoreThanOneDefaultUrl \|\| hasPrefixedUrls) {`
`40`	`40`	`gen.writeEndArray()`
`41`	`41`	`}`
`42`	`42`	`}`