fatty 0.99.0

data/lib/fatty/renderer.rb

@@ -0,0 +1,419 @@
+# frozen_string_literal: true
+
+# This Struct encapsulates the geometry of popup windows often needed in
+# rendering.
+PopupLayout = Struct.new(
+  :row,
+  :width,
+  :height,
+  keyword_init: true,
+)
+
+module Fatty
+  # The Renderer class implements drawing the elements of a Fatty terminal
+  # (output, input, alert, status, and popups) on the screen.  There are two
+  # ways of doing so: (1) using normal curses operations with curses-defined
+  # pairs and (2) using ANSI codes to write with a Truecolor full-color
+  # palette.  This class is the base class for those two rendering methods and
+  # provides methods common to them.
+  class Renderer
+    FRAME_STYLES = {
+      ascii: { h: "-", v: "|" },
+      single: { h: "─", v: "│" },
+      double: { h: "═", v: "║" },
+    }.freeze
+
+    CORNER_STYLES = {
+      square: {
+        ascii: { tl: "+", tr: "+", bl: "+", br: "+" },
+        single: { tl: "┌", tr: "┐", bl: "└", br: "┘" },
+        double: { tl: "╔", tr: "╗", bl: "╚", br: "╝" },
+      },
+      rounded: {
+        single: { tl: "╭", tr: "╮", bl: "╰", br: "╯" },
+      },
+    }.freeze
+
+    POPUP_SELECTED_GUTTER = "▶ "
+    POPUP_UNSELECTED_GUTTER = "  "
+
+    attr_reader :screen, :palette, :context
+
+    def initialize(screen:, palette:, context:)
+      @screen = screen
+      @palette = palette
+      @context = context
+      @last_status_state = nil
+      @last_alert_state = nil
+      @last_output_state = nil
+      @last_popup_state = nil
+      @last_prompt_popup_state = nil
+      @last_pager_field_state = nil
+    end
+
+    attr_writer :screen
+
+    def apply_theme!(theme)
+      Fatty::Themes::Manager.set(theme)
+      theme_spec = Fatty::Themes::Manager.roles(Fatty::Themes::Manager.current) || {}
+      @palette = Fatty::Colors::Palette.compile(theme_spec, available_colors: available_colors)
+
+      after_apply_theme!
+      invalidate!
+      sync_backgrounds!
+    end
+
+    def render_output(...)
+      raise NotImplementedError, "#{self.class} must implement #render_output"
+    end
+
+    def render_status(...)
+      raise NotImplementedError, "#{self.class} must implement #render_status"
+    end
+
+    def render_input_field(...)
+      raise NotImplementedError, "#{self.class} must implement #render_input_field"
+    end
+
+    def render_pager_field(...)
+      raise NotImplementedError, "#{self.class} must implement #render_pager_field"
+    end
+
+    def render_popup(...)
+      raise NotImplementedError, "#{self.class} must implement #render_popup"
+    end
+
+    def render_prompt_popup(...)
+      raise NotImplementedError, "#{self.class} must implement #render_prompt_popup"
+    end
+
+    def render_alert(...)
+      raise NotImplementedError, "#{self.class} must implement #render_alert"
+    end
+
+    def invalidate!
+      @last_output_state = nil
+      @last_input_state = nil
+      @last_alert_state = nil
+      @last_status_state = nil
+      @last_pager_field_state = nil
+      @last_popup_state = nil
+    end
+
+    protected
+
+    def available_colors
+      nil
+    end
+
+    def after_apply_theme!
+      nil
+    end
+
+    def alert_state(alert)
+      [
+        alert&.message.dup.freeze,
+        alert&.role,
+        alert&.details,
+        screen.alert_rect.row,
+        screen.alert_rect.cols,
+      ]
+    end
+
+    def status_state(text, role)
+      [
+        renderable_segments(text, role: role).map { |segment|
+          [
+            segment[:text].to_s.dup.freeze,
+            segment[:role],
+            segment[:style],
+          ].freeze
+        }.freeze,
+        role,
+        screen.status_rect.row,
+        screen.status_rect.rows,
+        screen.status_rect.cols,
+      ]
+    end
+
+    def popup_state(session)
+      [
+        popup_border,
+        session.title.to_s.dup.freeze,
+        session.message.to_s.dup.freeze,
+        session.displayed.map { |item| item.to_s.dup.freeze }.freeze,
+        session.selected,
+        session.field.buffer.text.to_s.dup.freeze,
+        session.field.buffer.cursor,
+        session.field.buffer.virtual_suffix.to_s.dup.freeze,
+        session.selected_labels.map { |label| label.to_s.dup.freeze }.sort.freeze,
+        session.counts&.dup&.freeze,
+        screen.rows,
+        screen.cols,
+      ]
+    end
+
+    def prompt_popup_state(session)
+      [
+        popup_border,
+        session.title.to_s.dup.freeze,
+        session.message.to_s.dup.freeze,
+        session.field.prompt_text.to_s.dup.freeze,
+        session.field.buffer.text.to_s.dup.freeze,
+        session.field.buffer.cursor,
+        session.field.buffer.virtual_suffix.to_s.dup.freeze,
+        screen.rows,
+        screen.cols,
+      ]
+    end
+
+    def output_state(viewport:, lines:, highlights:)
+      {
+        top: viewport.top,
+        height: viewport.height,
+        width: viewport.respond_to?(:width) ? viewport.width : screen.output_rect.cols,
+        col: viewport.respond_to?(:col) ? viewport.col : 0,
+        lines: lines.map { |line| line.to_s.dup.freeze }.freeze,
+        highlights: normalized_highlights_state(highlights),
+        output_rows: screen.output_rect.rows,
+        output_cols: screen.output_rect.cols,
+      }.freeze
+    end
+
+    def pager_field_state(field, row:, role:)
+      [
+        input_field_state(field),
+        row,
+        role,
+        screen.output_rect.row,
+        screen.output_rect.rows,
+        screen.output_rect.cols,
+      ].freeze
+    end
+
+    def renderable_text(value)
+      renderable_parts(value).map { |part|
+        if part.is_a?(Hash) && part.key?(:text)
+          part[:text].to_s
+        else
+          part.to_s
+        end
+      }.join
+    end
+
+    def status_render_lines(text, width:, max_rows:)
+      width = [width.to_i, 1].max
+      max_rows = [max_rows.to_i, 1].max
+
+      lines =
+        renderable_text(text)
+          .to_s
+          .lines
+          .flat_map do |line|
+        wrap_status_line(line.chomp, width: width)
+      end
+
+      lines = [""] if lines.empty?
+      lines.last(max_rows)
+    end
+
+    def wrap_status_line(line, width:)
+      text = Fatty::Ansi.strip(line.to_s)
+      return [""] if text.empty?
+
+      chunks = []
+      rest = text.dup
+
+      until rest.empty?
+        chunk = Fatty::Ansi.truncate_visible(rest, width)
+        chunks << chunk
+        rest = rest[chunk.length..].to_s
+      end
+
+      chunks
+    end
+
+    def renderable_segments(value, role:)
+      renderable_parts(value).map do |part|
+        if part.is_a?(Hash) && part.key?(:text)
+          {
+            text: part[:text].to_s,
+            role: part[:role] || role,
+            style: part[:style],
+          }.compact
+        else
+          {
+            text: part.to_s,
+            role: role,
+          }
+        end
+      end
+    end
+
+    def renderable_parts(value)
+      value.is_a?(Array) ? value : [value]
+    end
+
+    def input_field_state(field)
+      [
+        field.prompt_text.to_s.dup.freeze,
+        field.buffer.text.to_s.dup.freeze,
+        field.buffer.cursor,
+        field.buffer.virtual_suffix.to_s.dup.freeze,
+        field.buffer.region_active?,
+        field.buffer.region_range,
+        screen.input_rect.row,
+        screen.input_rect.cols,
+      ]
+    end
+
+    def popup_counts_text(session)
+      counts = session.counts
+
+      "#{counts[:total]} total · " \
+        "#{counts[:selected]} selected · " \
+        "#{counts[:matching]} matching · " \
+        "#{counts[:showing]} showing"
+    end
+
+    def popup_border
+      spec = popup_frame_spec
+
+      border = (spec[:border] || spec["border"] || :single).to_sym
+      corners = (spec[:corners] || spec["corners"] || :square).to_sym
+
+      edge = FRAME_STYLES.fetch(border, FRAME_STYLES[:single])
+      corner_set = CORNER_STYLES.fetch(corners, CORNER_STYLES[:square])
+      corner =
+        corner_set[border] ||
+        corner_set[:single] ||
+        CORNER_STYLES[:square][border] ||
+        CORNER_STYLES[:square][:single]
+
+      {
+        h: edge[:h],
+        v: edge[:v],
+        tl: corner[:tl],
+        tr: corner[:tr],
+        bl: corner[:bl],
+        br: corner[:br],
+      }
+    end
+
+    def popup_frame_spec
+      palette[:popup_frame] || {}
+    rescue StandardError => e
+      Fatty.warn("Could not resolve popup frame style: #{e.class}: #{e.message}", tag: :theme)
+      {}
+    end
+
+    def status_line(text, width:)
+      msg = text.to_s.tr("\r\n", " ")
+      msg.ljust(width)[0, width]
+    end
+
+    def pager_field_line(field, width:)
+      prompt = field.prompt_text.to_s
+      buf_text = field.buffer.text.to_s
+      text = (prompt + buf_text).tr("\r\n", "")
+      visible = Fatty::Ansi.plain_text(text)
+
+      visible[0, width].ljust(width)
+    end
+
+    def normalized_highlights(highlights)
+      return if highlights.nil?
+
+      highlights.each_with_object({}) do |(line_no, ranges), out|
+        out[line_no] =
+          Array(ranges).map do |r|
+          if r.is_a?(Hash)
+            [r[:from].to_i, r[:to].to_i, (r[:role] || :primary).to_sym]
+          else
+            [r[0].to_i, r[1].to_i, (r[2] || :primary).to_sym]
+          end
+        end
+      end
+    end
+
+    def normalized_highlights_state(highlights)
+      deep_state(highlights)
+    end
+
+    def deep_state(value)
+      case value
+      when Hash
+        value.to_h do |key, val|
+          [deep_state(key), deep_state(val)]
+        end.freeze
+      when Array
+        value.map { |item| deep_state(item) }.freeze
+      when String
+        value.dup.freeze
+      else
+        value
+      end
+    end
+
+    def highlight_ranges_for_line(highlights, abs_line)
+      return [] unless highlights
+
+      raw = highlights[abs_line]
+      return [] unless raw
+
+      # Accept any of:
+      #   [[from,to], ...]
+      #   [[from,to,:primary], [from,to,:secondary], ...]
+      #   [{from:, to:, role:}, ...]
+      ranges =
+        Array(raw).map do |r|
+          if r.is_a?(Hash)
+            [r[:from].to_i, r[:to].to_i, (r[:role] || :primary).to_sym]
+          else
+            a = r[0].to_i
+            b = r[1].to_i
+            role = (r[2] || :primary).to_sym
+            [a, b, role]
+          end
+        end
+
+      ranges.sort_by!(&:first)
+      ranges
+    end
+
+    def field_segments(field, base_role:, suggestion_role: :input_suggestion, region_role: :region)
+      buf = field.buffer
+      text = buf.text.to_s
+      segments = [{ text: field.prompt_text.to_s, role: base_role }]
+
+      region =
+        if buf.respond_to?(:region_range)
+          buf.region_range
+        end
+
+      if region && region.begin < region.end
+        max = text.length
+        s = region.begin.clamp(0, max)
+        e = region.end.clamp(0, max)
+
+        segments << { text: text[0...s].to_s, role: base_role }
+        segments << { text: text[s...e].to_s, role: region_role }
+        segments << { text: text[e..].to_s, role: base_role }
+      else
+        segments << { text: text, role: base_role }
+      end
+
+      suffix = buf.virtual_suffix.to_s
+      segments << { text: suffix, role: suggestion_role } unless suffix.empty?
+
+      segments.reject { |seg| seg[:text].empty? }
+    end
+
+    def sync_backgrounds!
+      nil
+    end
+  end
+end
+
+require_relative 'renderer/curses.rb'
+require_relative 'renderer/truecolor.rb'

