Merge branch 'main' into SBX-7-custom-items

Author: adrwa

src/main/kotlin/org/sandboxpowered/fabric/api/PolyglotStateProperty.kt

@@ -5,18 +5,10 @@ import org.graalvm.polyglot.HostAccess.Export
 
 class PolyglotStateProperty private constructor(
     private val property: Property<*>?,
-    @Export val name: String,
-    @Export val type: String,
-    val extra: Array<out Any>
+    @JvmField @Export val name: String,
+    @JvmField @Export val type: String,
+    @JvmField @Export val values: Array<*>
 ) {
-    // TODO: Coded : figure out what to do with this
-    //Int Property
-    @Export
-    fun values(): Array<Int> {
-        if (type == INT) return extra as Array<Int>
-        throw UnsupportedOperationException("Cannot get minimum value of $type property")
-    }
-
     companion object {
         infix fun from(property: Property<*>) = PolyglotStateProperty(
             property = property,
@@ -28,17 +20,17 @@ class PolyglotStateProperty private constructor(
                 is EnumProperty -> ENUM
                 else -> error("Unknown Property type: $property")
             },
-            extra = when (property) {
+            values = when (property) {
                 is BooleanProperty -> emptyArray()
                 else -> property.values.toTypedArray()
             }
         )
 
-        fun from(name: String, type: String, extra: Array<out Any> = emptyArray()) = PolyglotStateProperty(
+        fun from(name: String, type: String, extra: Array<*> = emptyArray<Any>()) = PolyglotStateProperty(
             property = null,
             name = name,
             type = type,
-            extra = extra
+            values = extra
         )
 
         const val BOOLEAN = "boolean"

src/main/kotlin/org/sandboxpowered/fabric/api/SandboxResourcePolyglotContext.kt

@@ -58,7 +58,7 @@ class SandboxResourcePolyglotContext(private val resource: String, private val s
     }
 
     @Export
-    fun getStateProperty(name: String, type: String, vararg extra: Value): PolyglotStateProperty? {
+    fun getStateProperty(name: String, type: String, vararg extra: Value): PolyglotStateProperty {
         return StateManagement.getStateProperty(name, type, *extra)
     }
 }

src/main/kotlin/org/sandboxpowered/fabric/api/StateManagement.kt

@@ -1,9 +1,9 @@
 package org.sandboxpowered.fabric.api
 
-import com.google.common.hash.Hashing
 import net.minecraft.state.property.Property
 import org.graalvm.polyglot.Value
-import java.nio.charset.StandardCharsets
+import org.sandboxpowered.fabric.util.Hash
+import org.sandboxpowered.fabric.util.hash
 
 object StateManagement {
     private val stateMap: MutableMap<String, PolyglotStateProperty> = hashMapOf()
@@ -14,7 +14,10 @@ object StateManagement {
             stateMap.computeIfAbsent(hash(name, type)) { PolyglotStateProperty.from(name, type) }
         }
         PolyglotStateProperty.INT -> {
-            val values = extra.map(Value::asInt).toTypedArray()
+            require(extra.size == 2) { "Invalid number of arguments specified, expected 2 got ${extra.size}" }
+            var values = extra.map(Value::asInt).toTypedArray()
+
+            values = (values[0]..values[1]).toList().toTypedArray()
             stateMap.computeIfAbsent(hash(name, type, values)) {
                 PolyglotStateProperty.from(name, type, values)
             }
@@ -29,15 +32,14 @@ object StateManagement {
     }
 
     private fun PolyglotStateProperty.hash(): String =
-        hash(name, type, extra)
+        hash(name, type, values)
 
-    private fun hash(name: String, type: String, extra: Array<out Any> = emptyArray()): String {
+    private fun hash(name: String, type: String, extra: Array<*> = emptyArray<Any>()): String {
         val compiled = buildString {
             append(name)
             append(type)
             extra.forEach(this::append)
         }
-        @Suppress("UnstableApiUsage") // apparently we ain't got anything better
-        return Hashing.sha256()?.hashString(compiled, StandardCharsets.UTF_8)?.toString() ?: compiled
+        return compiled.hash(Hash.SHA256)
     }
 }

src/main/kotlin/org/sandboxpowered/fabric/scripting/PolyglotScriptLoader.kt

@@ -7,9 +7,8 @@ import org.sandboxpowered.fabric.api.SandboxResourcePolyglotContext
 import org.sandboxpowered.fabric.api.item.PolyglotGlobalItemManager
 import org.sandboxpowered.fabric.api.item.PolyglotItemManager
 import org.sandboxpowered.fabric.scripting.polyglot.PolyglotFileSystem
+import org.sandboxpowered.fabric.util.TimingUtil
 import java.util.concurrent.Executors
-import java.util.concurrent.TimeUnit
-import java.util.concurrent.TimeoutException
 
 class PolyglotScriptLoader {
     private val executor = Executors.newSingleThreadExecutor()
@@ -56,12 +55,14 @@ class PolyglotScriptLoader {
         val bindings = context.getBindings(scriptSource.language)
         bindings.putMember("sandbox", getPolyglotContext(resource))
 
-        try {
-            executor.submit { context.eval(scriptSource) }.get(5, TimeUnit.SECONDS)
-        } catch (exception: TimeoutException) {
-            error("Script ${scriptSource.name} failed to run in under 5 seconds")
-        } catch (exception: Exception) {
-            exception.printStackTrace()
+        val result = TimingUtil.execute(func = { context.eval(scriptSource) }, executor = executor)
+
+        if (result is TimingUtil.Timeout) {
+            println("Script $resource:${scriptSource.name} failed to run in under 5 seconds")
+            //TODO: cancel and unload this script's resource due to failure, throw error if addon is deemed required
+        } else if (result is TimingUtil.Error) {
+            throw RuntimeException("Encountered unknown error when executing script $resource:${scriptSource.name}",
+                result.error)
         }
     }
 

src/main/kotlin/org/sandboxpowered/fabric/util/TimingUtil.kt

@@ -0,0 +1,45 @@
+package org.sandboxpowered.fabric.util
+
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.TimeoutException
+
+object TimingUtil {
+    private val executor = Executors.newSingleThreadExecutor()
+
+    fun execute(
+        func: () -> Unit,
+        timeout: Long = 5,
+        unit: TimeUnit = TimeUnit.SECONDS,
+        executor: ExecutorService? = null,
+    ): Result<Any, Exception> {
+        return try {
+            Success((executor ?: this.executor).submit(func).get(timeout, unit))
+        } catch (exception: TimeoutException) {
+            Timeout(exception)
+        } catch (exception: Exception) {
+            Error(exception)
+        }
+    }
+
+    fun <T> executeWithResponse(
+        func: () -> T,
+        timeout: Long = 5,
+        unit: TimeUnit = TimeUnit.SECONDS,
+        executor: ExecutorService? = null,
+    ): Result<T, Exception> {
+        return try {
+            Success((executor ?: this.executor).submit(func).get(timeout, unit))
+        } catch (exception: TimeoutException) {
+            Timeout(exception)
+        } catch (exception: Exception) {
+            Error(exception)
+        }
+    }
+
+    sealed class Result<out T, out E : Throwable>
+    class Success<out T>(val value: T) : Result<T, Nothing>()
+    class Timeout<out E : Throwable>(error: E) : Error<E>(error)
+    open class Error<out E : Throwable>(val error: E) : Result<Nothing, E>()
+}

src/main/kotlin/org/sandboxpowered/fabric/util/hashing.kt

@@ -0,0 +1,19 @@
+@file:Suppress("UnstableApiUsage")
+
+package org.sandboxpowered.fabric.util
+
+import com.google.common.hash.HashFunction
+import com.google.common.hash.Hashing
+import java.nio.charset.Charset
+import java.nio.charset.StandardCharsets
+
+fun String.hash(hash: Hash, charset: Charset = StandardCharsets.UTF_8): String {
+    return hash.hashFunction.hashString(this, charset).toString()
+}
+
+@Suppress("unused")
+enum class Hash(val hashFunction: HashFunction) {
+    MD5(Hashing.md5()),
+    SHA256(Hashing.sha256()),
+    SHA512(Hashing.sha512()),
+}