r2ui 0.1.0 → 0.2.0

data/lib/r2ui/compat/bubbletea/runner.rb

@@ -0,0 +1,425 @@
+# frozen_string_literal: true
+
+# Copied from bubbletea 0.1.4 (https://github.com/marcoroth/bubbletea-ruby); r2ui's changes are
+# marked "r2ui:".
+# Copyright (c) 2025 Marco Roth. MIT License; see LICENSE-bubbletea.txt in this directory.
+# Bubbletea::Program, which this drives, is r2ui's pure-Ruby replacement (native.rb).
+
+module Bubbletea
+  # Runner manages the event loop and coordinates between the model and the terminal
+  class Runner
+    attr_reader :options
+
+    DEFAULT_OPTIONS = {
+      alt_screen: false,
+      mouse_cell_motion: false,
+      mouse_all_motion: false,
+      bracketed_paste: false,
+      report_focus: false,
+      fps: 60,
+      input_timeout: 10,
+      without_renderer: false,
+      # r2ui: wrap each frame in DEC 2026 synchronized output (not an upstream option).
+      synchronized: false,
+      # r2ui: in the alt screen, write only the lines that changed since the last frame (not an
+      # upstream option).
+      line_diff: false,
+    }.freeze
+
+    def initialize(model, **options)
+      @model = model
+      @options = DEFAULT_OPTIONS.merge(options)
+      @program = Program.new
+      @renderer_id = nil
+      @running = false
+      @pending_ticks = []
+      @pending_ticks_lock = Mutex.new
+      @width = 80
+      @height = 24
+      @resize_pending = false
+      @repaint = false
+      @previous_winch_handler = nil
+      @in_alt_screen = false
+    end
+
+    def run
+      setup_terminal
+      @renderer_id = @program.create_renderer unless @options[:without_renderer]
+      if @renderer_id && @options[:synchronized]
+        R2UI::Compat::Tea.renderer(@renderer_id)&.synchronized = true
+      end
+      # r2ui: line diffing, the same way. setup_terminal entered the alt screen before the renderer
+      # existed, so upstream's renderer never learns it (it draws inline-style there); diffing
+      # needs to know, so tell it.
+      if @renderer_id && @options[:line_diff]
+        renderer = R2UI::Compat::Tea.renderer(@renderer_id)
+        renderer&.line_diff = true
+        @program.renderer_set_alt_screen(@renderer_id, true) if @in_alt_screen
+      end
+
+      update_terminal_size
+      @running = true
+
+      new_model, command = @model.init
+      @model = new_model if new_model
+      process_command(command)
+
+      return unless @running
+
+      handle_message(WindowSizeMessage.new(width: @width, height: @height))
+
+      render
+      run_loop
+      render
+    ensure
+      cleanup_terminal
+    end
+
+    def send(message)
+      @pending_messages ||= []
+      @pending_messages << message
+    end
+
+    private
+
+    def setup_terminal
+      @program.enter_raw_mode
+      @program.hide_cursor
+      @program.start_input_reader
+
+      if @options[:alt_screen]
+        @program.enter_alt_screen
+        @program.renderer_set_alt_screen(@renderer_id, true) if @renderer_id
+        @in_alt_screen = true
+      end
+
+      @program.enable_mouse_cell_motion if @options[:mouse_cell_motion]
+      @program.enable_mouse_all_motion if @options[:mouse_all_motion]
+      @program.enable_bracketed_paste if @options[:bracketed_paste]
+      @program.enable_report_focus if @options[:report_focus]
+
+      setup_resize_handler
+    end
+
+    def cleanup_terminal
+      restore_resize_handler
+
+      @program.disable_mouse if @options[:mouse_cell_motion] || @options[:mouse_all_motion]
+      @program.disable_bracketed_paste if @options[:bracketed_paste]
+      @program.disable_report_focus if @options[:report_focus]
+
+      if @in_alt_screen
+        @program.exit_alt_screen
+      else
+        print "\r\n"
+      end
+
+      @program.show_cursor
+      @program.stop_input_reader
+      @program.exit_raw_mode
+    end
+
+    def setup_resize_handler
+      @previous_winch_handler = Signal.trap("WINCH") do
+        @resize_pending = true
+        @previous_winch_handler.call if @previous_winch_handler.is_a?(Proc)
+      end
+    rescue ArgumentError
+      # SIGWINCH not supported on this platform
+      @previous_winch_handler = nil
+    end
+
+    def restore_resize_handler
+      if @previous_winch_handler
+        Signal.trap("WINCH", @previous_winch_handler)
+      else
+        Signal.trap("WINCH", "DEFAULT")
+      end
+    rescue ArgumentError
+      # SIGWINCH not supported on this platform
+    end
+
+    def update_terminal_size
+      size = @program.terminal_size
+      return unless size
+
+      @width, @height = size
+      @program.renderer_set_size(@renderer_id, @width, @height) if @renderer_id
+    end
+
+    def run_loop
+      frame_duration = 1.0 / @options[:fps]
+      last_frame = Time.now
+
+      while @running
+        check_resize
+        process_pending_messages
+
+        event = @program.poll_event(@options[:input_timeout])
+
+        if event
+          message = Bubbletea.parse_event(event)
+          handle_message(message) if message
+        end
+
+        process_ticks
+
+        now = Time.now
+
+        if now - last_frame >= frame_duration
+          # r2ui: a model with `frame_due?` (R2UI::App) skips frame slots where nothing changed;
+          # a resize always repaints.
+          render if @repaint || !@model.respond_to?(:frame_due?) || @model.frame_due?
+          @repaint = false
+          last_frame = now
+        end
+      end
+    end
+
+    def check_resize
+      return unless @resize_pending
+
+      @resize_pending = false
+
+      size = @program.terminal_size
+      return unless size
+
+      new_width, new_height = size
+
+      return if new_width == @width && new_height == @height
+
+      @width = new_width
+      @height = new_height
+
+      @program.renderer_set_size(@renderer_id, @width, @height) if @renderer_id
+      @repaint = true
+
+      handle_message(WindowSizeMessage.new(width: @width, height: @height))
+    end
+
+    def process_pending_messages
+      return unless @pending_messages&.any?
+
+      messages = @pending_messages
+      @pending_messages = []
+
+      messages.each { |message| handle_message(message) }
+    end
+
+    def handle_message(message)
+      return unless @running
+
+      new_model, command = @model.update(message)
+      @model = new_model if new_model
+      process_command(command)
+    end
+
+    def process_command(command)
+      return if command.nil?
+
+      case command
+      when QuitCommand
+        @running = false
+
+      when BatchCommand
+        Thread.new do
+          execute_batch_sync(command.commands)
+        end
+
+      when SequenceCommand
+        Thread.new do
+          execute_sequence_sync(command.commands)
+        end
+
+      when TickCommand
+        schedule_tick(command)
+
+      when SendMessage
+        if command.delay.positive?
+          schedule_delayed_message(command)
+        else
+          handle_message(command.message)
+        end
+
+      when EnterAltScreenCommand
+        @program.enter_alt_screen
+        @program.renderer_set_alt_screen(@renderer_id, true) if @renderer_id
+        @in_alt_screen = true
+
+      when ExitAltScreenCommand
+        @program.exit_alt_screen
+        @program.renderer_set_alt_screen(@renderer_id, false) if @renderer_id
+        @in_alt_screen = false
+
+      when SetWindowTitleCommand
+        Bubbletea._set_window_title(command.title)
+
+      when PutsCommand
+        warn "\r#{command.text}\r"
+
+      when SuspendCommand
+        suspend_process
+
+      when ExecCommand
+        exec_process(command)
+
+      when Proc
+        Thread.new do
+          result = command.call
+          next unless result
+
+          if result.is_a?(Message)
+            send(result)
+          else
+            process_command(result)
+          end
+        end
+      end
+    end
+
+    def execute_command_sync(command)
+      return if command.nil?
+
+      case command
+      when QuitCommand
+        @running = false
+
+      when BatchCommand
+        execute_batch_sync(command.commands)
+
+      when SequenceCommand
+        execute_sequence_sync(command.commands)
+
+      when TickCommand
+        schedule_tick(command)
+
+      when SendMessage
+        sleep(command.delay) if command.delay.positive?
+        handle_message(command.message)
+
+      when EnterAltScreenCommand
+        @program.enter_alt_screen
+        @program.renderer_set_alt_screen(@renderer_id, true) if @renderer_id
+        @in_alt_screen = true
+
+      when ExitAltScreenCommand
+        @program.exit_alt_screen
+        @program.renderer_set_alt_screen(@renderer_id, false) if @renderer_id
+        @in_alt_screen = false
+
+      when SetWindowTitleCommand
+        Bubbletea._set_window_title(command.title)
+
+      when PutsCommand
+        warn "\r#{command.text}\r"
+
+      when SuspendCommand
+        suspend_process
+
+      when ExecCommand
+        exec_process(command)
+
+      when Proc
+        result = command.call
+        return unless result
+
+        if result.is_a?(Message)
+          send(result)
+        else
+          execute_command_sync(result)
+        end
+      end
+    end
+
+    def execute_sequence_sync(commands)
+      commands.each do |cmd|
+        break unless @running
+
+        execute_command_sync(cmd)
+      end
+    end
+
+    def execute_batch_sync(commands)
+      threads = commands.map do |cmd|
+        Thread.new { execute_command_sync(cmd) }
+      end
+
+      threads.each(&:join)
+    end
+
+    def schedule_tick(tick_command)
+      tick = { at: Time.now + tick_command.duration, callback: tick_command.callback }
+      @pending_ticks_lock.synchronize { @pending_ticks << tick }
+    end
+
+    def schedule_delayed_message(send_command)
+      tick = { at: Time.now + send_command.delay, message: send_command.message }
+      @pending_ticks_lock.synchronize { @pending_ticks << tick }
+    end
+
+    def process_ticks
+      now = Time.now
+      ready = @pending_ticks_lock.synchronize do
+        ready, @pending_ticks = @pending_ticks.partition { |tick| tick[:at] <= now }
+        ready
+      end
+
+      ready.each do |tick|
+        if tick[:callback]
+          result = tick[:callback].call
+          handle_message(result) if result
+        elsif tick[:message]
+          handle_message(tick[:message])
+        end
+      end
+    end
+
+    def suspend_process
+      @program.disable_mouse if @options[:mouse_cell_motion] || @options[:mouse_all_motion]
+      @program.show_cursor
+      @program.stop_input_reader
+      @program.exit_raw_mode
+
+      Process.kill("TSTP", Process.pid)
+
+      # When we get here, we've been resumed (SIGCONT was received)
+      @program.enter_raw_mode
+      @program.hide_cursor
+      @program.start_input_reader
+      @program.enable_mouse_cell_motion if @options[:mouse_cell_motion]
+      @program.enable_mouse_all_motion if @options[:mouse_all_motion]
+
+      handle_message(ResumeMessage.new)
+    end
+
+    def exec_process(command)
+      @program.disable_mouse if @options[:mouse_cell_motion] || @options[:mouse_all_motion]
+      @program.show_cursor
+      @program.stop_input_reader
+      @program.exit_raw_mode
+
+      command.callable.call
+
+      @program.enter_raw_mode
+      @program.hide_cursor
+      @program.start_input_reader
+      @program.enable_mouse_cell_motion if @options[:mouse_cell_motion]
+      @program.enable_mouse_all_motion if @options[:mouse_all_motion]
+
+      handle_message(command.message) if command.message
+    end
+
+    def render
+      return if @options[:without_renderer]
+      return unless @renderer_id
+
+      view = @model.view
+      @program.render(@renderer_id, view)
+    end
+  end
+
+  def self.run(model, **options)
+    runner = Runner.new(model, **options)
+    runner.run
+  end
+end