data/lib/fatty/screen.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Fatty
+  # Screen is a backend-neutral layout model.
+  #
+  # It describes terminal geometry (rows/cols) and the logical regions that
+  # Fatty draws into (output/input/alert). Screen does not perform any IO
+  # and does not depend on curses.
+  #
+  # Curses uses Screen to allocate resources (windows) and to understand where
+  # drawing should occur.
+  class Screen
+    Rect = Struct.new(:row, :col, :rows, :cols, keyword_init: true) do
+      def bottom
+        row + rows
+      end
+
+      def right
+        col + cols
+      end
+    end
+
+    attr_reader :rows, :cols
+    attr_reader :output_rect
+    attr_reader :input_rect
+    attr_reader :alert_rect
+    attr_reader :status_rect
+
+    def initialize(rows:, cols:, status_rows: 0)
+      resize(rows: rows, cols: cols, status_rows: status_rows)
+    end
+
+    # Update the terminal geometry and recompute the layout.
+    def resize(rows:, cols:, status_rows: 0)
+      @rows = rows
+      @cols = cols
+      layout!(status_rows: status_rows)
+      self
+    end
+
+    # --- Regions ----------------------------------------------------------
+
+    private
+
+    # Default layout:
+    # - status: 1 row above input (when it has content)
+    # - input:  1 row above alert
+    # - alert:  1 bottom row
+    # - output: all remaining rows
+    #
+    # If the terminal is too small, clamp to non-negative sizes.
+    def layout!(status_rows: 0)
+      status_rows = status_rows.to_i
+      status_rows = 0 if status_rows.negative?
+
+      alert_rows = rows >= 1 ? 1 : 0
+      input_rows = rows >= 2 ? 1 : 0
+      status_rows = 0 if rows < 3
+
+      alert_row = rows - alert_rows
+      input_row = alert_row - input_rows
+      status_row = input_row - status_rows
+
+      @alert_rect = Rect.new(
+        row: [alert_row, 0].max,
+        col: 0,
+        rows: alert_rows,
+        cols: cols,
+      )
+
+      @input_rect = Rect.new(
+        row: [input_row, 0].max,
+        col: 0,
+        rows: input_rows,
+        cols: cols,
+      )
+
+      @status_rect = Rect.new(
+        row: [status_row, 0].max,
+        col: 0,
+        rows: status_rows,
+        cols: cols,
+      )
+
+      output_rows = status_row
+      output_rows = 0 if output_rows.negative?
+
+      @output_rect = Rect.new(
+        row: 0,
+        col: 0,
+        rows: output_rows,
+        cols: cols,
+      )
+    end
+  end
+end

