fatty 0.99.0 → 0.99.3

data/lib/fatty/renderer/truecolor.rb

@@ -9,38 +9,26 @@ module Fatty
         super
         @ansi_renderer = Fatty::Ansi::Renderer.new
         @pending_ansi_draws = []
+        @cursor_visible = true
       end
 
-      def render_status(text, role: :status_info)
-        state = status_state(text, role)
+      def render_status(status_session)
+        state = status_state(status_session)
         return if state == @last_status_state
 
         @last_status_state = state
 
-        lines = status_render_lines(
-          text,
-          width: screen.status_rect.cols,
-          max_rows: screen.status_rect.rows,
-        )
-
-        screen.status_rect.rows.times do |idx|
-          queue_ansi_line(
-            row: screen.status_rect.row + idx,
-            col: screen.status_rect.col,
-            width: screen.status_rect.cols,
-            text: lines[idx].to_s,
-            role: role,
-          )
-        end
+        draw_status_lines(status_session)
       end
 
-      def render_alert(alert)
-        state = alert_state(alert)
+      def render_alert(alert_session)
+        state = alert_state(alert_session)
         return if state == @last_alert_state
 
+        alert = alert_session.current
         @last_alert_state = state
         text = alert ? alert.format : ""
-        role = alert ? alert.role : :alert_info
+        role = alert ? alert_role(alert.role) : :alert_info
 
         queue_ansi_line(
           row: screen.alert_rect.row,
@@ -51,18 +39,24 @@ module Fatty
         )
       end
 
-      def render_output(output, viewport:, highlights: nil)
-        lines = viewport.slice(output.lines)
-        normalized = normalized_highlights(highlights)
+      def render_output(output_session, viewport: output_session.viewport)
+        lines = viewport.slice(output_session.visible_lines)
+        normalized = normalized_highlights(output_session.highlights)
+        line_number_width =
+          if output_session.line_numbers?
+            output_session.output.lines.length.to_s.length
+          end
+
+        curr = output_state(output_session, viewport: viewport)
+        return if curr == @last_output_state
 
-        curr = output_state(
+        draw_output_lines(
+          lines,
           viewport: viewport,
-          lines: lines,
           highlights: normalized,
+          line_number_width: line_number_width,
         )
-        return if curr == @last_output_state
-
-        draw_output_lines(lines, viewport: viewport, highlights: normalized)
+        @last_pager_field_state = nil
         @last_output_state = curr
       end
 
@@ -85,12 +79,22 @@ module Fatty
         )
       end
 
+      def clear_input_field
+        @last_input_state = nil
+        queue_ansi_line(
+          row: screen.input_rect.row,
+          col: screen.input_rect.col,
+          width: screen.input_rect.cols,
+          text: "",
+          role: :input,
+        )
+      end
+
       def render_pager_field(field, row:, role: :pager_status)
         state = pager_field_state(field, row: row, role: role)
         return if state == @last_pager_field_state
 
         @last_pager_field_state = state
-
         win = context.output_win
         return unless win
 
@@ -98,7 +102,6 @@ module Fatty
         return unless row0 && col0
 
         cols = win.respond_to?(:maxx) ? win.maxx : @screen.cols
-
         queue_ansi_segments_line(
           row: row0 + row,
           col: col0,
@@ -113,12 +116,14 @@ module Fatty
         )
       end
 
+      # Modal overlays, render_popup and render_prompt_popu are deliberately
+      # not state-cached.
+      #
+      # They must be restaged on every frame because they are drawn on top of the
+      # focused session. Even when the overlay's own state has not changed, the
+      # underlying session may have redrawn the area beneath it. Skipping the overlay
+      # render would let the underlying frame erase or visually punch through it.
       def render_popup(session:)
-        state = popup_state(session)
-        return if state == @last_popup_state
-
-        @last_popup_state = state
-
         win = session.win
         return unless win
 
@@ -140,33 +145,43 @@ module Fatty
         layout = PopupLayout.new(row: 0, width: inner_w)
         row = render_popup_message(session: session, layout: layout)
 
-        counts_present = !!session.counts
-        input_row = inner_h - 1
-        counts_row = counts_present ? input_row - 1 : nil
-
         # Draw the displayed items inside the window with a gutter to have an
         # indicator of what is selected, if any.
