tui_tui 0.1.0 → 0.3.0

data/lib/tui_tui/list.rb

@@ -12,20 +12,34 @@ module TuiTui
       @scroll = scroll
     end
 
-    def draw(canvas, rect, highlight: nil, scrollbar: nil)
-      body, gutter = scrollbar ? rect.split_gutter : [rect, nil]
+    def draw(canvas, rect, highlight: nil, scrollbar: nil, auto: false)
+      # With auto:, reserve the gutter only when the content overflows the rect.
+      show_bar = scrollbar && !(auto && @scroll.count <= rect.rows)
+      body, gutter = show_bar ? rect.split_gutter : [rect, nil]
       @scroll.ensure_visible(body.rows)
       @scroll.each_visible(body.rows) do |index, offset|
         row = body.row + offset
         selected = index == @scroll.cursor
         canvas.fill(Rect.new(row: row, col: body.col, rows: 1, cols: body.cols), highlight) if highlight && selected
-        canvas.line(row, body.col, as_line(yield(index, selected)).truncate(body.cols))
+        canvas.line(row, body.col, Line.coerce(yield(index, selected)).truncate(body.cols))
       end
 
       draw_scrollbar(canvas, gutter, scrollbar) if gutter
       canvas
     end
 
+    # Map a MouseEvent to the list index under it, or nil. Pass the same `rect`
+    # and `scrollbar:` used for `draw` so the gutter column is excluded and the
+    # scroll offset matches what was rendered. Returns nil for clicks outside the
+    # body or below the last item.
+    def index_at(rect, event, scrollbar: nil)
+      body = scrollbar ? rect.split_gutter.first : rect
+      return nil unless body.hit?(event)
+
+      index = @scroll.top + (event.row - body.row)
+      index < @scroll.count ? index : nil
+    end
+
     private
 
     def draw_scrollbar(canvas, gutter, theme)
@@ -39,7 +53,5 @@ module TuiTui
         thumb_style: theme.scroll_thumb
       )
     end
-
-    def as_line(content) = content.is_a?(Line) ? content : Line.new(Array(content))
   end
 end

data/lib/tui_tui/modal_host.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative "event"
+
+module TuiTui
+  # Host-side helper for the app that *owns* the current modal widget.
+  #
+  # Centralizes the open + dispatch loop every app with modals otherwise hand
+  # writes: it routes MouseEvents to #handle_mouse and other events to #handle,
+  # honors the "resolved value, or nil to stay open" widget contract, and runs
+  # the caller's on_result callback when the modal resolves.
+  #
+  #   host = TuiTui::ModalHost.new
+  #   host.open(TuiTui::Confirm.new("Quit?")) { |r| :quit if r == :ok }
+  #   # in update(event):
+  #   if host.open?
+  #     outcome = host.handle(event)   # nil while open; on_result value once resolved
+  #     return outcome == :quit ? :quit : self
+  #   end
+  #   # in view(size): host.draw(canvas, size) if host.open?
+  class ModalHost
+    def open(widget, &on_result)
+      @widget = widget
+      @on_result = on_result || ->(result) { result }
+      self
+    end
+
+    def open? = !@widget.nil?
+
+    def close
+      @widget = nil
+      @on_result = nil
+    end
+
+    def draw(canvas, size) = @widget&.draw(canvas, size)
+
+    # Route one event to the modal. Returns nil while the modal stays open
+    # (the event was consumed), or the on_result callback's value once the
+    # widget resolves (e.g. :quit, or a new app model).
+    def handle(event)
+      return nil unless open?
+
+      result = dispatch(event)
+      return nil if result.nil?
+
+      callback = @on_result
+      close
+      callback.call(result)
+    end
+
+    private
+
+    def dispatch(event)
+      case event
+      when MouseEvent then @widget.handle_mouse(event)
+      when KeyEvent then @widget.handle(event.key)
+      else @widget.handle(event)
+      end
+    end
+  end
+end

data/lib/tui_tui/pager.rb

@@ -2,6 +2,8 @@
 
 require_relative "display_text"
 require_relative "style"
+require_relative "span"
+require_relative "line"
 require_relative "rect"
 require_relative "modal"
 require_relative "key_intent"
@@ -12,13 +14,16 @@ module TuiTui
     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
-      @lines = lines.map { |line| DisplayText.new(line) }
+      @theme = theme
+      @lines = lines.map { |line| normalize_line(line) }
       @top = start
       @page = 1
       @close_keys = close_keys
