r2ui 0.1.0 → 0.2.0

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

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+module R2UI
+  module Compat
+    module Tea
+      # Pure-Ruby port of bubbletea 0.1.4's Go input parser (go/keys.go:
+      # ParseInput, parseMouseSGR, parseInts, keyNames, tea_get_key_name).
+      # Each event is the Hash that JSON.parse returns for Go's json.Marshal
+      # of the event struct, so Bubbletea.parse_event consumes it unchanged.
+      module Input
+        KEY_RUNES = -1
+        KEY_ESC = 27
+        KEY_SPACE = -25
+
+        KEY_NAMES = {
+          0 => "ctrl+@", 1 => "ctrl+a", 2 => "ctrl+b", 3 => "ctrl+c", 4 => "ctrl+d",
+          5 => "ctrl+e", 6 => "ctrl+f", 7 => "ctrl+g", 8 => "ctrl+h", 9 => "tab",
+          10 => "ctrl+j", 11 => "ctrl+k", 12 => "ctrl+l", 13 => "enter", 14 => "ctrl+n",
+          15 => "ctrl+o", 16 => "ctrl+p", 17 => "ctrl+q", 18 => "ctrl+r", 19 => "ctrl+s",
+          20 => "ctrl+t", 21 => "ctrl+u", 22 => "ctrl+v", 23 => "ctrl+w", 24 => "ctrl+x",
+          25 => "ctrl+y", 26 => "ctrl+z", 27 => "esc", 127 => "backspace",
+          -1 => "runes", -2 => "up", -3 => "down", -4 => "right", -5 => "left",
+          -6 => "home", -7 => "end", -8 => "pgup", -9 => "pgdown", -10 => "delete",
+          -11 => "insert", -12 => "f1", -13 => "f2", -14 => "f3", -15 => "f4",
+          -16 => "f5", -17 => "f6", -18 => "f7", -19 => "f8", -20 => "f9",
+          -21 => "f10", -22 => "f11", -23 => "f12", -24 => "shift+tab", -25 => "space"
+        }.freeze
+
+        # No sequence is a prefix of another, so Go's random map iteration
+        # order never changes the result.
+        ESCAPE_SEQUENCES = {
+          "\e[A" => -2, "\e[B" => -3, "\e[C" => -4, "\e[D" => -5,
+          "\e[H" => -6, "\e[F" => -7, "\e[1~" => -6, "\e[4~" => -7,
+          "\e[5~" => -8, "\e[6~" => -9, "\e[2~" => -11, "\e[3~" => -10,
+          "\eOP" => -12, "\eOQ" => -13, "\eOR" => -14, "\eOS" => -15,
+          "\e[15~" => -16, "\e[17~" => -17, "\e[18~" => -18, "\e[19~" => -19,
+          "\e[20~" => -20, "\e[21~" => -21, "\e[23~" => -22, "\e[24~" => -23,
+          "\e[Z" => -24,
+          # Upstream placeholders for shift/ctrl arrows; they have no name.
+          "\e[1;2A" => -100, "\e[1;2B" => -101, "\e[1;2C" => -102, "\e[1;2D" => -103,
+          "\e[1;5A" => -104, "\e[1;5B" => -105, "\e[1;5C" => -106, "\e[1;5D" => -107
+        }.each_with_object({}) { |(k, v), h| h[k.b.freeze] = v }.freeze
+
+        PASTE_START = "\e[200~".b.freeze
+        PASTE_END = "\e[201~".b.freeze
+
+        module_function
+
+        # Go tea_get_key_name: "" for unknown types.
+        def key_name(key_type)
+          KEY_NAMES.fetch(key_type, "")
+        end
+
+        # Go ParseInput: returns [consumed, event_hash_or_nil].
+        def parse(bytes)
+          data = bytes.b
+          return [0, nil] if data.empty?
+
+          b0 = data.getbyte(0)
+          b1 = data.getbyte(1)
+
+          if data.bytesize >= 3 && b0 == 0x1b && b1 == 0x5b
+            b2 = data.getbyte(2)
+            return [3, { "type" => "focus", "focus" => true }] if b2 == 0x49 # I
+            return [3, { "type" => "blur", "focus" => false }] if b2 == 0x4f # O
+          end
+
+          if data.bytesize >= 6 && b0 == 0x1b && b1 == 0x5b && data.getbyte(2) == 0x3c
+            consumed, mouse = parse_mouse_sgr(data)
+            return [consumed, mouse] if consumed.positive?
+          end
+
+          if b0 == 0x1b && data.bytesize > 1
+            ESCAPE_SEQUENCES.each do |seq, key_type|
+              next unless data.start_with?(seq)
+
+              name = KEY_NAMES.fetch(key_type, "")
+              name = "unknown" if name.empty?
+              return [seq.bytesize, key_event(key_type, nil, false, name)]
+            end
+
+            if b1 >= 32 && b1 < 127
+              char = b1.chr
+              return [2, key_event(KEY_RUNES, [b1], true, "alt+#{char}")]
+            end
+
+            return [1, key_event(KEY_ESC, nil, false, "esc")]
+          end
+
+          if b0 < 32 || b0 == 127
+            name = KEY_NAMES.fetch(b0, "")
+            name = "ctrl+?" if name.empty?
+            return [1, key_event(b0, nil, false, name)]
+          end
+
+          return [1, key_event(KEY_SPACE, [32], false, "space")] if b0 == 0x20
+
+          size = utf8_size(data)
+          return [1, nil] unless size
+
+          char = data.byteslice(0, size).force_encoding(Encoding::UTF_8)
+          [size, key_event(KEY_RUNES, [char.ord], false, char)]
+        end
+
+        # Decodes every event in one complete input, in order, plus bracketed
+        # paste. A paste with no end marker takes the rest of the input.
+        def parse_all(bytes)
+          decoder = Decoder.new
+          decoder.feed(bytes) + decoder.flush
+        end
+
+        # Decodes a stream of read chunks. An open bracketed paste, or a
+        # paste start marker cut off at the end of a chunk, is held until the
+        # following chunks complete it, so a paste of any length arrives as
+        # one paste event.
+        class Decoder
+          # Shortest chunk tail held as a possible split start marker. A lone
+          # "\e" or "\e[" is a real key press (esc, alt+[) and is never held.
+          MIN_HELD_PREFIX = 3
+
+          def initialize
+            @pending = "".b
+          end
+
+          # Events completed by this chunk; held bytes wait for the next one.
+          def feed(bytes)
+            data = @pending + bytes.b
+            @pending = "".b
+            events = []
+            pos = 0
+            while pos < data.bytesize
+              rest = data.byteslice(pos, data.bytesize - pos)
+              if rest.start_with?(PASTE_START)
+                body = pos + PASTE_START.bytesize
+                stop = data.index(PASTE_END, body)
+                unless stop
+                  @pending = rest
+                  break
+                end
+
+                events << Input.paste_event(data.byteslice(body, stop - body))
+                pos = stop + PASTE_END.bytesize
+                next
+              end
+
+              if rest.bytesize >= MIN_HELD_PREFIX && rest.bytesize < PASTE_START.bytesize &&
+                 PASTE_START.start_with?(rest)
+                @pending = rest
+                break
+              end
+
+              consumed, event = Input.parse(rest)
+              break if consumed <= 0
+
+              events << event if event
+              pos += consumed
+            end
+            events
+          end
+
+          # Events for whatever is held, as if the input ended here: an open
+          # paste becomes a paste of what arrived, a partial marker plain keys.
+          def flush
+            data = @pending
+            @pending = "".b
+            return [] if data.empty?
+            return [Input.paste_event(data.byteslice(PASTE_START.bytesize, data.bytesize))] if data.start_with?(PASTE_START)
+
+            events = []
+            pos = 0
+            while pos < data.bytesize
+              consumed, event = Input.parse(data.byteslice(pos, data.bytesize - pos))
+              events << event if event
+              pos += consumed
+            end
+            events
+          end
+        end
+
+        def key_event(key_type, runes, alt, name)
+          { "type" => "key", "key_type" => key_type, "runes" => runes, "alt" => alt, "name" => name }
+        end
+
+        def paste_event(bytes)
+          text = bytes.dup.force_encoding(Encoding::UTF_8).scrub
+          { "type" => "key", "key_type" => KEY_RUNES, "runes" => text.codepoints,
+            "alt" => false, "name" => "[#{text}]", "paste" => true }
+        end
+
+        # Go parseMouseSGR: ESC [ < Cb ; Cx ; Cy (M|m). Returns [0, nil] on failure.
+        def parse_mouse_sgr(data)
+          end_index = nil
+          i = 3
+          while i < data.bytesize && i < 32
+            byte = data.getbyte(i)
+            if byte == 0x4d || byte == 0x6d # M / m
+              end_index = i
+              break
+            end
+            i += 1
+          end
+          return [0, nil] unless end_index
+
+          count, (button, x, y) = parse_ints(data.byteslice(3, end_index - 3), 3)
+          return [0, nil] unless count == 3
+
+          button_num = button & 3
+          action = if data.getbyte(end_index) == 0x6d then 1
+                   elsif button.anybits?(32) then 2
+                   else 0
+                   end
+          if button.anybits?(64)
+            if button_num.zero? then button_num = 4
+            elsif button_num == 1 then button_num = 5
+            end
+          end
+
+          [end_index + 1, {
+            "type" => "mouse", "x" => x - 1, "y" => y - 1, "button" => button_num, "action" => action,
+            "shift" => button.anybits?(4), "alt" => button.anybits?(8), "ctrl" => button.anybits?(16)
+          }]
+        end
+
+        # Go parseInts: empty fields are skipped (slot left 0, not counted);
+        # a non-digit stops parsing and returns the count so far.
+        def parse_ints(str, slots)
+          vals = Array.new(slots, 0)
+          count = 0
+          start = 0
+          index = 0
+          i = 0
+          while i <= str.bytesize && index < slots
+            if i == str.bytesize || str.getbyte(i) == 0x3b
+              if i > start
+                num = 0
+                (start...i).each do |j|
+                  d = str.getbyte(j)
+                  return [count, vals] if d < 0x30 || d > 0x39
+
+                  num = (num * 10) + (d - 0x30)
+                end
+                vals[index] = num
+                count += 1
+              end
+              index += 1
+              start = i + 1
+            end
+            i += 1
+          end
+          [count, vals]
+        end
+
+        # Byte length of the valid UTF-8 rune at the start of data, or nil
+        # where Go's utf8.DecodeRune returns (RuneError, 1).
+        def utf8_size(data)
+          b0 = data.getbyte(0)
+          len = if b0 < 0x80 then 1
+                elsif b0 >= 0xc2 && b0 <= 0xdf then 2
+                elsif b0 >= 0xe0 && b0 <= 0xef then 3
+                elsif b0 >= 0xf0 && b0 <= 0xf4 then 4
+                end
+          return nil unless len && data.bytesize >= len
+
+          data.byteslice(0, len).force_encoding(Encoding::UTF_8).valid_encoding? ? len : nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module R2UI
+  module Compat
+    module Tea
+      # Upstream's InputReader (go/input.go): a background reader that pushes raw chunks of up to 256
+      # bytes onto a queue. Go reads through cancelreader so that a stopped reader no longer consumes
+      # stdin; here the thread waits with IO.select on a short timeout and checks a stop flag, and
+      # only reads once the input is readable. EOF or a read error ends the thread.
+      class InputReader
+        CHUNK = 256
+        WAIT = 0.02
+
+        attr_reader :queue
+
+        def initialize(io)
+          @io = io
+          @queue = Thread::Queue.new
+          @stop = false
+          @thread = nil
+        end
+
+        def start
+          @thread ||= Thread.new do
+            Thread.current.report_on_exception = false
+            Thread.current.name = "bubbletea input reader"
+            read_loop
+          end
+          self
+        end
+
+        def running? = !@thread.nil? && !@stop
+
+        # Stop consuming input. With wait, joins the thread (it notices the flag within WAIT seconds);
+        # a thread stuck in a read after all is killed rather than left to steal a child's input.
+        def stop(wait: true)
+          @stop = true
+          thread = @thread
+          return unless thread && wait && thread != Thread.current
+
+          thread.kill unless thread.join(WAIT * 10)
+          nil
+        end
+
+        # One chunk, or nil when none arrives within timeout_ms.
+        def pop(timeout_ms)
+          timeout = timeout_ms.to_i <= 0 ? 0 : timeout_ms / 1000.0
+          @queue.pop(timeout: timeout)
+        end
+
+        private
+
+        def read_loop
+          until @stop
+            ready = IO.select([@io], nil, nil, WAIT)
+            next unless ready && !@stop
+
+            @queue << @io.readpartial(CHUNK)
+          end
+        rescue EOFError, IOError, SystemCallError
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,251 @@
+# 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
+  class Message
+  end
+
+  class KeyMessage < Message
+    KEY_NULL      = 0
+    KEY_CTRL_A    = 1
+    KEY_CTRL_B    = 2
+    KEY_CTRL_C    = 3
+    KEY_CTRL_D    = 4
+    KEY_CTRL_E    = 5
+    KEY_CTRL_F    = 6
+    KEY_CTRL_G    = 7
+    KEY_CTRL_H    = 8
+    KEY_TAB       = 9
+    KEY_CTRL_J    = 10
+    KEY_CTRL_K    = 11
+    KEY_CTRL_L    = 12
+    KEY_ENTER     = 13
+    KEY_CTRL_N    = 14
+    KEY_CTRL_O    = 15
+    KEY_CTRL_P    = 16
+    KEY_CTRL_Q    = 17
+    KEY_CTRL_R    = 18
+    KEY_CTRL_S    = 19
+    KEY_CTRL_T    = 20
+    KEY_CTRL_U    = 21
+    KEY_CTRL_V    = 22
+    KEY_CTRL_W    = 23
+    KEY_CTRL_X    = 24
+    KEY_CTRL_Y    = 25
+    KEY_CTRL_Z    = 26
+    KEY_ESC       = 27
+    KEY_BACKSPACE = 127
+
+    KEY_RUNES     = -1
+    KEY_UP        = -2
+    KEY_DOWN      = -3
+    KEY_RIGHT     = -4
+    KEY_LEFT      = -5
+    KEY_HOME      = -6
+    KEY_END       = -7
+    KEY_PGUP      = -8
+    KEY_PGDOWN    = -9
+    KEY_DELETE    = -10
+    KEY_INSERT    = -11
+    KEY_F1        = -12
+    KEY_F2        = -13
+    KEY_F3        = -14
+    KEY_F4        = -15
+    KEY_F5        = -16
+    KEY_F6        = -17
+    KEY_F7        = -18
+    KEY_F8        = -19
+    KEY_F9        = -20
+    KEY_F10       = -21
+    KEY_F11       = -22
+    KEY_F12       = -23
+    KEY_SHIFT_TAB = -24
+    KEY_SPACE     = -25
+
+    attr_reader :key_type, :runes, :alt, :name
+
+    def initialize(key_type:, runes: [], alt: false, name: nil)
+      super()
+
+      @key_type = key_type
+      @runes = runes.is_a?(Array) ? runes : []
+      @alt = alt
+      @name = name || lookup_key_name
+    end
+
+    private
+
+    def lookup_key_name
+      base_name = if @key_type == KEY_RUNES && char
+                    char
+                  else
+                    go_name = Bubbletea.get_key_name(@key_type)
+                    go_name.empty? ? "unknown" : go_name
+                  end
+
+      @alt ? "alt+#{base_name}" : base_name
+    end
+
+    public
+
+    def to_s
+      @name
+    end
+
+    def char
+      @runes.pack("U*") if @runes.any?
+    end
+
+    def ctrl?
+      @key_type.between?(0, 31)
+    end
+
+    def runes?
+      @key_type == KEY_RUNES
+    end
+
+    def space?
+      @key_type == KEY_SPACE
+    end
+
+    def enter?
+      @key_type == KEY_ENTER
+    end
+
+    def backspace?
+      @key_type == KEY_BACKSPACE
+    end
+
+    def tab?
+      @key_type == KEY_TAB
+    end
+
+    def esc?
+      @key_type == KEY_ESC
+    end
+
+    def up?
+      @key_type == KEY_UP
+    end
+
+    def down?
+      @key_type == KEY_DOWN
+    end
+
+    def left?
+      @key_type == KEY_LEFT
+    end
+
+    def right?
+      @key_type == KEY_RIGHT
+    end
+  end
+
+  class MouseMessage < Message
+    BUTTON_NONE       = 0
+    BUTTON_LEFT       = 1
+    BUTTON_MIDDLE     = 2
+    BUTTON_RIGHT      = 3
+    BUTTON_WHEEL_UP   = 4
+    BUTTON_WHEEL_DOWN = 5
+
+    ACTION_PRESS   = 0
+    ACTION_RELEASE = 1
+    ACTION_MOTION  = 2
+
+    attr_reader :x, :y, :button, :action, :shift, :alt, :ctrl
+
+    def initialize(x:, y:, button:, action:, shift: false, alt: false, ctrl: false)
+      super()
+
+      @x = x
+      @y = y
+      @button = button
+      @action = action
+      @shift = shift
+      @alt = alt
+      @ctrl = ctrl
+    end
+
+    def press?
+      @action == ACTION_PRESS
+    end
+
+    def release?
+      @action == ACTION_RELEASE
+    end
+
+    def motion?
+      @action == ACTION_MOTION
+    end
+
+    def wheel?
+      @button >= BUTTON_WHEEL_UP
+    end
+
+    def left?
+      @button == BUTTON_LEFT
+    end
+
+    def right?
+      @button == BUTTON_RIGHT
+    end
+
+    def middle?
+      @button == BUTTON_MIDDLE
+    end
+  end
+
+  class WindowSizeMessage < Message
+    attr_reader :width, :height
+
+    def initialize(width:, height:)
+      super()
+
+      @width = width
+      @height = height
+    end
+  end
+
+  class FocusMessage < Message
+  end
+
+  class BlurMessage < Message
+  end
+
+  class QuitMessage < Message
+  end
+
+  class ResumeMessage < Message
+  end
+
+  def self.parse_event(hash)
+    return nil if hash.nil?
+
+    case hash["type"]
+    when "key"
+      KeyMessage.new(
+        key_type: hash["key_type"],
+        runes: hash["runes"] || [],
+        alt: hash["alt"] || false,
+        name: hash["name"]
+      )
+    when "mouse"
+      MouseMessage.new(
+        x: hash["x"],
+        y: hash["y"],
+        button: hash["button"],
+        action: hash["action"],
+        shift: hash["shift"] || false,
+        alt: hash["alt"] || false,
+        ctrl: hash["ctrl"] || false
+      )
+    when "focus"
+      FocusMessage.new
+    when "blur"
+      BlurMessage.new
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# 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
+  # Model module that provides the Elm Architecture interface.
+  # Include this module in your model class and implement:
+  #   - init: Returns [model, command] - initial state and optional command
+  #   - update(message): Returns [model, command] - new state and optional command
+  #   - view: Returns String - the current view to render
+  #
+  # Example:
+  #   class Counter
+  #     include Bubbletea::Model
+  #
+  #     attr_reader :count
+  #
+  #     def initialize
+  #       @count = 0
+  #     end
+  #
+  #     def init
+  #       [self, nil]
+  #     end
+  #
+  #     def update(message)
+  #       case message
+  #       when Bubbletea::KeyMessage
+  #         case message.to_s
+  #         when "q", "ctrl+c"
+  #           [self, Bubbletea.quit]
+  #         when "up", "k"
+  #           @count += 1
+  #           [self, nil]
+  #         when "down", "j"
+  #           @count -= 1
+  #           [self, nil]
+  #         else
+  #           [self, nil]
+  #         end
+  #       else
+  #         [self, nil]
+  #       end
+  #     end
+  #
+  #     def view
+  #       "Count: #{@count}\n\nPress up/down to change, q to quit"
+  #     end
+  #   end
+  #
+  module Model
+    def init
+      [self, nil]
+    end
+
+    def update(_message)
+      [self, nil]
+    end
+
+    def view
+      ""
+    end
+  end
+end