tui_tui 0.3.0 → 0.4.0

data/lib/tui_tui/pager.rb

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "display_text"
-require_relative "style"
-require_relative "span"
-require_relative "line"
-require_relative "rect"
-require_relative "modal"
-require_relative "key_intent"
-
-module TuiTui
-  # Scrollable read-only text modal.
-  class Pager < Modal
-    MARGIN = 2
-    WHEEL = 3
-
-    # Each line may be a plain String, a `Line`, or an array of `Span`s, so a
-    # log/diff/error view can color whole lines or runs within them. Spans
-    # without a style fall back to theme.muted.
-    def initialize(title, lines, start: 0, close_keys: [], theme: Theme::DEFAULT)
-      @title = title
-      @theme = theme
-      @lines = lines.map { |line| normalize_line(line) }
-      @top = start
-      @page = 1
-      @close_keys = close_keys
-    end
-
-    def handle(key)
-      return :close if @close_keys.include?(key)
-
-      case KeyIntent.for(key)
-      when :up
-        scroll(-1)
-      when :down
-        scroll(1)
-      when :top
-        scroll(-@lines.size)
-      when :bottom
-        scroll(@lines.size)
-      when :cancel
-        :close
-      else
-        paginate(key)
-      end
-    end
-
-    def handle_mouse(event)
-      scroll(event.button == :wheel_up ? -WHEEL : WHEEL) if event.action == :wheel
-    end
-
-    def draw(canvas, size)
-      width = [size.cols - (MARGIN * 2), 20].max
-      height = [size.rows - (MARGIN * 2), 5].max
-      rect = Rect.centered(size, cols: width, rows: height)
-      canvas.frame(rect, style: theme.frame)
-
-      inner = width - 4
-      body = [height - 4, 1].max
-      @page = body
-      clamp(body)
-
-      canvas.text(rect.row + 1, rect.col + 2, DisplayText.new(title_line(body)).truncate(inner), theme.title)
-      body.times do |offset|
-        line = @lines[@top + offset]
-        next if line.nil?
-
-        canvas.line(rect.row + 3 + offset, rect.col + 2, line.truncate(inner))
-      end
-
-      canvas
-    end
-
-    private
-
-    # -> Line. Accepts a String, a Line, or a Span array; spans left unstyled
-    # default to theme.muted so a bare line still reads as muted body text.
-    def normalize_line(line)
-      spans = Line.coerce(line).spans.map { |span| Span[span.text, span.style || theme.muted] }
-      Line.new(spans)
-    end
-
-    def paginate(key)
-      case key
-      when " ", :pgdn
-        scroll(@page)
-      when "b", :pgup
-        scroll(-@page)
-      end
-    end
-
-    def scroll(delta)
-      @top += delta
-      nil
-    end
-
-    def clamp(body)
-      @top = @top.clamp(0, [@lines.size - body, 0].max)
-    end
-
-    def title_line(body)
-      last = [@top + body, @lines.size].min
-      "#{@title}  (#{@top + 1}-#{last}/#{@lines.size})"
-    end
-  end
-end

