tui_tui 0.2.0 → 0.4.0

data/lib/tui_tui/box_chrome.rb

@@ -41,14 +41,5 @@ module TuiTui
       total_width == PROBE_GLYPHS.length
     end
 
-    # Full resolution given a live console. Honors TUITUI_BOX, else probes; falls
-    # back to ASCII when forced off, the terminal is too narrow, or the probe fails.
-    def self.resolve(input:, output:, term_cols:, env: ENV, prober: BoxProber.new)
-      forced = from(env["TUITUI_BOX"].to_s)
-      return forced unless forced == :auto
-      return ASCII if term_cols < MIN_PROBE_COLS
-
-      supported?(prober.measure_all(input: input, output: output)) ? UNICODE : ASCII
-    end
   end
 end

data/lib/tui_tui/box_chrome_resolver.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "box_chrome"
+require_relative "box_prober"
+
+module TuiTui
+  # Resolves the box-drawing glyph set for a live terminal.
+  class BoxChromeResolver
+    def initialize(prober: BoxProber.new)
+      @prober = prober
+    end
+
+    def resolve(input:, output:, term_cols:, env: ENV)
+      forced = BoxChrome.from(env["TUITUI_BOX"])
+      return forced unless forced == :auto
+      return BoxChrome::ASCII if term_cols < BoxChrome::MIN_PROBE_COLS
+
+      BoxChrome.supported?(@prober.measure_all(input: input, output: output)) ? BoxChrome::UNICODE : BoxChrome::ASCII
+    end
+  end
+end

data/lib/tui_tui/box_prober.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "box_chrome"
+require_relative "clock"
 
 module TuiTui
   # Measures how many columns a string of box-drawing glyphs actually occupies on
@@ -35,10 +36,10 @@ module TuiTui
     end
 
     def read_column(input)
-      deadline = monotonic + @timeout
+      deadline = Clock.monotonic + @timeout
       buf = +""
       loop do
-        remaining = deadline - monotonic
+        remaining = deadline - Clock.monotonic
         break if remaining <= 0
         break unless @wait.call(input, remaining)
 
@@ -55,7 +56,5 @@ module TuiTui
     end
 
     def wait_readable(io, timeout) = io.wait_readable(timeout)
-
-    def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
   end
 end

data/lib/tui_tui/canvas.rb

@@ -108,59 +108,15 @@ module TuiTui
       self
     end
 
-    def same_row?(other, r)
-      grid_row(r) == other.grid_row(r)
-    end
-
-    def same_size?(other)
-      @rows == other.rows && @cols == other.cols
-    end
-
-    # The changed column span of row `r` versus `other`, as [from, to] (1-origin,
-    # inclusive), or nil if the row is identical. The start is backed up off any
-    # wide-char continuation cell so a partial repaint never begins mid-glyph.
-    # Used by the compositor to repaint only the part of a row that moved.
-    def changed_span(other, r)
-      mine = grid_row(r)
-      theirs = other.grid_row(r)
-      first = last = nil
-      mine.each_index do |i|
-        next if mine[i] == theirs[i]
-
-        first ||= i
-        last = i
-      end
-
-      return nil if first.nil?
-
-      first -= 1 while first.positive? && mine[first].continuation?
-      [first + 1, last + 1]
-    end
-
-    # Render row `r`, or just the column span [from, to], coalescing same-styled
-    # runs and skipping wide-char continuation cells.
-    def render_row(r, from: 1, to: @cols, depth: :ansi256, enabled: true)
-      out = +""
-      run = +""
-      run_style = :none
-      grid_row(r)[(from - 1)..(to - 1)].each do |c|
-        next if c.continuation?
-
-        if run_style != :none && run_style != c.style
-          out << paint(run, run_style, depth, enabled)
-          run = +""
-        end
-
-        run_style = c.style
-        run << c.char
-      end
+    def grid_row(r) = @grid[r - 1]
 
-      out << paint(run, run_style, depth, enabled) unless run.empty?
-      out
+    # Style-free projection of the grid for snapshot tests: continuation cells
+    # of wide glyphs contribute nothing, each row loses its trailing blanks,
+    # and rows join with "\n" (no trailing newline). Never contains ANSI.
+    def to_text
+      @grid.map { |row| row.filter_map(&:char).join.rstrip }.join("\n")
     end
 
-    def grid_row(r) = @grid[r - 1]
-
     private
 
     # A fill glyph with any control bytes replaced by CONTROL_GLYPH, so `fill`
