fatty 0.99.0

data/lib/fatty/session/isearch_session.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module Fatty
+  class ISearchSession < Session
+    action_on :session
+
+    attr_reader :field, :direction
+
+    def id = :isearch
+
+    DEFAULT_ISEARCH_HISTORY_FILE = File.expand_path("~/.fatty_search_history")
+    DEFAULT_ISEARCH_HISTORY_MAX  = 200
+
+    def initialize(direction: :forward, last_pattern: nil, history: nil)
+      super(keymap: Keymaps.emacs, views: [])
+
+      @direction = direction.to_sym
+      @failed = false
+      @last_text = nil
+      @last_pattern = last_pattern.to_s
+
+      @field = Fatty::InputField.new(
+        prompt: Prompt.new { isearch_prompt },
+        history: history,
+        history_kind: :search_string,
+        # ? history_ctx: -> { { session: "pager_isearch" } },
+      )
+    end
+
+    #########################################################################################
+    # Framework and Session Hooks
+    #########################################################################################
+
+    def keymap_contexts
+      [:isearch, :text, :terminal]
+    end
+
+    def view(screen:, renderer:)
+      row = screen.output_rect.rows - 1
+
+      ::Curses.curs_set(1)
+      renderer.render_pager_field(@field, row: row, role: :search_input)
+      renderer.restore_output_cursor(@field, row: row)
+    end
+
+    ############################################################################################
+    # Actions
+    ############################################################################################
+
+    desc "Return the line so far as the search string"
+    action :isearch_accept do
+      accept!
+    end
+
+    desc "Quit the I-Search session"
+    action :isearch_cancel do
+      cancel!
+    end
+
+    desc "Move to the next matching text"
+    action :isearch_next do
+      step_next!
+    end
+
+    desc "Move to the prior matching text"
+    action :isearch_prev do
+      step_prev!
+    end
+
+    private
+
+    def update_cmd(name, payload)
+      cmds = []
+      case name
+      when :isearch_set_failed
+        @failed = !!payload[:failed]
+        @field.prompt = isearch_prompt
+      end
+      cmds
+    end
+
+    def action_env(event:)
+      ActionEnvironment.new(
+        session: self,
+        counter: counter,
+        event: event,
+        buffer: @field.buffer,
+        field: @field,
+      )
+    end
+
+    def handle_action(action, args, event:)
+      env = action_env(event: event)
+
+      if Fatty::Actions.lookup(action)&.fetch(:on) == :session
+        Fatty::Actions.call(action, env, *args)
+      else
+        @field.act_on(action, *args, env: env)
+        maybe_preview!
+      end
+    rescue Fatty::ActionError
+      []
+    end
+
+    def isearch_prompt
+      base = @failed ? "Failing I-search: " : "I-search: "
+      arrow = @direction == :backward ? "↑ " : "↓ "
+      arrow + base
+    end
+
+    def accept!
+      pattern = @field.accept_line.to_s
+      cmds = []
+      cmds << [:terminal, :send_modal_owner, [:cmd, :pager_isearch_commit, { pattern: pattern, direction: @direction }]]
+      cmds << [:terminal, :pop_modal]
+      cmds
+    end
+
+    def cancel!
+      [[:terminal, :send_modal_owner, [:cmd, :pager_isearch_cancel, {}]], [:terminal, :pop_modal]]
+    end
+
+    def step_next!
+      @direction = :forward
+      cmds = []
+      cmds.concat(prefill_last_pattern_if_empty!)
+      cmds << [:terminal, :send_modal_owner, [:cmd, :pager_isearch_step, { direction: @direction }]]
+      cmds
+    end
+
+    def step_prev!
+      @direction = :backward
+      cmds = []
+      cmds.concat(prefill_last_pattern_if_empty!)
+      cmds << [:terminal, :send_modal_owner, [:cmd, :pager_isearch_step, { direction: @direction }]]
+      cmds
+    end
+
+    def prefill_last_pattern_if_empty!
+      current = @field.buffer.text.to_s
+      pat = @last_pattern.to_s
+      return [] unless current.empty?
+      return [] if pat.strip.empty?
+
+      env = ActionEnvironment.new(
+        session: self,
+        counter: counter,
+        event: nil,
+        buffer: @field.buffer,
+        field: @field,
+      )
+
+      # Replace buffer contents with the last pattern, then preview immediately.
+      @field.act_on(:replace, pat, env: env)
+      maybe_preview!
+    end
+
+    def maybe_preview!
+      text = @field.buffer.text.to_s
+      return [] if @last_text == text
+
+      @last_text = text.dup
+      [
+        [
+          :terminal,
+          :send_modal_owner,
+          [:cmd, :pager_isearch_update, { pattern: text, direction: @direction }],
+        ]
+      ]
+    end
+  end
+end

