fatty 0.99.0 → 0.99.3

data/lib/fatty/session/output_session.rb

@@ -2,20 +2,384 @@
 
 module Fatty
   class OutputSession < Session
+    VisibleLine = Data.define(:number, :text) do
+      def to_s
+        text.to_s
+      end
+    end
+
+    action_on :session
+
     attr_reader :output, :viewport, :pager, :pager_field
 
-    def initialize(keymap: nil, views: [])
-      super(keymap: keymap, views: views)
+    def initialize(id: nil, keymap: nil, history: nil)
+      super(keymap: keymap)
       @output   = Fatty::OutputBuffer.new(max_lines: 500_000)
       @viewport = Fatty::Viewport.new(height: 10)
+      @history = history || Fatty::History.for_path(:default)
+      @line_numbers = false
+      @narrow_query = nil
+      @visible_lines = nil
       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 = Fatty::Pager.new(output: @output, viewport: @viewport, mode: mode, lines: -> { visible_lines })
       @pager_field = Fatty::InputField.new(prompt: -> { pager_status_prompt })
     end
 
+    #########################################################################################
+    # Session Protocol
+    #########################################################################################
+
+    def init(terminal:)
+      super
+    end
+
+    def update(command)
+      log_update(command)
+      payload = command.payload
+      commands =
+        case command.action
+        when :key
+          ev = payload.fetch(:event)
+          action, args = resolve_action(ev)
+          if action
+            apply_action(action, args, event: ev)
+          else
+            []
+          end
+        when :append
+          case payload[:mode]
+          when :scrolling
+            pager.toggle_paging_mode if pager.mode == :paging
+          when :paging
+            pager.toggle_paging_mode if pager.mode == :scrolling
+          end
+          before = output.lines.length
+          append_output(
+            payload.fetch(:text, ""),
+            follow: payload.fetch(:follow, true),
+          )
+          reveal_appended_block(before) if payload[:scroll]
+          []
+        when :set_mode
+          case payload.fetch(:mode).to_sym
+          when :scrolling
+            pager.set_to_scrolling
+          when :paging
+            pager.set_to_paging
+          end
+          []
+        when :clear
+          reset_output!
+          []
+        when :resize
+          resize_output!
+          []
+        when :begin_command
+          reset_for_command!
+          pager.begin_command!(anchor: output.lines.length)
+          []
+        when :finish_command
+          pager.finish_command!
+          []
+        when :quit_paging
+          pager.quit
+          [Command.terminal(:refresh_layout)]
+        when :pager_search_set
+          update_pager_search_set(payload)
+        when :pager_search_step
+          update_pager_search_step(payload)
+        when :pager_search_cancel
+          pager.search_cancel!
+          []
+        when :pager_search_commit
+          pager.search_commit!
+          []
+        when :pager_isearch_update
+          update_pager_isearch_update(payload)
+        when :pager_isearch_step
+          update_pager_isearch_step(payload)
+        when :pager_isearch_cancel
+          pager.isearch_cancel!
+          [Command.session(:isearch, :isearch_set_failed, failed: false)]
+        when :pager_isearch_commit
+          update_pager_isearch_commit(payload)
+        when :prompt_result
+          apply_prompt_result(payload)
+        when :prompt_cancelled
+          []
+        else
+          []
+        end
+      Array(commands)
+    end
+
+    def view
+      Fatty.debug(
+        "OutputSession#view id=#{id} pager_active=#{pager_active?} output_rect=#{renderer.screen.output_rect.inspect}",
+        tag: :render,
+      )
+      if pager_active?
+        renderer.hide_cursor
+        renderer.render_output(self, viewport: pager_status_viewport(renderer.screen))
+        renderer.render_pager_field(
+          pager_field,
+          row: renderer.screen.output_rect.rows - 1,
+          role: :pager_status,
+        )
+      else
+        renderer.render_output(self)
+      end
+    end
+
+    def tick
+      dirty = false
+      if pager.autoscroll?
+        step = [(viewport.height * 3) / 4, 1].max
+        dirty ||= pager.autoscroll_step?(max_lines: step)
+      end
+      dirty
+    end
+
+    #########################################################################################
+    # Actions
+    #########################################################################################
+
+    desc "Search pager forward"
+    action :pager_search_forward do
+      regex = consume_search_regex_flag
+      pager.search_begin!
+      searcher = Fatty::SearchSession.new(direction: :forward, regex: regex, history: @history)
+      Command.terminal(:push_modal, session: searcher, owner: self)
+    end
+
+    desc "Search pager backward"
+    action :pager_search_backward do
+      regex = consume_search_regex_flag
+      pager.search_begin!
+      searcher = Fatty::SearchSession.new(direction: :backward, regex: regex, history: @history)
+      Command.terminal(:push_modal, session: searcher, owner: self)
+    end
+
+    desc "Search pager forward with regex"
+    action :pager_regex_search_forward do
+      pager.search_begin!
+      searcher = Fatty::SearchSession.new(direction: :forward, regex: true, history: @history)
+      Command.terminal(:push_modal, session: searcher, owner: self)
+    end
+
+    desc "Search pager backward with regex"
+    action :pager_regex_search_backward do
+      pager.search_begin!
+      searcher = Fatty::SearchSession.new(direction: :backward, regex: true, history: @history)
+      Command.terminal(:push_modal, session: searcher, owner: self)
+    end
+
+    desc "Start incremental pager search forward"
+    action :pager_isearch_forward do
+      pager.isearch_begin!
+      isearcher = Fatty::ISearchSession.new(direction: :forward, history: @history, last_pattern: pager.search_pattern)
+      Command.terminal(:push_modal, session: isearcher, owner: self)
+    end
+
+    desc "Start incremental pager search backward"
+    action :pager_isearch_backward do
+      pager.isearch_begin!
+      isearcher = Fatty::ISearchSession.new(direction: :backward, history: @history, last_pattern: pager.search_pattern)
+      Command.terminal(:push_modal, session: isearcher, owner: self)
+    end
+
+    desc "Repeat pager search forward"
+    action :pager_search_next do
+      handle_search_result(pager.search_repeat_next!)
+    end
+
+    desc "Repeat pager search backward"
+    action :pager_search_prev do
+      handle_search_result(pager.search_repeat_prev!)
+    end
+
+    desc "Toggle output line numbers"
+    action :toggle_line_numbers do
+      @line_numbers = !@line_numbers
+      []
+    end
+
+    desc "Narrow output to matching lines"
+    action :narrow_output do
+      prompt = Fatty::PromptSession.new(
+        prompt: "Narrow: ",
+        title: "Narrow Output",
+        kind: :narrow_output,
+        history: @history,
+        history_ctx: :output_narrow,
+      )
+      Command.terminal(:push_modal, session: prompt, owner: self)
+    end
+
+    desc "Widen output"
+    action :widen_output do
+      clear_narrowing!
+      []
+    end
+
+    #########################################################################################
+    # Other public API methods
+    #########################################################################################
+
+    STATE_VIEWPORT = 0
+    STATE_LINES = 1
+
+    def state(viewport: @viewport)
+      [
+        viewport.state,
+        viewport.slice(visible_lines),
+        renderer.screen.output_rect.rows,
+        renderer.screen.output_rect.cols,
+        highlights,
+        renderer.theme_version,
+        line_numbers?,
+      ]
+    end
+
+    def visible_lines
+      @visible_lines ||=
+        if narrowed?
+          terms = narrow_query.split
+
+          output.lines.each_with_index.filter_map do |text, index|
+            visible_text = visible_output_text(text)
+            next unless terms.all? { |term| visible_text.include?(term) }
+
+            VisibleLine.new(number: index + 1, text: text)
+          end
+        else
+          output.lines.each_with_index.map do |text, index|
+            VisibleLine.new(number: index + 1, text: text)
+          end
+        end
+    end
+
+    def visible_output_text(text)
+      Fatty::Ansi.segment(text.to_s).map(&:first).join
+    end
+
+    def narrow_query
+      @narrow_query
+    end
+
+    def narrowed?
+      !@narrow_query.nil?
+    end
+
+    def apply_prompt_result(payload)
+      return [] unless payload[:kind].to_sym == :narrow_output
+
+      query = payload.fetch(:text, "").to_s
+      if query.empty?
+        clear_narrowing!
+      else
+        @narrow_query = query
+        invalidate_visible_lines!
+        viewport.top = 0
+        pager.clamp!
+      end
+      []
+    end
+
+    def clear_narrowing!
+      @narrow_query = nil
+      invalidate_visible_lines!
+      viewport.top = 0
+      pager.clamp!
+    end
+
+    def line_numbers?
+      @line_numbers
+    end
+
+    def incrementally_scrollable_from?(prev_state, curr_state)
+      prev_viewport = prev_state[STATE_VIEWPORT]
+      curr_viewport = curr_state[STATE_VIEWPORT]
+      prev_lines = prev_state[STATE_LINES]
+      curr_lines = curr_state[STATE_LINES]
+
+      delta = curr_viewport[0] - prev_viewport[0]
+      overlap = prev_lines.length - delta
+
+      delta.positive? &&
+      delta < curr_viewport[1] &&
+      overlap.positive? &&
+        prev_lines.drop(delta) == curr_lines.take(overlap)
+    end
+
+    def scroll_delta_from(prev_state, curr_state)
+      prev_viewport = prev_state[STATE_VIEWPORT]
+      curr_viewport = curr_state[STATE_VIEWPORT]
+
+      curr_viewport[0] - prev_viewport[0]
+    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.active?
+    end
+
+    def highlights
+      pager.search_visible_highlights(viewport: viewport)
+    end
+
+    private
+
+    # simplecov:disable
+
+    def invalidate_visible_lines!
+      @visible_lines = nil
+    end
+
+    def keymap_contexts
+      if pager.active?
+        [:paging, :terminal]
+      else
+        [:terminal]
+      end
+    end
+
+    def apply_action(action, args, event:)
+      env = ActionEnvironment.new(
+        session: self,
+        event: event,
+        counter: counter,
+        pager: pager,
+      )
+      result = pager.act_on(action, *args, env: env)
+      normalize_action_result(result)
+    rescue Fatty::ActionError => e
+      [alert_cmd(:error, e.message, ev: event)]
+    end
+
+    def reveal_appended_block(before)
+      added = output.lines.length - before
+      height = viewport.height.to_i
+
+      if added >= height
+        viewport.top = before
+        viewport.clamp!(output.lines)
+      else
+        viewport.page_bottom(output.lines)
+      end
+    end
+
+    def pager_status_viewport(screen)
+      vp = pager_viewport.dup
+      vp.height = [screen.output_rect.rows - 1, 1].max
+      vp
+    end
+
     def append_output(text, follow: true)
       ntrim = @output.append(text.to_s)
