fatty 0.99.0

data/lib/fatty/session.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module Fatty
+  # Base class for stateful runtime components.
+  #
+  # Charm/Bubbletea-style contract:
+  #
+  #   init(terminal:)               => commands
+  #   update(message)               => commands
+  #   view(screen:, renderer:, terminal:) => renders only (no return contract)
+  #
+  # Where `commands` is an Array (possibly empty). Terminal is responsible for
+  # executing commands after each update cycle.
+  class Session
+    include Actionable
+
+    attr_reader :terminal, :views, :keymap, :counter
+
+    def initialize(keymap: nil, views: [])
+      @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:)
+      @terminal = terminal
+      []
+    end
+
+    # Handle a message and return commands.
+    def update(message)
+      Fatty.debug("#{self.class}#update(message -> #{message})", tag: :session)
+
+      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
+    end
+
+    # Save any state we want saved on quit, error, etc.
+    def persist!
+    end
+
+    def tick
+      false
+    end
+
+    def resolve_action(ev)
+      return [nil, []] unless keymap
+
+      keymap.resolve_action(ev, contexts: keymap_contexts)
+    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]
+    end
+
+    # Subclasses override this to react to resolved actions.
+    def handle_action(_action, _args, event:)
+      []
+    end
+
+    desc "Accumulate a count with a decimal digit"
+    action :count_digit, on: :session do |n|
+      counter.push_digit(n)
+    end
+
+    desc "Clear the accumulated count"
+    action :count_clear, on: :session do
+      counter.clear!
+    end
+
+    desc "Universal argument (C-u)"
+    action :universal_argument, on: :session do
+      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
+
+    def close
+      nil
+    end
+
+    def handle_resize
+      []
+    end
+
+    private
+
+    def update_key(_ev)
+      []
+    end
+
+    def update_cmd(_name, _payload)
+      []
+    end
+
+    def match_all_query_terms?(haystack, query)
+      Fatty::Search.match_all_terms?(haystack, query)
+    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
+
+      begin
+        win.close
+      rescue RuntimeError => e
+        raise unless closed_window_error?(e)
+      end
+
+      nil
+    end
+
+    def closed_window_error?(error)
+      message = error.message
+      message.include?("closed window") || message.include?("already closed window")
+    end
+  end
+end

data/lib/fatty/sessions.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "session"
+
+require_relative "session/alert_session"
+require_relative "session/modal_session"
+require_relative "session/popup_session"
+require_relative "session/search_session"
+require_relative "session/isearch_session"
+require_relative "session/input_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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Fatty
+  class Terminal
+    class PopupOwner
+      attr_reader :on_result, :on_cancel
+
+      def initialize(on_result: nil, on_cancel: nil)
+        @on_result = on_result
+        @on_cancel = on_cancel
+      end
+
+      def update(msg)
+        _cmd, name, payload = msg
+
+        case name
+        when :popup_result, :prompt_result
+          on_result&.call(payload)
+        when :popup_cancelled, :prompt_cancelled
+          on_cancel&.call
+        end
+        []
+      end
+    end
+  end
+end

data/lib/fatty/terminal/progress.rb