data/lib/fatty/session/keytest_session.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+
+module Fatty
+  class KeyTestSession < Session
+    def id = :keytest
+
+    def initialize(owner: nil)
+      super(keymap: nil, views: [])
+      @owner = owner
+    end
+
+    def init(terminal:)
+      super
+      @suggestions = []
+      @owner ||= terminal.focused_session
+      show_quit_status
+      force_scrolling_output!
+      append <<~TEXT
+        Key test mode
+
+        Press keys to inspect Fatty's decoding and binding resolution.
+        Press q, ESC, or C-g to leave key test mode.
+
+      TEXT
+      []
+    end
+
+    def update_key(ev)
+      if quit_key?(ev)
+        append "Leaving key test mode.\n\n"
+        return [[:terminal, :pop_modal]]
+      end
+
+      # append "  TERM:      #{terminal_name}\n"
+      append ev.report
+      snippet = ev.suggested_snippet(terminal_name)
+      append snippet + "\n"
+      @suggestions << snippet unless snippet.empty?
+      show_quit_status
+      []
+    end
+
+    def view(screen:, renderer:)
+      # Intentionally blank. The underlying shell session renders the output
+      # pane; this modal only captures keys and appends diagnostic text.
+      nil
+    end
+
+    def close
+      write_suggestions!
+      restore_owner_pager!
+      terminal.clear_status if terminal.respond_to?(:clear_status)
+      nil
+    end
+
+    private
+
+    def append(text)
+      return unless @owner&.respond_to?(:append_output)
+
+      force_scrolling_output!
+
+      before = @owner.output.lines.length
+      @owner.append_output(text.to_s, follow: false)
+
+      height = @owner.viewport.height.to_i
+      added = @owner.output.lines.length - before
+
+      if added >= height
+        @owner.viewport.top = before
+        @owner.viewport.clamp!(@owner.output.lines)
+      else
+        @owner.viewport.page_bottom(@owner.output.lines)
+      end
+
+      terminal.renderer.reset_frame_cache if terminal.respond_to?(:renderer)
+    end
+
+    def force_scrolling_output!
+      if @owner&.respond_to?(:pager)
+        @owner.pager.paging_to_scrolling
+      end
+    end
+
+    def quit_key?(ev)
+      ev.key == :q ||
+        ev.key == :escape ||
+        (ev.key == :g && ev.ctrl?)
+    end
+
+    def terminal_name
+      env =
+        if terminal.respond_to?(:env)
+          terminal.env
+        else
+          terminal.instance_variable_get(:@env)
+        end
+
+      env && env[:terminal] || ENV.fetch("TERM", "unknown")
+    end
+
+    def show_quit_status
+      terminal.warn("KeyTest — press q, ESC, or C-g to quit  (TERM: #{terminal_name})")
+    end
+
+    def write_suggestions!
+      suggestions = @suggestions.uniq
+      return if suggestions.empty?
+
+      path = File.join(Dir.tmpdir, "fatty-keytest-#{Time.now.strftime('%Y%m%d-%H%M%S')}.yml")
+
+      File.write(path, suggestion_file_text(suggestions))
+
+      append <<~TEXT
+        =======================================================
+        KeyTest suggestions written to:
+        #{path}
+
+      TEXT
+
+      terminal.good("KeyTest suggestions written to #{path}")
+    end
+
+    def suggestion_file_text(suggestions)
+      out = <<~TEXT
+        # Fatty keytest suggestions
+        # Generated at #{Time.now}
+
+        KEYNAMES
+
+        Known/common key names for keydefs.yml/keybindings.yml:
+      TEXT
+
+      Fatty::Curses.valid_keynames.each do |name|
+        out << "   #{name}\n"
+      end
+
+      out << <<~TEXT
+
+        Printable keys are also valid key names, for example:
+          a
+          y
+          ]
+          /
+        Use ctrl/meta/shift flags in keybindings.yml for modifiers.
+
+        NOTE: You can also define additional key names in keydefs.yml.
+        For example: if your terminal reports code 652 for the Pause key:
+
+         terminal:
+           tmux:
+             map:
+               652:
+                 key: pause
+
+         Then you can bind it to an action in keybindings.yml:
+
+         - key: pause
+           action: your_action
+
+        ACTIONS
+
+        Valid action names for keybindings.yml:
+
+        NOTE: Fatty also supports user-defined actions. The extension mechanism is still
+        evolving; see README.md for the current plugin/action registration details.
+      TEXT
+
+      Fatty::Actions.catalog_by_target.each do |target, names|
+        out << "\n"
+        out << "#{target} actions:\n"
+
+        names.each do |name|
+          out << "   #{name}\n"
+        end
+      end
+
+      out << <<~TEXT
+
+        CONTEXTS
+
+        Valid contexts for keybindings.yml:\n
+      TEXT
+
+      Fatty::KeyMap.valid_contexts.each do |name|
+        out << "    #{name}\n"
+      end
+
+      out << <<~TEXT
+         If context is omitted, the default is #{Fatty::KeyMap::DEFAULT_CONTEXT}.
+
+         MOUSE EVENTS
+
+         Mouse events may also be bound in keybindings.yml, for example:
+
+         - mouse: <BUTTONNAME>
+           context: paging
+           action: page_up
+
+        Where <BUTTONNAME> is one of:
+          scroll_up
+          scroll_down
+          left_pressed,
+          left_released,
+          left_clicked,
+          left_double_clicked,
+          left_triple_clicked,
+          middle_pressed,
+          middle_released,
+          middle_clicked,
+          middle_double_clicked,
+          middle_triple_clicked,
+          right_pressed,
+          right_released,
+          right_clicked,
+          right_double_clicked,
+          right_triple_clicked
+
+        All of which may also be combined with modifiers: ctrl, meta, and shift.
+
+      TEXT
+      out << "\n"
+      out << suggestions.join("\n\n")
+      out << "\n"
+      out
+    end
+
+    def restore_owner_pager!
+      if @owner&.respond_to?(:pager)
+        @owner.pager.quit_paging
+      end
+    end
+  end
+end

