added jpms url protocol

gbcs-base/build.gradle

@@ -1,5 +1,3 @@
-import org.jetbrains.kotlin.gradle.dsl.JvmTarget
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
     id 'java-library'
@@ -10,16 +8,6 @@ plugins {
 dependencies {
     compileOnly project(':gbcs-api')
     compileOnly catalog.slf4j.api
-    api catalog.jwo
-}
-
-tasks.named(JavaPlugin.COMPILE_JAVA_TASK_NAME, JavaCompile) {
-    options.compilerArgs << '--patch-module' << 'net.woggioni.gbcs.base=' + project.sourceSets.main.output.asPath
-    options.javaModuleVersion = version
-}
-
-tasks.named("compileKotlin", KotlinCompile.class) {
-    compilerOptions.jvmTarget = JvmTarget.JVM_21
 }
 
 publishing {

gbcs-base/src/main/java/module-info.java

@@ -3,7 +3,6 @@ module net.woggioni.gbcs.base {
     requires java.logging;
     requires org.slf4j;
     requires kotlin.stdlib;
-    requires net.woggioni.jwo;
 
     exports net.woggioni.gbcs.base;
 }

gbcs-base/src/main/kotlin/net/woggioni/gbcs/base/GbcsUrlStreamHandlerFactory.kt

@@ -1,16 +1,20 @@
 package net.woggioni.gbcs.base
 
+import java.io.IOException
 import java.io.InputStream
 import java.net.URL
 import java.net.URLConnection
 import java.net.URLStreamHandler
 import java.net.URLStreamHandlerFactory
+import java.util.Optional
 import java.util.concurrent.atomic.AtomicBoolean
 import java.util.stream.Collectors
 
 
-class ClasspathUrlStreamHandlerFactoryProvider : URLStreamHandlerFactory {
-    private class Handler(private val classLoader: ClassLoader = ClasspathUrlStreamHandlerFactoryProvider::class.java.classLoader) : URLStreamHandler() {
+class GbcsUrlStreamHandlerFactory : URLStreamHandlerFactory {
+
+    private class ClasspathHandler(private val classLoader: ClassLoader = GbcsUrlStreamHandlerFactory::class.java.classLoader) :
+        URLStreamHandler() {
 
         override fun openConnection(u: URL): URLConnection? {
             return javaClass.module
@@ -20,23 +24,48 @@ class ClasspathUrlStreamHandlerFactoryProvider : URLStreamHandlerFactory {
                     val i = path.lastIndexOf('/')
                     val packageName = path.substring(0, i).replace('/', '.')
                     val modules = packageMap[packageName]!!
-                    ModuleResourceURLConnection(
+                    ClasspathResourceURLConnection(
                         u,
                         modules
                     )
                 }
                 ?: classLoader.getResource(u.path)?.let(URL::openConnection)
-            }
         }
+    }
+
+    private class JpmsHandler : URLStreamHandler() {
+
+        override fun openConnection(u: URL): URLConnection {
+            val thisModule = javaClass.module
+            val sourceModule = Optional.ofNullable(thisModule)
+                .map { obj: Module -> obj.layer }
+                .flatMap { layer: ModuleLayer ->
+                    val moduleName = u.host
+                    layer.findModule(moduleName)
+                }.orElse(thisModule)
+            return JpmsResourceURLConnection(u, sourceModule)
+        }
+    }
+
+    private class JpmsResourceURLConnection(url: URL, private val module: Module) : URLConnection(url) {
+        override fun connect() {
+        }
+
+        @Throws(IOException::class)
+        override fun getInputStream(): InputStream {
+            return module.getResourceAsStream(getURL().path)
+        }
+    }
 
     override fun createURLStreamHandler(protocol: String): URLStreamHandler? {
         return when (protocol) {
-            "classpath" -> Handler()
+            "classpath" -> ClasspathHandler()
+            "jpms" -> JpmsHandler()
             else -> null
         }
     }
 
-    private class ModuleResourceURLConnection(url: URL?, private val modules: List<Module>) :
+    private class ClasspathResourceURLConnection(url: URL?, private val modules: List<Module>) :
         URLConnection(url) {
         override fun connect() {}
 
@@ -53,12 +82,12 @@ class ClasspathUrlStreamHandlerFactoryProvider : URLStreamHandlerFactory {
         private val installed = AtomicBoolean(false)
         fun install() {
             if (!installed.getAndSet(true)) {
-                URL.setURLStreamHandlerFactory(ClasspathUrlStreamHandlerFactoryProvider())
+                URL.setURLStreamHandlerFactory(GbcsUrlStreamHandlerFactory())
             }
         }
 
         private val packageMap: Map<String, List<Module>> by lazy {
-            ClasspathUrlStreamHandlerFactoryProvider::class.java.module.layer
+            GbcsUrlStreamHandlerFactory::class.java.module.layer
                 .modules()
                 .stream()
                 .flatMap { m: Module ->