fatty 0.99.0

data/lib/fatty/action.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Fatty
+  class ActionError < StandardError; end
+
+  module Actions
+    @defs = {} # { Symbol => { owner:, on:, doc:, method: } }
+
+    def self.names
+      @defs.keys.sort
+    end
+
+    def self.valid_names
+      names.map(&:to_s)
+    end
+
+    def self.catalog
+      names.map do |name|
+        defn = @defs[name]
+        {
+          name: name.to_s,
+          doc: defn[:doc],
+          on: defn[:on].to_s,
+          method: defn[:method].to_s,
+        }
+      end
+    end
+
+    def self.catalog_by_target
+      @defs
+        .group_by { |_name, defn| defn[:on].to_s }
+        .sort
+        .to_h do |target, entries|
+          names = entries.map { |name, _defn| name.to_s }.sort
+          [target, names]
+        end
+    end
+
+    def self.snapshot
+      @defs.dup
+    end
+
+    def self.restore(snapshot)
+      @defs = snapshot
+    end
+
+    def self.reset!
+      @defs.clear
+    end
+
+    def self.defs
+      @defs
+    end
+
+    def self.lookup(name)
+      @defs[name.to_sym]
+    end
+
+    def self.register(name, owner:, on:, method_name: name, doc: nil)
+      arg_str = "Action.register: name: #{name}, on: #{on}, method_name: #{method_name}, doc: #{doc}"
+      Fatty.debug("Action.register(#{arg_str})", tag: :action)
+      key = name.to_sym
+      raise ActionError, "action already registered for #{key}" if @defs.key?(key)
+
+      @defs[key] = {
+        owner: owner,
+        on: on.to_sym,
+        doc: doc,
+        method: method_name.to_sym,
+      }
+    end
+
+    def self.call(name, env, *args, **kwargs)
+      arg_str = "name: #{name}, env: #{env}, args: #{args}, kwargs: #{kwargs}"
+      Fatty.debug("Action.call(#{arg_str})", tag: :action)
+      key = name.to_sym
+      defn = @defs[key] or raise ActionError, "Unknown action: #{key}"
+
+      target = env.public_send(defn[:on])
+      raise ActionError, "env.#{defn[:on]} is nil for action #{key}" unless target
+
+      # Inject count: from env.counter when the target accepts it.
+      if env.counter&.active? && !kwargs.key?(:count)
+        meth = target.method(defn[:method])
+        params = meth.parameters
+
+        accepts_count =
+          params.any? { |(kind, pname)| kind == :key && pname == :count } ||
+          params.any? { |(kind, _pname)| kind == :keyrest }
+
+        if accepts_count
+          kwargs = kwargs.merge(count: env.counter.consume(default: 1))
+        end
+      end
+
+      target.public_send(defn[:method], *args, **kwargs)
+    end
+
+    def self.registered?(name)
+      @defs.key?(name.to_sym)
+    end
+  end
+end

data/lib/fatty/action_environment.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Fatty
+  # For holding the environment in which an action is executed
+  class ActionEnvironment
+    attr_accessor :session, :event, :counter, :buffer, :field, :pager
+
+    def initialize(
+      session: nil,
+      terminal: nil,
+      counter: nil,
+      event: nil,
+      buffer: nil,
+      field: nil,
+      pager: nil
+    )
+      @session = session
+      @terminal = terminal
+      @counter = counter
+      @event = event
+      @buffer = buffer
+      @field = field
+      @pager = pager
+    end
+
+    def terminal
+      session&.terminal
+    end
+
+    def to_s
+      parts = []
+      parts << "session: #{session}" if session
+      parts << "terminal: #{terminal}" if terminal
+      parts << "counter: #{counter}" if counter
+      parts << "event: #{event.to_s[0..90]}" if event
+      parts << "buffer: #{buffer}" if buffer
+      parts << "field: #{field}" if field
+      parts << "pager: #{pager}" if pager
+      parts.join('; ')
+    end
+  end
+end

