fatty 0.99.0 → 0.99.3

data/lib/fatty/renderer/curses.rb

@@ -11,50 +11,44 @@ module Fatty
         super
       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
-
-        win = context.status_win
-        return unless win
-
-        rows = screen.status_rect.rows
-        cols = screen.status_rect.cols
-        base_attr = pair_attr(role, fallback: ::Curses::A_REVERSE)
-
-        win.bkgdset(base_attr) if win.respond_to?(:bkgdset)
-        win.erase
-        win.attrset(base_attr)
-
-        status_render_lines(text, width: cols, max_rows: rows).each_with_index do |line, row|
-          win.setpos(row, 0)
-          rendered = Fatty::Ansi.truncate_visible(line, cols)
-          padding = [cols - Fatty::Ansi.visible_length(rendered), 0].max
-          win.addstr(rendered + (" " * padding))
-        end
-        stage_window(win)
+        draw_status_lines(status_session)
       end
 
-      def render_output(output, viewport:, highlights: nil)
-        lines = viewport.slice(output.lines)
-        normalized = normalized_highlights(highlights)
-
-        curr = output_state(
-          viewport: viewport,
-          lines: lines,
-          highlights: normalized,
-        )
+      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)
         prev = @last_output_state
 
-        if prev && can_incrementally_scroll_output?(prev, curr)
-          scroll_output_window_delta!(prev: prev, curr: curr)
+        if prev &&
+           !output_session.line_numbers? &&
+           !ansi_lines?(lines) &&
+           output_session.incrementally_scrollable_from?(prev, curr)
+          scroll_output_window_delta!(
+            delta: output_session.scroll_delta_from(prev, curr),
+            lines: lines,
+            viewport: viewport,
+            highlights: normalized,
+          )
         else
-          draw_output_lines(lines, viewport: viewport, highlights: normalized)
+          draw_output_lines(
+            lines,
+            viewport: viewport,
+            highlights: normalized,
+            line_number_width: line_number_width,
+          )
         end
-
+        @last_pager_field_state = nil
         @last_output_state = curr
       end
 
@@ -91,8 +85,21 @@ module Fatty
         stage_window(win)
       end
 
-      def render_alert(alert)
-        state = alert_state(alert)
+      def clear_input_field
+        @last_input_state = nil
+
+        win = context.input_win
+        return unless win
+
+        attr = pair_attr(:input, fallback: ::Curses::A_NORMAL)
+        win.bkgdset(attr) if win.respond_to?(:bkgdset)
+        win.erase
+        win.attrset(attr)
+        stage_window(win)
+      end
+
+      def render_alert(alert_session)
+        state = alert_state(alert_session)
         return if state == @last_alert_state
 
         @last_alert_state = state
@@ -100,17 +107,32 @@ module Fatty
         win = context.alert_win
         return unless win
 
+        alert = alert_session.current
         text = alert ? alert.format : ""
-        text = Fatty::Ansi.strip(text)
-        role = alert ? alert.role : :alert
-        attr = pair_attr(role, fallback: pair_attr(:alert, fallback: ::Curses::A_REVERSE))
+        role = alert ? alert_role(alert.role) : :alert_info
+        base_attr = pair_attr(role, fallback: pair_attr(:alert, fallback: ::Curses::A_REVERSE))
         cols = win.respond_to?(:maxx) ? win.maxx : screen.alert_rect.cols
 
-        win.bkgdset(attr) if win.respond_to?(:bkgdset)
+        win.bkgdset(base_attr) if win.respond_to?(:bkgdset)
         win.erase
-        win.attrset(attr)
+        win.attrset(base_attr)
         win.setpos(0, 0)
-        win.addstr(text.ljust(cols)[0, cols])
+
+        segments = Fatty::Ansi.segment(text).map do |segment_text, style|
+          {
+            text: segment_text,
+            role: role,
+            style: style,
+          }
+        end
+
+        draw_status_row(
+          win,
+          row: 0,
+          cols: cols,
+          segments: segments,
+          base_attr: base_attr,
+        )
 
         stage_window(win)
       end
@@ -155,12 +177,14 @@ module Fatty
         field_win&.close if field_win&.respond_to?(:close)
       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
 