+      invalidate_visible_lines!
       @pager.on_append(ntrim: ntrim)
 
       # When callers request follow behavior (scrolling mode),
@@ -29,8 +393,89 @@ module Fatty
       ntrim
     end
 
+    def update_pager_search_set(payload)
+      pattern = payload.fetch(:pattern, "").to_s
+      regex = !!payload[:regex]
+      direction = (payload[:direction] || :forward).to_sym
+      result = pager.search_set!(pattern: pattern, regex: regex, direction: direction)
+
+      if result[:status] == :moved
+        pager.search_commit!
+      else
+        pager.search_cancel!
+      end
+
+      handle_search_result(result)
+    end
+
+    def update_pager_search_step(payload)
+      pattern = payload.fetch(:pattern, nil)
+      regex = !!payload[:regex]
+      direction = (payload[:direction] || :forward).to_sym
+
+      result =
+        if pattern
+          pager.search_set!(pattern: pattern, regex: regex, direction: direction)
+        else
+          pager.search_step!(direction: direction)
+        end
+
+      handle_search_result(result)
+    end
+
+    def update_pager_isearch_update(payload)
+      pattern = payload.fetch(:pattern, "").to_s
+      direction = (payload[:direction] || :forward).to_sym
+      result = pager.isearch_update!(pattern: pattern, direction: direction)
+
+      handle_search_result(result) <<
+        Command.session(:isearch, :isearch_set_failed, failed: result[:status] != :moved)
+    end
+
+    def update_pager_isearch_step(payload)
+      direction = (payload[:direction] || :forward).to_sym
+      result = pager.isearch_step!(direction: direction)
+
+      handle_search_result(result) <<
+        Command.session(:isearch, :isearch_set_failed, failed: result[:status] != :moved)
+    end
+
+    def update_pager_isearch_commit(payload)
+      pattern = payload.fetch(:pattern, "").to_s
+      direction = (payload[:direction] || :forward).to_sym
+      result = pager.isearch_accept!(pattern: pattern, direction: direction)
+
+      handle_search_result(result) <<
+        Command.session(:isearch, :isearch_set_failed, failed: false)
+    end
+
+    def handle_search_result(result)
+      return [] unless result.is_a?(Hash)
+
+      case result[:status]
+      when :boundary
+        msg = result[:message].to_s
+        msg = "Search reached boundary" if msg.empty?
+        [alert_cmd(:info, msg)]
+      when :not_found
+        [alert_cmd(:info, "No matches")]
+      else
+        []
+      end
+    end
+
+    def consume_search_regex_flag
+      regex = false
+      if counter.digits.to_s == "4"
+        regex = true
+        counter.clear!
+      end
+      regex
+    end
+
     def reset_output!
       @output.lines.clear