@@ -0,0 +1,374 @@
+# frozen_string_literal: true
+
+module Fatty
+  class Terminal
+    class Progress
+      PARTIAL_BLOCKS = ["", "▏", "▎", "▍", "▌", "▋", "▊", "▉"].freeze
+      FULL_BLOCK = "█"
+      EMPTY_BAR = "."
+
+      SHADE_EMPTY = "░"
+      SHADE_HALF  = "▒"
+      SHADE_FULL  = "▓"
+
+      BRAILLE_STEPS = ["⠀", "⣀", "⣄", "⣆", "⣇", "⣧", "⣷", "⣿"].freeze
+
+      attr_reader :terminal, :label, :total, :style, :role, :width
+
+      # The width parameter's purpose varies by style:
+      #
+      # :trail       width = max visible width of the trail portion
+      # :bar         width = max bar width
+      # :unicode_bar width = max bar width
+      # :braille_bar width = max bar width
+      # :spinner     width ignored, unless later used for suffix/trail
+      # :count       width ignored
+      # :percent     width ignored
+      def initialize(terminal:, label:, total: nil, style: :percent, role: :info, width: 40)
+        @terminal = terminal
+        @label = label.to_s
+        @total = total&.to_i
+        @style = style.to_sym
+        @role = role
+        @width = width.to_i
+        @trail = []
+        @current = 0
+        @spinner_index = 0
+
+        validate_total_requirement!
+
+        refresh
+      end
+
+      def update(current: nil, total: @total, label: @label, indicator: nil, render: false)
+        @current = current.to_i unless current.nil?
+        @total = total&.to_i
+        @label = label.to_s
+
+        if style == :spinner
+          advance_spinner
+        else
+          append_indicator(indicator)
+        end
+
+        refresh
+        terminal.render_now if render
+        self
+      end
+
+      def finish(message = nil, clear: false, role: @role, render: false, transient: true)
+        if clear
+          terminal.clear_status
+        else
+          text =
+            if message && !message.empty?
+              render_text(suffix: message)
+            else
+              render_text
+            end
+          terminal.set_status(text, role: role, transient: transient)
+        end
+
+        terminal.render_now if render
+        self
+      end
+
+      def clear
+        terminal.clear_status
+        self
+      end
+
+      private
+
+      attr_reader :current
+
+      def append_indicator(indicator)
+        return if indicator.nil?
+
+        item =
+          if indicator.is_a?(Hash) && indicator.key?(:text)
+            indicator
+          else
+            indicator.to_s
+          end
+
+        return if renderable_indicator_text(item).empty?
+
+        @trail << item
+        trim_trail if @width && @width > 0
+      end
+
+      def renderable_indicator_text(item)
+        if item.is_a?(Hash) && item.key?(:text)
+          item[:text].to_s
+        else
+          item.to_s
+        end
+      end
+
+      def refresh
+        terminal.set_status(render_text, role: role)
+      end
+
+      def render_text(suffix: nil)
+        case style
+        when :count
+          base = total ? "#{label} [#{current}/#{total}]" : "#{label} [#{current}]"
+          suffix_text(base, suffix)
+        when :simple_percent
+          base = total && total > 0 ? "#{label} #{percent}%" : label.to_s
+          suffix_text(base, suffix)
+        when :trail
+          render_trail_text(suffix: suffix)
+        when :bar
+          render_bar_text(suffix: suffix, mode: :solid)
+        when :unicode_bar
+          render_bar_text(suffix: suffix, mode: :unicode)
+        when :braille_bar
+          render_bar_text(suffix: suffix, mode: :braille)
+        when :spinner
+          render_spinner_text(suffix: suffix)
+        else
+          base = total && total > 0 ? "#{label} [#{current}/#{total}] #{percent}%" : "#{label} [#{current}]"
+          suffix_text(base, suffix)
+        end
+      end
+
+      def percent
+        ((current.to_f / total.to_f) * 100).round
+      end
+
+      def suffix_text(base, suffix)
+        extra = suffix.to_s
+        return base if extra.empty?
+
+        "#{base}  #{extra}"
+      end
+
+      def render_trail_text(suffix: nil)
+        base =
+          if total && total > 0
+            "#{label} [#{current}/#{total}] #{percent}%"
+          else
+            "#{label} [#{current}]"
+          end
+
+        trailer = suffix.to_s.empty? ? "" : "  #{suffix}"
+        return "#{base}#{trailer}" if @trail.empty?
+
+        limit = trail_limit(base, trailer)
+        trail = limited_trail(limit)
+        [base, "  ", *trail, trailer]
+      end
+
+      def trail_limit(prefix, suffix = "")
+        cols =
+          if terminal.screen
+            terminal.screen.cols.to_i
+          else
+            80
+          end
+
+        available = cols - visible_length(prefix) - visible_length(suffix) - 4
+        available = 0 if available < 0
+        available
+      end
+
+      def limited_trail(limit)
+        used = 0
+        selected = []
+
+        @trail.reverse_each do |item|
+          width = visible_length(item)
+          break if used + width > limit
+
+          selected.unshift(item)
+          used += width
+        end
+
+        selected
+      end
+
+      def trim_trail
+        used = 0
+        selected = []
+
+        @trail.reverse_each do |item|
+          width = visible_length(item)
+          break if used + width > @width
+
+          selected.unshift(item)
+          used += width
+        end
+
+        @trail = selected
+      end
+
+      def visible_length(value)
+        if value.is_a?(Hash) && value.key?(:text)
+          Fatty::Ansi.visible_length(value[:text].to_s)
+        else
+          Fatty::Ansi.visible_length(value.to_s)
+        end
+      end
+
+      def render_bar_text(suffix: nil, mode: :solid)
+        base = label.to_s
+        info = progress_info_text
+        extra = suffix.to_s
+        trailer = extra.empty? ? "" : "  #{extra}"
+
+        bar_width = bar_width_for(base, info, trailer)
+        bar =
+          case mode
+          when :unicode
+            unicode_bar(bar_width)
+          when :braille
+            braille_bar(bar_width)
+          else
+            solid_bar(bar_width)
+          end
+
+        pieces = [base]
+        pieces << "[#{bar}]" unless bar.empty?
+        pieces << info unless info.empty?
+
+        text = pieces.join(" ")
+        text = "#{text}#{trailer}" unless trailer.empty?
+        text
+      end
+
+      def render_spinner_text(suffix: nil)
+        frame = spinner_frames[@spinner_index % spinner_frames.length]
+        base =
+          if total && total > 0
+            "#{label} #{frame} #{percent}%"
+          else
+            "#{label} #{frame}"
+          end
+
+        suffix_text(base, suffix)
+      end
+
+      def progress_info_text
+        if total && total > 0
+          "#{percent}% [#{current}/#{total}]"
+        else
+          "[#{current}]"
+        end
+      end
+
+      def bar_width_for(base, info, trailer)
+        cols =
+          if terminal.screen
+            terminal.screen.cols.to_i
+          else
+            80
+          end
+
+        reserved = visible_length(base)
+        reserved += 1 + visible_length(info) unless info.empty?
+        reserved += visible_length(trailer) unless trailer.empty?
+
+        # Space for:
+        #   " ["
+        #   "]"
+        # around the bar
+        available = cols - reserved - 4
+        available = 0 if available < 0
+        [available, @width].min
+      end
+
+      def solid_bar(width)
+        return "" if width <= 0
+
+        ratio = progress_ratio
+        filled = (ratio * width).round
+        filled = 0 if filled < 0
+        filled = width if filled > width
+
+        empty = width - filled
+        (FULL_BLOCK * filled) + (EMPTY_BAR * empty)
+      end
+
+      def unicode_bar(width)
+        return "" if width <= 0
+
+        raw = progress_ratio * width
+        full = raw.floor
+
+        # Show a transition block whenever the bar is in progress but not complete,
+        # provided there is space for it.
+        half =
+          if progress_ratio.positive? && progress_ratio < 1.0 && full < width
+            1
+          else
+            0
+          end
+
+        bar = +""
+        bar << (SHADE_FULL * full)
+        bar << SHADE_HALF if half == 1
+
+        remaining = width - Fatty::Ansi.visible_length(bar)
+        remaining = 0 if remaining < 0
+        bar << (SHADE_EMPTY * remaining)
+        bar
+      end
+
+      def braille_bar(width)
+        return "" if width <= 0
+
+        raw = progress_ratio * width
+        full = raw.floor
+        remainder = raw - full
+
+        partial_idx = (remainder * (BRAILLE_STEPS.length - 1)).round
+        partial_idx = 0 if partial_idx < 0
+        partial_idx = BRAILLE_STEPS.length - 1 if partial_idx >= BRAILLE_STEPS.length
+
+        bar = +""
+        bar << (BRAILLE_STEPS[-1] * full)
+
+        if progress_ratio.positive? && progress_ratio < 1.0 && full < width
+          partial =
+            if partial_idx.zero?
+              BRAILLE_STEPS[1]
+            else
+              BRAILLE_STEPS[partial_idx]
+            end
+          bar << partial
+        end
+
+        remaining = width - Fatty::Ansi.visible_length(bar)
+        remaining = 0 if remaining < 0
+        bar << (BRAILLE_STEPS[0] * remaining)
+        bar
+      end
+
+      def progress_ratio
+        return 0.0 unless total && total > 0
+
+        ratio = current.to_f / total.to_f
+        ratio = 0.0 if ratio < 0.0
+        ratio = 1.0 if ratio > 1.0
+        ratio
+      end
+
+      def validate_total_requirement!
+        return if style == :spinner
+        return if total && total > 0
+
+        raise ArgumentError, "progress style #{style.inspect} requires total:"
+      end
+
+      def advance_spinner
+        @spinner_index = (@spinner_index + 1) % spinner_frames.length
+      end
+
+      def spinner_frames
+        BRAILLE_STEPS[1..]
+      end
+    end
+  end
+end