@@ -178,16 +202,7 @@ module Fatty
 
         win.attrset(frame_attr)
         draw_popup_frame(win, width: width, height: height)
-
-        if session.title && !session.title.empty?
-          title = Fatty::Ansi.strip(session.title.to_s).tr("\r\n", " ")
-          title = Fatty::Ansi.truncate_visible(" #{title} ", [width - 4, 0].max)
-
-          unless title.empty?
-            win.setpos(0, 2)
-            win.addstr(title)
-          end
-        end
+        render_popup_title(win, session: session, width: width)
 
         inner_h = height - 2
         inner_w = width - 2
@@ -197,72 +212,58 @@ module Fatty
         inner.bkgdset(popup_attr) if inner.respond_to?(:bkgdset)
         inner.erase
 
-        row = 0
-
-        if session.message && !session.message.empty?
-          message = Fatty::Ansi.strip(session.message.to_s).tr("\r\n", " ")
-          message = Fatty::Ansi.truncate_visible(message, inner_w)
+        row = render_popup_message(inner, session: session, row: 0, width: inner_w, attr: popup_attr)
 
-          inner.attrset(popup_attr)
-          inner.setpos(row, 0)
-          inner.addstr(message.ljust(inner_w))
-          row += 1
-        end
+        counts_present = session.counts_present?
+        filter_present = session.filter_present?
 
-        counts_present = !!session.counts
-        input_row = inner_h - 1
-        counts_row = counts_present ? input_row - 1 : nil
+        input_row = inner_h - 1 if filter_present
+        counts_row =
+          if counts_present
+            filter_present ? input_row - 1 : inner_h - 1
+          end
 
         list_row = row
-        list_h = input_row - list_row
-        list_h -= 1 if counts_present
-        list_h = [list_h, 0].max
-
-        items = session.displayed
-        selected = session.selected
-        start = session.scroll_start(list_h: list_h)
-
-        (0...list_h).each do |offset|
-          item_index = start + offset
-          item_selected = item_index == selected
-          attr = item_selected ? selected_attr : popup_attr
-
-          line = ""
-          if item_index < items.length
-            item = items[item_index]
-            gutter = session.gutter_for(item: item, selected: item_selected)
-            text = Fatty::Ansi.strip(item.to_s).tr("\r\n", " ")
-            available = [inner_w - Fatty::Ansi.visible_length(gutter), 0].max
-            text = Fatty::Ansi.truncate_visible(text, available)
-            line = Fatty::Ansi.truncate_visible(gutter + text, inner_w)
+        list_end =
+          if counts_present
+            counts_row
+          elsif filter_present
+            input_row
+          else
+            inner_h
           end
 
-          inner.attrset(attr)
-          inner.setpos(list_row + offset, 0)
-          inner.addstr(line.ljust(inner_w))
-        end
-
-        if counts_present && counts_row && counts_row >= 0
-          counts_text = Fatty::Ansi.truncate_visible(popup_counts_text(session), inner_w)
+        list_h = [list_end - list_row, 0].max
 
-          inner.attrset(counts_attr)
-          inner.setpos(counts_row, 0)
-          inner.addstr(counts_text.ljust(inner_w))
-        end
+        render_popup_items(
+          inner,
+          session: session,
+          row: list_row,
+          height: list_h,
+          width: inner_w,
+          popup_attr: popup_attr,
+          selected_attr: selected_attr,
+        )
 
-        render_field_into(
-          win: inner,
-          field: session.field,
-          row: input_row,
+        render_popup_counts(
+          inner,
+          session: session,
+          row: counts_row,
           width: inner_w,
-          base_role: :popup_input,
-          base_attr: input_attr,
-          region_attr: pair_attr(:region, fallback: ::Curses::A_REVERSE),
-          suggestion_attr: pair_attr(:input_suggestion, fallback: input_attr),
+          attr: counts_attr,
         )
 
-        cursor_x = session.field.cursor_x.to_i.clamp(0, [inner_w - 1, 0].max)
-        win.setpos(1 + input_row, 1 + cursor_x)
+        if filter_present
+          render_popup_filter(
+            inner,
+            session: session,
+            row: input_row,
+            width: inner_w,
+            attr: input_attr,
+          )
+          cursor_x = session.field.cursor_x.to_i.clamp(0, [inner_w - 1, 0].max)
+          win.setpos(1 + input_row, 1 + cursor_x)
+        end
 
         stage_window(win)
       rescue RuntimeError => e
@@ -275,11 +276,6 @@ module Fatty
       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
 
@@ -331,6 +327,7 @@ module Fatty
         )
 
         cursor_x = session.field.cursor_x.to_i.clamp(0, [inner_w - 1, 0].max)
