Fix Classloader Problem

Ignore the previous versions
Now ImportClass works
Material has been set to defaultImport

build.gradle

@@ -3,6 +3,7 @@ plugins {
     id 'com.github.johnrengelman.shadow' version '5.0.0'
     id 'java'
     id 'org.jetbrains.kotlin.jvm' version "1.3.41"
+    id 'me.qoomon.git-versioning' version '1.2.1'
 }
 ext{
     kotlin_version ="1.3.41"
@@ -35,7 +36,7 @@ shadowJar {
 //start
 
 dependencies{
-    compile 'cf.wayzer:LibraryManager:1.1'
+    compile 'cf.wayzer:LibraryManager:1.2'
     compile "org.jetbrains.kotlin:kotlin-script-util:$kotlin_version"
     compile "org.jetbrains.kotlin:kotlin-scripting-jvm-host:$kotlin_version"
     compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
@@ -45,11 +46,20 @@ dependencies{
     compileOnly files("$rootDir/lib/PowerNBT.jar")
 //    compile "me.dpohvar.powernbt:PowerNBT:0.8.9.2"
 }
-version="1.3.4"
+version "1.3-SNAPSHOT"
+gitVersioning{
+    tag {
+        pattern = 'v(?<tagVersion>[0-9].*)'
+        versionFormat = '${tagVersion}'
+    }
+    commit {
+        versionFormat = '${version}-${commit.short}'
+    }
+}
 processResources{
     filesMatching(["plugin.yml","bungee.yml"]){
         filter{
-            it.replace("@version@", project.version.toString())
+            it.replace("@version@", version.toString())
         }
     }
 }
@@ -63,12 +73,12 @@ task buildArtifact(type: Zip){
         into("items")
     }
     from(jar.getArchiveFile()){
-        rename(".jar","-lib.jar")
+        rename(".jar","-developLib.jar")
     }
     from(shadowJar.getArchiveFile()){
         rename("-all","")
     }
-    archiveFileName ="SuperItem-${project.version}.zip"
+    archiveFileName ="SuperItem-${version}.zip"
     destinationDirectory =file("$rootDir/artifacts/")
 }
 artifacts {

src/main/kotlin/cf/wayzer/SuperItem/ItemManager.kt

@@ -3,13 +3,13 @@ package cf.wayzer.SuperItem
 import cf.wayzer.SuperItem.Main.Companion.main
 import cf.wayzer.SuperItem.features.NBT
 import cf.wayzer.SuperItem.features.Permission
+import cf.wayzer.SuperItem.scripts.ScriptSupporter
 import org.bukkit.Material
 import org.bukkit.inventory.ItemStack
 import java.io.File
 import java.net.URLClassLoader
 import java.util.*
 import java.util.logging.Level
-import kotlin.script.experimental.api.*
 
 object ItemManager {
     private val logger = main.logger
@@ -57,26 +57,10 @@ object ItemManager {
     fun loadFile(file: File,className: String):Item?{
         var item:Item? = null
         if(file.name.endsWith("superitem.kts")){
+            ScriptSupporter.init(logger)
             logger.info("Load Item in async: ${file.name}")
             run {
-                val result = ScriptSupporter.loadFile(file)
-                result.onSuccess {
-                    val res = result.resultOrNull()!!.returnValue
-                    if(res is ResultValue.Value && res.value is Item) {
-                        item = (res.value as Item)
-                        result.reports.filterNot { it.severity==ScriptDiagnostic.Severity.DEBUG }.forEachIndexed { index, rep ->
-                            logger.log(Level.WARNING,"##$index##"+rep.message,rep.exception)
-                        }
-                        return@onSuccess ResultWithDiagnostics.Success(ResultValue.Unit)
-                    } else {
-                        return@onSuccess ResultWithDiagnostics.Failure(ScriptDiagnostic("非物品Kts: ${file.name}"))
-                    }
-                }.onFailure {
-                    logger.warning("物品Kts加载失败: ")
-                    it.reports.forEachIndexed { index, rep ->
-                        logger.log(Level.WARNING,"##$index##"+rep.message,rep.exception)
-                    }
-                }
+                item = ScriptSupporter.load(file)
             }
         }else if (file.name.endsWith(".class")&&!file.name.contains("$")){
             val c = ucl.loadClass(className)

src/main/kotlin/cf/wayzer/SuperItem/Main.kt

@@ -20,17 +20,17 @@ class Main : JavaPlugin() {
     }
 
     override fun onDisable() {
-        ItemManager.getItems().forEach(ItemManager::unregisterItem)
+        ItemManager.getItems().toList().forEach(ItemManager::unregisterItem)
     }
 
     companion object {
-        val kotlinVersion = "1.3.41"
+        const val kotlinVersion = "1.3.41"
         lateinit var main: Main
             private set
         init {
             LibraryManager(Paths.get("./libs/")).apply {
                 addMavenCentral()
-                require(Dependency("org.jetbrains.kotlin:kotlin-reflect:${kotlinVersion}"))
+                require(Dependency("org.jetbrains.kotlin:kotlin-reflect:$kotlinVersion"))
                 require(Dependency("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.1.1"))
                 require(Dependency("org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion"))
                 require(Dependency("org.jetbrains.kotlin:kotlin-stdlib-common:$kotlinVersion"))

src/main/kotlin/cf/wayzer/SuperItem/scripts/CompilationConfiguration.kt

@@ -1,8 +1,8 @@
 package cf.wayzer.SuperItem.scripts
 
 import cf.wayzer.SuperItem.Item
-import cf.wayzer.SuperItem.ScriptSupporter
 import org.bukkit.Bukkit
+import org.bukkit.Material
 import java.io.File
 import kotlin.reflect.KClass
 import kotlin.script.experimental.api.*
@@ -13,25 +13,26 @@ import kotlin.script.experimental.jvm.util.classpathFromClass
 
 object CompilationConfiguration: ScriptCompilationConfiguration({
     jvm {
-        dependenciesFromClass(ScriptSupporter::class.java.classLoader, Bukkit::class, Item::class)
+        dependenciesFromClass(Bukkit::class, Item::class)
     }
-    defaultImports(Item::class, ImportClass::class)
+    defaultImports(Item::class, ImportClass::class,Material::class)
     defaultImports.append("cf.wayzer.SuperItem.features.*")
     refineConfiguration{
-        onAnnotations(JvmName::class){ context->
-            val annotations = context.collectedData?.get(ScriptCollectedData.foundAnnotations)?.filter { it.annotationClass== JvmName::class }?: listOf()
-            val classes = annotations.map { Class.forName((it as JvmName).name).kotlin}
+        onAnnotations(ImportClass::class){ context->
+            val annotations = context.collectedData?.get(ScriptCollectedData.foundAnnotations)?.filter { it.annotationClass== ImportClass::class }?: listOf()
+            val classes = annotations.map { Class.forName((it as ImportClass).name).kotlin}
             val diagnostics = classes.map { ScriptDiagnostic("[Info]PluginDependency: ${it.java.name}",ScriptDiagnostic.Severity.INFO) }
             ScriptCompilationConfiguration(context.compilationConfiguration) {
                 jvm {
-                    dependenciesFromClass(ScriptSupporter::class.java.classLoader, *classes.toTypedArray())
+                    dependenciesFromClass(*classes.toTypedArray())
                 }
             }.asSuccess(diagnostics)
         }
     }
 })
-private fun JvmScriptCompilationConfigurationBuilder.dependenciesFromClass(classLoader: ClassLoader, vararg classes: KClass<out Any>) {
+private fun JvmScriptCompilationConfigurationBuilder.dependenciesFromClass(vararg classes: KClass<out Any>) {
     classes.flatMap {c->
+        val classLoader = c.java.classLoader
         classpathFromClass(classLoader,c) ?:let {
             val clp = "${c.java.canonicalName.replace('.', '/')}.class"
             val url = classLoader.getResource(clp)

src/main/kotlin/cf/wayzer/SuperItem/scripts/ImportClass.kt

@@ -1,6 +1,7 @@
 package cf.wayzer.SuperItem.scripts
 
 @Target(AnnotationTarget.FILE)
+@Repeatable
 annotation class ImportClass(
-        val value:String
+        val name:String
 )

src/main/kotlin/cf/wayzer/SuperItem/scripts/ScriptLoader.kt

@@ -0,0 +1,58 @@
+package cf.wayzer.SuperItem.scripts
+
+import cf.wayzer.SuperItem.Item
+import cf.wayzer.SuperItem.Main
+import java.io.File
+import java.util.logging.Level
+import java.util.logging.Logger
+import kotlin.script.experimental.api.*
+import kotlin.script.experimental.host.ScriptingHostConfiguration
+import kotlin.script.experimental.host.configurationDependencies
+import kotlin.script.experimental.host.toScriptSource
+import kotlin.script.experimental.jvm.JvmDependency
+import kotlin.script.experimental.jvm.baseClassLoader
+import kotlin.script.experimental.jvm.defaultJvmScriptingHostConfiguration
+import kotlin.script.experimental.jvm.jvm
+import kotlin.script.experimental.jvm.util.classpathFromClassloader
+import kotlin.script.experimental.jvmhost.BasicJvmScriptingHost
+import kotlin.script.experimental.jvmhost.createJvmCompilationConfigurationFromTemplate
+
+class ScriptLoader {
+    lateinit var logger: Logger
+    private val hostConfiguration by lazy { ScriptingHostConfiguration(defaultJvmScriptingHostConfiguration){
+        configurationDependencies(JvmDependency(classpathFromClassloader(Main::class.java.classLoader) ?:listOf()))
+    }}
+    private val compilationConfiguration by lazy {createJvmCompilationConfigurationFromTemplate<SuperItemScript> (hostConfiguration) }
+
+    fun load(file: File):Item?{
+        var item:Item?=null
+        val result = load0(file)
+        result.onSuccess {
+            val res = result.resultOrNull()!!.returnValue
+            if(res is ResultValue.Value && res.value is Item) {
+                item = (res.value as Item)
+                result.reports.filterNot { it.severity== ScriptDiagnostic.Severity.DEBUG }.forEachIndexed { index, rep ->
+                    logger.log(Level.WARNING,"##$index##"+rep.message,rep.exception)
+                }
+                return@onSuccess ResultWithDiagnostics.Success(ResultValue.Unit)
+            } else {
+                return@onSuccess ResultWithDiagnostics.Failure(ScriptDiagnostic("非物品Kts: ${file.name}"))
+            }
+        }.onFailure {
+            logger.warning("物品Kts加载失败: ")
+            it.reports.forEachIndexed { index, rep ->
+                logger.log(Level.WARNING,"##$index##"+rep.message,rep.exception)
+            }
+        }
+        return item
+    }
+
+    private fun load0(f: File):ResultWithDiagnostics<EvaluationResult>{
+        return BasicJvmScriptingHost(hostConfiguration).eval(f.toScriptSource(),compilationConfiguration, ScriptEvaluationConfiguration {
+            jvm {
+                baseClassLoader(ScriptSupporter::class.java.classLoader)
+            }
+            constructorArgs(f.name.split(".")[0].toUpperCase())
+        })
+    }
+}

src/main/kotlin/cf/wayzer/SuperItem/scripts/ScriptSupporter.kt

@@ -0,0 +1,39 @@
+package cf.wayzer.SuperItem.scripts
+
+import cf.wayzer.SuperItem.Item
+import cf.wayzer.SuperItem.Main
+import cf.wayzer.libraryManager.Dependency
+import cf.wayzer.libraryManager.LibraryManager
+import java.io.File
+import java.net.URLClassLoader
+import java.nio.file.Paths
+import java.util.logging.Logger
+
+object ScriptSupporter {
+    lateinit var loader:ScriptLoader
+    private var inited=false
+    fun init(logger:Logger){
+        if(inited)return
+        LibraryManager(Paths.get("./libs/")).apply {
+            addMavenCentral()
+            require(Dependency("org.jetbrains.kotlin:kotlin-script-runtime:${Main.kotlinVersion}"))
+            require(Dependency("org.jetbrains.kotlin:kotlin-scripting-common:${Main.kotlinVersion}"))
+            require(Dependency("org.jetbrains.intellij.deps:trove4j:1.0.20181211"))
+            require(Dependency("org.jetbrains.kotlin:kotlin-daemon-client:${Main.kotlinVersion}"))
+            require(Dependency("org.jetbrains.kotlin:kotlin-scripting-jvm:${Main.kotlinVersion}"))
+            require(Dependency("org.jetbrains.kotlin:kotlin-scripting-jvm-host:${Main.kotlinVersion}"))
+            require(Dependency("org.jetbrains.kotlin:kotlin-scripting-compiler:${Main.kotlinVersion}"))
+            require(Dependency("org.jetbrains.kotlin:kotlin-scripting-compiler-impl:${Main.kotlinVersion}"))
+            require(Dependency("org.jetbrains.kotlin:kotlin-compiler:${Main.kotlinVersion}"))
+            require(Dependency("org.jetbrains.kotlin:kotlin-script-util:${Main.kotlinVersion}"))
+        }.loadToClassLoader(Main::class.java.classLoader as URLClassLoader)
+        loader = ScriptLoader()
+        loader.logger=logger
+        inited =true
+    }
+
+    fun load(file: File): Item?{
+        if(!inited)throw IllegalStateException("Must init first!!")
+        return loader.load(file)
+    }
+}

src/main/resources/Mythicmobs_Support.superitem.kts

@@ -1,18 +1,17 @@
-@file:JvmName("io.lumine.xikage.mythicmobs.api.bukkit.events.MythicDropLoadEvent")
+@file:ImportClass("io.lumine.xikage.mythicmobs.api.bukkit.events.MythicDropLoadEvent")
 
 import cf.wayzer.SuperItem.ItemManager
 import io.lumine.xikage.mythicmobs.adapters.bukkit.BukkitItemStack
 import io.lumine.xikage.mythicmobs.api.bukkit.events.MythicDropLoadEvent
-import io.lumine.xikage.mythicmobs.drops.droppables.*
-import org.bukkit.Material
+import io.lumine.xikage.mythicmobs.drops.droppables.ItemDrop
 
 require(ItemInfo(Material.NAME_TAG,"&cMythicmobs_Support", listOf("&c This Item doesn't have other effect")))
 
 listen<MythicDropLoadEvent>{
     val name = (it.dropName as String).toUpperCase()
     if(!name.startsWith("SI_"))return@listen
     val item = ItemManager.getItem(name.substring(3))
-    if(item==null)it.register(NothingDrop(it.config.line,it.config))
-    else it.register(ItemDrop(it.config.line,it.config,BukkitItemStack(item.get<ItemInfo>().newItemStack())))
+    //if(item==null)it.register(NothingDrop(it.config.line,it.config))
+    if(item!=null)it.register(ItemDrop(it.config.line,it.config,BukkitItemStack(item.get<ItemInfo>().newItemStack())))
 }