fatty 0.99.0 → 0.99.3

data/lib/fatty/session/status_session.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module Fatty
+  class StatusSession < Session
+    DEFAULT_MAX_ROWS = 6
+
+    attr_reader :text, :role
+
+    def initialize(id: nil)
+      super
+      @text = nil
+      @role = :info
+    end
+
+    #########################################################################################
+    # Session Protocol
+    #########################################################################################
+
+    def update(command)
+      Fatty.debug(
+        "StatusSession before action=#{command.action} text=#{text.inspect}",
+        tag: :session,
+      )
+      log_update(command)
+      old_rows = rows
+      case command.action
+      when :show
+        set(command.payload)
+      when :clear
+        clear
+      end
+      Fatty.debug(
+        "StatusSession after action=#{command.action} text=#{text.inspect}",
+        tag: :session,
+      )
+      new_rows = rows
+      commands = []
+      if old_rows != new_rows
+        commands << Command.terminal(:set_status_rows, rows: new_rows)
+        commands << Command.terminal(:refresh_layout)
+      end
+      commands.compact
+    end
+
+    def view
+      return unless visible?
+
+      renderer.render_status(self)
+    end
+
+    #########################################################################################
+    # Other public API methods
+    #########################################################################################
+
+    def state
+      [
+        text.dup.freeze,
+        role.dup,
+        renderer.screen.status_rect.row.dup,
+        renderer.screen.status_rect.rows.dup,
+        renderer.screen.status_rect.cols.dup,
+        renderer.theme_version
+      ]
+    end
+
+    private
+
+    # simplecov:disable
+
+    def rows
+      return 0 unless visible?
+
+      lines.length.clamp(1, max_rows)
+    end
+
+    def max_rows
+      Fatty::Config.config.dig(:status, :max_rows)&.to_i || DEFAULT_MAX_ROWS
+    end
+
+    def lines
+      renderable_text(@text)
+        .lines
+        .flat_map { |line| wrap_line(line.chomp, width) }
+        .last(max_rows)
+    end
+
+    def renderable_text(value)
+      parts = value.is_a?(Array) ? value : [value]
+
+      parts.map do |part|
+        if part.is_a?(Hash) && part.key?(:text)
+          part[:text].to_s
+        else
+          part.to_s
+        end
+      end.join
+    end
+
+    def visible?
+      @text && !@text.empty?
+    end
+
+    def set(payload)
+      new_text = chomp_text(payload.fetch(:text))
+      new_role = payload[:role] || :info
+
+      if payload[:append] && visible?
+        @text = status_parts(@text, role)
+                  .push(
+                    "\n",
+                    {
+                      text: new_text,
+                      role: new_role,
+                    },
+                  )
+      else
+        @text = new_text
+        @role = new_role
+      end
+    end
+
+    def status_parts(text, role)
+      if text.is_a?(Array)
+        text.dup
+      else
+        [
+          {
+            text: text,
+            role: role,
+          },
+        ]
+      end
+    end
+
+    def chomp_text(text)
+      case text
+      when String
+        text.chomp
+      when Array
+        text = text.dup
+        index = text.rindex { |segment| segment.is_a?(String) && !segment.empty? }
+        text[index] = text[index].chomp if index
+        text
+      else
+        text
+      end
+    end
+
+    def clear
+      return unless visible?
+
+      @text = nil
+      @role = :info
+    end
+
+    def wrap_line(line, width)
+      text = Fatty::Ansi.strip(line.to_s)
+      return [""] if text.empty?
+
+      text.scan(/.{1,#{[width, 1].max}}/)
+    end
+
+    def width
+      terminal&.screen&.cols || 80
+    end
+  end
+end

data/lib/fatty/session.rb

@@ -14,23 +14,14 @@ module Fatty
   class Session
     include Actionable
 
-    attr_reader :terminal, :views, :keymap, :counter
+    attr_reader :id, :terminal, :keymap, :counter
 
-    def initialize(keymap: nil, views: [])
+    def initialize(id: nil, keymap: nil)
+      @id = id || default_id
       @keymap = keymap
-      @views = Array(views)
       @counter = Counter.new
     end
 
-    def inspect
-      "#{self.class.name}:#{object_id}"
-    end
-
-    def add_view(view)
-      @views << view
-      view
-    end
-
     # Called once when the session becomes active (e.g. pushed).
     # Subclasses may override to kick off timers/async work, etc.
     def init(terminal:)
@@ -38,34 +29,23 @@ module Fatty
       []
     end
 
-    # Handle a message and return commands.
-    def update(message)
-      Fatty.debug("#{self.class}#update(message -> #{message})", tag: :session)
+    # Handle an incoming Command, which can carry an action or a KeyEvent.  On
+    # execution, those can return one or more Commands, which update returns
+    # to its caller for further dispatch.
+    def update(command)
+      # raise NotImplementedError, "#{self.class} must implement \#update"
+    end
 
-      commands =
-        case message[0]
-        when :key
-          ev = message[1]
-          action, args = resolve_action(ev)
-
-          Fatty.debug(
-            "#{self.class}#update: key ev=#{ev.inspect} action=#{action.inspect} args=#{args.inspect}",
-            tag: :session,
-          )
-
-          if action
-            handle_action(action, args, event: ev)
-          else
-            update_key(ev)
-          end
-        when :cmd
-          Fatty.debug("#{self.class}#update: cmd message=#{message.inspect}", tag: :session)
-          update_cmd(message[1], message[2])
-        else
-          Fatty.warn("#{self.class}#update: unknown message[0]=#{message[0].inspect}", tag: :session)
-          []
-        end
-      commands
+    # By default, does nothing.  Subclasses can override, but should not
+    # mutate state here.
+    def view
+    end
+
+    def close
+    end
+
+    def handle_resize
+      []
     end
 
     # Save any state we want saved on quit, error, etc.
@@ -76,22 +56,22 @@ module Fatty
       false
     end
 
-    def resolve_action(ev)
-      return [nil, []] unless keymap
+    def renderer
+      terminal.renderer
+    end
 
-      keymap.resolve_action(ev, contexts: keymap_contexts)
+    def screen
+      terminal.screen
     end
 
-    # Subclasses can override to vary contexts dynamically
-    # (paging/isearch/popup/etc).  Must return an Array of symbols in
-    # precedence order.
-    def keymap_contexts
-      [:input]
+    desc "Cycle to the next theme"
+    action :cycle_theme do
+      Command.terminal(:cycle_theme)
     end
 
-    # Subclasses override this to react to resolved actions.
-    def handle_action(_action, _args, event:)
-      []
+    desc "Choose a theme from a popup"
+    action :choose_theme do
+      Command.terminal(:choose_theme)
     end
 
     desc "Accumulate a count with a decimal digit"
@@ -109,65 +89,85 @@ module Fatty
       counter.universal_argument!
     end
 
-    # Render the session.
-    #
-    # By default, renders all views belonging to the session, ordered by z-index.
-    # Subclasses can override, but should not mutate state here.
-    def view(screen:, renderer:)
-      views.sort_by(&:z).each do |v|
-        v.render(screen:, renderer:, terminal:, session: self)
-      end
-    end
+    private
 
-    def close
-      nil
-    end
+    # simplecov:disable
 
-    def handle_resize
-      []
+    def log_update(command)
+      payload = command.payload
+      text = payload[:text] || "(NO TEXT)"
+      msg =
+        case command.action
+        when :key
+          "#{self.class}#update(command -> #{command.inspect}) key: #{payload[:event]}"
+        else
+          sess_str =
+            if command.target == :focused_session
+              Terminal.find(:focused_session).to_s
+            else
+              command.target.to_s
+            end
+          "#{self.class}#update(command -> #{command.inspect}) session: #{sess_str} text: #{text}"
+        end
+      Fatty.debug(msg, tag: :session)
     end
 
-    private
-
-    def update_key(_ev)
-      []
+    def normalize_action_result(result)
+      Command.normalize_list(result)
     end
 
-    def update_cmd(_name, _payload)
-      []
+    def alert_cmd(role, text, ev: nil)
+      details =
+        if ev
+          {
+            key: ev.key,
+            ctrl: ev.respond_to?(:ctrl?) ? ev.ctrl? : ev.ctrl,
+            meta: ev.respond_to?(:meta?) ? ev.meta? : ev.meta,
+            shift: ev.respond_to?(:shift?) ? ev.shift? : ev.shift,
+            text: ev.text
+          }
+        else
+          {}
+        end
+      alert = Alert.new(text: text, role: role, details: details)
+      Command.session(:alert, :show, alert: alert)
     end
 
-    def match_all_query_terms?(haystack, query)
-      Fatty::Search.match_all_terms?(haystack, query)
+    def default_id
+      self.class.name
+        .delete_prefix("Fatty::")
+        .gsub(/([a-z])([A-Z])/, '\1_\2')
+        .downcase
+        .then { |name| :"#{name}_#{object_id}" }
     end
 
-    def safely_close_window(win)
-      return unless win
-
-      begin
-        win.erase
-      rescue RuntimeError => e
-        raise unless closed_window_error?(e)
-      end
-
-      begin
-        win.noutrefresh if win.respond_to?(:noutrefresh)
-      rescue RuntimeError => e
-        raise unless closed_window_error?(e)
-      end
+    def resolve_action(ev)
+      return [nil, []] unless keymap
 
-      begin
-        win.close
-      rescue RuntimeError => e
-        raise unless closed_window_error?(e)
-      end
+      keymap.resolve_action(ev, contexts: keymap_contexts)
+    end
 
-      nil
+    # Subclasses can override to vary contexts dynamically
+    # (paging/isearch/popup/etc).  Must return an Array of symbols in
+    # precedence order.
+    def keymap_contexts
+      [:input]
     end
 
-    def closed_window_error?(error)
-      message = error.message
-      message.include?("closed window") || message.include?("already closed window")
+    # Subclasses override this to react to resolved actions.
+    def apply_action(_action, _args, event:)
+      []
     end
   end
 end
+
+require_relative "session/alert_session"
+require_relative "session/status_session"
+require_relative "session/modal_session"
+require_relative "session/popup_session"
+require_relative "session/search_session"
+require_relative "session/isearch_session"
+require_relative "session/output_session"
+require_relative "session/shell_session"
+require_relative 'session/prompt_session'
+require_relative 'session/keytest_session'

data/lib/fatty/terminal/popup_owner.rb

@@ -3,23 +3,26 @@
 module Fatty
   class Terminal
     class PopupOwner
-      attr_reader :on_result, :on_cancel
+      attr_reader :on_result, :on_cancel, :on_change
 
-      def initialize(on_result: nil, on_cancel: nil)
+      def initialize(on_result: nil, on_cancel: nil, on_change: nil)
         @on_result = on_result
         @on_cancel = on_cancel
+        @on_change = on_change
       end
 
-      def update(msg)
-        _cmd, name, payload = msg
+      def update(command)
+        result =
+          case command.action
+          when :popup_result, :prompt_result
+            on_result&.call(command.payload)
+          when :popup_cancelled, :prompt_cancelled
+            on_cancel&.call
+          when :popup_changed
+            on_change&.call(command.payload)
+          end
 
-        case name
-        when :popup_result, :prompt_result
-          on_result&.call(payload)
-        when :popup_cancelled, :prompt_cancelled
-          on_cancel&.call
-        end
-        []
+        Command.normalize_list(result)
       end
     end
   end