fatty 0.99.0 → 0.99.3

data/lib/fatty/renderer.rb

@@ -37,7 +37,7 @@ module Fatty
     POPUP_SELECTED_GUTTER = "▶ "
     POPUP_UNSELECTED_GUTTER = "  "
 
-    attr_reader :screen, :palette, :context
+    attr_reader :screen, :palette, :context, :theme_version
 
     def initialize(screen:, palette:, context:)
       @screen = screen
@@ -49,12 +49,14 @@ module Fatty
       @last_popup_state = nil
       @last_prompt_popup_state = nil
       @last_pager_field_state = nil
+      @theme_version = 0
     end
 
     attr_writer :screen
 
     def apply_theme!(theme)
       Fatty::Themes::Manager.set(theme)
+      @theme_version += 1
       theme_spec = Fatty::Themes::Manager.roles(Fatty::Themes::Manager.current) || {}
       @palette = Fatty::Colors::Palette.compile(theme_spec, available_colors: available_colors)
 
@@ -75,6 +77,14 @@ module Fatty
       raise NotImplementedError, "#{self.class} must implement #render_input_field"
     end
 
+    def clear_input_field(...)
+      raise NotImplementedError, "#{self.class} must implement #clear_input_field"
+    end
+
+    def restore_cursor(...)
+      raise NotImplementedError, "#{self.class} must implement #restore_cursor"
+    end
+
     def render_pager_field(...)
       raise NotImplementedError, "#{self.class} must implement #render_pager_field"
     end
@@ -98,10 +108,23 @@ module Fatty
       @last_status_state = nil
       @last_pager_field_state = nil
       @last_popup_state = nil
+      @last_prompt_popup_state = nil
+    end
+
+    def hide_cursor
+    end
+
+    def show_cursor
     end
 
     protected
 
+    # simplecov:disable
+
+    def alert_role(role)
+      :"alert_#{role}"
+    end
+
     def available_colors
       nil
     end
@@ -110,74 +133,37 @@ module Fatty
       nil
     end
 
-    def alert_state(alert)
-      [
-        alert&.message.dup.freeze,
-        alert&.role,
-        alert&.details,
-        screen.alert_rect.row,
-        screen.alert_rect.cols,
-      ]
+    def alert_state(session)
+      session.state
     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,
-      ]
+    def status_state(session)
+      session.state
     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,
+        session.state
       ]
     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,
+        session.state
       ]
     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
+    def output_state(session, viewport: session.viewport)
+      session.state(viewport: viewport)
+    end
+
+    def input_field_state(input_field)
+      [
+        input_field.state,
+        theme_version
+      ]
     end
 
     def pager_field_state(field, row:, role:)
@@ -201,20 +187,43 @@ module Fatty
       }.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)
+    def status_segment_lines(status_session)
+      segments = renderable_segments(
+        status_session.text,
+        role: status_session.role,
+      )
+      segment_lines(segments, width: screen.status_rect.cols)
+        .last(screen.status_rect.rows)
+    end
+
+    def segment_lines(segments, width:)
+      lines = [[]]
+      col = 0
+      segments.each do |segment|
+        text = segment[:text].to_s
+        text.each_line do |raw|
+          rest = raw.chomp
+          until rest.empty?
+            remaining = width - col
+            if remaining <= 0
+              lines << []
+              col = 0
+              remaining = width
+            end
+            piece = Fatty::Ansi.truncate_visible(rest, remaining)
+            break if piece.empty?
+
+            lines.last << segment.merge(text: piece)
+            col += Fatty::Ansi.visible_length(piece)
+            rest = rest[piece.length..].to_s
+          end
+          if raw.end_with?("\n")
+            lines << []
+            col = 0
+          end
+        end
       end
-
-      lines = [""] if lines.empty?
-      lines.last(max_rows)
+      lines
     end
 
     def wrap_status_line(line, width:)
@@ -234,18 +243,35 @@ module Fatty
     end
 
     def renderable_segments(value, role:)