+        show_cursor
         win.setpos(1 + input_row, 1 + cursor_x)
 
         stage_window(inner)
@@ -382,15 +379,117 @@ module Fatty
         stage_window(win)
       end
 
+      def hide_cursor
+        ::Curses.curs_set(0)
+        self
+      end
+
+      def show_cursor
+        ::Curses.curs_set(1)
+        self
+      end
+
       private
 
+      # simplecov:disable
+
+      def render_popup_title(win, session:, width:)
+        return unless session.title && !session.title.empty?
+
+        title = Fatty::Ansi.strip(session.title.to_s).tr("\r\n", " ")
+        title = Fatty::Ansi.truncate_visible(" #{title} ", [width - 4, 0].max)
+        return if title.empty?
+
+        win.setpos(0, 2)
+        win.addstr(title)
+      end
+
+      def render_popup_message(win, session:, row:, width:, attr:)
+        return row unless session.message && !session.message.empty?
+
+        message = Fatty::Ansi.strip(session.message.to_s).tr("\r\n", " ")
+        message = Fatty::Ansi.truncate_visible(message, width)
+        render_popup_plain_row(win, row: row, width: width, text: message, attr: attr)
+
+        row + 1
+      end
+
+      def render_popup_items(win, session:, row:, height:, width:, popup_attr:, selected_attr:)
+        items = session.displayed
+        selected = session.current
+        start = session.scroll_start(list_h: height)
+
+        (0...height).each do |offset|
+          item_index = start + offset
+          item_selected = item_index == selected
+          attr = item_selected ? selected_attr : popup_attr
+          text = popup_item_text(session, items: items, item_index: item_index, selected: item_selected, width: width)
+
+          render_popup_plain_row(
+            win,
+            row: row + offset,
+            width: width,
+            text: text,
+            attr: attr,
+          )
+        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(win, session:, row:, width:, attr:)
+        return unless row && row >= 0
+
+        text = Fatty::Ansi.truncate_visible(popup_counts_text(session), width)
+        render_popup_plain_row(win, row: row, width: width, text: text, attr: attr)
+      end
+
+      def render_popup_filter(win, session:, row:, width:, attr:)
+        render_popup_plain_row(win, row: row, width: width, text: "", attr: attr)
+
+        render_field_into(
+          win: win,
+          field: session.field,
+          row: row,
+          width: width,
+          base_role: :popup_input,
+          base_attr: attr,
+          region_attr: pair_attr(:region, fallback: ::Curses::A_REVERSE),
+          suggestion_attr: pair_attr(:input_suggestion, fallback: attr),
+        )
+      end
+
+      def render_popup_plain_row(win, row:, width:, text:, attr:)
+        line = Fatty::Ansi.truncate_visible(text.to_s, width)
+        line = line.ljust(width)
+
+        win.attrset(attr)
+        win.setpos(row, 0)
+        win.addstr(line)
+      end
+
       def available_colors
         ::Curses.colors
       end
 
+      def ansi_lines?(lines)
+        lines.any? { |line| line.to_s.include?("\e[") }
+      end
+
       def after_apply_theme!
-        @ansi_pair_cache = {}
-        @next_ansi_pair_id = nil
         context.apply_palette(palette)
       end
 
@@ -409,49 +508,105 @@ module Fatty
           delta != 0 && delta.abs < curr[:height]
       end
 
-      def scroll_output_window_delta!(prev:, curr:)
+      def scroll_output_window_delta!(delta:, lines:, viewport:, highlights:)
         Fatty.debug("calling scroll_output_window_delta!", tag: :scrolling)
         win = context.output_win
-        delta = curr[:top] - prev[:top]
-        base_attr = pair_attr(:output, fallback: ::Curses::A_NORMAL)
+        return unless win
 