data/lib/tui_tui/prompt.rb

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "display_text"
-require_relative "text_sanitizer"
-require_relative "style"
-require_relative "modal"
-require_relative "key_code"
-
-module TuiTui
-  # Single-line text input modal with terminal-column-aware cursor placement.
-  class Prompt < Modal
-    MIN_INNER = 24
-
-    def initialize(label, value: "", theme: Theme::DEFAULT)
-      @label = DisplayText.new(label)
-      @graphemes = value.grapheme_clusters
-      @pos = @graphemes.length
-      @theme = theme
-    end
-
-    def value = @graphemes.join
-
-    def handle(key)
-      case key
-      when "\r"
-        [:ok, value]
-      when :escape, KeyCode::CTRL_C
-        :cancel
-      when KeyCode::BACKSPACE, :backspace
-        edit { delete_back }
-      when :delete
-        edit { delete_forward }
-      when :left
-        edit { @pos = [@pos - 1, 0].max }
-      when :right
-        edit { @pos = [@pos + 1, @graphemes.length].min }
-      when :home
-        edit { @pos = 0 }
-      when :end
-        edit { @pos = @graphemes.length }
-      when String
-        edit { insert(key) if TextSanitizer.printable?(key) }
-      end
-    end
-
-    def handle_mouse(event)
-      return nil unless event.action == :press && @text_row == event.row
-
-      edit { @pos = index_at(event.col - @text_col) }
-    end
-
-    def draw(canvas, size)
-      inner = [MIN_INNER, @label.width + 1 + DisplayText.new(value).width].max
-      rect, col = panel(canvas, inner: inner, body_rows: 1)
-
-      canvas.text(rect.row + 1, col, @label, theme.title)
-      @text_row = rect.row + 1
-      @text_col = col + @label.width + 1
-      canvas.text(@text_row, @text_col, value, theme.text)
-      draw_cursor(canvas, @text_row, @text_col)
-      canvas
-    end
-
-    private
-
-    def edit
-      yield
-      nil
-    end
-
-    # Grapheme index whose left edge is closest to `rel` columns into the value.
-    def index_at(rel)
-      return 0 if rel <= 0
-
-      width = 0
-      @graphemes.each_with_index do |grapheme, i|
-        w = DisplayText.new(grapheme).width
-        return i if rel < width + ((w + 1) / 2)
-
-        width += w
-      end
-
-      @graphemes.length
-    end
-
-    def draw_cursor(canvas, row, text_col)
-      cursor_col = text_col + DisplayText.new(@graphemes[0...@pos].join).width
-      canvas.text(row, cursor_col, @graphemes[@pos] || " ", theme.cursor)
-    end
-
-    def insert(string)
-      head = @graphemes[0...@pos].join
-      @graphemes = (head + string + @graphemes[@pos..].join).grapheme_clusters
-      @pos = (head + string).grapheme_clusters.length
-    end
-
-    def delete_back
-      return if @pos.zero?
-
-      @graphemes.delete_at(@pos - 1)
-      @pos -= 1
-    end
-
-    def delete_forward
-      @graphemes.delete_at(@pos) if @pos < @graphemes.length
-    end
-  end
-end

data/lib/tui_tui/scroll_list.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module TuiTui
-  # Cursor and viewport arithmetic shared by list-like widgets.
-  class ScrollList
-    attr_reader :cursor, :top
-
-    def initialize(count = 0)
-      @count = count
-      @cursor = 0
-      @top = 0
-    end
-
-    def count=(value)
-      @count = [value, 0].max
-      @cursor = @cursor.clamp(0, last)
-    end
-
-    attr_reader :count
-
-    def empty? = @count.zero?
-    def last = [@count - 1, 0].max
-    def at_end? = @cursor == last
-
-    def move(delta) = go_to(@cursor + delta)
-    def page(height) = move(height)
-    def to_top = go_to(0)
-    def to_end = go_to(last)
-
-    def go_to(index)
-      @cursor = index.clamp(0, last)
-      self
-    end
-
-    def ensure_visible(height)
-      return self if height <= 0
-
-      @top = @cursor if @cursor < @top
-      @top = @cursor - height + 1 if @cursor >= @top + height
-      @top = 0 if @top.negative?
-      self
-    end
-
-    def each_visible(height)
-      return enum_for(:each_visible, height) unless block_given?
-
-      height.times do |offset|
-        index = @top + offset
-        break if index >= @count
-
-        yield index, offset
-      end
-
-      self
-    end
-  end
-end