-      renderable_parts(value).map do |part|
-        if part.is_a?(Hash) && part.key?(:text)
+      renderable_parts(value).flat_map do |part|
+        part_role =
+          if part.is_a?(Hash) && part.key?(:text)
+            part[:role] || role
+          else
+            role
+          end
+
+        text =
+          if part.is_a?(Hash) && part.key?(:text)
+            part[:text].to_s
+          else
+            part.to_s
+          end
+
+        if part.is_a?(Hash) && part[:style]
           {
-            text: part[:text].to_s,
-            role: part[:role] || role,
+            text: text,
+            role: part_role,
             style: part[:style],
-          }.compact
-        else
-          {
-            text: part.to_s,
-            role: role,
           }
+        else
+          Fatty::Ansi.segment(text).map do |segment_text, style|
+            {
+              text: segment_text,
+              role: part_role,
+              style: style,
+            }
+          end
         end
       end
     end
@@ -254,19 +280,6 @@ module Fatty
       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
 
@@ -327,12 +340,12 @@ module Fatty
       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]
+            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
     end
 
@@ -343,9 +356,7 @@ module Fatty
     def deep_state(value)
       case value
       when Hash
-        value.to_h do |key, val|
-          [deep_state(key), deep_state(val)]
-        end.freeze
+        value.to_h { |key, val| [deep_state(key), deep_state(val)] }.freeze
       when Array
         value.map { |item| deep_state(item) }.freeze
       when String
@@ -384,7 +395,14 @@ module Fatty
     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 }]
+      segments =
+        Fatty::Ansi.segment(field.prompt_text.to_s).map do |prompt_text, style|
+        {
+          text: prompt_text,
+          role: base_role,
+          style: style,
+        }
+      end
 
       region =
         if buf.respond_to?(:region_range)

data/lib/fatty/screen.rb

@@ -42,6 +42,8 @@ module Fatty
 
     private
 
+    # simplecov:disable
+
     # Default layout:
     # - status: 1 row above input (when it has content)
     # - input:  1 row above alert

data/lib/fatty/session/alert_session.rb

@@ -2,37 +2,56 @@
 
 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)])
+    def initialize(id: nil)
+      super
       @current = nil
     end
 
-    def id
-      :alert
-    end
-
-    private
+    #########################################################################################
+    # Session Protocol
+    #########################################################################################
 
-    def update_cmd(name, payload)
-      payload ||= {}
-      case name
+    def update(command)
+      Fatty.debug("AlertSession#update: action: #{command.action} alert: #{command.payload[:alert].inspect}")
+      case command.action
       when :show
-        show_from_payload(payload)
+        show_from_payload(command.payload[:alert] || command.payload)
       when :clear
         @current = nil unless @current&.sticky?
       end
       []
     end
 
+    def view
+      renderer.render_alert(self)
+    end
+
+    def state
+      [
+        current&.text.dup.freeze,
+        current&.role,
+        current&.details,
+        renderer.screen.alert_rect.row,
+        renderer.screen.alert_rect.cols,
+        renderer.theme_version
+      ]
+    end
+
+    private
+
+    # simplecov:disable
+
+    def clear
+      @current = nil
+    end
+
+    def visible?
+      !!current
+    end
+
     def show_from_payload(payload)
       return if payload.nil?
 
@@ -41,12 +60,11 @@ module Fatty
         return
       end
 
-      level   = (payload[:level] || :info).to_sym
-      message = (payload[:message] || payload[:text]).to_s
+      role = (payload[:role] || :info).to_sym
+      text = payload[:text].to_s
       details = payload[:details]
       sticky  = !!payload[:sticky]
-
-      @current = Fatty::Alert.new(level: level, message: message, details: details, sticky: sticky)
+      @current = Fatty::Alert.new(role: role, text: text, details: details, sticky: sticky)
     end
   end
 end

data/lib/fatty/session/isearch_session.rb

@@ -4,7 +4,7 @@ module Fatty
   class ISearchSession < Session
     action_on :session
 
-    attr_reader :field, :direction
+    attr_reader :field, :direction, :last_pattern
 
     def id = :isearch
 