+        height = viewport.height
+        base_attr = pair_attr(:output, fallback: ::Curses::A_NORMAL)
         win.attrset(base_attr)
         win.scrl(delta)
-
-        if delta > 0
-          start_y = curr[:height] - delta
+        if delta.positive?
+          start_y = height - delta
           start_y = 0 if start_y < 0
 
-          (start_y...curr[:height]).each do |y|
-            line = curr[:lines][y]
-            abs_line = curr[:top] + y
+          (start_y...height).each do |y|
             draw_output_row(
               win,
-              line: line,
+              line: lines[y],
               y: y,
-              abs_line: abs_line,
-              highlights: curr[:highlights],
+              abs_line: viewport.top + y,
+              highlights: highlights,
             )
           end
         else
           count = -delta
-          count = curr[:height] if count > curr[:height]
+          count = height if count > height
+
           (0...count).each do |y|
-            line = curr[:lines][y]
-            abs_line = curr[:top] + y
             draw_output_row(
               win,
-              line: line,
+              line: lines[y],
               y: y,
-              abs_line: abs_line,
-              highlights: curr[:highlights],
+              abs_line: viewport.top + y,
+              highlights: highlights,
             )
           end
         end
         stage_window(win)
       end
 
-      def draw_output_lines(lines, viewport:, highlights: nil)
+      def draw_status_lines(status_session)
+        win = context.status_win
+        return unless win
+
+        rect = screen.status_rect
+        base_attr = pair_attr(status_session.role, fallback: ::Curses::A_REVERSE)
+        lines = status_segment_lines(status_session)
+        win.bkgdset(base_attr) if win.respond_to?(:bkgdset)
+        win.erase
+        rect.rows.times do |row|
+          draw_status_row(
+            win,
+            row: row,
+            cols: rect.cols,
+            segments: lines[row] || [],
+            base_attr: base_attr,
+          )
+        end
+        stage_window(win)
+      end
+
+      def draw_status_row(win, row:, cols:, segments:, base_attr:)
+        win.setpos(row, 0)
+        remaining = cols
+
+        segments.each do |segment|
+          break if remaining <= 0
+
+          text = segment[:text].to_s.tr("\r\n", " ")
+          text = Fatty::Ansi.truncate_visible(text, remaining)
+          next if text.empty?
+
+          segment_role = segment[:role] || :status
+          role_attr = pair_attr(segment_role, fallback: base_attr)
+
+          attr =
+            if segment[:style]
+              ansi_style_attr(
+                segment[:style],
+                fallback: role_attr,
+                fallback_role: segment_role,
+              )
+            else
+              role_attr
+            end
+
+          win.attrset(attr)
+          win.addstr(text)
+          remaining -= Fatty::Ansi.visible_length(text)
+        end
+
+        if remaining.positive?
+          win.attrset(base_attr)
+          win.addstr(" " * remaining)
+        end
+      end
+
+      def draw_output_lines(lines, viewport:, highlights: nil, line_number_width: nil)
+        context.reset_ansi_pairs!
+
         win = context.output_win
         base_attr = pair_attr(:output, fallback: ::Curses::A_NORMAL)
 
@@ -459,40 +614,48 @@ module Fatty
         win.bkgdset(base_attr) if win.respond_to?(:bkgdset)
         win.erase
 
-        lines.each_with_index do |line, y|
-          abs_line = viewport.top + y
+        lines.each_with_index do |visible_line, y|
           draw_output_row(
             win,
-            line: line,
+            line: visible_line.text,
             y: y,
-            abs_line: abs_line,
+            abs_line: visible_line.number - 1,
             highlights: highlights,
+            line_number: visible_line.number,
+            line_number_width: line_number_width,
           )
         end
         stage_window(win)
       end
 
-      def draw_output_row(win, line:, y:, abs_line:, highlights:)
+      def draw_output_row(win, line:, y:, abs_line:, highlights:, line_number: nil, line_number_width: nil)
         base_attr = pair_attr(:output, fallback: ::Curses::A_NORMAL)