data/lib/tui_tui/scrollbar.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "rect"
-require_relative "style"
-require_relative "theme"
-
-module TuiTui
-  # A vertical scroll indicator for a 1-column gutter.
-  # It sizes a thumb from top/visible/total and draws ASCII-only chrome.
-  module Scrollbar
-    module_function
-
-    TRACK = Theme::DEFAULT.scroll_track
-    THUMB = Theme::DEFAULT.scroll_thumb
-
-    def draw(canvas, rect, top:, visible:, total:, track: nil, thumb: " ", track_style: TRACK, thumb_style: THUMB)
-      return canvas if rect.rows <= 0
-
-      track ||= canvas.chrome.track
-      length, offset = geometry(rect.rows, top, visible, total)
-      rect.rows.times do |i|
-        in_thumb = i >= offset && i < offset + length
-        canvas.text(rect.row + i, rect.col, in_thumb ? thumb : track, in_thumb ? thumb_style : track_style)
-      end
-
-      canvas
-    end
-
-    # The thumb's [length, offset] in rows for a `height`-row track. Returns
-    # [0, 0] (no thumb, track only) when everything fits — nothing to scroll.
-    def geometry(height, top, visible, total)
-      visible = [visible, 1].max
-      total = [total, visible].max
-      return [0, 0] if total <= visible
-
-      length = [(height * visible / total.to_f).round, 1].max.clamp(1, height)
-      offset = ((height - length) * top.to_f / (total - visible)).round
-      [length, offset.clamp(0, height - length)]
-    end
-  end
-end

data/lib/tui_tui/select.rb

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "display_text"
-require_relative "style"
-require_relative "scroll_list"
-require_relative "list"
-require_relative "line"
-require_relative "span"
-require_relative "rect"
-require_relative "modal"
-require_relative "key_intent"
-
-module TuiTui
-  # Scrollable list picker modal.
-  class Select < Modal
-    MAX_ROWS = 12
-    MIN_INNER = 16
-    WHEEL = 3
-
-    def initialize(title, items, default: 0, theme: Theme::DEFAULT)
-      @title = DisplayText.new(title)
-      @items = items.map { |item| DisplayText.new(item) }
-      @list = ScrollList.new(@items.size)
-      @list.go_to(default)
-      @theme = theme
-    end
-
-    def cursor = @list.cursor
-
-    def handle(key)
-      case KeyIntent.for(key)
-      when :up
-        nudge(-1)
-      when :down
-        nudge(1)
-      when :top
-        nudge_to(0)
-      when :bottom
-        nudge_to(@list.last)
-      when :cancel
-        :cancel
-      else
-        @list.cursor if ["\r", " "].include?(key)
-      end
-    end
-
-    # Wheel moves the highlighted item; a click on an item picks it. Returns the
-    # chosen index on a click, otherwise nil (stay open).
-    def handle_mouse(event)
-      case event.action
-      when :wheel
-        nudge(event.button == :wheel_up ? -WHEEL : WHEEL)
-      when :press
-        click(event)
-      end
-    end
-
-    def draw(canvas, size)
-      rows = visible_rows(size)
-      inner = [MIN_INNER, @title.width, *@items.map(&:width)].max
-      rect, text_col = panel(canvas, inner: inner, body_rows: rows + 2)
-
-      canvas.text(rect.row + 1, text_col, @title.truncate(inner), theme.title)
-      draw_items(canvas, rect.row + 3, text_col, inner, rows)
-      canvas
-    end
-
-    private
-
-    def nudge(delta)
-      @list.move(delta)
-      nil
-    end
-
-    def nudge_to(index)
-      @list.go_to(index)
-      nil
-    end
-
-    def visible_rows(size)
-      room = [size.rows - 4, 1].max
-      [@items.size, MAX_ROWS, room].min
-    end
-
-    def draw_items(canvas, row, col, inner, rows)
-      @items_rect = Rect.new(row: row, col: col, rows: rows, cols: inner)
-      List.new(@list).draw(canvas, @items_rect) do |index, focused|
-        Line[Span[@items[index].to_s, focused ? theme.selection : theme.text]]
-      end
-    end
-
-    # The item under a click, picked, or nil if the click missed the list.
-    def click(event)
-      return nil unless @items_rect
-
-      index = List.new(@list).index_at(@items_rect, event)
-      return nil if index.nil?
-
-      @list.go_to(index)
-      @list.cursor
-    end
-  end
-end

data/lib/tui_tui/status_bar.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "display_text"
-
-module TuiTui
-  # A one-row status/footer bar.
-  # It draws left text from the start and optional right text flush right.
-  module StatusBar
-    module_function
-
-    def draw(canvas, rect, left: "", right: nil, style: nil)
-      canvas.fill(rect, style)
-
-      right_width = right ? DisplayText.new(right).width : 0
-      fits_right = right && right_width < rect.cols
-      left_max = fits_right ? rect.cols - right_width : rect.cols
-
-      canvas.text(rect.row, rect.col, DisplayText.new(left).truncate(left_max), style)
-      canvas.text(rect.row, rect.col + rect.cols - right_width, right, style) if fits_right
-      canvas
-    end
-  end
-end