@@ -181,10 +137,5 @@ module TuiTui
       grid_row[col - 1] = cell
     end
 
-    def paint(text, style, depth, enabled)
-      return text if style.nil? || style == :none
-
-      style.paint(text, depth: depth, enabled: enabled)
-    end
   end
 end

data/lib/tui_tui/canvas_compositor.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "ansi"
+require_relative "canvas_renderer"
 
 module TuiTui
   # Builds the terminal update string.
@@ -12,11 +13,12 @@ module TuiTui
 
     def render(previous, canvas)
       out = +""
-      if full_repaint?(previous, canvas)
+      renderer = CanvasRenderer.new(canvas)
+      if full_repaint?(previous, renderer)
         out << Ansi::CLEAR
-        (1..canvas.rows).each { |row| out << row_paint(canvas, row) }
+        (1..canvas.rows).each { |row| out << row_paint(renderer, row) }
       else
-        (1..canvas.rows).each { |row| out << row_diff(canvas, previous, row) }
+        (1..canvas.rows).each { |row| out << row_diff(renderer, previous, row) }
       end
 
       out
@@ -24,22 +26,22 @@ module TuiTui
 
     private
 
-    def full_repaint?(previous, canvas)
-      previous.nil? || !previous.same_size?(canvas)
+    def full_repaint?(previous, renderer)
+      previous.nil? || !renderer.same_size?(previous)
     end
 
     # The whole row, positioned at column 1 (used for a full repaint).
-    def row_paint(canvas, row)
-      Ansi.move(row, 1) + canvas.render_row(row, depth: @depth, enabled: true)
+    def row_paint(renderer, row)
+      Ansi.move(row, 1) + renderer.render_row(row, depth: @depth, enabled: true)
     end
 
     # Only the changed span of `row`, positioned at its first changed column; ""
     # when the row is unchanged.
-    def row_diff(canvas, previous, row)
-      span = canvas.changed_span(previous, row)
+    def row_diff(renderer, previous, row)
+      span = renderer.changed_span(previous, row)
       return "" unless span
 
-      Ansi.move(row, span.first) + canvas.render_row(row, from: span.first, to: span.last, depth: @depth, enabled: true)
+      Ansi.move(row, span.first) + renderer.render_row(row, from: span.first, to: span.last, depth: @depth, enabled: true)
     end
   end
 end

data/lib/tui_tui/canvas_renderer.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module TuiTui
+  # Terminal-facing row rendering and diff helpers for Canvas.
+  class CanvasRenderer
+    def initialize(canvas)
+      @canvas = canvas
+    end
+
+    def same_size?(other_canvas)
+      other_canvas.rows == @canvas.rows && other_canvas.cols == @canvas.cols
+    end
+
+    def changed_span(previous, row)
+      mine = @canvas.grid_row(row)
+      theirs = previous.grid_row(row)
+      first = last = nil
+      mine.each_index do |i|
+        next if mine[i] == theirs[i]
+
+        first ||= i
+        last = i
+      end
+
+      return nil if first.nil?
+
+      first -= 1 while first.positive? && mine[first].continuation?
+      [first + 1, last + 1]
+    end
+
+    def render_row(row, from: 1, to: @canvas.cols, depth: :ansi256, enabled: true)
+      out = +""
+      run = +""
+      run_style = :none
+      @canvas.grid_row(row)[(from - 1)..(to - 1)].each do |cell|
+        next if cell.continuation?
+
+        if run_style != :none && run_style != cell.style
+          out << paint(run, run_style, depth, enabled)
+          run = +""
+        end
+
+        run_style = cell.style
+        run << cell.char
+      end
+
+      out << paint(run, run_style, depth, enabled) unless run.empty?
+      out
+    end
+
+    private
+
+    def paint(text, style, depth, enabled)
+      return text if style.nil? || style == :none
+
+      style.paint(text, depth: depth, enabled: enabled)
+    end
+  end
+end

data/lib/tui_tui/cell.rb

@@ -2,10 +2,11 @@
 
 module TuiTui
   # One terminal cell; a nil char marks the continuation cell of a wide glyph.
-  Cell = Data.define(:char, :style) do
+  Cell = Data.define(:char, :style)
+
+  class Cell
+    BLANK = Cell.new(char: " ", style: nil)
     def self.blank = BLANK
     def continuation? = char.nil?
   end
-
-  Cell::BLANK = Cell.new(char: " ", style: nil)
 end

