fatty 0.99.0 → 0.99.3

data/lib/fatty/key_map.rb

@@ -12,7 +12,7 @@ module Fatty
   class KeyGesture
     attr_reader :key, :ctrl, :meta, :shift
 
-    def initialize(key:, ctrl:, meta:, shift:)
+    def initialize(key:, ctrl: false, meta: false, shift: false)
       @key = key
       @ctrl = ctrl
       @meta = meta
@@ -64,7 +64,7 @@ module Fatty
   class MouseGesture
     attr_reader :button, :ctrl, :meta, :shift
 
-    def initialize(button:, ctrl:, meta:, shift:)
+    def initialize(button:, ctrl: false, meta: false, shift: false)
       @button = button
       @ctrl = ctrl
       @meta = meta
@@ -152,15 +152,13 @@ module Fatty
 
     # Bind a KeyEvent to an action in the given context.
     def bind(context: DEFAULT_CONTEXT, key:, ctrl: false, meta: false, shift: false, action: nil)
+      context = normalize_binding_symbol(context, field: :context)
+      key = normalize_binding_symbol(key, field: :key)
+      action = normalize_action(action)
+
       bind_str = "#{KeyEvent.key_to_str(key:, ctrl:, meta:, shift:)} -> #{action} in context: #{context}"
       Fatty.info("KeyMap#bind: (#{bind_str})", tag: :keybinding)
 