data/lib/fatty/session/modal_session.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Fatty
+  class ModalSession < Session
+    attr_reader :win
+    private attr_writer :win
+
+    def close
+      Fatty.debug("#{self.class}#close: object_id=#{object_id}", tag: :session)
+      old_win = win
+      self.win = nil
+      safely_close_window(old_win)
+      nil
+    end
+
+    def handle_resize
+      rebuild_windows!
+      []
+    end
+
+    def rebuild_windows!
+      old_win = win
+      self.win = nil
+      safely_close_window(old_win)
+
+      cols = ::Curses.cols
+      rows = ::Curses.lines
+      width, height = geometry(cols: cols, rows: rows)
+      x = (cols - width) / 2
+      y = (rows - height) / 2
+      self.win = ::Curses::Window.new(height, width, y, x)
+      nil
+    end
+
+    # Return the outer width and height of the window for this modal,
+    # including any padding and borders.
+    def geometry(cols:, rows:)
+      raise NotImplementedError, "#{self.class} must implement #geometry"
+    end
+
+    # Common helpers for computing geometry
+
+    def max_width(cols:, margin:, min_width:)
+      [cols - (margin * 2), min_width].max
+    end
+
+    def max_height(rows:, margin:, min_height:)
+      [rows - (margin * 2), min_height].max
+    end
+
+    def clamp_width(width, max_width:, hard_max: nil)
+      width = [width, max_width].min
+      width = [width, hard_max].min if hard_max
+      width
+    end
+
+    def clamp_height(height, max_height:, min_height:)
+      height.clamp(min_height, max_height)
+    end
+  end
+end