data/lib/tui_tui/clock.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module TuiTui
+  # The single source of monotonic time, so timers and timeouts never depend on
+  # wall-clock adjustments. Injected as a callable where tests need to control it.
+  module Clock
+    module_function
+
+    def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+end

data/lib/tui_tui/command.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module TuiTui
+  # One-shot instructions an app returns from `update` alongside its next
+  # state: `[app, *commands]`. The Runtime performs them before rendering.
+  module Command
+    # Write text to the system clipboard (OSC 52).
+    Copy = Data.define(:text)
+    # Force a full repaint on the next render (e.g. after Ctrl-L).
+    Invalidate = Data.define
+
+    # The canonical list of known commands; add new command types here.
+    ALL = [Copy, Invalidate].freeze
+
+    def self.validate!(command)
+      return if ALL.any? { |type| command.is_a?(type) }
+
+      raise ArgumentError, "tui_tui: unknown command #{command.inspect}"
+    end
+  end
+end

data/lib/tui_tui/event_stream.rb

@@ -1,23 +1,32 @@
 # frozen_string_literal: true
 
-require_relative "event"
+require_relative "clock"
+require_relative "events"
 require_relative "key_reader"
 
 module TuiTui
-  # Converts terminal input readiness and resize notifications into runtime events.
+  # Converts terminal input readiness and resize notifications into runtime
+  # events. Ticks are scheduled against a monotonic deadline, so TickEvent
+  # arrives at a fixed cadence even while input keeps flowing (key repeat
+  # cannot starve animations or timers).
   class EventStream
-    def initialize(input:, size:)
+    def initialize(input:, size:, clock: Clock)
       @input = input
       @size = size
+      @clock = clock
       @key_reader = KeyReader.new
       @resized = false
       @queue = []
+      @deadline = nil
     end
 
     def resized!
       @resized = true
     end
 
+    # Returns the next event: queued input first, then resize, then whichever
+    # of "tick deadline reached" or "input ready" happens first. `tick` is the
+    # TickEvent period — ticks land between input events, not after idle gaps.
     def next_event(tick: 0.1)
       return @queue.shift unless @queue.empty?
 
@@ -26,14 +35,40 @@ module TuiTui
         return ResizeEvent.new(size: @size.size)
       end
 
-      ready = IO.select([@input], nil, nil, tick)
-      return TickEvent.new unless ready
+      now = @clock.monotonic
+      @deadline ||= now + tick
+      if now >= @deadline
+        # Drain pending input into the queue before returning the tick, so a
+        # zero (or tiny) period cannot starve keys: the tick goes out now, the
+        # input on the very next calls.
+        return EofEvent.new if IO.select([@input], nil, nil, 0) && read_input == :eof
 
+        return advance_deadline(now, tick)
+      end
+
+      ready = IO.select([@input], nil, nil, @deadline - now)
+      return advance_deadline(@clock.monotonic, tick) unless ready
+      return EofEvent.new if read_input == :eof
+
+      @queue.shift
+    end
+
+    private
+
+    # Read whatever is ready into the queue; :eof when the input is closed.
+    def read_input
       raw = @key_reader.read_all(@input)
-      return EofEvent.new if raw.nil?
+      return :eof if raw.nil?
 
       @queue.concat(raw.map { |event| event.is_a?(MouseEvent) ? event : KeyEvent.new(key: event) })
-      @queue.shift
+    end
+
+    # Emit one tick and schedule the next. When we have fallen a whole period
+    # behind, resync from now instead of bursting a backlog of stale ticks.
+    def advance_deadline(now, tick)
+      @deadline += tick
+      @deadline = now + tick if @deadline <= now
+      TickEvent.new
     end
   end
 end

data/lib/tui_tui/key_code.rb

@@ -4,6 +4,9 @@ module TuiTui
   module KeyCode
     ESCAPE = "\e"
     CTRL_C = "\u0003"
+    CTRL_L = "\u000C"
+    CTRL_N = "\u000E"
+    CTRL_P = "\u0010"
     BACKSPACE = "\u007F"
   end
 end

data/lib/tui_tui/key_reader.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "event"
+require_relative "events"
 require_relative "key_code"
 
 module TuiTui

data/lib/tui_tui/line.rb

@@ -10,6 +10,17 @@ module TuiTui
     # Convenience constructor: Line[Span["a", s1], Span["b", s2]].
     def self.[](*spans) = new(spans)
 