data/lib/fatty/search.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Fatty
+  module Search
+    extend self
+
+    # Split query into white-space-separated terms.
+    def split_terms(query)
+      query.to_s.strip.split(/\s+/).reject(&:empty?)
+    end
+
+    # Return the haystack items that match all the space-separated terms in
+    # query, regarless of order or case.
+    def match_all_terms?(haystack, query)
+      terms = split_terms(query)
+      return true if terms.empty?
+
+      text = haystack.to_s.downcase
+      terms.all? { |term| text.include?(term.downcase) }
+    end
+
+    def compile_regexp(pattern, regex: false)
+      return Regexp.new(pattern) if regex
+
+      terms = split_terms(pattern)
+      flags = pattern.match?(/[[:upper:]]/) ? 0 : Regexp::IGNORECASE
+      return Regexp.new("", flags) if terms.empty?
+
+      lookaheads =
+        terms.map { |term|
+          "(?=.*#{Regexp.escape(term)})"
+        }.join
+
+      Regexp.new("#{lookaheads}.*", flags)
+    end
+
+    def compile_term_regexps(pattern)
+      terms = split_terms(pattern)
+      flags = pattern.match?(/[A-Z]/) ? 0 : Regexp::IGNORECASE
+      terms.map { |term| Regexp.new(Regexp.escape(term), flags) }
+    end
+  end
+end