-      raise ArgumentError, "context must be a Symbol" unless context.is_a?(Symbol)
-      raise ArgumentError, "key must be a Symbol" unless key.is_a?(Symbol)
-      unless action.is_a?(Symbol) || (action.is_a?(Array) && action.first.is_a?(Symbol))
-        raise ArgumentError, "action must be a Symbol or [Symbol, *args]"
-      end
-
       self.class.register_context(context)
 
       evt = KeyEvent.new(
@@ -175,19 +173,17 @@ module Fatty
     end
 
     def bind_mouse(context: DEFAULT_CONTEXT, button:, ctrl: false, meta: false, shift: false, action: nil)
+      context = normalize_binding_symbol(context, field: :context)
+      button = normalize_binding_symbol(button, field: :button)
+      action = normalize_action(action)
+
       bind_str = "#{KeyEvent.key_to_str(key: button, ctrl:, meta:, shift:)} -> #{action} in context: #{context}"
       Fatty.info("KeyMap#bind_mouse(#{bind_str})", tag: :keybinding)
 
-      raise ArgumentError, "context must be a Symbol" unless context.is_a?(Symbol)
-      raise ArgumentError, "button must be a Symbol" unless button.is_a?(Symbol)
-      unless action.is_a?(Symbol) || (action.is_a?(Array) && action.first.is_a?(Symbol))
-        raise ArgumentError, "action must be a Symbol or [Symbol, *args]"
-      end
-
       self.class.register_context(context)
 
       gest = MouseGesture.new(
-        button: button,
+        button:,
         ctrl: truthy?(ctrl),
         meta: truthy?(meta),
         shift: truthy?(shift),
@@ -291,16 +287,58 @@ module Fatty
       return result unless event
 
       gest = gesture_from_event(event)
-
       @bindings.each do |context, map|
         binding = map[gest]
         result[context] = binding if binding
       end
+      if event.printable?
+        self_insert_contexts.each do |context|
+          result[context] ||= [:self_insert, event.text]
+        end
+      end
       result
     end
 
     private
 
+    # simplecov:disable
+
+    def self_insert_contexts
+      [:text, :pager_input].select { |context| self.class.registered_contexts.include?(context) }
+    end
+
+    def normalize_binding_symbol(value, field:)
+      case value
+      when Symbol
+        value
+      when String
+        normalize_symbol_string(value, field:)
+      else
+        raise ArgumentError, "#{field} must be a Symbol or String"
+      end
+    end
+
+    def normalize_action(action)
+      case action
+      when Symbol, String
+        normalize_binding_symbol(action, field: :action)
+      when Array
+        raise ArgumentError, "action must be a Symbol, String, or [Symbol/String, *args]" if action.empty?
+
+        [normalize_binding_symbol(action.first, field: :action), *action.drop(1)]
+      else
+        raise ArgumentError, "action must be a Symbol, String, or [Symbol/String, *args]"
+      end
+    end
+
+    def normalize_symbol_string(value, field:)
+      str = value.strip
+      str = str.delete_prefix(":")
+      raise ArgumentError, "#{field} must not be empty" if str.empty?
+
+      str.to_sym
+    end
+
     def gesture_from_event(event)
       case event
       when Fatty::MouseEvent

data/lib/fatty/keymaps/emacs.rb

@@ -54,8 +54,8 @@ module Fatty
       # Counts (prefix arg)
       map.bind(key: :u, ctrl: true, action: :universal_argument)
       map.bind_digits(context: :text, meta: true)
-      map.bind_digits(context: :popup)
       map.bind_digits(context: :paging)
+      map.bind_digits(context: :paging, meta: true)
       # ShellSession uses contexts [:paging, :terminal] while the pager is
       # active. Bind C-u in :terminal so it works as a prefix during paging
       # (e.g. C-u / to start a regex search).
@@ -70,6 +70,7 @@ module Fatty
 
       # Completion on input
       map.bind(context: :input, key: :tab, action: :complete)
+      map.bind(context: :input, key: :tab, shift: true, action: :complete_previous)
       map.bind(context: :input, key: :tab, meta: true, action: :completion_popup)
 
       # Popup
@@ -77,12 +78,13 @@ module Fatty
       map.bind(context: :popup, key: :g, ctrl: true, action: :popup_cancel)
       map.bind(context: :popup, key: :escape, action: :popup_cancel)
       map.bind(context: :popup, key: :enter, action: :popup_accept)
-      map.bind(context: :popup, key: :tab, action: :popup_accept)
       map.bind(context: :popup, key: :return, action: :popup_accept)
       map.bind(context: :popup, key: :up, action: :popup_prev)
       map.bind(context: :popup, key: :down, action: :popup_next)
       map.bind(context: :popup, key: :p, ctrl: true, action: :popup_prev)
       map.bind(context: :popup, key: :n, ctrl: true, action: :popup_next)
+      map.bind(context: :popup, key: :p, meta: true, action: :history_prev)
+      map.bind(context: :popup, key: :n, meta: true, action: :history_next)
       map.bind(context: :popup, key: :page_up, action: :popup_page_up)
       map.bind(context: :popup, key: :page_down, action: :popup_page_down)
       map.bind(context: :popup, key: :v, meta: true, action: :popup_page_up)
@@ -92,6 +94,10 @@ module Fatty
       map.bind(context: :popup, key: :'<', meta: true, action: :popup_top)
       map.bind(context: :popup, key: :'>', meta: true, action: :popup_bottom)
       map.bind(context: :popup, key: :l, ctrl: true, action: :popup_recenter)
+      map.bind(context: :popup, key: :tab, action: :popup_tab)
+      map.bind(context: :popup, key: :tab, shift: true, action: :popup_backtab)
+      map.bind(context: :popup, key: :right, action: :popup_tab)
+      map.bind(context: :popup, key: :left, action: :popup_backtab)
 
       # Popups that present multiple items for selection have a special
       # context that steals the SPACE key for toggling selection
@@ -100,10 +106,16 @@ module Fatty
       # Prompt
       map.bind(context: :prompt, key: :c, ctrl: true, action: :prompt_cancel)
       map.bind(context: :prompt, key: :g, ctrl: true, action: :prompt_cancel)
+      map.bind(context: :prompt, key: :escape, action: :prompt_cancel)
       map.bind(context: :prompt, key: :enter, action: :prompt_accept)
       map.bind(context: :prompt, key: :return, action: :prompt_accept)
       map.bind(context: :prompt, key: :j, ctrl: true, action: :prompt_accept)
 
+      # Prompt history
+      map.bind(context: :prompt, key: :p, ctrl: true, action: :history_prev)
+      map.bind(context: :prompt, key: :n, ctrl: true, action: :history_next)
+      map.bind(context: :prompt, key: :up, action: :history_prev)
+      map.bind(context: :prompt, key: :down, action: :history_next)
       #
       # Themes
       map.bind(context: :terminal, key: :t, meta: true, ctrl: true, action: :cycle_theme)
@@ -144,14 +156,30 @@ module Fatty
       map.bind(context: :paging, key: :c, ctrl: true, action: :quit_paging)
       map.bind(context: :paging, key: :g, ctrl: true, action: :quit_paging)
       map.bind(context: :paging, key: :q, action: :quit_paging)
+      map.bind(context: :paging, key: :escape, action: :quit_paging)
 
       # Paging search (opens SearchSession via ShellSession actions)
       map.bind(context: :paging, key: :/, action: :pager_search_forward)
       map.bind(context: :paging, key: :'?', action: :pager_search_backward)
+      map.bind(context: :paging, key: :/, ctrl: true, action: :pager_regex_search_forward)
+      map.bind(context: :paging, key: :'?', ctrl: true, action: :pager_regex_search_backward)
       # Incremental (string-only) search like Emacs isearch.
       # Regex is intentionally non-incremental (use C-u / or / then toggle).
       map.bind(context: :paging, key: :s, ctrl: true, action: :pager_isearch_forward)
       map.bind(context: :paging, key: :r, ctrl: true, action: :pager_isearch_backward)
+      map.bind(context: :paging, key: :s, meta: true, ctrl: true, action: :pager_regex_search_forward)
+      map.bind(context: :paging, key: :r, meta: true, ctrl: true, action: :pager_regex_search_backward)
+
+      # Repeat last search (no minibuffer)
+      map.bind(context: :paging, key: :n, action: :pager_search_next)
+      map.bind(context: :paging, key: :N, action: :pager_search_prev)
+
+      # Line numbers
+      map.bind(context: :paging, key: :'=', action: :toggle_line_numbers)
+
+      # Narrowing
+      map.bind(context: :paging, key: :'<', action: :narrow_output)
+      map.bind(context: :paging, key: :'>', action: :widen_output)
 
       # I-search controls (within ISearchSession)
       map.bind(context: :isearch, key: :enter, action: :isearch_accept)
@@ -159,14 +187,14 @@ module Fatty
       map.bind(context: :isearch, key: :j, ctrl: true, action: :isearch_accept)
       map.bind(context: :isearch, key: :s, ctrl: true, action: :isearch_next)
       map.bind(context: :isearch, key: :r, ctrl: true, action: :isearch_prev)
+      map.bind(context: :isearch, key: :p, ctrl: true, action: :history_prev)
+      map.bind(context: :isearch, key: :n, ctrl: true, action: :history_next)
+      map.bind(context: :isearch, key: :up, action: :history_prev)
+      map.bind(context: :isearch, key: :down, action: :history_next)
       map.bind(context: :isearch, key: :c, ctrl: true, action: :isearch_cancel)
       map.bind(context: :isearch, key: :g, ctrl: true, action: :isearch_cancel)
       map.bind(context: :isearch, key: :escape, action: :isearch_cancel)
 
-      # Repeat last search (no minibuffer)
-      map.bind(context: :paging, key: :n, action: :pager_search_next)
-      map.bind(context: :paging, key: :N, action: :pager_search_prev)
-
       # Search controls (within SearchSession)
       map.bind(context: :search, key: :enter, action: :search_accept)
       map.bind(context: :search, key: :return, action: :search_accept)
@@ -174,6 +202,10 @@ module Fatty
       map.bind(context: :search, key: :s, ctrl: true, action: :search_step_forward)
       map.bind(context: :search, key: :r, ctrl: true, action: :search_step_backward)
       map.bind(context: :search, key: :r, meta: true, action: :search_toggle_regex)
+      map.bind(context: :search, key: :p, ctrl: true, action: :history_prev)
+      map.bind(context: :search, key: :n, ctrl: true, action: :history_next)
+      map.bind(context: :search, key: :up, action: :history_prev)
+      map.bind(context: :search, key: :down, action: :history_next)
       map.bind(context: :search, key: :c, ctrl: true, action: :search_cancel)
       map.bind(context: :search, key: :g, ctrl: true, action: :search_cancel)
       map.bind(context: :search, key: :escape, action: :search_cancel)
@@ -181,6 +213,8 @@ module Fatty
       # Mouse scrolling in paging
       map.bind_mouse(context: :paging, button: :scroll_up, action: :scroll_up)
       map.bind_mouse(context: :paging, button: :scroll_down, action: :scroll_down)
+      map.bind_mouse(context: :paging, button: :scroll_up, ctrl: true, action: :page_up)
+      map.bind_mouse(context: :paging, button: :scroll_down, ctrl: true, action: :page_down)
 
       # Load the user's keybindings
       map.load_user_config.activate!

data/lib/fatty/log_formats/json.rb

@@ -22,6 +22,8 @@ module Fatty
 
       private
 
+      # simplecov:disable
+
       def stringify_keys(hash)
         hash.each_with_object({}) do |(k, v), memo|
           memo[k.to_s] = v

data/lib/fatty/log_formats/text.rb

@@ -42,6 +42,8 @@ module Fatty
 
       private
 
+      # simplecov:disable
+
       def render_hash(msg)
         event = msg[:event] || msg["event"]
         tag = msg[:tag] || msg["tag"]

data/lib/fatty/logger.rb

@@ -66,17 +66,22 @@ module Fatty
     #     - command:: Terminal.apply_command / :send dispatches
     #     - session:: session update calls, mode/context stack changes
     #     - render:: viewports, layout sizes, redraw triggers
-    #     - perf:: timings, frame time, slow paths
     #     - all:: All of the above
+    #     - perf:: timings, frame time, slow paths
     def self.log(event = nil, level: :debug, tag: nil, **data)
       return unless logger
 
       tags = active_tags
+
+      # The :perf tag has to be requested explicitly: it is not implied by
+      # :all.
+      return if tag == :perf && !tags.include?(:perf)
+
       if tag && !tags.include?(:all)
         return unless tags.include?(tag.to_sym)
       end
 
-      payload = { event: event, tag: tag }
+      payload = { tag: tag, event: event }
       payload.merge!(data.reject { |k, _| k == :event || k == :tag })
 
       logger.add(severity(level), payload)

data/lib/fatty/markdown/ansi_renderer.rb

@@ -7,15 +7,17 @@ module Fatty
   class AnsiRenderer < Redcarpet::Render::Base
     HARD_BREAK = "\uE000"
 
-    def initialize(width: 80, palette: nil)
+    def initialize(width: 80, palette: nil, theme: nil, truecolor: false)
       super()
       @width = width.to_i
       @palette = palette || {}
+      @theme = theme || {}
+      @truecolor = truecolor
     end
 
     def block_code(code, language)
       lexer = rouge_lexer(language.to_s, code.to_s)
-      formatter = Rouge::Formatters::Terminal256.new
+      formatter = rouge_formatter
       gutter = md("│ ", :markdown_code_gutter)
 
       highlighted = formatter.format(lexer.lex(code.to_s))
@@ -271,6 +273,8 @@ module Fatty
 
     private
 
+    # simplecov:disable
+
     def wrap(text, first_prefix: "", rest_prefix: first_prefix)
       hard_lines = text.to_s.split(HARD_BREAK, -1)
 
@@ -336,20 +340,30 @@ module Fatty
       codes << 4 if attrs.include?(:underline)
       codes << 7 if attrs.include?(:reverse)
 
-      if (fg_rgb = spec[:fg_rgb] || spec["fg_rgb"])
+      fg_rgb = spec[:fg_rgb] || spec["fg_rgb"]
+      bg_rgb = spec[:bg_rgb] || spec["bg_rgb"]
+      fg = spec[:fg] || spec["fg"]
+      bg = spec[:bg] || spec["bg"]
+
+      if fg_rgb
         codes.push(38, 2, *fg_rgb)
-      elsif (fg = spec[:fg] || spec["fg"])
+      elsif !default_color?(fg)
         codes.concat(color_codes(fg, foreground: true))
       end
 
-      if (bg_rgb = spec[:bg_rgb] || spec["bg_rgb"])
+      if bg_rgb
         codes.push(48, 2, *bg_rgb)
-      elsif (bg = spec[:bg] || spec["bg"])
+      elsif !default_color?(bg)
         codes.concat(color_codes(bg, foreground: false))
       end
+
       codes
     end
 
+    def default_color?(color)
+      color.nil? || color.to_i == Fatty::Color::DEFAULT_INDEX
+    end
+
     def color_codes(color, foreground:)
       color = color.to_i
 
@@ -369,5 +383,60 @@ module Fatty
         [48, 5, color]
       end
     end
+
+    def rouge_theme
+      case markdown_code_theme
+      when :solarized_light
+        Rouge::Themes::Base16::Solarized.mode(:light).new
+      when :solarized_dark
+        Rouge::Themes::Base16::Solarized.mode(:dark).new
+      when :base16
+        Rouge::Themes::Base16.new
+      when :base16_monokai
+        Rouge::Themes::Base16::Monokai.mode(:dark).new
+      when :monokai
+        Rouge::Themes::Monokai.new
+      when :monokai_sublime
+        Rouge::Themes::MonokaiSublime.new
+      when :gruvbox_light
+        Rouge::Themes::Gruvbox.mode(:light).new
+      when :gruvbox_dark
+        Rouge::Themes::Gruvbox.mode(:dark).new
+      when :github
+        Rouge::Themes::Github.mode(:light).new
+      when :github_dark
+        Rouge::Themes::Github.mode(:dark).new
+      when :molokai
+        Rouge::Themes::Molokai.new
+      when :colorful
+        Rouge::Themes::Colorful.new
+      when :bw
+        Rouge::Themes::BlackWhiteTheme.new
+      when :pastie
+        Rouge::Themes::Pastie.new
+      when :tulip
+        Rouge::Themes::Tulip.new
+      when :igor_pro
+        Rouge::Themes::IgorPro.new
+      when :magritte
+        Rouge::Themes::Magritte.new
+      else
+        Rouge::Themes::ThankfulEyes.new
+      end
+    end
+
+    def markdown_code_theme
+      value = @theme[:markdown_code_theme] if @theme.respond_to?(:[])
+      value.to_s.tr("-", "_").to_sym
+    end
+
+    def rouge_formatter
+      formatter_class = truecolor? ? Rouge::Formatters::TerminalTruecolor : Rouge::Formatters::Terminal256
+      formatter_class.new(rouge_theme)
+    end
+
+    def truecolor?
+      @truecolor
+    end
   end
 end

data/lib/fatty/markdown/render.rb

@@ -2,10 +2,9 @@
 
 module Fatty
   module Markdown
-    def self.render(text, width: 80, palette: nil)
+    def self.render(text, width: 80, palette: nil, theme: nil, truecolor: false) #
       markdown = Redcarpet::Markdown.new(
-        Fatty::AnsiRenderer.new(width: width, palette: palette),
-        no_intra_emphasis: true,
+        Fatty::AnsiRenderer.new(width: width, palette: palette, theme: theme, truecolor: truecolor),
         tables: true,
         fenced_code_blocks: true,
         autolink: true,

data/lib/fatty/mouse_event.rb

@@ -6,7 +6,7 @@ module Fatty
   class MouseEvent
     attr_reader :button, :x, :y, :ctrl, :meta, :shift, :raw
 
-    def initialize(button:, x: nil, y:, raw: nil, ctrl: false, meta: false, shift: false)
+    def initialize(button:, x: 0, y: 0, raw: nil, ctrl: false, meta: false, shift: false)
       @button = button
       @x = x
       @y = y
@@ -17,8 +17,21 @@ module Fatty
       Fatty.debug("#{self.class}#new(#{self})", tag: :event)
     end
 
+    def key
+      :mouse
+    end
+
     def to_s
-      "MouseEvent: button: `#{button}`, x: `#{x}`, y: `#{y}`, raw: `#{raw}`, ctrl: `#{ctrl}`, meta: `#{meta}`, shift: `#{shift}`"
+      self.class.button_to_str(button:, ctrl:, meta:, shift:)
+    end
+
+    def self.button_to_str(button:, ctrl: false, meta: false, shift: false)
+      mods = []
+      mods << "C" if ctrl
+      mods << "M" if meta
+      mods << "S" if shift
+      button_str = button.to_s
+      mods.empty? ? button_str : "#{mods.join('-')}-#{button_str}"
     end
 
     def printable?
@@ -28,5 +41,132 @@ module Fatty
     def mouse?
       true
     end
+
+    def ctrl?
+      @ctrl
+    end
+
+    def meta?
+      @meta
+    end
+
+    def shift?
+      @shift
+    end
+
+    def bindings
+      Fatty::KeyMap.active.bindings_for(self) || {}
+    end
+
+    def report
+      rule = "=" * 55 + "\n"
+      out = +""
+      out << rule
+      out << "Mouse report #{status_string}:\n"
+      out << "  raw:       #{raw.inspect}\n"
+      out << "  button:    #{button.inspect}\n"
+      out << "  name:      #{to_s}\n"
+      out << "  x:         #{x.inspect}\n"
+      out << "  y:         #{y.inspect}\n"
+      out << "  modifiers: #{modifier_text}\n"
+      out << "  bindings:\n#{bindings_text}\n"
+      out << "\n"
+    end
+
+    def suggested_snippet(_terminal_name)
+      bindings.empty? ? suggested_mouse_binding : ""
+    end
+
+    private
+
+    def status_string
+      bindings.empty? ? "(UNBOUND)" : "(BOUND)"
+    end
+
+    def modifier_text
+      mods = []
+      mods << "ctrl" if ctrl?
+      mods << "meta" if meta?
+      mods << "shift" if shift?
+      mods.empty? ? "(none)" : mods.join(", ")
+    end
+
+    def bindings_text
+      return "(none)" if bindings.empty?
+
+      bindings.map { |context, binding|
+        action, _args = binding_action(binding)
+        "    context: #{context}: #{binding_text(binding)}#{action_target_text(action)}"
+      }.join("\n")
+    end
+
+    def binding_action(binding)
+      case binding
+      when Array
+        [binding[0], binding[1..] || []]
+      else
+        [binding, []]
+      end
+    end
+
+    def binding_text(binding)
+      case binding
+      when nil
+        "(none)"
+      when Array
+        action = binding[0]
+        args = binding[1..] || []
+        args.empty? ? action.inspect : "#{action.inspect} #{args.inspect}"
+      else
+        binding.inspect
+      end
+    end
+
+    def action_target_text(action)
+      return "" unless action
+
+      defn = Fatty::Actions.lookup(action)
+      return "  (unregistered action)" unless defn
+
+      "  (#{defn[:on]}: #{action_owner_name(defn[:owner])}##{defn[:method]})"
+    end
+
+    def action_owner_name(owner)
+      name =
+        if owner.respond_to?(:name) && owner.name
+          owner.name
+        else
+          owner.to_s
+        end
+      name.split("::").last
+    end
+
+    def suggested_mouse_binding
+      out = <<~TEXT
+
+        No action is bound to #{to_s}.
+
+        Suggested keybindings.yml entry:
+
+        ............>8 snip here 8<....................
+        #{yaml_desc}
+        ............>8 snip here 8<....................
+      TEXT
+
+      out << <<~TEXT
+
+      TEXT
+      out
+    end
+
+    def yaml_desc
+      lines = ["# #{to_s}", "- button: #{button}"]
+      lines << "  shift: true" if shift?
+      lines << "  ctrl: true" if ctrl?
+      lines << "  meta: true" if meta?
+      lines << "  context: <valid_context>"
+      lines << "  action: <action_name>"
+      lines.join("\n")
+    end
   end
 end

data/lib/fatty/output_buffer.rb

@@ -52,6 +52,8 @@ module Fatty
 
     private
 
+    # simplecov:disable
+
     def append_fragment(fragment)
       ntrimmed = 0
       if @line_open && @lines.any?