data/lib/fatty/session/output_session.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Fatty
+  class OutputSession < Session
+    attr_reader :output, :viewport, :pager, :pager_field
+
+    def initialize(keymap: nil, views: [])
+      super(keymap: keymap, views: views)
+      @output   = Fatty::OutputBuffer.new(max_lines: 500_000)
+      @viewport = Fatty::Viewport.new(height: 10)
+      mode = Fatty::Config.config.dig(:output, :mode)&.to_sym || :paging
+      @default_output_mode = mode
+      @pager = Fatty::Pager.new(output: @output, viewport: @viewport, mode: mode)
+      @pager_field = Fatty::InputField.new(prompt: -> { pager_status_prompt })
+    end
+
+    def append_output(text, follow: true)
+      ntrim = @output.append(text.to_s)
+      @pager.on_append(ntrim: ntrim)
+
+      # When callers request follow behavior (scrolling mode),
+      # keep the viewport at the bottom unless paging is actively paused.
+      if follow && !@pager.paused?
+        case @pager.mode
+        when :scrolling
+          @viewport.page_bottom(@output.lines)
+        end
+      end
+      ntrim
+    end
+
+    def reset_output!
+      @output.lines.clear
+      @viewport.reset
+    end
+
+    def resize_output!
+      was_at_bottom = pager.at_bottom?
+      @viewport.height = terminal.screen.output_rect.rows
+      pager.preserve_after_resize!(was_at_bottom: was_at_bottom)
+    end
+
+    def reset_for_command!
+      reset_output!
+      mode = @default_output_mode # Fatty::Config.config.dig(:output, :mode)&.to_sym || :paging
+      @pager.reset!(mode: mode)
+    end
+
+    # True when the pager is currently holding the screen (i.e., paging mode is
+    # active and the output is paused).
+    def pager_active?
+      @pager.reserve_prompt_row?
+    end
+
+    # When the pager is active, the last output row is reserved for the pager
+    # InputField. This returns the viewport to use for rendering the output
+    # content itself.
+    def pager_viewport
+      if pager_active? && @viewport.height > 1
+        Fatty::Viewport.new(top: @viewport.top, height: @viewport.height - 1)
+      else
+        @viewport
+      end
+    end
+
+    def pager_status_prompt
+      total = @output.lines.length
+      visible_h = pager_active? ? pager.page_height : @viewport.height
+      bottom = [@viewport.top + visible_h, total].min
+      pct =
+        if total.positive?
+          ((bottom * 100.0) / total).round
+        end
+
+      search = pager.search_label
+      search = "  [#{search}]" if search && !search.empty?
+      if pct
+        "  #{pager.nav_arrow} --More--  #{bottom}/#{total} (#{pct}%)#{search} "
+      else
+        "  #{pager.nav_arrow} --More--  #{bottom}#{search} "
+      end
+    end
+
+    def reset_pager!
+      # Start the next command from the bottom of existing scrollback.
+      @viewport.page_bottom(@output.lines)
+      @pager.reset!(total_lines: @output.lines.length, mode: @default_output_mode)
+    end
+
+    def follow_output!
+      pager.end_of_output
+      []
+    end
+
+    def page_output_from_top!
+      pager.page_top
+      []
+    end
+
+    def page_output_from_bottom!
+      pager.page_bottom
+      []
+    end
+  end
+end