@@ -12,33 +12,58 @@ module Fatty
     DEFAULT_ISEARCH_HISTORY_MAX  = 200
 
     def initialize(direction: :forward, last_pattern: nil, history: nil)
-      super(keymap: Keymaps.emacs, views: [])
-
+      super(keymap: Keymaps.emacs)
       @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" } },
+        history_ctx: { kind: :search, regex: false },
       )
     end
 
     #########################################################################################
-    # Framework and Session Hooks
+    # Session Protocol
     #########################################################################################
 
-    def keymap_contexts
-      [:isearch, :text, :terminal]
-    end
-
-    def view(screen:, renderer:)
+    def update(command)
+      log_update(command)
+      commands =
+        case command.action
+        when :key
+          ev = command.payload.fetch(:event)
+          action, args = resolve_action(ev)
+          if action
+            apply_action(action, args, event: ev)
+          else
+            []
+          end
+        when :terminal_paste
+          env = action_env(event: nil)
+          @field.act_on(
+            :paste,
+            command.payload.fetch(:text, ""),
+            env: env,
+          )
+          @field.sync_virtual_suffix!
+          maybe_preview!
+        when :isearch_set_failed
+          @failed = !!command.payload[:failed]
+          @field.prompt = isearch_prompt
+          []
+        else
+          []
+        end
+      Array(commands)
+    end
+
+    def view
       row = screen.output_rect.rows - 1
 
-      ::Curses.curs_set(1)
+      renderer.show_cursor
       renderer.render_pager_field(@field, row: row, role: :search_input)
       renderer.restore_output_cursor(@field, row: row)
     end
@@ -69,14 +94,10 @@ module Fatty
 
     private
 
-    def update_cmd(name, payload)
-      cmds = []
-      case name
-      when :isearch_set_failed
-        @failed = !!payload[:failed]
-        @field.prompt = isearch_prompt
-      end
-      cmds
+    # simplecov:disable
+
+    def keymap_contexts
+      [:isearch, :text, :terminal]
     end
 
     def action_env(event:)
@@ -89,13 +110,14 @@ module Fatty
       )
     end
 
-    def handle_action(action, args, event:)
+    def apply_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)
+        @field.sync_virtual_suffix!
         maybe_preview!
       end
     rescue Fatty::ActionError
@@ -110,30 +132,58 @@ module Fatty
 
     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
+      [
+        Command.terminal(
+          :send_modal_owner,
+          command: Command.session(
+            :focused,
+            :pager_isearch_commit,
+            pattern: pattern,
+            direction: @direction,
+          ),
+        ),
+        Command.terminal(:pop_modal),
+      ]
     end
 
     def cancel!
-      [[:terminal, :send_modal_owner, [:cmd, :pager_isearch_cancel, {}]], [:terminal, :pop_modal]]
+      [
+        Command.terminal(
+          :send_modal_owner,
+          command: Command.session(:focused, :pager_isearch_cancel),
+        ),
+        Command.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
+
+      prefill_last_pattern_if_empty! + [
+        Command.terminal(
+          :send_modal_owner,
+          command: Command.session(
+            :focused,
+            :pager_isearch_step,
+            direction: @direction,
+          ),
+        ),
+      ]
     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
+
+      prefill_last_pattern_if_empty! + [
+        Command.terminal(
+          :send_modal_owner,
+          command: Command.session(
+            :focused,
+            :pager_isearch_step,
+            direction: @direction,
+          ),
+        ),
+      ]
     end
 
     def prefill_last_pattern_if_empty!
@@ -161,11 +211,15 @@ module Fatty
 
       @last_text = text.dup
       [
-        [
-          :terminal,
+        Command.terminal(
           :send_modal_owner,
-          [:cmd, :pager_isearch_update, { pattern: text, direction: @direction }],
-        ]
+          command: Command.session(
+            :focused,
+            :pager_isearch_update,
+            pattern: text,
+            direction: @direction,
+          ),
+        ),
       ]
     end
   end