data/lib/tui_tui/text_view.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "line"
-require_relative "span"
-require_relative "scrollbar"
-
-module TuiTui
-  # A scrolled read-only text window.
-  # Lines may be Strings, Lines, or Span arrays, supplied eagerly or lazily.
-  module TextView
-    module_function
-
-    def draw(canvas, rect, lines = nil, top: 0, style: nil, scrollbar: nil, total: nil, auto: false)
-      # With auto:, reserve the gutter only when the content overflows the rect.
-      # When the total is unknown (lazy block, no total:), the bar is kept.
-      count = total || lines&.length
-      show_bar = scrollbar && !(auto && count && count <= rect.rows)
-      body, gutter = show_bar ? rect.split_gutter : [rect, nil]
-      body.rows.times do |offset|
-        index = top + offset
-        content = lines ? lines[index] : yield(index)
-        next if content.nil?
-
-        canvas.line(body.row + offset, body.col, Line.coerce(content, style).truncate(body.cols))
-      end
-
-      draw_scrollbar(canvas, gutter, top, total || lines&.length, body.rows, scrollbar) if gutter
-      canvas
-    end
-
-    def draw_scrollbar(canvas, gutter, top, total, visible, theme)
-      return unless total
-
-      Scrollbar.draw(
-        canvas,
-        gutter,
-        top: top,
-        visible: visible,
-        total: total,
-        track_style: theme.scroll_track,
-        thumb_style: theme.scroll_thumb
-      )
-    end
-  end
-end

data/lib/tui_tui/toast.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "display_text"
-require_relative "style"
-require_relative "clock"
-
-module TuiTui
-  # A transient notification overlay.
-  # The clock is injectable so expiry is testable without sleeping.
-  class Toast
-    DEFAULT_SECONDS = 2.0
-    DEFAULT_STYLE = Style.new(attrs: [:reverse])
-    DEFAULT_POSITION = :bottom_center
-    POSITIONS = {
-      top_left: [:top, :left],
-      top_center: [:top, :center],
-      top_right: [:top, :right],
-      middle_left: [:middle, :left],
-      middle_center: [:middle, :center],
-      middle_right: [:middle, :right],
-      bottom_left: [:bottom, :left],
-      bottom_center: [:bottom, :center],
-      bottom_right: [:bottom, :right],
-      center: [:middle, :center]
-    }.freeze
-    MONOTONIC = -> { Clock.monotonic }
-
-    def initialize(message, seconds: DEFAULT_SECONDS, position: DEFAULT_POSITION, clock: MONOTONIC)
-      @message = DisplayText.new(message)
-      @position = position
-      @clock = clock
-      @expires_at = clock.call + seconds
-      validate_position!
-    end
-
-    def expired? = @clock.call >= @expires_at
-
-    def draw(canvas, size, style: DEFAULT_STYLE, position: @position)
-      return canvas if expired?
-
-      label = DisplayText.new(" #{@message} ").truncate(size.cols)
-      vertical, horizontal = position_parts(position)
-      row = row_for(size, vertical)
-      col = col_for(size, label.width, horizontal)
-      canvas.text(row, col, label, style)
-      canvas
-    end
-
-    private
-
-    def validate_position!
-      position_parts(@position)
-    end
-
-    def position_parts(position)
-      POSITIONS.fetch(position) do
-        raise ArgumentError, "unknown toast position: #{position.inspect}"
-      end
-    end
-
-    def row_for(size, vertical)
-      case vertical
-      when :top
-        1
-      when :middle
-        ((size.rows + 1) / 2).clamp(1, size.rows)
-      when :bottom
-        [size.rows - 2, 1].max
-      end
-    end
-
-    def col_for(size, width, horizontal)
-      case horizontal
-      when :left
-        1
-      when :center
-        [((size.cols - width) / 2) + 1, 1].max
-      when :right
-        [size.cols - width + 1, 1].max
-      end
-    end
-  end
-end