+      invalidate_visible_lines!
       @viewport.reset
     end
 
@@ -42,16 +487,11 @@ module Fatty
 
     def reset_for_command!
       reset_output!
+      @narrow_query = nil
       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.
@@ -64,20 +504,31 @@ module Fatty
     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
+      visible_total = visible_lines.length
+      original_total = output.lines.length
+      visible_h = pager_active? ? pager.page_height : viewport.height
+      bottom = [viewport.top + visible_h, visible_total].min
 
-      search = pager.search_label
-      search = "  [#{search}]" if search && !search.empty?
-      if pct
-        "  #{pager.nav_arrow} --More--  #{bottom}/#{total} (#{pct}%)#{search} "
+      if pager.scrolling?
+        "--Scrolling--"
       else
-        "  #{pager.nav_arrow} --More--  #{bottom}#{search} "
+        search = pager.search_label
+        pct =
+          if visible_total.positive?
+            ((bottom * 100.0) / visible_total).round
+          end
+        narrow =
+          if narrowed?
+            " narrowed #{visible_total}/#{original_total}"
+          else
+            ""
+          end
+
+        if pct
+          "  #{pager.nav_arrow} --More--  #{bottom}/#{visible_total} (#{pct}%)#{narrow}#{search} "
+        else
+          "  #{pager.nav_arrow} --More--  #{bottom}#{narrow}#{search} "
+        end
       end
     end