fatty 0.99.0 → 0.99.3

data/lib/fatty/api/menu.rb

@@ -0,0 +1,104 @@
+# lib/fatty/api/prompt.rb
+
+module Fatty
+  module MenuApi
+    def menu(prompt, choices:, initial_choice_idx: 0, cancel_value: nil)
+      items = normalize_menu_choices(choices)
+      raise ArgumentError, "choices must not be empty" if items.empty?
+
+      labels = items.keys
+      popup = Fatty::PopUpSession.new(
+        source: labels,
+        kind: :terminal_menu,
+        title: "Menu",
+        message: prompt,
+        prompt: "Narrow: ",
+        current: :top,
+        validate_unique_labels: true,
+        history: terminal.history,
+        history_kind: :popup_filter,
+        history_ctx: { kind: :popup_filter, popup: :menu, prompt: prompt.to_s },
+      )
+      popup.instance_variable_set(
+        :@current,
+        initial_choice_idx.to_i.clamp(0, labels.length - 1),
+      )
+
+      done = false
+      result = nil
+      acc_proc = ->(payload) do
+        label = payload[:item]
+        action = items[label]
+
+        result =
+          if action
+            call_menu_action(action, label: label)
+          else
+            cancel_value
+          end
+
+        done = true
+      end
+      cancel_proc = -> do
+        result = cancel_value
+        done = true
+      end
+      owner = Fatty::Terminal::PopupOwner.new(
+        on_result: acc_proc,
+        on_cancel: cancel_proc,
+      )
+
+      begin
+        terminal.apply_command(
+          Command.terminal(:push_modal, session: popup, owner: owner),
+        )
+        terminal.render_frame
+
+        while !done && terminal.running?
+          dirty = false
+          command = terminal.event_source.next_event
+          if command
+            terminal.apply_command(command)
+            dirty = true
+          end
+
+          begin
+            dirty ||= !!terminal.tick_active_session
+          rescue StandardError => e
+            Fatty.error(
+              "MenuApi#menu tick failed: #{e.class}: #{e.message}",
+              tag: :terminal,
+            )
+            dirty = true
+          end
+
+          terminal.render_frame if dirty
+        end
+      ensure
+        terminal.render_frame
+      end
+      result
+    end
+
+    private
+
+    # simplecov:disable
+
+    def normalize_menu_choices(choices)
+      unless choices.is_a?(Hash)
+        raise ArgumentError, "menu choices must be a Hash of label => callable"
+      end
+
+      choices.each_with_object({}) do |(label, action), normalized|
+        unless action.respond_to?(:call)
+          raise ArgumentError, "menu choice #{label.inspect} is not callable"
+        end
+        normalized[label.to_s] = action
+      end
+    end
+
+    def call_menu_action(action, label:)
+      action.call(self, label)
+    end
+  end
+end

data/lib/fatty/api/output.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Fatty
+  module OutputApi
+    def append(text, follow: true)
+      queue(Command.session(output_id, :append, text: text.to_s, follow: follow))
+      nil
+    end
+
+    def append_now(text, follow: true, mode: nil)
+      payload = { text: text.to_s, follow: follow }
+      payload[:mode] = mode if mode
+
+      terminal.apply_command(Command.session(output_id, :append, **payload))
+      terminal.render_frame
+
+      nil
+    end
+
+    def markdown(text)
+      md = Fatty::Markdown.render(
+        text,
+        palette: markdown_palette,
+        theme: markdown_theme,
+        truecolor: markdown_truecolor?,
+      )
+      append(md)
+      nil
+    end
+
+    private
+
+    def markdown_palette
+      terminal.renderer.palette if terminal.respond_to?(:renderer) && terminal.renderer
+    end
+
+    def markdown_theme
+      Fatty::Themes::Manager.fetch(Fatty::Themes::Manager.current)
+    rescue StandardError
+      nil
+    end
+
+    def markdown_truecolor?
+      if terminal.respond_to?(:ctx) && terminal.ctx.respond_to?(:truecolor_enabled?)
+        terminal.ctx.truecolor_enabled?
+      elsif terminal.respond_to?(:renderer) &&
+            terminal.renderer.respond_to?(:context) &&
+            terminal.renderer.context.respond_to?(:truecolor)
+        terminal.renderer.context.truecolor
+      else
+        false
+      end
+    end
+  end
+end