-        list_h = [inner_h - row - 1 - (counts_present ? 1 : 0), 0].max
+        filter_present = session.filter_present?
+        counts_present = session.counts_present?
+        input_row = filter_present ? inner_h - 1 : nil
+        counts_row =
+          if counts_present
+            filter_present ? input_row - 1 : inner_h - 1
+          end
+
+        list_end =
+          if counts_present
+            counts_row
+          elsif filter_present
+            input_row
+          else
+            inner_h
+          end
+        list_h = [list_end - row, 0].max
+
         layout = PopupLayout.new(row: row, width: inner_w, height: list_h)
         render_popup_items(session: session, layout: layout)
 
         # Draw the "counts" line to indicate the total number of items, items
         # selected, and items displayed.
         layout = PopupLayout.new(row: counts_row, width: inner_w)
-        render_popup_counts(session: session, layout: layout) if counts_present
+        render_popup_counts(session: session, layout: layout) if session.counts_present?
 
-        # Draw the input field for the user to type narrowing selection
-        # queries.
-        layout = PopupLayout.new(row: input_row, width: inner_w)
-        render_popup_input_field(session: session, layout: layout)
+        if filter_present
+          # Draw the input field for the user to type narrowing selection
+          # queries.
+          layout = PopupLayout.new(row: input_row, width: inner_w)
+          render_popup_input_field(session: session, layout: layout)
+        end
       end
 
       def render_prompt_popup(session:)
-        state = prompt_popup_state(session)
-        return if state == @last_prompt_popup_state
-
-        @last_prompt_popup_state = state
-
         win = session.win
         return unless win
 
@@ -184,6 +199,7 @@ module Fatty
         row = render_popup_message(session: session, layout: layout)
 
         layout = PopupLayout.new(row: row, width: inner_w)
+        show_cursor
         render_popup_input_field(session: session, layout: layout)
       rescue RuntimeError => e
         raise unless e.message.include?("closed window") ||
@@ -208,11 +224,27 @@ module Fatty
       end
 
       def restore_cursor(field)
+        return self unless @cursor_visible
+
         rect = screen.input_rect
         x = field.cursor_x.to_i.clamp(0, [rect.cols - 1, 0].max)
         queue_ansi_cursor(row: rect.row, col: rect.col + x)
       end
 
+      def show_cursor
+        @cursor_visible = true
+        ::Curses.curs_set(1)
+        @ansi_renderer.write_ansi(@ansi_renderer.hide_cursor)
+        self
+      end
+
+      def hide_cursor
+        @cursor_visible = false
+        ::Curses.curs_set(0)
+        @ansi_renderer.write_ansi(@ansi_renderer.hide_cursor)
+        self
+      end
+
       # In truecolor mode, curses windows must still have themed backgrounds.
       # ncurses may repaint or expose its backing store during getch/doupdate,
       # so we must keep the backing store visually consistent with ANSI output.
@@ -229,8 +261,28 @@ module Fatty
         self
       end
 
+      # Restore cursor into the output window at a specific *output-win* row.
+      # `row:` is 0..(screen.output_rect.rows-1), NOT an absolute screen row.
+      def restore_output_cursor(field, row:)
+        return self unless @cursor_visible
+
+        cols = @screen.cols
+        x = field.cursor_x.to_i
+        x = x.clamp(0, [cols - 1, 0].max)
+        row0 = @screen.output_rect.row
+        col0 = @screen.output_rect.col
+        cols = @screen.output_rect.cols
+        @pending_ansi_draws << {
+          type: :cursor,
+          row: row0 + row,
+          col: col0 + x.clamp(0, [cols - 1, 0].max),
+        }
+      end
+
       private
 
+      # simplecov:disable
+
       def sync_window_background(win, role)
         return unless win
 
@@ -332,24 +384,32 @@ module Fatty
         return unless win
 
         items = session.displayed
-        sel = session.selected
+        selected = session.current
         start = session.scroll_start(list_h: layout.height)