+    # Coerce loose content into a Line: a Line passes through, a Span or an Array
+    # of Spans is wrapped, and anything else is one Span (in `style`, when given).
+    def self.coerce(content, style = nil)
+      case content
+      when Line then content
+      when Span then new([content])
+      when Array then new(content)
+      else Line[Span[content.to_s, style]]
+      end
+    end
+
     def initialize(spans = [])
       @spans = spans
     end

data/lib/tui_tui/modal/command_palette.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require_relative "../text_input"
+require_relative "../widget/scroll_list"
+require_relative "../widget/list"
+require_relative "../line"
+require_relative "../span"
+require_relative "../rect"
+require_relative "../modal"
+require_relative "../fuzzy"
+require_relative "../key_code"
+
+module TuiTui
+  class Modal
+    # Fuzzy-filtered command palette modal (think Ctrl-P): type to narrow a list of
+    # commands, arrows or Ctrl-N/Ctrl-P to move, Enter to pick, Esc to cancel.
+    #
+    # Items are arbitrary objects; pass a block to derive each one's display label
+    # (defaults to #to_s). Resolves to the chosen item on Enter and :cancel on
+    # escape; stays open (nil) while the query has no matches.
+    #
+    #   host.open(CommandPalette.new(commands) { |c| c.title }) { |cmd| cmd.run; self }
+    class CommandPalette < Modal
+      MAX_ROWS = 10
+      MIN_INNER = 28
+      WHEEL = 3
+
+      def initialize(items, prompt: "> ", placeholder: "Type to search…", theme: Theme::DEFAULT, &label)
+        @items = items.to_a
+        @label = label || :to_s.to_proc
+        @prompt = DisplayText.new(prompt)
+        @placeholder = DisplayText.new(placeholder)
+        @theme = theme
+        # The query buffer. Editing keys stay append-only here: the cursor is
+        # pinned at the end (we never feed it left/right/Home/End), because those
+        # keys drive the list below, not the query.
+        @query = TextInput.new
+        @list = Widget::ScrollList.new(0)
+        refilter
+      end
+
+      def query = @query.value
+
+      # The original item under the cursor, or nil when nothing matches.
+      def selection = @filtered[@list.cursor]&.first
+
+      def handle(key)
+        case key
+        when "\r"
+          selection
+        when :escape, KeyCode::CTRL_C
+          :cancel
+        when :up, KeyCode::CTRL_P
+          move(-1)
+        when :down, KeyCode::CTRL_N
+          move(1)
+        when :home
+          move_to(0)
+        when :end
+          move_to(@list.last)
+        when KeyCode::BACKSPACE, :backspace
+          edit { @query.delete_back }
+        when String
+          edit { @query.type(key) }
+        end
+      end
+
+      # Wheel scrolls the highlight; a click on a row picks it (returns the item),
+      # otherwise nil to stay open.
+      def handle_mouse(event)
+        case event.action
+        when :wheel
+          move(event.button == :wheel_up ? -WHEEL : WHEEL)
+        when :press
+          click(event)
+        end
+      end
+
+      def draw(canvas, size)
+        rows = visible_rows(size)
+        inner = [MIN_INNER, *@filtered.map { |_item, label, _pos| label.width }].max
+        rect, col = panel(canvas, inner: inner, body_rows: rows + 2)
+
+        draw_query(canvas, rect.row + 1, col, inner)
+        draw_items(canvas, rect.row + 3, col, inner, rows)
+        canvas
+      end
+
+      private
+
+      def move(delta)
+        @list.move(delta)
+        nil
+      end
+
+      def move_to(index)
+        @list.go_to(index)
+        nil
+      end
+
+      # Apply a query edit, then refilter. Returns nil so the modal stays open.
+      def edit
+        yield
+        refilter
+        nil
+      end
+
+      # Recompute the visible list: fuzzy-ranked (best first, with matched positions
+      # for highlighting) while querying, otherwise the items in their given order.
+      # Each entry is [item, DisplayText(label), positions]; the cursor resets so a
+      # narrowed query always lands on the top match.
+      def refilter
+        @filtered =
+          if @query.empty?
+            @items.map { |item| [item, label_text(item), []] }
+          else
+            Fuzzy.new(query).rank(@items) { |item| @label.call(item).to_s }
+                .map { |item, found| [item, label_text(item), found.positions] }
+          end
+        @list.count = @filtered.size
+        @list.go_to(0)
+      end
+
+      def label_text(item) = DisplayText.new(@label.call(item).to_s)
+
+      def visible_rows(size)
+        room = [size.rows - 4, 1].max
+        [[@filtered.size, 1].max, MAX_ROWS, room].min
+      end
+
+      def draw_query(canvas, row, col, inner)
+        canvas.text(row, col, @prompt, theme.accent)
+        text_col = col + @prompt.width
+        budget = inner - @prompt.width
+        if @query.empty?
+          canvas.text(row, text_col, @placeholder.truncate(budget), theme.muted)
+        else
+          canvas.text(row, text_col, DisplayText.new(query).truncate(budget), theme.text)
+        end
+      end
+
+      def draw_items(canvas, row, col, inner, rows)
+        @items_rect = Rect.new(row: row, col: col, rows: rows, cols: inner)
+        if @filtered.empty?
+          canvas.text(row, col, DisplayText.new("No matches").truncate(inner), theme.muted)
+          return
+        end
+
+        Widget::List.new(@list).draw(canvas, @items_rect, highlight: theme.selection) do |index, focused|
+          _item, label, positions = @filtered[index]
+          base = focused ? theme.selection : theme.text
+          # Keep the focused row a single style; highlight matches with accent only
+          # on unfocused rows so the selection bar stays legible.
+          match = focused ? base : theme.accent
+          styled_line(label.to_s, positions, base, match)
+        end
+      end
+
+      # The label as a Line with matched graphemes in `match` and the rest in `base`;
+      # runs of the same style coalesce into one Span (grapheme indices line up with
+      # Fuzzy#positions).
+      def styled_line(label, positions, base, match)
+        return Line[Span[label, base]] if positions.empty?
+
+        spans = []
+        run = +""
+        run_style = nil
+        label.grapheme_clusters.each_with_index do |grapheme, i|
+          style = positions.include?(i) ? match : base
+          if style != run_style && !run.empty?
+            spans << Span[run, run_style]
+            run = +""
+          end
+          run_style = style
+          run << grapheme
+        end
+        spans << Span[run, run_style] unless run.empty?
+        Line.new(spans)
+      end
+
+      # The item under a click, picked, or nil if the click missed the list.
+      def click(event)
+        return nil unless @items_rect
+
+        index = Widget::List.new(@list).index_at(@items_rect, event)
+        return nil if index.nil?
+
+        @list.go_to(index)
+        selection
+      end
+    end
+  end
+end