+        line_number_attr = base_attr | ::Curses::A_DIM
         hi_attr = pair_attr(:match_current, fallback: ::Curses::A_REVERSE)
         hi2_attr = pair_attr(:match_other, fallback: hi_attr)
 
         semantic_ranges = highlight_ranges_for_line(highlights, abs_line)
         win.setpos(y, 0)
         win.attrset(base_attr)
+
+        line_number_attr = pair_attr(:line_number, fallback: base_attr | ::Curses::A_DIM)
+        if line_number && line_number_width
+          number_text = line_number.to_s.rjust(line_number_width, "0")
+          win.attrset(line_number_attr)
+          win.addstr("#{number_text}: ")
+          win.attrset(base_attr)
+        end
+
         curses_ranges =
           Array(semantic_ranges).map do |from, to, role|
-            attr =
-              case role
-              when :secondary then hi2_attr
-              else hi_attr
-              end
-            [from.to_i, to.to_i, attr]
-          end
-        # plain = Fatty::Ansi.plain_text(line.to_s)
-        # slices = build_line_slices(plain, ranges: curses_ranges) do |_style|
-        #   base_attr
-        # end
+          attr =
+            case role
+            when :secondary then hi2_attr
+            else hi_attr
+            end
+          [from.to_i, to.to_i, attr]
+        end
+
         slices = build_line_slices(line.to_s, ranges: curses_ranges) do |style|
           ansi_style_attr(style, fallback: base_attr)
         end
@@ -625,13 +788,16 @@ module Fatty
           break if remaining <= 0
 
           attr =
-            case segment[:role]
-            when :region then region_attr
-            when :input_suggestion then suggestion_attr
-            else base_attr
+            if segment[:style]
+              ansi_style_attr(segment[:style], fallback: base_attr, fallback_role: base_role)
+            else
+              case segment[:role]
+              when :region then region_attr
+              when :input_suggestion then suggestion_attr
+              else base_attr
+              end
             end
-
-          text = Fatty::Ansi.strip(segment[:text].to_s).tr("\r\n", " ")
+          text = segment[:text].to_s.tr("\r\n", " ")
           text = Fatty::Ansi.truncate_visible(text, remaining)
           next if text.empty?
 
@@ -641,18 +807,27 @@ module Fatty
         end
       end
 
-      def ansi_style_attr(style, fallback:)
+      def ansi_style_attr(style, fallback:, fallback_role: :output)
         attr = fallback
+
         if style.fg || style.bg
           fg = curses_color_for_style(style.fg)
           bg = curses_color_for_style(style.bg)
 
-          output_spec = palette[:output] || {}
-          fg = output_spec[:fg] if fg.nil?
-          bg = output_spec[:bg] if bg.nil?
+          role_spec = palette[fallback_role] || palette[:output] || {}
+          fg = role_spec[:fg] if fg.nil?
+          bg = role_spec[:bg] if bg.nil?
 
-          attr = ::Curses.color_pair(ansi_pair_for(fg, bg))
+          fallback_pair_id = Fatty::Colors::Pairs::ROLE_TO_PAIR.fetch(fallback_role)
+          pair_id = context.ansi_pair_for(
+            fg,
+            bg,
+            fallback_pair_id: fallback_pair_id,
+          )
+
+          attr = ::Curses.color_pair(pair_id)
         end
+
         attr |= ::Curses::A_BOLD if style.bold
         attr |= ::Curses::A_DIM if style.respond_to?(:dim) && style.dim
         attr |= ::Curses::A_UNDERLINE if style.underline
@@ -673,25 +848,6 @@ module Fatty
           )
         end
       end
-
-      def ansi_pair_for(fg, bg)
-        @ansi_pair_cache ||= {}
-        key = [fg.to_i, bg.to_i]
-
-        @ansi_pair_cache[key] ||=
-          begin
-            pair_id = next_ansi_pair_id
-            ::Curses.init_pair(pair_id, fg.to_i, bg.to_i)
-            pair_id
-          end
-      end
-
-      def next_ansi_pair_id
-        @next_ansi_pair_id ||= Fatty::Colors::Pairs::ROLE_TO_PAIR.values.max + 1
-        id = @next_ansi_pair_id
-        @next_ansi_pair_id += 1
-        id
-      end
     end
   end
 end