potty 0.0.1 → 0.0.2

data/lib/potty/surfaces/curses_surface.rb

@@ -8,21 +8,18 @@ require_relative '../keys'
 module Potty
   module Surfaces
     # The default render target: a full-screen curses display. Wraps the
-    # WindowManager / stdscr so existing widgets draw exactly as before.
-    #
-    # attron accepts EITHER a Potty::Style (resolved to a colour pair +
-    # attributes) OR a raw integer (a legacy curses attribute, passed
-    # through). That dual acceptance is what lets un-migrated widgets — and
-    # direct-to-window consumers like a host's own paint code — keep working
-    # untouched while new widgets go render-target-agnostic.
+    # WindowManager / stdscr. It resolves a Style to a curses colour pair +
+    # attributes (allocating pairs on demand); a raw integer is passed through
+    # unchanged, so a host that draws to the surface with its own curses attrs
+    # still works.
     class CursesSurface < Surface
       def initialize(window_manager, theme, tick_interval: nil)
         super()
         @wm = window_manager
         @theme = theme
         @tick_interval = tick_interval
-        @next_pair = theme.palette.size + 1 # leave 1..N for theme[]'s pairs
-        @pairs = nil
+        @next_pair = 1
+        @pairs = {}
       end
 
       def start
@@ -36,7 +33,10 @@ module Potty
         ::Curses.cbreak
         stdscr.keypad(true)
         stdscr.timeout = @tick_interval if @tick_interval
-        @theme.setup_colors if ::Curses.has_colors?
+        if ::Curses.has_colors?
+          ::Curses.start_color
+          ::Curses.use_default_colors # enables -1 = terminal default
+        end
       end
 
       def finalize
@@ -88,21 +88,15 @@ module Potty
         attr
       end
 
+      # Allocate (once) and cache a curses colour pair per (fg, bg) combo the
+      # theme's Styles use. The palette is small, so this stays well within
+      # the terminal's pair budget.
       def color_pair(fg, bg)
         return 0 unless ::Curses.has_colors?
 
-        (@pairs ||= seed_pairs)
         @pairs[[fg, bg]] ||= allocate_pair(fg, bg)
       end
 
-      # Reuse the pairs Theme already allocated for its palette combos so we
-      # don't burn a second pair on every colour we share with theme[].
-      def seed_pairs
-        map = {}
-        @theme.palette.each { |name, c| map[[c[:fg], c[:bg]]] = @theme[name] }
-        map
-      end
-
       def allocate_pair(fg, bg)
         n = @next_pair
         @next_pair += 1

data/lib/potty/surfaces/inline_surface.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
+require 'io/console'
 require_relative '../surface'
+require_relative '../ansi'
+require_relative '../input/decoder'
 
 module Potty
   module Surfaces
@@ -15,25 +18,21 @@ module Potty
     # then cursor back to the top). finalize freezes the last frame and drops
     # the cursor to the line below so the next prompt lands cleanly.
     class InlineSurface < Surface
-      SGR_FG = {
-        default: 39, black: 30, red: 31, green: 32, yellow: 33,
-        blue: 34, magenta: 35, cyan: 36, white: 37, bright_black: 90
-      }.freeze
-      SGR_BG = {
-        default: 49, black: 40, red: 41, green: 42, yellow: 43,
-        blue: 44, magenta: 45, cyan: 46, white: 47, bright_black: 100
-      }.freeze
-
-      def initialize(theme:, lines: nil, tick_interval: 40, out: $stdout)
+      def initialize(theme:, lines: nil, tick_interval: 40, out: $stdout, listen: false, input: $stdin)
         super()
         @theme = theme
         @rows = [lines || 1, 1].max
         @tick_interval = tick_interval
         @out = out
+        @listen = listen
+        @input = input
         @cols = detect_cols
         @cursor = [0, 0]
         @cur_style = nil
         @primed = false
+        @raw = false
+        @decoder = (Input::Decoder.new if listen)
+        @queue = []
         erase
       end
 
@@ -44,11 +43,16 @@ module Potty
       def start
         @out.write("\e[?25l") # hide cursor
         @out.flush