data/lib/tui_tui/modal/confirm.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "../modal"
+require_relative "../key_code"
+
+module TuiTui
+  class Modal
+    # OK / Cancel confirmation modal.
+    class Confirm < Modal
+      GAP = 2
+
+      attr_reader :focus
+
+      def initialize(message, ok: "OK", cancel: "Cancel", default: :cancel, theme: Theme::DEFAULT)
+        @message = DisplayText.new(message)
+        @ok = button_text(ok)
+        @cancel = button_text(cancel)
+        @focus = default
+        @theme = theme
+      end
+
+      def handle(key)
+        case key
+        when :left, :right, "\t", "h", "l"
+          toggle
+        when "\r", " "
+          @focus
+        when "y", "Y"
+          :ok
+        when "n", "N", :escape, KeyCode::CTRL_C
+          :cancel
+        end
+      end
+
+      def handle_mouse(event)
+        return nil unless event.action == :press && @buttons_row == event.row
+
+        return :ok if hit?(event.col, @ok_at, @ok.width)
+        return :cancel if hit?(event.col, @cancel_at, @cancel.width)
+
+        nil
+      end
+
+      def draw(canvas, size)
+        inner = [@message.width, buttons_width].max
+        rect, col = panel(canvas, inner: inner, body_rows: 3)
+        canvas.text(rect.row + 1, col, @message.center(inner), theme.text)
+        draw_buttons(canvas, rect.row + 3, col, inner)
+        canvas
+      end
+
+      private
+
+      def hit?(col, start, width) = col.between?(start, start + width - 1)
+
+      def toggle
+        @focus = @focus == :ok ? :cancel : :ok
+        nil
+      end
+
+      def draw_buttons(canvas, row, col, inner)
+        start = col + [(inner - buttons_width) / 2, 0].max
+        @buttons_row = row
+        @ok_at = start
+        @cancel_at = start + @ok.width + GAP
+        canvas.text(row, @ok_at, @ok, @focus == :ok ? theme.selection : theme.text)
+        canvas.text(row, @cancel_at, @cancel, @focus == :cancel ? theme.selection : theme.text)
+      end
+
+      def buttons_width = @ok.width + GAP + @cancel.width
+      def button_text(label) = DisplayText.new("[ #{label} ]")
+    end
+  end
+end