-      @theme = theme
     end
 
     def handle(key)
@@ -60,7 +65,7 @@ module TuiTui
         line = @lines[@top + offset]
         next if line.nil?
 
-        canvas.text(rect.row + 3 + offset, rect.col + 2, line.truncate(inner), theme.muted)
+        canvas.line(rect.row + 3 + offset, rect.col + 2, line.truncate(inner))
       end
 
       canvas
@@ -68,6 +73,13 @@ module TuiTui
 
     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

data/lib/tui_tui/prompt.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "display_text"
+require_relative "text_sanitizer"
 require_relative "style"
 require_relative "modal"
 require_relative "key_code"
@@ -38,7 +39,7 @@ module TuiTui
       when :end
         edit { @pos = @graphemes.length }
       when String
-        edit { insert(key) if printable?(key) }
+        edit { insert(key) if TextSanitizer.printable?(key) }
       end
     end
 
@@ -103,9 +104,5 @@ module TuiTui
     def delete_forward
       @graphemes.delete_at(@pos) if @pos < @graphemes.length
     end
-
-    def printable?(string)
-      string.bytes.all? { |byte| byte >= 0x20 && byte != 0x7F }
-    end
   end
 end

data/lib/tui_tui/rect.rb

@@ -37,6 +37,14 @@ module TuiTui
       Rect.new(row: row, col: col + by, rows: rows, cols: cols - by)
     end
 
+    # Whether a 1-origin cell (row, col) falls inside this rectangle.
+    def include?(r, c)
+      r.between?(row, row + rows - 1) && c.between?(col, col + cols - 1)
+    end
+
+    # Whether a MouseEvent's cell falls inside this rectangle.
+    def hit?(mouse) = include?(mouse.row, mouse.col)
+
     # Carve `width` columns off the right edge for a scrollbar gutter. Returns
     # [body, gutter]; gutter is nil when the rect is too narrow to spare them.
     def split_gutter(width = 1)

data/lib/tui_tui/render_context.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "canvas"
+
+module TuiTui
+  # What an app's `view` receives: the terminal size plus the resolved chrome
+  RenderContext = Data.define(:size, :chrome) do
+    def rows = size.rows
+    def cols = size.cols
+
+    # A blank canvas already carrying the resolved chrome.
+    def canvas = Canvas.blank(size, chrome: chrome)
+  end
+end

data/lib/tui_tui/runtime.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "screen"
+require_relative "render_context"
 
 module TuiTui
   # Small Elm-style loop: render, read one event, fold it through the app, repeat.
@@ -9,11 +10,11 @@ module TuiTui
       @app = app
     end
 
-    def run(input: $stdin, output: $stdout, depth: ColorDepth.detect, tick: 0.1, mouse: Screen.mouse_default)
-      Screen.run(input: input, output: output, depth: depth, mouse: mouse) do |screen|
+    def run(input: $stdin, output: $stdout, depth: ColorDepth.detect, tick: 0.1, mouse: Screen.mouse_default, box: ENV["TUITUI_BOX"])
+      Screen.run(input: input, output: output, depth: depth, mouse: mouse, box: box) do |screen|
         raise "tui_tui: not a terminal" if screen.nil?
 
-        screen.render(@app.view(screen.size))
+        screen.render(view(screen))
         loop do
           event = screen.events.next_event(tick: tick)
           break if event.is_a?(EofEvent)
@@ -25,13 +26,20 @@ module TuiTui
 
           @app = result
           flush_clipboard(screen)
-          screen.render(@app.view(screen.size))
+          flush_mouse(screen)
+          screen.render(view(screen))
         end
       end
     end
 
     private
 
+    # Pass a RenderContext (size + resolved chrome + canvas factory). It is
+    # Size-compatible, so legacy `view(size)` apps keep working (ASCII).
+    def view(screen)
+      @app.view(RenderContext.new(size: screen.size, chrome: screen.chrome))
+    end
+
     def flush_clipboard(screen)
       # Clipboard writes stay an effect of the loop, requested by the app.
       return unless @app.respond_to?(:take_clipboard)
@@ -40,6 +48,14 @@ module TuiTui
       screen.copy(text) if text
     end
 
+    # Apps may release/recapture the mouse per frame (e.g. to allow a native
+    # terminal selection while a read-only pane is open).
+    def flush_mouse(screen)
+      return unless @app.respond_to?(:wants_mouse?)
+
+      screen.mouse = @app.wants_mouse?
+    end
+
     def wants_redraw?(event)
       @app.respond_to?(:redraw?) && @app.redraw?(event)
     end