+        enter_raw if @listen
       end
 
       def finalize
         present                 # freeze the final frame
-        @out.write("\n")        # drop below the region
+        restore_cooked
+        # Explicit CR+LF: present leaves the cursor at the end of the last
+        # rendered row, and in raw mode \n alone is a bare line-feed (no
+        # column reset), which would indent whatever the host prints next.
+        @out.write("\r\n")      # drop below the region, at column 0
         @out.write("\e[?25h")   # restore cursor
         @out.flush
       end
@@ -97,15 +101,56 @@ module Potty
         @out.flush
       end
 
-      # Inline mode ignores input; sleeping here gives the loop its tick
-      # cadence. Terminal stays cooked, so Ctrl-C raises Interrupt normally.
+      # In listen mode: drain raw stdin (non-blocking, waiting up to one tick
+      # for the first byte), decode to Keys codes, and return them one per
+      # call (queueing the rest). Without listening (or off a real TTY): just
+      # pace the loop and return nil, leaving input alone. Ctrl-C arrives as a
+      # byte the decoder passes through as Keys::CTRL_C; the event loop raises.
       def read_key
-        sleep(@tick_interval / 1000.0) if @tick_interval
-        nil
+        return @queue.shift unless @queue.empty?
+
+        if @raw
+          fill_queue
+          @queue.shift
+        else
+          sleep(@tick_interval / 1000.0) if @tick_interval
+          nil
+        end
       end
 
       private
 
+      def enter_raw
+        return unless @input.respond_to?(:raw!) && tty_input?
+
+        @input.raw!     # no echo, no canonical, no signal processing
+        @raw = true
+      end
+
+      def restore_cooked
+        return unless @raw
+
+        @input.cooked!
+        @raw = false
+      end
+
+      def tty_input?
+        @input.respond_to?(:tty?) && @input.tty?
+      end
+
+      def fill_queue
+        seconds = (@tick_interval || 40) / 1000.0
+        bytes = +''
+        if IO.select([@input], nil, nil, seconds)
+          begin
+            loop { bytes << @input.read_nonblock(256) }
+          rescue IO::WaitReadable, EOFError
+            # drained for now
+          end
+        end
+        @queue.concat(@decoder.feed(bytes, Time.now))
+      end
+
       def render_row(cells)
         last = cells.rindex { |ch, _| ch != ' ' } || -1
         return '' if last.negative?
@@ -115,27 +160,15 @@ module Potty
         (0..last).each do |i|
           ch, style = cells[i]
           if style != emitted
-            out << sgr(style)
+            out << Ansi.sgr(style)
             emitted = style
           end
           out << ch
         end
-        out << "\e[0m" if emitted
+        out << Ansi::RESET if emitted
         out
       end
 
-      def sgr(style)
-        return "\e[0m" if style.nil?
-
-        codes = []
-        codes << 1 if style.bold?
-        codes << 4 if style.underline?
-        codes << 7 if style.reverse?
-        codes << SGR_FG.fetch(style.fg, 39)
-        codes << SGR_BG.fetch(style.bg, 49)
-        "\e[#{codes.join(';')}m"
-      end
-
       def detect_cols
         return @out.winsize[1] if @out.respond_to?(:winsize) && @out.tty?
 

data/lib/potty/theme.rb

@@ -4,18 +4,18 @@ require 'curses'
 require_relative 'style'
 
 module Potty
-  # Theme maps semantic names to colours, and speaks two dialects:
+  # Theme maps semantic names to a render-target-agnostic Style (symbolic
+  # colours + attributes). It is pure data — it does NOT touch curses. Each
+  # Surface resolves a Style to its concrete form (CursesSurface to a colour
+  # pair, InlineSurface to ANSI SGR), which is why a single Theme drives both
+  # rendering modes and why every widget that asks the theme for an attribute
+  # works in either mode with no per-widget special-casing.
   #
