fatty 0.99.0 → 0.99.3

data/lib/fatty/config_files/themes/wordperfect_light.yml

@@ -1,77 +0,0 @@
-name: wordperfect_light
-inherit: wordperfect
-
-output:
-  fg: white
-  bg: lightblue
-
-# input:
-#   fg: white
-#   bg: navy
-#   attrs: [bold]
-
-# input_suggestion:
-#   fg: lightgray
-#   bg: navy
-
-# cursor:
-#   fg: white
-#   bg: red
-
-# region:
-#   fg: navy
-#   bg: yellow
-
-# good:
-#   fg: green
-#   bg: navy
-
-# info:
-#   fg: black
-#   bg: navy
-
-# warn:
-#   fg: black
-#   bg: magenta
-
-# error:
-#   fg: white
-#   bg: red
-
-# pager_status:
-#   fg: black
-#   bg: lightgreen
-
-# search_input:
-#   fg: black
-#   bg: cyan
-
-# match_current:
-#   fg: black
-#   bg: red
-
-# match_other:
-#   fg: grey
-#   bg: pink
-
-# popup:
-#   fg: white
-#   bg: navy
-
-# popup_input:
-#   fg: white
-#   bg: navy
-
-# popup_counts:
-#   fg: navy
-#   bg: red
-
-# popup_selection:
-#   fg: navy
-#   bg: yellow
-
-# popup_frame:
-#   fg: navy
-#   bg: yellow
-#   border: single
-#   corners: rounded

data/lib/fatty/menu_env.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Fatty
-  class MenuEnv
-    attr_reader :terminal, :session, :label, :payload
-
-    def initialize(terminal:, session:, label: '', payload: nil)
-      @terminal = terminal
-      @session = session
-      @label = label
-      @payload = payload
-    end
-
-    def output(text)
-      session.output.append(text.to_s)
-    end
-
-    def status(text)
-      terminal.set_status(text.to_s)
-    end
-  end
-end

data/lib/fatty/session/input_session.rb

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-module Fatty
-  class InputSession < Session
-    attr_reader :field
-
-    # @param on_accept: ->(line, session, terminal) { ... }
-    def initialize(field:, keymap:, views: [], on_accept: nil)
-      super(keymap: keymap, views: views)
-      @field = field
-      @on_accept = on_accept
-    end
-
-    #########################################################################################
-    # Framework and Session Hooks
-    #########################################################################################
-
-    def keymap_contexts
-      if paging_mode?
-        [:paging, :text, :terminal]
-      else
-        [:text, :terminal]
-      end
-    end
-
-    ############################################################################################
-    # Actions
-    ############################################################################################
-
-    action_on :session
-
-    action :input_accept do
-      line = @field.accept_line
-
-      if @on_accept
-        Array(@on_accept.call(line, self, terminal))
-      else
-        Array(emit([:accept_line, line]))
-      end
-    end
-
-    action :input_cycle_theme do
-      [[:terminal, :cycle_theme]]
-    end
-
-    private
-
-    # Unbound keys land here.
-    def update_key(ev)
-      []
-    end
-
-    def update_cmd(name, payload)
-      case name
-      when :paste
-        text = payload.fetch(:text, "").to_s
-        env = action_env(event: nil)
-        field.act_on(:paste, text, env: env)
-      end
-      []
-    end
-
-    # Bound keys land here because Session#update resolves via keymap first.
-    def handle_action(action, args, event:)
-      which =
-        if event&.respond_to?(:key)
-          event.key.inspect
-        elsif event&.respond_to?(:mouse)
-          event.mouse.inspect
-        end
-      Fatty.debug("InputSession#handle_action: #{which}", tag: :session)
-      env = action_env(event: event)
-
-      with_virtual_suffix_sync do
-        Fatty::Actions.call(action, env, *args)
-      end
-      []
-    rescue ActionError => e
-      Fatty.error("InputSession#handle_action: ActionError #{e.message}", tag: :session)
-      []
-    end
-
-    def action_env(event:)
-      ActionEnvironment.new(
-        session: self,
-        terminal: terminal,
-        event: event,
-        field: @field,
-      )
-    end
-
-    def with_virtual_suffix_sync
-      @field.sync_virtual_suffix!
-      result = yield
-      @field.sync_virtual_suffix!
-      result
-    end
-  end
-end

data/lib/fatty/sessions.rb

@@ -1,14 +0,0 @@
-# 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/progress.rb

@@ -1,374 +0,0 @@
-# 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

data/lib/fatty/view/alert_view.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Fatty
-  class AlertView < Fatty::View
-    def initialize(id: "alert", z: 1_000, log: false)
-      super(id: id, z: z, log: log)
-    end
-
-    def draw(screen:, renderer:, terminal:, session:)
-      # session is AlertSession; it owns `current`
-      renderer.render_alert(session.current)
-    end
-  end
-end

data/lib/fatty/view/cursor_view.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Fatty
-  class CursorView < Fatty::View
-    def draw(screen:, renderer:, terminal:, session:)
-      # When paging is active, the output pane owns the screen and the shell
-      # input cursor should be turned off. This also prevents the underlying
-      # ShellSession from overriding the cursor while a modal (e.g. SearchSession)
-      # is displayed over the pager/status line.
-      if session.respond_to?(:pager_active?) && session.pager_active?
-        ::Curses.curs_set(0)
-      else
-        ::Curses.curs_set(1)
-        renderer.restore_cursor(session.field)
-      end
-    end
-  end
-end

data/lib/fatty/view/input_view.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Fatty
-  class InputView < Fatty::View
-    def draw(screen:, renderer:, terminal:, session:)
-      renderer.render_input_field(session.field)
-    end
-  end
-end

data/lib/fatty/view/output_view.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Fatty
-  class OutputView < View
-    def draw(screen:, renderer:, terminal:, session:)
-      renderer.render_output(session.output, viewport: session.viewport)
-    end
-  end
-end

data/lib/fatty/view/status_view.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Fatty
-  class StatusView < View
-    def render(screen:, renderer:, terminal:)
-      return unless terminal.status_text
-
-      renderer.render_status(
-        terminal.status_text,
-        role: terminal.status_role || :info,
-      )
-    end
-  end
-end

data/lib/fatty/view.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Fatty
-  class View
-    attr_reader :id, :z
-
-    def initialize(id: nil, z: 0, log: false)
-      @id = (id || self.class.name.split("::").last).to_s
-      @z  = Integer(z)
-      @log = !!log
-    end
-
-    # Render wrapper: logs once, then delegates to #draw.
-    # Subclasses implement #draw.
-    def render(screen:, renderer:, terminal:, session:)
-      if @log
-        Fatty.debug(
-          "View#render",
-          tag: :render,
-          view: id,
-          z: z,
-          session: session.respond_to?(:id) ? session.id : session.class.name,
-        )
-      end
-
-      draw(screen:, renderer:, terminal:, session:)
-    end
-
-    def draw(screen:, renderer:, terminal:, session:)
-      raise NotImplementedError, "#{self.class} must implement #draw"
-    end
-  end
-end

data/lib/fatty/views.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "view"
-
-require_relative "view/output_view"
-require_relative "view/alert_view"
-require_relative "view/input_view"
-require_relative "view/cursor_view"
-require_relative "view/status_view"

data/sig/fatty.rbs

@@ -1,4 +0,0 @@
-module Fatty
-  VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
-end