data/lib/fatty/session/alert_session.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Fatty
+  # A pinned, non-interactive overlay session responsible for rendering alerts.
+  #
+  # It is intentionally dumb:
+  #   - Terminal does not special-case alerts
+  #   - other sessions emit commands like:
+  #       [:send, :alert, :show, { level:, message: }]
+  #       [:send, :alert, :clear, {}]
+  class AlertSession < Session
+    attr_reader :current
+
+    def initialize
+      super(views: [Fatty::AlertView.new(z: 1_000)])
+      @current = nil
+    end
+
+    def id
+      :alert
+    end
+
+    private
+
+    def update_cmd(name, payload)
+      payload ||= {}
+      case name
+      when :show
+        show_from_payload(payload)
+      when :clear
+        @current = nil unless @current&.sticky?
+      end
+      []
+    end
+
+    def show_from_payload(payload)
+      return if payload.nil?
+
+      if payload.is_a?(Fatty::Alert)
+        @current = payload
+        return
+      end
+
+      level   = (payload[:level] || :info).to_sym
+      message = (payload[:message] || payload[:text]).to_s
+      details = payload[:details]
+      sticky  = !!payload[:sticky]
+
+      @current = Fatty::Alert.new(level: level, message: message, details: details, sticky: sticky)
+    end
+  end
+end