data/lib/fatty/api/progress.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Fatty
+  module ProgressApi
+    # Create a transient status-line progress indicator.
+    # For style :spinner, total may be omitted for indeterminate progress.
+    def add_progress(
+          label: Progress::DEFAULT_LABEL,
+          total: nil,
+          style: Progress::DEFAULT_STYLE,
+          role: Progress::DEFAULT_ROLE,
+          width: Progress::DEFAULT_WIDTH
+        )
+      @progress = Progress.new(
+        terminal: terminal,
+        label: label,
+        total: total,
+        style: style,
+        role: role,
+        width: width,
+      )
+    end
+  end
+end

data/lib/fatty/api/prompt.rb

@@ -0,0 +1,77 @@
+# lib/fatty/api/prompt.rb
+
+module Fatty
+  module PromptApi
+    # Create a popup to ask the user to enter an arbitrary string.  These
+    # prompts will keep their own history based on the history_key, or if not
+    # history_key is given, the prompt text.  If save_history is set to false, no
+    # history will be recorded, which can suppress writing sensitive values
+    # such as passwords to the history file.
+    def prompt(prompt, initial: "", cancel_value: nil, history_key: nil, save_history: true)
+      history_ctx = lambda do
+        base =
+          if @history_ctx.respond_to?(:call)
+            @history_ctx.call
+          elsif @history_ctx.is_a?(Hash)
+            @history_ctx
+          else
+            {}
+          end
+
+        base.merge(prompt: (history_key || prompt).to_s)
+      end
+
+      popup = Fatty::PromptSession.new(
+        title: "Prompt",
+        message: prompt,
+        prompt: "> ",
+        initial: initial,
+        kind: :terminal_prompt,
+        save_history: save_history,
+        history_ctx: history_ctx,
+      )
+      done = false
+      result = nil
+
+      acc_proc = ->(payload) do
+        result = payload[:text]
+        done = true
+      end
+
+      cancel_proc = -> do
+        result = cancel_value
+        done = true
+      end
+
+      owner = Terminal::PopupOwner.new(on_result: acc_proc, on_cancel: cancel_proc)
+
+      begin
+        terminal.apply_command(
+          Fatty::Command.terminal(:push_modal, session: popup, owner: owner)
+        )
+        terminal.render_frame
+
+        while !done && terminal.running?
+          dirty = false
+          command = terminal.event_source.next_event
+
+          if command
+            terminal.apply_command(command)
+            dirty = true
+          end
+
+          begin
+            dirty ||= !!terminal.tick_active_session
+          rescue StandardError => e
+            Fatty.error("PromptApi#prompt tick failed: #{e.class}: #{e.message}", tag: :terminal)
+            dirty = true
+          end
+          terminal.render_frame if dirty
+        end
+      ensure
+        terminal.render_frame
+      end
+      result
+    end
+  end
+end