data/lib/tui_tui/screen.rb

@@ -5,6 +5,8 @@ require "io/console"
 require_relative "ansi"
 require_relative "size"
 require_relative "color_depth"
+require_relative "box_chrome"
+require_relative "box_prober"
 require_relative "canvas_compositor"
 require_relative "terminal_size"
 require_relative "event_stream"
@@ -15,12 +17,12 @@ module TuiTui
   class Screen
     DEFAULT_SIZE = Size.new(rows: 24, cols: 80)
 
-    def self.run(input: $stdin, output: $stdout, depth: ColorDepth.detect, mouse: mouse_default)
+    def self.run(input: $stdin, output: $stdout, depth: ColorDepth.detect, mouse: mouse_default, box: ENV["TUITUI_BOX"])
       console = IO.console
       # Let callers provide a non-interactive fallback for piped output.
       return yield(nil) if console.nil? || !output.tty?
 
-      screen = new(console, input, output, depth, mouse: mouse)
+      screen = new(console, input, output, depth, mouse: mouse, box: box)
       screen.start
       begin
         yield screen
@@ -33,8 +35,12 @@ module TuiTui
       !%w[0 off false].include?(ENV["TUITUI_MOUSE"])
     end
 
-    def initialize(console, input, output, depth, mouse: true)
+    def initialize(console, input, output, depth, mouse: true, box: nil)
+      @input = input
       @output = output
+      @box_override = box
+      # ASCII until start probes a real TTY; safe for non-TTY/StringIO callers.
+      @chrome = BoxChrome::ASCII
       @compositor = CanvasCompositor.new(depth: depth)
       @term_size = TerminalSize.new(console, default: DEFAULT_SIZE)
       @events = EventStream.new(input: input, size: @term_size)
@@ -44,9 +50,27 @@ module TuiTui
       @cursor = nil
     end
 
-    attr_reader :events
+    attr_reader :events, :chrome
 
-    def start = @session.start
+    # Toggle mouse reporting mid-session (so an app can release the mouse for a
+    # native terminal selection while a read-only pane is open).
+    def mouse=(enabled)
+      @session.mouse = enabled
+    end
+
+    def mouse = @session.mouse
+
+    def start
+      @session.start
+      # Probe box-drawing support once, after raw mode + alt screen, before the
+      # first render/next_event so the DSR reply never reaches the key reader.
+      @chrome = BoxChrome.resolve(
+        input: @input,
+        output: @output,
+        term_cols: size.cols,
+        env: {"TUITUI_BOX" => @box_override}
+      )
+    end
 
     def size = @term_size.size
 

data/lib/tui_tui/scrollbar.rb

@@ -13,9 +13,10 @@ module TuiTui
     TRACK = Theme::DEFAULT.scroll_track
     THUMB = Theme::DEFAULT.scroll_thumb
 
