ratatui_ruby 1.1.1 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 410fcf24b7399d5e9cdab0c6819555fe91e277484d7c772587c9811860bdd372
-  data.tar.gz: 67cd5478a880a29ec4fa1f5500892fc854af285b90c9505dec8c14c22a027161
+  metadata.gz: aa64c94e2dded3a4de71ebdff888860a1528f42a4b9a1ed0200361d3a811e715
+  data.tar.gz: aa98fe686ef20f10e310b3a0bc87b60412279d85d1d60befa31c60c3eef5bf01
 SHA512:
-  metadata.gz: ee74b8f1092d5dd4ea0348363230acd1edb198a87eeb4f0a6bc7052e5f5e49f9c3fb02ea8c2690e7e3e91ab07d703fe4ff6de91b6db50a72f98040ff1d98c62f
-  data.tar.gz: '08e7944efa53c1a78ed90c889ef9f7eed9b192beb0a39d0b3c4615cc1dfb08659f10bdacc03f626c526344e204e29dfe0bc14c2a7ba4c831e508cebee571538c'
+  metadata.gz: fab99ab43c386a115027ea204ec578c7d20c1b4bd7ddfeee43d384825f536ed49162ca8957e1c46b994809cbd20137d16857f39c792330148a5b1eb3d69957a3
+  data.tar.gz: c6b42590b5f920d19062e99fef14a92dfffe2a5482a9b3295fc5b73df095336a99c33b782e1ae14fd17027593253f545957919cf8603936842e121e166dd54b7

data/ext/ratatui_ruby/Cargo.lock