data/lib/fatty/session/input_session.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Fatty
+  class InputSession < Session
+    attr_reader :field
+
+    # @param on_accept: ->(line, session, terminal) { ... }
+    def initialize(field:, keymap:, views: [], on_accept: nil)
+      super(keymap: keymap, views: views)
+      @field = field
+      @on_accept = on_accept
+    end
+
+    #########################################################################################
+    # Framework and Session Hooks
+    #########################################################################################
+
+    def keymap_contexts
+      if paging_mode?
+        [:paging, :text, :terminal]
+      else
+        [:text, :terminal]
+      end
+    end
+
+    ############################################################################################
+    # Actions
+    ############################################################################################
+
+    action_on :session
+
+    action :input_accept do
+      line = @field.accept_line
+
+      if @on_accept
+        Array(@on_accept.call(line, self, terminal))
+      else
+        Array(emit([:accept_line, line]))
+      end
+    end
+
+    action :input_cycle_theme do
+      [[:terminal, :cycle_theme]]
+    end
+
+    private
+
+    # Unbound keys land here.
+    def update_key(ev)
+      []
+    end
+
+    def update_cmd(name, payload)
+      case name
+      when :paste
+        text = payload.fetch(:text, "").to_s
+        env = action_env(event: nil)
+        field.act_on(:paste, text, env: env)
+      end
+      []
+    end
+
+    # Bound keys land here because Session#update resolves via keymap first.
+    def handle_action(action, args, event:)
+      which =
+        if event&.respond_to?(:key)
+          event.key.inspect
+        elsif event&.respond_to?(:mouse)
+          event.mouse.inspect
+        end
+      Fatty.debug("InputSession#handle_action: #{which}", tag: :session)
+      env = action_env(event: event)
+
+      with_virtual_suffix_sync do
+        Fatty::Actions.call(action, env, *args)
+      end
+      []
+    rescue ActionError => e
+      Fatty.error("InputSession#handle_action: ActionError #{e.message}", tag: :session)
+      []
+    end
+
+    def action_env(event:)
+      ActionEnvironment.new(
+        session: self,
+        terminal: terminal,
+        event: event,
+        field: @field,
+      )
+    end
+
+    def with_virtual_suffix_sync
+      @field.sync_virtual_suffix!
+      result = yield
+      @field.sync_virtual_suffix!
+      result
+    end
+  end
+end