data/lib/fatty/api/status.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Fatty
+  ###########################################################################################
+  # Public API convenience methods for use by the library user
+  ###########################################################################################
+  module StatusApi
+    # Display text in the status area with the given "role", which determines
+    # the coloring of the displayed text via themeing.
+    def status(text, role: :info, replace: false, render: true)
+      terminal.apply_command(
+        Command.session(
+          :status,
+          :show,
+          text: text,
+          role: role,
+          append: !replace,
+        )
+      )
+      terminal.without_cursor_restore do
+        terminal.render_frame
+      end if render
+      nil
+    end
+
+    # Display a message to the user in the status line, colored according to
+    # the Config for "good," i.e., success.
+    def good(text, replace: false, render: true)
+      status(text, role: :good, replace:, render:)
+    end
+
+    # Display a message to the user in the status line, colored according to
+    # the Config for "info".
+    def info(text, replace: false, render: true)
+      status(text, role: :info, replace:, render:)
+    end
+
+    # Display a message to the user in the status line, colored according to
+    # the Config for "warn," i.e., short of an error but not complete
+    # success either.
+    def warn(text, replace: false, render: true)
+      status(text, role: :warn, replace:, render:)
+    end
+
+    # Display a message to the user in the status line, colored according to
+    # the Config for "oops," i.e., a soft failure.
+    def error(text, replace: false, render: true)
+      status(text, role: :error, replace:, render:)
+    end
+
+    def oops(text, replace: false, render: true)
+      status(text, role: :error, replace:, render:)
+    end
+  end
+end

data/lib/fatty/api.rb

@@ -0,0 +1,38 @@
+module Fatty
+  module ChooseApi
+    # simplecov:disable
+
+    private
+
+    def normalize_choices(choices)
+      case choices
+      when Hash
+        choices.map do |label, value|
+          [label.to_s, value]
+        end
+      when Array
+        choices.map do |choice|
+          unless choice.is_a?(String)
+            raise ArgumentError, "choices array must contain strings"
+          end
+
+          [choice, choice]
+        end
+      else
+        raise ArgumentError, "choices must be an Array of strings or a Hash"
+      end
+    end
+  end
+end
+
+# simplecov:enable
+
+require_relative './api/output.rb'
+require_relative './api/status.rb'
+require_relative './api/alert.rb'
+require_relative './api/choose.rb'
+require_relative './api/prompt.rb'
+require_relative './api/progress.rb'
+require_relative './api/menu.rb'
+require_relative './api/keytest.rb'
+require_relative './api/environment.rb'

data/lib/fatty/callback_environment.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+#
+# This class provides a wrapper around components that can be handed off to
+# Terminal's on_accept method (or other callbacks) for access to Fatty's
+# facilities.  The on_accept proc will receive two parameters: (1) the edited
+# line and (2) an instance of this class called `env` from which the user can
+# access certain facilities that Fatty provides.
+#
+# For example, by using env.append("some text"), the given text will be
+# displayed in the output pane with scrolling, search, etc.  A related method,
+# `env.markdown(<markdown_text>)` will render the given text as markdown and
+# then append it to the output pane.
+#
+# Using env.status will display text in the status area.  Likewise with
+# env.alert for the alert panel.
+#
+# You can add a Progress object to the status_area with env.add_progress and
+# update it with `env.progress.update`.
+module Fatty
+  class CallbackEnvironment
+    INTERRUPT_POLL_INTERVAL = 1.0
+
+    include OutputApi
+    include MenuApi
+    include ProgressApi
+    include ChooseApi
+    include PromptApi
+    include StatusApi
+    include AlertApi
+    include KeytestApi
+    include EnvironmentApi
+
+    attr_reader :label, :payload, :commands, :terminal, :progress
+
+    def initialize(terminal:, output_id:, label: nil)
+      @terminal = terminal
+      @output_id = output_id
+      @label = label
+      @commands = []
+      @last_interrupt_check_at = nil
+    end
+
+    def queue(command)
+      @commands << command
+      command
+    end
+
+    def check_interrupt!
+      now = monotonic_time
+
+      if interrupt_check_due?(now)
+        @last_interrupt_check_at = now
+        raise Fatty::Interrupt if terminal.interrupt_pending?
+      end
+
+      nil
+    end
+
+    private
+
+    def interrupt_check_due?(now)
+      @last_interrupt_check_at.nil? ||
+        now - @last_interrupt_check_at >= INTERRUPT_POLL_INTERVAL
+    end
+
+    def monotonic_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    # simplecov:disable
+
+    attr_reader :output_id
+  end
+end