thaum 0.1.0 → 0.2.0

data/lib/thaum/sigils/status_bar.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Thaum
+  # Horizontal bar of labeled segments separated by a configurable
+  # delimiter. Segments are either plain Strings (decorative) or Hashes
+  # `{ label:, on_click: }` whose click handler fires when the user
+  # left-presses inside the segment's column range. Non-focusable —
+  # status bars sit at the bottom of the focus order. Mouse events the
+  # bar does not act on are eaten (not propagated) so the bar acts as
+  # the floor of the click target.
+  class StatusBar
+    include Sigil
+
+    DEFAULT_SEPARATOR = " │ "
+
+    attr_reader :separator, :segments
+
+    def initialize(segments:, separator: DEFAULT_SEPARATOR)
+      @segments  = segments
+      @separator = separator
+      @ranges    = [] # parallel array: [start_col, end_col_exclusive] per segment
+    end
+
+    def focusable? = false
+
+    def segments=(value)
+      @segments = value
+      request_render
+    end
+
+    def on_mouse(event)
+      return unless event.action == :press && event.button == :left
+
+      seg = segment_at(event.x) or return
+      handler = on_click(seg) or return
+      if handler.arity.zero?
+        handler.call
+      else
+        handler.call(event)
+      end
+    end
+
+    def render(canvas:, theme:)
+      canvas.fill(bg: theme.bar_bg)
+      @ranges = []
+      x = 0
+      width = canvas.width
+      @segments.each_with_index do |seg, idx|
+        x += draw_separator(canvas: canvas, theme: theme, x: x, width: width) if idx.positive?
+        break if x >= width
+
+        label = label(seg)
+        label_w = label.display_width
+        start = x
+        canvas.text(content: label, x: x, fg: theme.fg, bg: theme.bar_bg)
+        x += label_w
+        finish = [x, width].min
+        @ranges << [start, finish]
+      end
+    end
+
+    private
+
+    def draw_separator(canvas:, theme:, x:, width:)
+      return 0 if x >= width
+
+      canvas.text(content: @separator, x: x, fg: theme.dim, bg: theme.bar_bg)
+      @separator.display_width
+    end
+
+    def label(seg)
+      seg.is_a?(Hash) ? seg.fetch(:label).to_s : seg.to_s
+    end
+
+    def on_click(seg)
+      return nil unless seg.is_a?(Hash)
+
+      seg[:on_click]
+    end
+
+    def segment_at(col)
+      @segments.each_with_index do |seg, idx|
+        range = @ranges[idx] or next
+        return seg if col >= range[0] && col < range[1]
+      end
+      nil
+    end
+  end
+end