-        row = layout.row
-
-        (0...layout.height).each do |i|
-          idx = start + i
-          selected = idx == sel
-          role = selected ? :popup_selection : :popup
-          line = ""
-          if idx < items.length
-            item = items[idx]
-            gutter = session.gutter_for(item: item, selected: selected)
-            avail = [layout.width - gutter.length, 0].max
-            line = (gutter + item.to_s[0, avail])[0, layout.width]
-          end
+
+        (0...layout.height).each do |offset|
+          item_index = start + offset
+          item_selected = item_index == selected
+          role = item_selected ? :popup_selection : :popup
+
+          line = popup_item_text(
+            session,
+            items: items,
+            item_index: item_index,
+            selected: item_selected,
+            width: layout.width,
+          )
+
+          queue_ansi_popup_fill_row(
+            win: win,
+            inner_row: layout.row + offset,
+            width: layout.width,
+            role: role,
+          )
+
           queue_ansi_popup_line(
             win: win,
-            inner_row: row + i,
+            inner_row: layout.row + offset,
             width: layout.width,
             text: line,
             role: role,
@@ -357,6 +417,21 @@ module Fatty
         end
       end
 
+      def popup_item_text(session, items:, item_index:, selected:, width:)
+        line = ""
+
+        if item_index < items.length
+          item = items[item_index]
+          gutter = session.gutter_for(item: item, selected: selected)
+          text = Fatty::Ansi.strip(item.to_s).tr("\r\n", " ")
+          available = [width - Fatty::Ansi.visible_length(gutter), 0].max
+          text = Fatty::Ansi.truncate_visible(text, available)
+          line = Fatty::Ansi.truncate_visible(gutter + text, width)
+        end
+
+        line
+      end
+
       def render_popup_counts(session:, layout:)
         win = session.win
         return unless win
@@ -378,6 +453,14 @@ module Fatty
 
         row = win.origin[0] + 1 + layout.row
         col = win.origin[1] + 1
+
+        queue_ansi_popup_fill_row(
+          win: win,
+          inner_row: layout.row,
+          width: layout.width,
+          role: :popup_input,
+        )
+
         queue_ansi_segments_line(
           row: row,
           col: col,
@@ -390,6 +473,7 @@ module Fatty
           ),
           fill_role: :popup_input,
         )
+
         cursor_x = session.field.cursor_x.to_i.clamp(0, [layout.width - 1, 0].max)
         queue_ansi_cursor(row: row, col: col + cursor_x)
       end
@@ -421,24 +505,50 @@ module Fatty
         }
       end
 
-      def draw_output_lines(lines, viewport:, highlights: nil)
+      def draw_output_lines(lines, viewport:, highlights: nil, line_number_width: nil)
         rect = screen.output_rect
 
         rect.rows.times do |y|
-          line = lines[y].to_s
-          abs_line = viewport.top + y
+          visible_line = lines[y]
+          text = visible_line&.text.to_s
+          abs_line = visible_line ? visible_line.number - 1 : nil
           ranges = highlight_ranges_for_line(highlights, abs_line)
+          segments = []
+
+          if visible_line && line_number_width
+            number_text = visible_line.number.to_s.rjust(line_number_width, "0")
+            segments << {
+              text: "#{number_text}: ",
+              role: :line_number,
+            }
+          end
 
+          segments.concat(output_segments(text, ranges: ranges))
           queue_ansi_segments_line(
             row: rect.row + y,
             col: rect.col,
             width: rect.cols,
-            segments: output_segments(line, ranges: ranges),
+            segments: segments,
             fill_role: :output,
           )
         end
       end
 
+      def draw_status_lines(status_session)
+        rect = screen.status_rect
+        lines = status_segment_lines(status_session)
+
+        rect.rows.times do |y|
+          queue_ansi_segments_line(
+            row: rect.row + y,
+            col: rect.col,
+            width: rect.cols,
+            segments: lines[y] || [],
+            fill_role: status_session.role,
+          )
+        end
+      end
+
       def output_segments(line, ranges:)
         plain = Fatty::Ansi.plain_text(line.to_s)
         base_segments = []
@@ -495,113 +605,106 @@ module Fatty
 
         out.reject { |seg| seg[:text].empty? }
       end
-    end
 
-    # Restore cursor into the output window at a specific *output-win* row.
-    # `row:` is 0..(screen.output_rect.rows-1), NOT an absolute screen row.
-    def restore_output_cursor(field, row:)
-      cols = @screen.cols
-
-      x = field.cursor_x.to_i
-      x = x.clamp(0, [cols - 1, 0].max)
-
-      row0 = @screen.output_rect.row
-      col0 = @screen.output_rect.col
-      cols = @screen.output_rect.cols
-
-      @pending_ansi_draws << {
-        type: :cursor,
-        row: row0 + row,
-        col: col0 + x.clamp(0, [cols - 1, 0].max),
-      }
-    end
-
-    def queue_ansi_popup_line(win:, inner_row:, inner_col: 0, width:, text:, role:)
-      row, col = win.origin
-      return unless row && col
-
-      queue_ansi_line(
-        row: row + 1 + inner_row,
-        col: col + 1 + inner_col,
-        width: width,
-        text: text.to_s,
-        role: role,
-      )
-    end
-
-    def queue_ansi_segments_line(row:, col:, width:, segments:, fill_role: :output)
-      @pending_ansi_draws << {
-        type: :segments_line,
-        row: row,
-        col: col,
-        width: width,
-        segments: segments,
-        fill_role: fill_role,
-      }
-      nil
-    end
-
-    def queue_ansi_line(row:, col:, width:, text:, role: nil)
-      spec = palette[role] || {}
-      @pending_ansi_draws << {
-        row: row,
-        col: col,
-        width: width,
-        text: text,
-        role: role,
-        spec: spec,
-      }
-    end
-
-    def queue_ansi_rect(row:, col:, width:, height:, role:)
-      return if height <= 0 || width <= 0
+      def queue_ansi_popup_line(win:, inner_row:, inner_col: 0, width:, text:, role:)
+        row, col = win.origin
+        return unless row && col
 