-    def draw(canvas, rect, top:, visible:, total:, track: "|", thumb: " ", track_style: TRACK, thumb_style: 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

data/lib/tui_tui/select.rb

@@ -91,11 +91,10 @@ module TuiTui
 
     # The item under a click, picked, or nil if the click missed the list.
     def click(event)
-      rect = @items_rect
-      return nil unless rect && event.col.between?(rect.col, rect.col + rect.cols - 1)
+      return nil unless @items_rect
 
-      index = @list.top + (event.row - rect.row)
-      return nil unless (event.row - rect.row).between?(0, rect.rows - 1) && !@list.empty? && index <= @list.last
+      index = List.new(@list).index_at(@items_rect, event)
+      return nil if index.nil?
 
       @list.go_to(index)
       @list.cursor

data/lib/tui_tui/span.rb

@@ -6,6 +6,11 @@ module TuiTui
   # A run of text sharing one Style.
   # Width is terminal-column aware via DisplayText.
   Span = Data.define(:text, :style) do
+    # Data.define auto-generates Span.[] as an alias of .new. Remove it before
+    # redefining so our convenience form (style optional, text coerced) does not
+    # print a "method redefined" warning under -w.
+    singleton_class.send(:remove_method, :[])
+
     # Convenience constructor: Span["hi", style] (style optional).
     def self.[](text, style = nil) = new(text: text.to_s, style: style)
 

data/lib/tui_tui/terminal_session.rb

@@ -16,7 +16,8 @@ module TuiTui
     end
 
     def start
-      @console.raw!
+      # `intr: true` keeps the interrupt/quit/suspend characters live in raw mode, so Ctrl-C raises SIGINT.
+      @console.raw!(intr: true)
       @output.write(Ansi::ALT_ON + Ansi::HIDE + Ansi::CLEAR + (@mouse ? Ansi::MOUSE_ON : ""))
       @output.flush
       @prev_winch = trap("WINCH") { @events.resized! }
@@ -24,6 +25,20 @@ module TuiTui
       at_exit { close }
     end
 
+    attr_reader :mouse
+
+    # Toggle mouse reporting mid-session. Releasing it (false) lets the user
+    # make a native terminal selection (drag to select / copy) over the alternate
+    # screen; re-enabling restores in-app mouse events. No-op if unchanged.
+    def mouse=(enabled)
+      enabled = !!enabled
+      return if @closed || enabled == @mouse
+
+      @output.write(enabled ? Ansi::MOUSE_ON : Ansi::MOUSE_OFF)
+      @output.flush
+      @mouse = enabled
+    end
+
     def close
       # Close is called from ensure, at_exit, and signal traps.
       return if @closed

data/lib/tui_tui/text_sanitizer.rb

@@ -1,13 +1,21 @@
 # frozen_string_literal: true
 
 module TuiTui
-  # Normalizes text before rendering so malformed input bytes are displayed
-  # safely instead of raising encoding errors.
+  # Character-level text hygiene: keeps malformed or control bytes out of the
+  # render/input pipeline so they are displayed safely (or rejected as input)
+  # instead of raising encoding errors or emitting raw control codes.
   module TextSanitizer
     module_function
 
     def sanitize(string)
       string.valid_encoding? ? string : string.scrub("?")
     end
+
+    # Whether `string` is safe to insert as literal text: every byte is a
+    # printable character (no C0 controls and no DEL). Multibyte UTF-8 passes,
+    # since its bytes are all >= 0x80.
+    def printable?(string)
+      string.bytes.all? { |byte| byte >= 0x20 && byte != 0x7F }
+    end
   end
 end

data/lib/tui_tui/text_view.rb

@@ -10,14 +10,18 @@ module TuiTui
   module TextView
     module_function
 
-    def draw(canvas, rect, lines = nil, top: 0, style: nil, scrollbar: nil, total: nil)
-      body, gutter = scrollbar ? rect.split_gutter : [rect, nil]
+    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, as_line(content, style).truncate(body.cols))
+        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
@@ -37,16 +41,5 @@ module TuiTui
         thumb_style: theme.scroll_thumb
       )
     end
-
-    def as_line(content, style)
-      case content
-      when Line
-        content
-      when Array
-        Line.new(content)
-      else
-        Line[Span[content.to_s, style]]
-      end
-    end
   end
 end

data/lib/tui_tui/theme.rb

@@ -22,23 +22,47 @@ module TuiTui
     :bar,
     :cursor,
     :scroll_track,
-    :scroll_thumb
+    :scroll_thumb,
+    # semantic status roles (hue-independent, background-aware)
+    :success,
+    :warning,
+    :danger,
+    :info
   )
 
   class Theme
+    # Map a symbolic status to its semantic role Style (with common aliases).
+    def status(kind)
+      case kind
+      when :ok, :success then success
+      when :warn, :warning then warning
+      when :error, :danger then danger
+      when :info then info
+      else text
+      end
+    end
+
     # Background-dependent neutral roles.
     SURFACES = {
       dark: {
         text: Style.new,
         muted: Style.new(fg: 245),
         bar: Style.new(fg: 252, bg: 238),
-        selection_dim: Style.new(fg: 247, bg: 238)
+        selection_dim: Style.new(fg: 247, bg: 238),
+        success: Style.new(fg: 71),
+        warning: Style.new(fg: 179),
+        danger: Style.new(fg: 167),
+        info: Style.new(fg: 110)
       },
       light: {
         text: Style.new,
         muted: Style.new(fg: 240),
         bar: Style.new(fg: 16, bg: 252),
-        selection_dim: Style.new(fg: 240, bg: 252)
+        selection_dim: Style.new(fg: 240, bg: 252),
+        success: Style.new(fg: 28),
+        warning: Style.new(fg: 130),
+        danger: Style.new(fg: 124),
+        info: Style.new(fg: 25)
       }
     }.freeze
 