data/lib/r2ui/compat/bubbletea/terminal.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+require "io/console"
+
+module R2UI
+  module Compat
+    module Tea
+      # The terminal half of upstream's Go extension (go/terminal.go): raw mode, mode toggles and
+      # size, with the same idempotence flags and the exact bytes charmbracelet/x/ansi v0.8.0 writes.
+      # Upstream ignores write errors; so do we. Every write is flushed.
+      class Terminal
+        SET_ALT_SCREEN = "\e[?1049h"
+        RESET_ALT_SCREEN = "\e[?1049l"
+        ERASE_ENTIRE_SCREEN = "\e[2J"
+        CURSOR_HOME = "\e[H"
+        HIDE_CURSOR = "\e[?25l"
+        SHOW_CURSOR = "\e[?25h"
+        SET_BUTTON_EVENT_MOUSE = "\e[?1002h"
+        RESET_BUTTON_EVENT_MOUSE = "\e[?1002l"
+        SET_ANY_EVENT_MOUSE = "\e[?1003h"
+        RESET_ANY_EVENT_MOUSE = "\e[?1003l"
+        SET_SGR_EXT_MOUSE = "\e[?1006h"
+        RESET_SGR_EXT_MOUSE = "\e[?1006l"
+        SET_BRACKETED_PASTE = "\e[?2004h"
+        RESET_BRACKETED_PASTE = "\e[?2004l"
+        SET_FOCUS_EVENT = "\e[?1004h"
+        RESET_FOCUS_EVENT = "\e[?1004l"
+
+        def self.window_title(title) = "\e]2;#{title}\a"
+
+        def self.write(output, string)
+          output.write(string)
+          output.flush
+          nil
+        rescue IOError, SystemCallError
+          nil
+        end
+
+        # Safety net: terminals left with any mode on are restored at exit, as Go's tea_free_program
+        # restores raw mode. Only dirty terminals are held, so a clean one is never written twice.
+        @dirty = {}.compare_by_identity
+        @lock = Mutex.new
+        @hook_installed = false
+
+        class << self
+          def track(terminal)
+            @lock.synchronize do
+              if terminal.dirty?
+                @dirty[terminal] = true
+                install_hook
+              else
+                @dirty.delete(terminal)
+              end
+            end
+          end
+
+          def restore_all
+            terminals = @lock.synchronize { @dirty.keys }
+            terminals.each(&:restore)
+          end
+
+          private
+
+          # Installed lazily (on the first dirty terminal) so it runs after any at_exit hook that was
+          # running the program, such as a test runner's.
+          def install_hook
+            return if @hook_installed
+
+            @hook_installed = true
+            at_exit { Terminal.restore_all }
+          end
+        end
+
+        attr_reader :input, :output
+
+        def initialize(input, output)
+          @input = input
+          @output = output
+          @raw_mode = false
+          @previous_mode = nil
+          @alt_screen = false
+          @cursor_hidden = false
+          @mouse_enabled = false
+          @bracketed_paste = false
+          @report_focus = false
+        end
+
+        def dirty?
+          @raw_mode || @alt_screen || @cursor_hidden || @mouse_enabled || @bracketed_paste || @report_focus
+        end
+
+        # Like x/term MakeRaw on the input: true on success or when already raw, false when the input
+        # is not a terminal.
+        def enter_raw_mode
+          return true if @raw_mode
+
+          mode = @input.console_mode
+          @input.raw!
+          @previous_mode = mode
+          @raw_mode = true
+          Terminal.track(self)
+          true
+        rescue StandardError
+          false
+        end
+
+        def exit_raw_mode
+          return true unless @raw_mode
+
+          @input.console_mode = @previous_mode if @previous_mode
+          @raw_mode = false
+          Terminal.track(self)
+          true
+        rescue StandardError
+          false
+        end
+
+        def enter_alt_screen
+          return if @alt_screen
+
+          write(SET_ALT_SCREEN + ERASE_ENTIRE_SCREEN + CURSOR_HOME)
+          @alt_screen = true
+          Terminal.track(self)
+          nil
+        end
+
+        def exit_alt_screen
+          return unless @alt_screen
+
+          write(RESET_ALT_SCREEN)
+          @alt_screen = false
+          Terminal.track(self)
+          nil
+        end
+
+        def hide_cursor
+          return if @cursor_hidden
+
+          write(HIDE_CURSOR)
+          @cursor_hidden = true
+          Terminal.track(self)
+          nil
+        end
+
+        def show_cursor
+          return unless @cursor_hidden
+
+          write(SHOW_CURSOR)
+          @cursor_hidden = false
+          Terminal.track(self)
+          nil
+        end
+
+        def enable_mouse_cell_motion
+          write(SET_BUTTON_EVENT_MOUSE + SET_SGR_EXT_MOUSE)
+          @mouse_enabled = true
+          Terminal.track(self)
+          nil
+        end
+
+        def enable_mouse_all_motion
+          write(SET_ANY_EVENT_MOUSE + SET_SGR_EXT_MOUSE)
+          @mouse_enabled = true
+          Terminal.track(self)
+          nil
+        end
+
+        def disable_mouse
+          return unless @mouse_enabled
+
+          write(RESET_BUTTON_EVENT_MOUSE + RESET_ANY_EVENT_MOUSE + RESET_SGR_EXT_MOUSE)
+          @mouse_enabled = false
+          Terminal.track(self)
+          nil
+        end
+
+        # Upstream writes paste and focus toggles unconditionally; the flags only feed the exit restore.
+        def enable_bracketed_paste
+          write(SET_BRACKETED_PASTE)
+          @bracketed_paste = true
+          Terminal.track(self)
+          nil
+        end
+
+        def disable_bracketed_paste
+          write(RESET_BRACKETED_PASTE)
+          @bracketed_paste = false
+          Terminal.track(self)
+          nil
+        end
+
+        def enable_report_focus
+          write(SET_FOCUS_EVENT)
+          @report_focus = true
+          Terminal.track(self)
+          nil
+        end
+
+        def disable_report_focus
+          write(RESET_FOCUS_EVENT)
+          @report_focus = false
+          Terminal.track(self)
+          nil
+        end
+
+        # [width, height] of the output (Go asks stdout), or nil when it is not a terminal.
+        def size
+          rows, cols = @output.winsize
+          [cols, rows]
+        rescue StandardError
+          nil
+        end
+
+        # Undo whatever is still on, in the runner's cleanup order. Each step is guarded by its flag.
+        def restore
+          disable_mouse
+          disable_bracketed_paste if @bracketed_paste
+          disable_report_focus if @report_focus
+          exit_alt_screen
+          show_cursor
+          exit_raw_mode
+        end
+
+        private
+
+        def write(string) = Terminal.write(@output, string)
+      end
+    end
+  end
+end

data/lib/r2ui/compat/bubbletea/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Copied unchanged from bubbletea 0.1.4 (https://github.com/marcoroth/bubbletea-ruby).
+# Copyright (c) 2025 Marco Roth. MIT License; see LICENSE-bubbletea.txt in this directory.
+
+module Bubbletea
+  VERSION = "0.1.4"
+end