-      height.times do |i|
         queue_ansi_line(
-          row: row + i,
+          row: row + 1 + inner_row,
+          col: col + 1 + inner_col,
+          width: width,
+          text: text.to_s,
+          role: role,
+        )
+      end
+
+      def queue_ansi_segments_line(row:, col:, width:, segments:, fill_role: :output)
+        @pending_ansi_draws << {
+          type: :segments_line,
+          row: row,
           col: col,
           width: width,
+          segments: segments,
+          fill_role: fill_role,
+        }
+        nil
+      end
+
+      def queue_ansi_popup_fill_row(win:, inner_row:, inner_col: 0, width:, role:)
+        queue_ansi_popup_line(
+          win: win,
+          inner_row: inner_row,
+          inner_col: inner_col,
+          width: width,
           text: " " * width,
           role: role,
         )
       end
-      nil
-    end
 
-    def flush_ansi_draws
-      Fatty.debug("flush_ansi_draws pending_count=#{@pending_ansi_draws.length}", tag: :render)
-
-      # Hide the cursor
-      @ansi_renderer.write_ansi("\e[?25l")
-
-      @pending_ansi_draws.each do |draw|
-        case draw[:type]
-        when :cursor
-          @ansi_renderer.write_ansi("\e[#{draw[:row] + 1};#{draw[:col] + 1}H")
-        when :segments_line
-          @ansi_renderer.render_segments_line(
-            row: draw[:row],
-            col: draw[:col],
-            width: draw[:width],
-            segments: draw[:segments],
-            palette: palette,
-            fill_role: draw[:fill_role] || :output,
-          )
-        else
-          @ansi_renderer.render_line(
-            row: draw[:row],
-            col: draw[:col],
-            width: draw[:width],
-            text: draw[:text],
-            role: draw[:role],
-            palette: palette,
+      def queue_ansi_line(row:, col:, width:, text:, role: nil)
+        spec = palette[role] || {}
+        @pending_ansi_draws << {
+          row: row,
+          col: col,
+          width: width,
+          text: text,
+          role: role,
+          spec: spec,
+        }
+      end
+
+      def queue_ansi_rect(row:, col:, width:, height:, role:)
+        return if height <= 0 || width <= 0
+
+        height.times do |i|
+          queue_ansi_line(
+            row: row + i,
+            col: col,
+            width: width,
+            text: " " * width,
+            role: role,
           )
         end
+        nil
+      end
+
+      def flush_ansi_draws
+        Fatty.debug("flush_ansi_draws pending_count=#{@pending_ansi_draws.length}", tag: :render)
+
+        # Hide the cursor
+        @ansi_renderer.write_ansi("\e[?25l")
+
+        @pending_ansi_draws.each do |draw|
+          case draw[:type]
+          when :cursor
+            if @cursor_visible
+              @ansi_renderer.write_ansi("\e[#{draw[:row] + 1};#{draw[:col] + 1}H")
+            end
+          when :segments_line
+            @ansi_renderer.render_segments_line(
+              row: draw[:row],
+              col: draw[:col],
+              width: draw[:width],
+              segments: draw[:segments],
+              palette: palette,
+              fill_role: draw[:fill_role] || :output,
+            )
+          else
+            @ansi_renderer.render_line(
+              row: draw[:row],
+              col: draw[:col],
+              width: draw[:width],
+              text: draw[:text],
+              role: draw[:role],
+              palette: palette,
+            )
+          end
+        end
+        @pending_ansi_draws.clear
+      ensure
+        @ansi_renderer.write_ansi(@cursor_visible ? "\e[?25h" : "\e[?25l")
       end
-      @pending_ansi_draws.clear
-    ensure
-      # Unhide the cursor
-      @ansi_renderer.write_ansi("\e[?25h")
     end
   end
 end