@@ -1059,7 +1059,7 @@ dependencies = [
 
 [[package]]
 name = "ratatui_ruby"
-version = "1.1.1"
+version = "1.2.1"
 dependencies = [
  "bumpalo",
  "lazy_static",

data/ext/ratatui_ruby/Cargo.toml

@@ -3,7 +3,7 @@
 
 [package]
 name = "ratatui_ruby"
-version = "1.1.1"
+version = "1.2.1"
 edition = "2021"
 
 [lib]

data/ext/ratatui_ruby/src/events.rs

@@ -4,8 +4,15 @@
 use magnus::{Error, IntoValue, TryConvert, Value};
 use std::cell::RefCell;
 
+/// Wrapper enum for test events - includes crossterm events and our Sync event.
+#[derive(Debug, Clone)]
+enum TestEvent {
+    Crossterm(ratatui::crossterm::event::Event),
+    Sync,
+}
+
 thread_local! {
-    static EVENT_QUEUE: RefCell<Vec<ratatui::crossterm::event::Event>> = const { RefCell::new(Vec::new()) };
+    static EVENT_QUEUE: RefCell<Vec<TestEvent>> = const { RefCell::new(Vec::new()) };
 }
 
 use ratatui::crossterm::event::{KeyCode, KeyModifiers, MediaKeyCode, ModifierKeyCode};
@@ -107,12 +114,13 @@ pub fn all_key_codes() -> magnus::RHash {
 pub fn inject_test_event(event_type: String, data: magnus::RHash) -> Result<(), Error> {
     let ruby = magnus::Ruby::get().unwrap();
     let event = match event_type.as_str() {
-        "key" => parse_key_event(data, &ruby)?,
-        "mouse" => parse_mouse_event(data, &ruby)?,
-        "resize" => parse_resize_event(data, &ruby)?,
-        "paste" => parse_paste_event(data, &ruby)?,
-        "focus_gained" => ratatui::crossterm::event::Event::FocusGained,
-        "focus_lost" => ratatui::crossterm::event::Event::FocusLost,
+        "key" => TestEvent::Crossterm(parse_key_event(data, &ruby)?),
+        "mouse" => TestEvent::Crossterm(parse_mouse_event(data, &ruby)?),
+        "resize" => TestEvent::Crossterm(parse_resize_event(data, &ruby)?),
+        "paste" => TestEvent::Crossterm(parse_paste_event(data, &ruby)?),
+        "focus_gained" => TestEvent::Crossterm(ratatui::crossterm::event::Event::FocusGained),
+        "focus_lost" => TestEvent::Crossterm(ratatui::crossterm::event::Event::FocusLost),
+        "sync" => TestEvent::Sync,
         _ => {
             return Err(Error::new(
                 ruby.exception_arg_error(),
@@ -317,7 +325,7 @@ pub fn poll_event(ruby: &magnus::Ruby, timeout_val: Option<f64>) -> Result<Value
     });
 
     if let Some(e) = event {
-        return handle_event(e);
+        return handle_test_event(e);
     }
 
     let is_test_mode = crate::terminal::with_query(|q| q.is_test_mode()).unwrap_or(false);
@@ -334,7 +342,7 @@ pub fn poll_event(ruby: &magnus::Ruby, timeout_val: Option<f64>) -> Result<Value
         {
             let event = ratatui::crossterm::event::read()
                 .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
-            handle_event(event)
+            handle_crossterm_event(event)
         } else {
             Ok(ruby.qnil().into_value_with(ruby))
         }
@@ -342,11 +350,18 @@ pub fn poll_event(ruby: &magnus::Ruby, timeout_val: Option<f64>) -> Result<Value
         // Blocking: wait indefinitely for an event
         let event = ratatui::crossterm::event::read()
             .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
-        handle_event(event)
+        handle_crossterm_event(event)
+    }
+}
+
+fn handle_test_event(event: TestEvent) -> Result<Value, Error> {
+    match event {
+        TestEvent::Crossterm(e) => handle_crossterm_event(e),
+        TestEvent::Sync => handle_sync_event(),
     }
 }
 
-fn handle_event(event: ratatui::crossterm::event::Event) -> Result<Value, Error> {
+fn handle_crossterm_event(event: ratatui::crossterm::event::Event) -> Result<Value, Error> {
     match event {
         ratatui::crossterm::event::Event::Key(key) => handle_key_event(key),
         ratatui::crossterm::event::Event::Mouse(event) => handle_mouse_event(event),
@@ -357,6 +372,13 @@ fn handle_event(event: ratatui::crossterm::event::Event) -> Result<Value, Error>
     }
 }
 
+fn handle_sync_event() -> Result<Value, Error> {
+    let ruby = magnus::Ruby::get().unwrap();
+    let hash = ruby.hash_new();
+    hash.aset(ruby.to_symbol("type"), ruby.to_symbol("sync"))?;
+    Ok(hash.into_value_with(&ruby))
+}
+
 fn media_key_to_string(m: MediaKeyCode) -> &'static str {
     MEDIA_KEY_MAPPINGS
         .iter()

data/lib/ratatui_ruby/synthetic_events.rb

@@ -48,8 +48,28 @@ module RatatuiRuby
   module SyntheticEvents
     @queue = [] #: Array[Event]
     @mutex = Mutex.new
+    @inline_sync = false #: bool
 
     class << self
+      ##
+      # Enables inline sync mode for deterministic event ordering.
+      #
+      # Call once at startup. Cannot be disabled.
+      #
+      # When enabled, +inject_sync+ routes through the native event queue
+      # and +poll_event+ returns +Event::Sync+ like any other event.
+      # This ensures sync events are processed in sequence with key events.
+      #
+      # Runtimes that need ordering guarantees (like Rooibos) should call
+      # this before entering their event loop.
+      def inline_sync!
+        @inline_sync = true
+      end
+
+      def inline_sync? # :nodoc:
+        @inline_sync
+      end
+
       ##
       # Pushes an event to the synthetic queue.
       #

data/lib/ratatui_ruby/test_helper/event_injection.rb

@@ -89,8 +89,13 @@ module RatatuiRuby
         when RatatuiRuby::Event::FocusLost
           RatatuiRuby.inject_test_event("focus_lost", {})
         when RatatuiRuby::Event::Sync
-          # Sync events use the engine-level synthetic queue
-          RatatuiRuby::SyntheticEvents.push(event)
+          if RatatuiRuby::SyntheticEvents.inline_sync?
+            # Route through native queue for deterministic ordering with key events
+            RatatuiRuby.inject_test_event("sync", {})
+          else
+            # Default 1.0 behavior: use the engine-level synthetic queue
+            RatatuiRuby::SyntheticEvents.push(event)
+          end
         else
           raise ArgumentError, "Unknown event type: #{event.class}"
         end

data/lib/ratatui_ruby/version.rb

@@ -8,5 +8,5 @@
 module RatatuiRuby
   # The version of the ratatui_ruby gem.
   # See https://semver.org/spec/v2.0.0.html
-  VERSION = "1.1.1"
+  VERSION = "1.2.1"
 end

data/lib/ratatui_ruby.rb

@@ -409,6 +409,8 @@ module RatatuiRuby
       Event::FocusGained.new.freeze
     when :focus_lost
       Event::FocusLost.new.freeze
+    when :sync
+      Event::Sync.new.freeze
     else
       # Return None for unknown event types
       Event::None.new.freeze

data/sig/ratatui_ruby/synthetic_events.rbs

@@ -12,7 +12,10 @@ module RatatuiRuby
   # Used primarily for testing and the andThen-like integration pattern.
   module SyntheticEvents
     @queue: Array[Event]
+    @inline_sync: bool
 
+    def self.inline_sync!: () -> void
+    def self.inline_sync?: () -> bool
     def self.push: (Event event) -> void
     def self.pop: () -> Event?
     def self.clear: () -> void

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ratatui_ruby
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.1
 platform: ruby
 authors:
 - Kerrick Long