-  #   theme.style(:info)  => a Style (symbolic, render-target-agnostic) —
-  #                          the path Surfaces resolve, for curses OR inline.
-  #   theme[:info]        => a curses attribute integer (a colour pair) —
-  #                          back-compat for code that draws straight to a
-  #                          Curses window. Only meaningful once curses is up.
-  #
-  # The symbolic PALETTE is the source of truth; the curses pairs are derived
-  # from it in setup_colors, so the two dialects never drift.
+  # `style`, `[]`, and `attr` all return a Style — `[]`/`attr` are kept as
+  # ergonomic aliases (attr adds bold/underline).
   class Theme
     # Symbolic colour names -> curses colour numbers (-1 = terminal default).
+    # Used by CursesSurface when it resolves a Style to a colour pair.
     COLORS = {
       default: -1,
       black: ::Curses::COLOR_BLACK,   red: ::Curses::COLOR_RED,
@@ -41,24 +41,11 @@ module Potty
       status:   { fg: :black,        bg: :cyan }
     }.freeze
 
-    attr_reader :palette, :colors
+    attr_reader :palette
 
     # Pass a partial palette ({ name => { fg:, bg: } }) to override entries.
     def initialize(palette = nil)
       @palette = palette ? PALETTE.merge(palette) : PALETTE
-      @colors = {}
-      setup_colors if ::Curses.has_colors?
-    end
-
-    # Allocate a curses colour pair per palette entry (curses mode only).
-    def setup_colors
-      ::Curses.start_color
-      ::Curses.use_default_colors
-      @palette.each_with_index do |(name, c), idx|
-        pair = idx + 1
-        ::Curses.init_pair(pair, COLORS.fetch(c[:fg], -1), COLORS.fetch(c[:bg], -1))
-        @colors[name] = ::Curses.color_pair(pair)
-      end
     end
 
     # Semantic style — symbolic colours + attributes, resolved by a Surface.
@@ -67,16 +54,14 @@ module Potty
       Style.new(fg: c[:fg], bg: c[:bg], bold: bold, underline: underline, reverse: reverse)
     end
 
-    # Curses attribute integer (back-compat for direct-to-window drawing).
+    # Ergonomic aliases — both return a Style, so widgets can use whichever
+    # reads best and still render in any mode.
     def [](name)
-      @colors[name] || @colors[:normal] || 0
+      style(name)
     end
 
     def attr(name, bold: false, underline: false)
-      a = self[name]
-      a |= ::Curses::A_BOLD if bold
-      a |= ::Curses::A_UNDERLINE if underline
-      a
+      style(name, bold: bold, underline: underline)
     end
   end
 end

data/lib/potty/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Potty
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

data/lib/potty/view.rb

@@ -37,13 +37,20 @@ module Potty
       rows, cols = @app.surface.size
       container = Layout::Rect.new(0, 0, cols, rows)
 
-      # Simple stack layout with spacing
-      rects = Layout.stack(container, @widgets, spacing: 1)
+      # Simple stack layout. Override #spacing to pack tighter — inline views
+      # in particular want 0 so their height matches the region exactly.
+      rects = Layout.stack(container, @widgets, spacing: spacing)
       @widgets.zip(rects).each do |widget, rect|
         widget.layout(rect)
       end
     end
 
+    # Rows of blank space the default layout leaves between top-level widgets.
+    # Override to change it (e.g. 0 for a tightly-packed inline region).
+    def spacing
+      1
+    end
+
     # Draw the widget tree onto the application's surface. The surface frame
     # (erase/present) is owned by Application#refresh_all, so this just paints.
     def render
@@ -63,9 +70,13 @@ module Potty
       # Delegate to focused widget first
       return true if focused_widget&.handle_key(ch)
 
-      # Handle view-level keys
+      # Handle view-level keys. Enter advances focus like Tab when the
+      # focused widget didn't consume it — so a form flows field -> field ->
+      # button (where the button finally consumes Enter and fires). A view
+      # that wants Enter for itself (e.g. a prompt that submits) intercepts it
+      # before delegating to super.
       case ch
-      when Keys::TAB
+      when Keys::TAB, *Keys::ENTERS
         cycle_focus(1)
         true
       when Keys::SHIFT_TAB

