schemurai 2.2.3 → 3.0.0

data/ext/schemurai_native/protocol.def

@@ -0,0 +1,63 @@
+/* Shared C/Rust/Ruby native protocol. Keep wire values stable. */
+SN_OPCODE(BOOLEAN, boolean, 0)
+SN_OPCODE(TYPE_NULL, type_null, 1)
+SN_OPCODE(TYPE_BOOLEAN, type_boolean, 2)
+SN_OPCODE(TYPE_OBJECT, type_object, 3)
+SN_OPCODE(TYPE_ARRAY, type_array, 4)
+SN_OPCODE(TYPE_NUMBER, type_number, 5)
+SN_OPCODE(TYPE_INTEGER, type_integer, 6)
+SN_OPCODE(TYPE_STRING, type_string, 7)
+SN_OPCODE(TYPES, types, 8)
+SN_OPCODE(CONST, const, 9)
+SN_OPCODE(ENUM, enum, 10)
+SN_OPCODE(ALL_OF, allOf, 11)
+SN_OPCODE(ANY_OF, anyOf, 12)
+SN_OPCODE(ONE_OF, oneOf, 13)
+SN_OPCODE(NOT, not, 14)
+SN_OPCODE(CONDITIONAL, conditional, 15)
+SN_OPCODE(NUMBER, number, 16)
+SN_OPCODE(TYPED_NUMBER, typed_number, 17)
+SN_OPCODE(TYPED_INTEGER, typed_integer, 18)
+SN_OPCODE(STRING, string, 19)
+SN_OPCODE(TYPED_STRING, typed_string, 20)
+SN_OPCODE(ARRAY, array, 21)
+SN_OPCODE(TYPED_ARRAY, typed_array, 22)
+SN_OPCODE(OBJECT, object, 23)
+SN_OPCODE(TYPED_OBJECT, typed_object, 24)
+SN_OPCODE(REF, ref, 25)
+SN_OPCODE(RECURSIVE_REF, recursive_ref, 26)
+SN_OPCODE(DYNAMIC_REF, dynamic_ref, 27)
+
+/* Match VM::TypeRules and VM::NumberRules bit masks. */
+SN_CONSTANT(TYPE_NULL, 1)
+SN_CONSTANT(TYPE_BOOLEAN, 2)
+SN_CONSTANT(TYPE_OBJECT, 4)
+SN_CONSTANT(TYPE_ARRAY, 8)
+SN_CONSTANT(TYPE_NUMBER, 16)
+SN_CONSTANT(TYPE_INTEGER, 32)
+SN_CONSTANT(TYPE_STRING, 64)
+SN_CONSTANT(TYPE_INTEGRAL_NUMBER, 48)
+SN_CONSTANT(TYPE_UNSUPPORTED, 128)
+SN_CONSTANT(MAXIMUM, 1)
+SN_CONSTANT(MINIMUM, 2)
+SN_CONSTANT(EXCLUSIVE_MAXIMUM, 4)
+SN_CONSTANT(EXCLUSIVE_MINIMUM, 8)
+SN_CONSTANT(MULTIPLE_OF, 16)
+SN_CONSTANT(TRACKS_EVALUATION, 1)
+SN_CONSTANT(TRACKS_DYNAMIC_SCOPE, 2)
+
+/* Adapter results; comparison/packing reserves 3 beyond ordinary -2..2. */
+SN_CONSTANT(VERDICT_INVALID, 0)
+SN_CONSTANT(VERDICT_VALID, 1)
+SN_CONSTANT(VERDICT_UNSUPPORTED, 2)
+SN_CONSTANT(ADAPTER_UNSUPPORTED, 3)
+SN_CONSTANT(STATUS_PANIC, -1)
+SN_CONSTANT(STATUS_EXCEPTION, -2)
+SN_CONSTANT(OPCODE_UNKNOWN, -1)
+SN_CONSTANT(SMALL_HASH_ORDINARY, 16)
+SN_CONSTANT(SMALL_HASH_COUNT_MASK, 15)
+SN_CONSTANT(SMALL_HASH_TOO_LARGE, -2)
+SN_CONSTANT(ENCODING_OTHER, 0)
+SN_CONSTANT(ENCODING_UTF8, 1)
+SN_CONSTANT(ENCODING_ASCII, 2)
+SN_CONSTANT(ENCODING_SEVEN_BIT, 3)

data/ext/schemurai_native/protocol.h

@@ -0,0 +1,10 @@
+#ifndef SCHEMURAI_PROTOCOL_H
+#define SCHEMURAI_PROTOCOL_H
+enum {
+#define SN_OPCODE(name, symbol, value) SN_OP_##name = value,
+#define SN_CONSTANT(name, value) SN_##name = value,
+#include "protocol.def"
+#undef SN_OPCODE
+#undef SN_CONSTANT
+};
+#endif

data/ext/schemurai_native/src/budget.rs

@@ -0,0 +1,101 @@
+//! Invocation-local native limits. Exhaustion is terminal, not VM delegation.
+use std::cell::Cell;
+use std::time::{Duration, Instant};
+
+#[repr(C)]
+#[derive(Clone, Copy, Default)]
+pub struct Limits {
+    pub max_errors: usize,
+    pub enabled: u32,
+    pub timeout: f64,
+}
+#[repr(C)]
+#[derive(Default)]
+pub struct Outcome {
+    pub kind: u32,
+    pub attempted: usize,
+}
+#[derive(Default)]
+pub(super) struct Budget {
+    pub limits: Limits,
+    pub hit: Cell<(u32, usize)>,
+    deadline: Option<Instant>,
+    checks: Cell<usize>,
+}
+impl Budget {
+    pub fn new(limits: Limits) -> Self {
+        Self {
+            limits,
+            deadline: if limits.enabled & 2 != 0 {
+                Duration::try_from_secs_f64(limits.timeout.max(0.0))
+                    .ok()
+                    .and_then(|duration| Instant::now().checked_add(duration))
+            } else {
+                None
+            },
+            ..Self::default()
+        }
+    }
+    pub fn timed(&self) -> bool {
+        self.limits.enabled & 2 != 0
+    }
+    pub fn check_deadline(&self) -> bool {
+        if self.hit.get().0 != 0 {
+            return false;
+        }
+        if self
+            .deadline
+            .is_some_and(|deadline| Instant::now() >= deadline)
+        {
+            self.hit.set((2, 0));
+            return false;
+        }
+        true
+    }
+    pub fn checkpoint(&self) -> bool {
+        if !self.timed() {
+            return true;
+        }
+        let checks = self.checks.get().wrapping_add(1);
+        self.checks.set(checks);
+        if checks & 255 == 0 {
+            self.check_deadline()
+        } else {
+            self.hit.get().0 == 0
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn deadline_is_sampled_and_exhaustion_is_sticky() {
+        let mut budget = Budget::new(Limits {
+            timeout: 10.0,
+            enabled: 2,
+            ..Limits::default()
+        });
+        assert!(budget.check_deadline());
+        budget.deadline = Some(Instant::now() - Duration::from_secs(1));
+        for _ in 0..255 {
+            assert!(budget.checkpoint());
+        }
+        assert!(!budget.checkpoint());
+        assert_eq!(budget.hit.get(), (2, 0));
+        assert!(!budget.checkpoint());
+    }
+
+    #[test]
+    fn huge_finite_deadlines_do_not_panic() {
+        assert!(
+            Budget::new(Limits {
+                timeout: f64::MAX,
+                enabled: 2,
+                ..Limits::default()
+            })
+            .check_deadline()
+        );
+    }
+}