data/lib/thaum/sigils/table.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module Thaum
+  class Table
+    include Sigil
+
+    SelectedEvent = Thaum::Event.define(:index, :row)
+
+    PAGE_STEP = 10
+
+    attr_reader :headers, :rows, :widths, :cursor, :offset
+
+    def initialize(headers:, rows:, widths: nil)
+      @headers = headers
+      @rows    = rows
+      @widths  = widths
+      @cursor  = 0
+      @offset  = 0
+    end
+
+    def on_key(event)
+      case event.key
+      when :up        then @cursor = [@cursor - 1, 0].max
+      when :down      then @cursor = [@cursor + 1, rows.length - 1].min if rows.any?
+      when :home      then @cursor = 0
+      when :end       then @cursor = rows.length - 1 if rows.any?
+      when :page_up   then @cursor = [@cursor - PAGE_STEP, 0].max
+      when :page_down then @cursor = [@cursor + PAGE_STEP, rows.length - 1].min if rows.any?
+      when :enter     then emit_selected
+      else                 emit event
+      end
+    end
+
+    def render(canvas:, theme:)
+      canvas.fill(bg: theme.bg)
+      widths = effective_widths(canvas.width)
+      visible_offset(canvas)
+
+      render_header(canvas: canvas, theme: theme, widths: widths)
+      render_separator(canvas: canvas, theme: theme)
+      render_data_rows(canvas: canvas, theme: theme, widths: widths)
+    end
+
+    private
+
+    def emit_selected
+      return if rows.empty?
+
+      emit SelectedEvent.new(index: @cursor, row: rows[@cursor])
+    end
+
+    def render_header(canvas:, theme:, widths:)
+      row = canvas.row(0) or return
+
+      row.fill(bg: theme.bar_bg)
+      row.text(content: format_cells(cells: @headers, widths: widths), fg: theme.accent, bg: theme.bar_bg)
+    end
+
+    def render_separator(canvas:, theme:)
+      row = canvas.row(1) or return
+
+      row.fill(bg: theme.bg)
+      row.text(content: "─" * canvas.width, fg: theme.border, bg: theme.bg)
+    end
+
+    def render_data_rows(canvas:, theme:, widths:)
+      visible_rows = canvas.height - 2
+      return if visible_rows <= 0
+
+      visible_rows.times do |i|
+        file_idx = @offset + i
+        row_data = rows[file_idx] or break
+        row      = canvas.row(i + 2) or break
+
+        selected = file_idx == @cursor
+        bg = selected ? theme.selection : theme.bg
+        fg = selected ? theme.selection_fg : theme.fg
+        row.fill(bg: bg)
+        row.text(content: format_cells(cells: row_data, widths: widths), fg: fg, bg: bg)
+      end
+    end
+
+    def format_cells(cells:, widths:)
+      cells.each_with_index.map { |cell, idx| fit(str: cell.to_s, width: widths[idx] || 0) }.join(" ")
+    end
+
+    # Pad with spaces or truncate to fit exactly `width` display columns.
+    def fit(str:, width:)
+      return "" if width <= 0
+
+      w = str.display_width
+      return str + (" " * (width - w)) if w <= width
+
+      truncate_to_width(str: str, width: width)
+    end
+
+    def truncate_to_width(str:, width:)
+      out  = +""
+      cols = 0
+      str.each_char do |c|
+        cw = c.display_width
+        break if cols + cw > width
+
+        out << c
+        cols += cw
+      end
+      out << (" " * (width - cols)) if cols < width
+      out
+    end
+
+    def visible_offset(canvas)
+      visible_rows = canvas.height - 2
+      return @offset = 0 if visible_rows <= 0
+
+      if @cursor < @offset
+        @offset = @cursor
+      elsif @cursor >= @offset + visible_rows
+        @offset = @cursor - visible_rows + 1
+      end
+
+      max_offset = [rows.length - visible_rows, 0].max
+      @offset = @offset.clamp(0, max_offset)
+    end
+
+    def effective_widths(canvas_width)
+      return widths if widths
+
+      col_count = headers.length
+      return [] if col_count.zero?
+
+      max_widths = column_max_widths(col_count)
+      separators = col_count - 1
+      total_max  = max_widths.sum
+      budget     = canvas_width - separators
+
+      return max_widths if total_max <= budget || budget <= 0
+
+      scale_widths(max_widths: max_widths, total_max: total_max, budget: budget)
+    end
+
+    def column_max_widths(col_count)
+      Array.new(col_count) do |idx|
+        header_w = (headers[idx] || "").to_s.display_width
+        row_w    = rows.map { |r| (r[idx] || "").to_s.display_width }.max || 0
+        [header_w, row_w].max
+      end
+    end
+
+    def scale_widths(max_widths:, total_max:, budget:)
+      scaled = max_widths.map { |w| (budget * w / total_max).floor }
+      leftover = budget - scaled.sum
+      scaled[-1] += leftover if scaled.any?
+      scaled
+    end
+  end
+end

data/lib/thaum/sigils/tabs.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Thaum
+  # Horizontal tab strip. ←/→ cycle the active tab (with wrap). Emits
+  # Tabs::ActivatedEvent when the active index changes. The content under each
+  # tab is the App's concern — Tabs only owns the strip.
+  class Tabs
+    include Sigil
+
+    ActivatedEvent = Thaum::Event.define(:index, :label)
+
+    attr_reader :labels, :active
+
+    def initialize(labels:, active: 0)
+      raise ArgumentError, "Tabs needs at least one label" if labels.empty?
+
+      @labels = labels
+      @active = active.clamp(0, labels.length - 1)
+    end
+
+    def current = @labels[@active]
+
+    def on_key(event)
+      case event.key
+      when :left  then move(-1)
+      when :right then move(1)
+      else             emit event
+      end
+    end
+
+    def render(canvas:, theme:)
+      canvas.fill(bg: theme.bar_bg)
+      x = 0
+      @labels.each_with_index do |label, idx|
+        x += draw_tab(canvas: canvas, label: label, idx: idx, x: x, theme: theme)
+      end
+    end
+
+    private
+
+    def move(delta)
+      new_idx = (@active + delta) % @labels.length
+      return if new_idx == @active
+
+      @active = new_idx
+      emit ActivatedEvent.new(index: @active, label: current)
+    end
+
+    def draw_tab(canvas:, label:, idx:, x:, theme:)
+      cell  = " #{label} "
+      width = cell.display_width
+      bg    = idx == @active ? theme.selection : theme.bar_bg
+      fg    = idx == @active ? theme.selection_fg : theme.fg
+      canvas.fill(bg: bg, x: x, width: width)
+      canvas.text(content: cell, x: x, fg: fg, bg: bg)
+      width
+    end
+  end
+end