data/lib/potty/widgets/button.rb

@@ -43,7 +43,7 @@ module Potty
         return unless @visible && @rect
 
         text = "[ #{@label} ]"[0, @rect.width]
-        attr = @focused ? theme.attr(:selected, bold: true) : theme[@color]
+        attr = @focused ? theme.style(:selected, bold: true) : theme.style(@color)
         window.setpos(@rect.y, @rect.x)
         window.attron(attr) { window.addstr(text) }
       end

data/lib/potty/widgets/checkbox_group.rb

@@ -63,7 +63,7 @@ module Potty
 
           mark = selected?(opt[:value]) ? "[\u2713]" : "[ ]"
           on_cursor = @focused && i == @cursor
-          attr = on_cursor ? theme.attr(:selected, bold: true) : theme[:normal]
+          attr = on_cursor ? theme.style(:selected, bold: true) : theme.style(:normal)
           window.setpos(@rect.y + i, @rect.x)
           window.attron(attr) { window.addstr("#{mark} #{opt[:label]}"[0, @rect.width]) }
         end

data/lib/potty/widgets/colored_fields_item.rb

@@ -38,7 +38,7 @@ module Potty
           text = text[0, remaining]
 
           if color
-            attr = bold ? theme.attr(color, bold: true) : theme[color]
+            attr = bold ? theme.style(color, bold: true) : theme.style(color)
             window.attron(attr) do
               window.addstr(text)
             end

data/lib/potty/widgets/countdown.rb

@@ -74,7 +74,7 @@ module Potty
 
         text = @format.call(remaining).to_s[0, @rect.width]
         window.setpos(@rect.y, @rect.x)
-        window.attron(theme[:warning]) { window.addstr(text) }
+        window.attron(theme.style(:warning)) { window.addstr(text) }
       end
     end
   end

data/lib/potty/widgets/flash_message.rb

@@ -45,10 +45,10 @@ module Potty
         # Show message if present
         if @message
           attr = case @type
-                 when :success then theme[:success]
-                 when :error then theme[:error]
-                 when :warning then theme[:warning]
-                 else theme[:info]
+                 when :success then theme.style(:success)
+                 when :error then theme.style(:error)
+                 when :warning then theme.style(:warning)
+                 else theme.style(:info)
                  end
 
           window.setpos(@rect.y, @rect.x)

data/lib/potty/widgets/label.rb

@@ -28,7 +28,7 @@ module Potty
       def render(window)
         return unless @visible && @rect
 
-        attr = @bold ? theme.attr(@color, bold: true) : theme[@color]
+        attr = theme.style(@color, bold: @bold)
         window.setpos(@rect.y, @rect.x)
         window.attron(attr) { window.addstr(@text.to_s[0, @rect.width] || '') }
       end

data/lib/potty/widgets/list.rb

@@ -55,7 +55,7 @@ module Potty
         # Show empty message if no items
         if @items.empty?
           window.setpos(@rect.y + 1, @rect.x + 2)
-          window.attron(theme[:dim]) do
+          window.attron(theme.style(:dim)) do
             window.addstr("No items")
           end
           return
@@ -94,7 +94,7 @@ module Potty
       private
 
       def draw_border(window)
-        Border.draw(window, @rect, attr: theme[:normal])
+        Border.draw(window, @rect, attr: theme.style(:normal))
       end
 
       def render_item(window, item, index, y, x)
@@ -105,7 +105,7 @@ module Potty
         window.setpos(y, x)
 
         # Selection prefix
-        prefix_attr = is_selected && @focused ? theme.attr(:selected, bold: true) : theme[:normal]
+        prefix_attr = is_selected && @focused ? theme.style(:selected, bold: true) : theme.style(:normal)
         window.attron(prefix_attr) do
           prefix = is_selected ? "\u2192 " : "  "
           window.addstr(prefix)
@@ -118,13 +118,13 @@ module Potty
 
         # Default single-color rendering
         attr = if is_selected && @focused