@@ -79,7 +103,11 @@ module TuiTui
         bar: surface[:bar],
         cursor: selection,
         scroll_track: Style.new(fg: a[:line]),
-        scroll_thumb: Style.new(bg: a[:sel][1])
+        scroll_thumb: Style.new(bg: a[:sel][1]),
+        success: surface[:success],
+        warning: surface[:warning],
+        danger: surface[:danger],
+        info: surface[:info]
       )
     end
 

data/lib/tui_tui/toast.rb

@@ -2,6 +2,7 @@
 
 require_relative "display_text"
 require_relative "style"
+require_relative "clock"
 
 module TuiTui
   # A transient notification overlay.
@@ -22,7 +23,7 @@ module TuiTui
       bottom_right: [:bottom, :right],
       center: [:middle, :center]
     }.freeze
-    MONOTONIC = -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) }
+    MONOTONIC = -> { Clock.monotonic }
 
     def initialize(message, seconds: DEFAULT_SECONDS, position: DEFAULT_POSITION, clock: MONOTONIC)
       @message = DisplayText.new(message)

data/lib/tui_tui/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TuiTui
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

data/lib/tui_tui.rb

@@ -2,6 +2,7 @@
 
 require_relative "tui_tui/version"
 
+require_relative "tui_tui/clock"
 require_relative "tui_tui/width"
 require_relative "tui_tui/text_sanitizer"
 require_relative "tui_tui/display_text"
@@ -9,6 +10,8 @@ require_relative "tui_tui/span"
 require_relative "tui_tui/line"
 require_relative "tui_tui/ansi"
 require_relative "tui_tui/color_depth"
+require_relative "tui_tui/box_chrome"
+require_relative "tui_tui/box_prober"
 require_relative "tui_tui/palette"
 require_relative "tui_tui/style"
 require_relative "tui_tui/theme"
@@ -16,6 +19,7 @@ require_relative "tui_tui/size"
 require_relative "tui_tui/rect"
 require_relative "tui_tui/cell"
 require_relative "tui_tui/canvas"
+require_relative "tui_tui/render_context"
 require_relative "tui_tui/canvas_compositor"
 require_relative "tui_tui/event"
 require_relative "tui_tui/key_code"
@@ -32,8 +36,10 @@ require_relative "tui_tui/toast"
 require_relative "tui_tui/focus_ring"
 require_relative "tui_tui/fuzzy"
 require_relative "tui_tui/modal"
+require_relative "tui_tui/modal_host"
 require_relative "tui_tui/confirm"
 require_relative "tui_tui/select"
+require_relative "tui_tui/command_palette"
 require_relative "tui_tui/help"
 require_relative "tui_tui/prompt"
 require_relative "tui_tui/pager"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tui_tui
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - takahashim
@@ -19,6 +19,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".github/workflows/ci.yml"
+- CHANGELOG.md
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -33,10 +34,14 @@ files:
 - examples/widgets.rb
 - lib/tui_tui.rb
 - lib/tui_tui/ansi.rb
+- lib/tui_tui/box_chrome.rb
+- lib/tui_tui/box_prober.rb
 - lib/tui_tui/canvas.rb
 - lib/tui_tui/canvas_compositor.rb
 - lib/tui_tui/cell.rb
+- lib/tui_tui/clock.rb
 - lib/tui_tui/color_depth.rb
+- lib/tui_tui/command_palette.rb
 - lib/tui_tui/confirm.rb
 - lib/tui_tui/display_text.rb
 - lib/tui_tui/event.rb
@@ -50,10 +55,12 @@ files:
 - lib/tui_tui/line.rb
 - lib/tui_tui/list.rb
 - lib/tui_tui/modal.rb
+- lib/tui_tui/modal_host.rb
 - lib/tui_tui/pager.rb
 - lib/tui_tui/palette.rb
 - lib/tui_tui/prompt.rb
 - lib/tui_tui/rect.rb
+- lib/tui_tui/render_context.rb
 - lib/tui_tui/runtime.rb
 - lib/tui_tui/screen.rb
 - lib/tui_tui/scroll_list.rb
@@ -78,6 +85,7 @@ metadata:
   allowed_push_host: https://rubygems.org
   homepage_uri: https://github.com/takahashim/tui_tui
   source_code_uri: https://github.com/takahashim/tui_tui
+  changelog_uri: https://github.com/takahashim/tui_tui/blob/main/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib
@@ -92,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A tiny, dependency-free TUI runtime for modern terminals.
 test_files: []