data/lib/fatty/actionable.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Fatty
+  module Actionable
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # Optional override; by default infer slot from class name (InputBuffer -> :buffer)
+      def action_on(sym = nil)
+        @default_action_target = sym&.to_sym
+      end
+
+      def default_action_target
+        @default_action_target || infer_action_target
+      end
+
+      def desc(text)
+        @__next_action_doc = text.to_s
+      end
+
+      def next_action_doc
+        doc = @__next_action_doc
+        @__next_action_doc = nil
+        doc
+      end
+
+      # Define instance method AND register as bindable action.
+      #
+      # Examples:
+      #   action :bol { @cursor = 0 }
+      #   action :insert { |str| ... }
+      #   action :backward_char, to: :move_left  # alias action name to a method
+      #
+      def action(name, on: default_action_target, to: name, doc: nil, &block)
+        name = name.to_sym
+        on   = on.to_sym
+        to   = to.to_sym
+
+        # Prefer desc() if present, else doc: kwarg
+        doc ||= next_action_doc
+
+        if block
+          # define the underlying method (usually same as name)
+          define_method(to, &block)
+        elsif name != to && !method_defined?(name)
+          # If this is an alias (action name differs from method), define the alias method
+
+          # Prefer a real alias if the target method already exists; otherwise define a delegator.
+          if method_defined?(to)
+            alias_method name, to
+          else
+            define_method(name) { |*args, &blk| public_send(to, *args, &blk) }
+          end
+        end
+        Fatty::Actions.register(name, owner: self, on: on, method_name: to, doc: doc)
+      end
+
+      private
+
+      def infer_action_target
+        base = name.split("::").last
+        return :buffer   if base == "InputBuffer"
+        return :field    if base == "InputField"
+        return :terminal if base == "Terminal"
+        return :pager    if base == "Pager"
+
+        base.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase.to_sym
+      end
+    end
+  end
+end

data/lib/fatty/alert.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Fatty
+  class Alert
+    DETAIL_ORDER = %i[terminal key ctrl meta shift].freeze
+
+    attr_reader :level, :message, :details
+
+    # Return a new Alert object
+    #
+    # @param message [String]
+    # @param level [:info, :warn, :error]
+    # @param details [Hash|String]
+    # @param sticky [Boolean]
+    # @return [Alert]
+    def initialize(message:, level: :info, details: nil, sticky: false)
+      @message = message
+      @level = level.to_sym
+      @details = details
+      @sticky  = !!sticky
+    end
+
+    # Return a new Alert object at level info
+    #
+    # @param msg [String]
+    # @return [Alert] with level info
+    def self.info(msg)
+      new(message: msg, level: :info)
+    end
+
+    # Return a new Alert object at level warn
+    #
+    # @param msg [String]
+    # @return [Alert] with level warn
+    def self.warn(msg)
+      new(message: msg, level: :warn)
+    end
+
+    # Return a new Alert object at level error
+    #
+    # @param msg [String]
+    # @return [Alert] with level error
+    def self.error(msg)
+      new(message: msg, level: :error)
+    end
+
+    # Translate the "level" to a "role" used by the renderers. The returned
+    # roles are "composite" roles in the resolver in that they take the
+    # background ot the alert panel and apply a foreground color based on
+    # severity.
+    #   @param level [:info, :warn, :error]
+    #   @return [Symbol] composite or semantic role
+    # used by renderer (e.g., alert_good, :alert_info, :alert_warn, :alert_error)
+    def role
+      case level
+      when :good then :alert_good
+      when :warn then :alert_warn
+      when :error then :alert_error
+      else :alert_info
+      end
+    end
+
+    # Build a string version of the Alert suitable for display to the user.
+    def format
+      icon =
+        case level
+        when :warn then "⚠"
+        when :error then "✖"
+        else "ℹ"
+        end
+      msg = message.to_s
+      details_str = ""
+      if details.respond_to?(:empty?) ? !details.empty? : !!details
+        details_str = if details.is_a?(Hash)
+          " (" +
+            DETAIL_ORDER.filter_map { |k| "#{k}=#{details[k]}" if details.key?(k) }.join(" ") +
+            ")"
+        else
+          " (#{details})"
+        end
+      end
+      "#{icon} #{msg}#{details_str}"
+    end
+
+    # Return whether this Alert is sticky, meaning that it should not be
+    # cleared until a key is presses or another Alert displayed
+    #
+    # @return [true, false] is this Alert sticky?
+    def sticky?
+      @sticky
+    end
+  end
+end