-                 theme.attr(:selected, bold: true)
+                 theme.style(:selected, bold: true)
                elsif is_disabled
-                 theme[:dim]
+                 theme.style(:dim)
                elsif item.color
-                 theme[item.color]
+                 theme.style(item.color)
                else
-                 theme[:normal]
+                 theme.style(:normal)
                end
 
         window.attron(attr) do

data/lib/potty/widgets/list_item.rb

@@ -2,6 +2,7 @@
 
 require 'curses'
 require_relative '../keys'
+require_relative '../line_editor'
 
 module Potty
   module Widgets
@@ -59,46 +60,44 @@ module Potty
       end
     end
 
-    # Text input item - allows inline text editing
+    # Text input item — inline text editing within a List. Shares the
+    # LineEditor model with the TextInput widget.
     class InputItem < ListItem
-      attr_accessor :input_value
-
       def initialize(label, default: "", &on_submit)
         super(label)
-        @input_value = default
+        @editor = LineEditor.new(default)
         @on_submit = on_submit
-        @cursor_pos = @input_value.length
+      end
+
+      # Back-compat accessor for the entered text.
+      def input_value
+        @editor.text
+      end
+
+      def input_value=(value)
+        @editor.text = value
       end
 
       def display_text
-        cursor = "_"
-        "#{@text}: #{@input_value}#{cursor}"
+        "#{@text}: #{@editor.text}_"
       end
 
       def handle_key(ch)
         case ch
         when *Keys::ENTERS
-          @on_submit&.call(@input_value)
-          true
+          @on_submit&.call(@editor.text)
         when *Keys::BACKSPACES
-          if @cursor_pos > 0
-            @input_value[@cursor_pos - 1] = ''
-            @cursor_pos -= 1
-          end
-          true
+          @editor.backspace
         when Keys::LEFT
-          @cursor_pos = [@cursor_pos - 1, 0].max
-          true
+          @editor.left
         when Keys::RIGHT
-          @cursor_pos = [@cursor_pos + 1, @input_value.length].min
-          true
-        when Keys::SPACE..(Keys::DEL_ASCII - 1)  # Printable ASCII
-          @input_value.insert(@cursor_pos, ch.chr)
-          @cursor_pos += 1
-          true
+          @editor.right
+        when Keys::SPACE..(Keys::DEL_ASCII - 1) # Printable ASCII
+          @editor.insert(ch.chr)
         else
-          false
+          return false
         end
+        true
       end
     end
 

data/lib/potty/widgets/panel.rb

@@ -41,7 +41,7 @@ module Potty
       def render(window)
         return unless @visible && @rect
 
-        Border.draw(window, @rect, style: @style, attr: theme[@color], title: @title)
+        Border.draw(window, @rect, style: @style, attr: theme.style(@color), title: @title)
         super # render children inside the frame
       end
     end

data/lib/potty/widgets/radio_group.rb

@@ -41,6 +41,14 @@ module Potty
         @selected
       end
 
+      # The value under the cursor (the highlighted row), which may differ
+      # from the committed selection while navigating. Choosers commit this
+      # on Enter.
+      def cursor_value
+        opt = @options[@cursor]
+        opt && opt[:value]
+      end
+
       def selected=(value)
         idx = index_of(value)
         return unless idx
@@ -77,7 +85,7 @@ module Potty
 
           marker = opt[:value] == @selected ? "(\u25CF)" : "(\u25CB)"
           on_cursor = @focused && i == @cursor
-          attr = on_cursor ? theme.attr(:selected, bold: true) : theme[:normal]
+          attr = on_cursor ? theme.style(:selected, bold: true) : theme.style(:normal)
           text = "#{marker} #{opt[:label]}"[0, @rect.width]
 
           window.setpos(@rect.y + i, @rect.x)

data/lib/potty/widgets/status_bar.rb

@@ -23,7 +23,7 @@ module Potty
         return unless @rect
 
         window.setpos(@rect.y, @rect.x)
-        window.attron(theme[:status]) do
+        window.attron(theme.style(:status)) do
           # Clear line with background color
           window.addstr(" " * @rect.width)