data/lib/thaum/sigils/text.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Thaum
+  class Text
+    include Sigil
+
+    attr_accessor :content
+
+    def initialize(content:, align: :left, wrap: :none)
+      @content = content
+      @align   = align
+      @wrap    = wrap
+    end
+
+    def focusable? = false
+
+    def render(canvas:, theme:)
+      resolved = content.respond_to?(:call) ? content.call : content
+      canvas.text(content: resolved.to_s, fg: theme.fg, align: @align, wrap: @wrap)
+    end
+  end
+end

data/lib/thaum/sigils/text_input.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Thaum
+  class TextInput
+    include Sigil
+
+    SubmittedEvent = Thaum::Event.define(:value)
+
+    attr_reader :value, :cursor
+
+    def initialize(value: "")
+      @value  = value.dup
+      @cursor = @value.length
+    end
+
+    def clear
+      @value  = +""
+      @cursor = 0
+    end
+
+    def on_key(event)
+      key = event.key
+      case key
+      when String        then insert(key) unless event.ctrl? || event.alt?
+      when :backspace    then backspace
+      when :delete       then delete_forward
+      when :left         then @cursor = [@cursor - 1, 0].max
+      when :right        then @cursor = [@cursor + 1, @value.length].min
+      when :home         then @cursor = 0
+      when :end          then @cursor = @value.length
+      when :enter        then emit SubmittedEvent.new(value: @value)
+      else                    emit event
+      end
+    end
+
+    def render(canvas:, theme:)
+      offset    = scroll_offset(canvas.width)
+      visible   = @value[offset..] || ""
+      cursor_x  = display_width(@value[offset...@cursor])
+      canvas.fill(bg: theme.input_bg)
+      canvas.text(content: visible, fg: theme.fg, bg: theme.input_bg)
+      canvas.cursor(x: cursor_x, y: 0) if focused?
+    end
+
+    private
+
+    def insert(char)
+      @value = @value[0...@cursor] + char + @value[@cursor..]
+      @cursor += char.length
+    end
+
+    def backspace
+      return if @cursor.zero?
+
+      @value = @value[0...(@cursor - 1)] + @value[@cursor..]
+      @cursor -= 1
+    end
+
+    def delete_forward
+      return if @cursor >= @value.length
+
+      @value = @value[0...@cursor] + @value[(@cursor + 1)..]
+    end
+
+    # Keep the cursor inside the visible window, measured in display columns
+    # (not character indices) so wide chars (CJK, emoji) scroll correctly.
+    # When the prefix fits, no scroll. Otherwise drop leading chars until the
+    # cursor sits at column width-1.
+    def scroll_offset(width)
+      prefix_cols = display_width(@value[0...@cursor])
+      return 0 if prefix_cols < width
+
+      target = width - 1
+      chars  = @value.chars
+      offset = 0
+      cols   = prefix_cols
+      while cols > target && offset < @cursor
+        cols -= chars[offset].display_width
+        offset += 1
+      end
+      offset
+    end
+
+    def display_width(str) = (str || "").display_width
+  end
+end

data/lib/thaum/terminal.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "io/console"
+
+module Thaum
+  # Manages terminal setup and teardown: alternate screen, cursor, mouse, and bracketed paste.
+  class Terminal
+    def initialize(input: $stdin, output: $stdout)
+      @input = input
+      @output = output
+    end
+
+    def setup
+      @original_stty = stty_save
+      @input.raw!
+      write Seq::ALT_SCREEN_ON
+      write Seq::CURSOR_HIDE
+      write Seq::BRACKETED_PASTE_ON
+      write Seq::SGR_MOUSE_ON
+      write Seq::CELL_MOTION_ON
+    end
+
+    def teardown
+      write Seq::CELL_MOTION_OFF
+      write Seq::SGR_MOUSE_OFF
+      write Seq::BRACKETED_PASTE_OFF
+      write Seq::CURSOR_SHOW
+      write Seq::ALT_SCREEN_OFF
+      stty_restore(@original_stty)
+    end
+
+    def size
+      rows, cols = @input.winsize
+      [cols, rows]
+    end
+
+    private
+
+    def write(str) = @output.write(str)
+    def stty_save = @input.respond_to?(:tty?) && @input.tty? ? `stty -g 2>/dev/null`.chomp : ""
+
+    def stty_restore(state)
+      system("stty", state) if state && !state.empty?
+    end
+  end
+end