data/lib/fatty/ansi/renderer.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module Fatty
+  module Ansi
+    class Renderer
+      CSI = "\e["
+
+      def initialize(io: nil)
+        @io = io
+      end
+
+      def render_line(row:, col:, width:, text:, role:, palette:)
+        spec = palette&.[](role)
+        return unless spec
+
+        msg = text.to_s.tr("\r\n", " ")
+        msg = Fatty::Ansi.truncate_visible(msg, width)
+        visible = Fatty::Ansi.visible_length(msg)
+        pad = width - visible
+        sgr = sgr_for_spec(spec)
+        padding = pad.positive? ? " " * pad : ""
+        write_ansi("#{CSI}#{row + 1};#{col + 1}H", sgr, msg, sgr, padding, reset)
+      end
+
+      def render_segments_line(row:, col:, width:, segments:, palette:, fill_role: :output)
+        rendered = +""
+        visible = 0
+        segments.each do |seg|
+          spec = palette&.[](seg[:role])
+          next unless spec
+
+          remaining = width - visible
+          break if remaining <= 0
+
+          text = Fatty::Ansi.truncate_visible(seg[:text].to_s, remaining)
+          next if text.empty?
+
+          visible += Fatty::Ansi.visible_length(text)
+
+          sgr =
+            if seg[:style]
+              sgr_for_style(seg[:style], fallback_spec: spec)
+            else
+              sgr_for_spec(spec)
+            end
+
+          rendered << sgr
+          rendered << text
+        end
+
+        if visible < width
+          spec = palette&.[](fill_role)
+          rendered << sgr_for_spec(spec) if spec
+          rendered << (" " * (width - visible))
+        end
+        write_ansi("#{CSI}#{row + 1};#{col + 1}H", rendered, reset)
+      end
+
+      def write_ansi(*parts)
+        text = parts.join
+
+        if defined?(::Curses) && ::Curses.respond_to?(:putp)
+          ::Curses.putp(text)
+        else
+          io.write(text)
+          io.flush
+        end
+
+        nil
+      end
+
+      def io
+        @io || $stdout
+      end
+
+      private
+
+      def save_cursor
+        "#{CSI}s"
+      end
+
+      def restore_cursor
+        "#{CSI}u"
+      end
+
+      def reset
+        "#{CSI}0m"
+      end
+
+      def move_to(row, col)
+        "#{CSI}#{row + 1};#{col + 1}H"
+      end
+
+      def sgr_for_spec(spec)
+        fg = spec[:fg_rgb]
+        bg = spec[:bg_rgb]
+        codes = []
+
+        Array(spec[:attrs]).each do |attr|
+          case attr.to_sym
+          when :bold
+            codes << "1"
+          when :dim
+            codes << "2"
+          when :underline
+            codes << "4"
+          when :reverse
+            if fg && bg
+              fg, bg = bg, fg
+            else
+              codes << "7"
+            end
+          end
+        end
+
+        parts = [reset]
+        parts << "#{CSI}#{codes.join(';')}m" unless codes.empty?
+        parts << "#{CSI}38;2;#{fg[0]};#{fg[1]};#{fg[2]}m" if fg
+        parts << "#{CSI}48;2;#{bg[0]};#{bg[1]};#{bg[2]}m" if bg
+
+        return reset if parts.empty?
+
+        parts.join
+      end
+
+      def sgr_for_style(style, fallback_spec:)
+        fg = rgb_for_style_color(style.fg, fallback: fallback_spec[:fg_rgb])
+        bg = rgb_for_style_color(style.bg, fallback: fallback_spec[:bg_rgb])
+
+        codes = []
+        codes << "1" if style.bold
+        codes << "3" if style.italic
+        codes << "4" if style.underline
+        codes << "9" if style.strike
+
+        if style.reverse
+          if fg && bg
+            fg, bg = bg, fg
+          else
+            codes << "7"
+          end
+        end
+
+        parts = [reset]
+        parts << "#{CSI}#{codes.join(';')}m" unless codes.empty?
+        parts << "#{CSI}38;2;#{fg[0]};#{fg[1]};#{fg[2]}m" if fg
+        parts << "#{CSI}48;2;#{bg[0]};#{bg[1]};#{bg[2]}m" if bg
+
+        parts.join
+      end
+
+      def rgb_for_style_color(color, fallback:)
+        case color
+        when Array
+          color
+        when Integer
+          if color.between?(0, 15)
+            Fatty::Color::ANSI_RGB[color]
+          else
+            Fatty::Color.xterm_rgb_for_index(color)
+          end
+        else
+          fallback
+        end
+      end
+    end
+  end
+end