fatty 0.99.0

data/lib/fatty/key_map.rb

@@ -0,0 +1,392 @@
+# frozen_string_literal: true
+
+require_relative 'keymaps/emacs'
+
+module Fatty
+  # This struct is used as a key into the KeyMap.  It represents only those
+  # parts of the KeyEvent that are relevant for resolving bindings.  It also
+  # normalizes the use of uppercase letters, like 'G' to convert them to a
+  # canonical :g with shift: true.  That way the user can bind either to mean
+  # the same thing.
+  # KeyGesture = Struct.new(:key, :ctrl, :meta, :shift, keyword_init: true) do
+  class KeyGesture
+    attr_reader :key, :ctrl, :meta, :shift
+
+    def initialize(key:, ctrl:, meta:, shift:)
+      @key = key
+      @ctrl = ctrl
+      @meta = meta
+      @shift = shift
+    end
+
+    def self.from_event(ev)
+      k = ev&.key
+      ctrl = !!ev&.ctrl
+      meta = !!ev&.meta
+      shift = !!ev&.shift
+
+      if k.is_a?(Symbol)
+        s = k.to_s
+        if s.length == 1
+          ch = s[0]
+          if ('A'..'Z').cover?(ch)
+            # Decoder (or config) used :G. Canonicalize to :g + shift.
+            k = ch.downcase.to_sym
+            shift = true
+          elsif ('a'..'z').cover?(ch)
+            # Decoder used :g. Keep it, but allow explicit shift to mean uppercase.
+            k = ch.to_sym
+          end
+        end
+      end
+
+      new(key: k, ctrl: ctrl, meta: meta, shift: shift)
+    end
+
+    def ==(other)
+      other.is_a?(self.class) &&
+        key == other.key &&
+        ctrl == other.ctrl &&
+        meta == other.meta &&
+        shift == other.shift
+    end
+    alias_method :eql?, :==
+
+    def hash
+      [self.class, key, ctrl, meta, shift].hash
+    end
+
+    def inspect
+      "#<#{self.class} key=#{key.inspect} ctrl=#{ctrl} meta=#{meta} shift=#{shift}>"
+    end
+  end
+
+  class MouseGesture
+    attr_reader :button, :ctrl, :meta, :shift
+
+    def initialize(button:, ctrl:, meta:, shift:)
+      @button = button
+      @ctrl = ctrl
+      @meta = meta
+      @shift = shift
+    end
+
+    def self.from_event(event)
+      new(
+        button: event.button,
+        ctrl: !!event.ctrl,
+        meta: !!event.meta,
+        shift: !!event.shift,
+      )
+    end
+
+    def ==(other)
+      other.is_a?(self.class) &&
+        button == other.button &&
+        ctrl == other.ctrl &&
+        meta == other.meta &&
+        shift == other.shift
+    end
+    alias_method :eql?, :==
+
+    def hash
+      [self.class, button, ctrl, meta, shift].hash
+    end
+
+    def inspect
+      "#<#{self.class} button=#{button.inspect} ctrl=#{ctrl} meta=#{meta} shift=#{shift}>"
+    end
+  end
+
+  # The KeyMap class maintains the mapping between KeyEvent's and action names
+  # that can be handled by Terminal.  Terminal can delegate the action to any
+  # of its controlled components or handle the action itself.  Currently,
+  # there are two contexts for KeyBinding: :input (for composing a line at the
+  # Terminal) and :paging (for controlling the display of output that is
+  # longer than the Viewport).  The default keybinding context is :input.
+  class KeyMap
+    attr_reader :bindings
+
+    DEFAULT_CONTEXT = :text
+
+    class << self
+      attr_accessor :active
+    end
+
+    def self.registered_contexts
+      @registered_contexts ||= [DEFAULT_CONTEXT, :input, :paging]
+    end
+
+    def self.valid_contexts
+      registered_contexts.map(&:to_s).sort
+    end
+
+    # Register a context (optionally before/after another for precedence/printing)
+    def self.register_context(ctx, before: nil, after: nil)
+      ctx = ctx.to_s.to_sym
+      list = registered_contexts
+      return ctx if list.include?(ctx)
+
+      if before
+        i = list.index(before.to_s.to_sym) || 0
+        list.insert(i, ctx)
+      elsif after
+        i = list.index(after.to_s.to_sym)
+        i ? list.insert(i + 1, ctx) : list << ctx
+      else
+        list << ctx
+      end
+
+      ctx
+    end
+
+    def initialize
+      @bindings = Hash.new { |h, ctx| h[ctx] = {} }
+      self.class.active ||= self
+    end
+
+    def activate!
+      self.class.active = self
+      self
+    end
+
+    # Bind a KeyEvent to an action in the given context.
+    def bind(context: DEFAULT_CONTEXT, key:, ctrl: false, meta: false, shift: false, action: nil)
+      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(
+        key:,
+        ctrl: truthy?(ctrl),
+        meta: truthy?(meta),
+        shift: truthy?(shift),
+      )
+      gest = KeyGesture.from_event(evt)
+      @bindings[context][gest] = action
+      self
+    end
+
+    def bind_mouse(context: DEFAULT_CONTEXT, button:, ctrl: false, meta: false, shift: false, action: nil)
+      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,
+        ctrl: truthy?(ctrl),
+        meta: truthy?(meta),
+        shift: truthy?(shift),
+      )
+      @bindings[context][gest] = action
+      self
+    end
+
+    def resolve(event, contexts: [])
+      result = binding_for(event, contexts: contexts)
+      map_str = "#{event} -> #{result.inspect} in contexts: #{contexts} "
+      Fatty.debug("KeyMap#resolve: #{map_str}", tag: :keybinding)
+      result
+    end
+
+    # Return [action, args] where args is always an Array (possibly empty).
+    def resolve_action(event, contexts: [])
+      binding = resolve(event, contexts: contexts)
+
+      if binding
+        if binding.is_a?(Array)
+          action = binding[0]
+          args = binding[1..] || []
+          Fatty.debug("KeyMap.resolve_action: action: #{action.inspect}, args: #{args.inspect}", tag: :keybinding)
+          [action, args]
+        else
+          Fatty.debug("KeyMap.resolve_action: action: #{binding.inspect}, args: []", tag: :keybinding)
+          [binding, []]
+        end
+      elsif event&.printable? && (contexts.include?(:text) || contexts.include?(:pager_input))
+        # Default: treat printable characters as a self-insert but only in
+        # those contexts designed to take text input, not contexts like
+        # :paging where keys are meant for control.
+        [:self_insert, [event.text]]
+      else
+        [nil, []]
+      end
+    end
+
+    # Return all contexts currently used in this instance
+    def contexts
+      @bindings.keys
+    end
+
+    # Make the bindings from the user's config file, usually at
+    # ~/.config/fatty/keybindings.yml
+    def load_user_config
+      Fatty.info("Read keybindings from #{Config.user_keybindings_path}", tag: :keybinding)
+      data = Fatty::Config.keybindings
+      return self unless data.is_a?(Array)
+
+      Fatty.info("User keybindings", config: data, tag: :keybinding)
+      data.each_with_index do |entry, idx|
+        bind_entry(entry, idx)
+      end
+      self
+    rescue Psych::SyntaxError => e
+      Fatty.error("KeyMap#load_config syntax error in keybindings: #{e.message}", tag: :keybinding)
+      self
+    end
+
+    # Bind the digits in the given context with either meta, ctrl, neither or
+    # both as the required modifier keys.
+    def bind_digits(context: DEFAULT_CONTEXT, meta: nil, ctrl: nil)
+      meta = !!meta
+      ctrl = !!ctrl
+      (0..9).each do |n|
+        bind(
+          context: context,
+          key: n.to_s.to_sym,
+          meta: meta,
+          ctrl: ctrl,
+          action: [:count_digit, n],
+        )
+      end
+    end
+
+    # Return the keybinding for event in contexts without executing.  For
+    # reporting purposes, especially in Session::KeyTest.
+    def binding_for(event, contexts: [])
+      return unless event
+
+      ctxs = normalize_contexts(contexts)
+      gest = gesture_from_event(event)
+
+      result = nil
+      ctxs.each do |ctx|
+        map = @bindings.fetch(ctx, nil)
+        next unless map
+
+        result = map[gest]
+        break if result
+      end
+      result
+    end
+
+    # Return all keybindings for event across every context actually loaded
+    # without executing.
+    def bindings_for(event)
+      result = {}
+      return result unless event
+
+      gest = gesture_from_event(event)
+
+      @bindings.each do |context, map|
+        binding = map[gest]
+        result[context] = binding if binding
+      end
+      result
+    end
+
+    private
+
+    def gesture_from_event(event)
+      case event
+      when Fatty::MouseEvent
+        MouseGesture.from_event(event)
+      else
+        KeyGesture.from_event(event)
+      end
+    end
+
+    # Make a binding from an entry Hash that has keys for context, key (the
+    # unmodified key name), the modifiers, 'ctrl', 'meta', and 'shift'.  The
+    # valid keynames, apart from all the printable characters on the keyboard,
+    # are given in the constant Fatty::CURSES_TO_EVENT map defined in the
+    # curses_coder file.
+    def bind_entry(entry, idx, default_context: DEFAULT_CONTEXT)
+      unless entry.is_a?(Hash)
+        Fatty.error("KeyMap#bind_entry invalid keybinding at index #{idx} (not a map)", tag: :keybinding)
+        return
+      end
+
+      key = entry["key"] || entry[:key]
+      button = entry["button"] || entry[:button]
+      action = entry["action"] || entry[:action]
+      ctx =
+        if entry.key?("context")
+          entry["context"]
+        elsif entry.key?(:context)
+          entry[:context]
+        else
+          default_context
+        end
+
+      unless (key || button) && action
+        Fatty.error(
+          "KeyMap#bind_entry missing key/button or action for context `#{ctx}` at index #{idx}",
+          tag: :keybinding,
+        )
+        return
+      end
+
+      if button
+        bind_mouse(
+          context: ctx.to_sym,
+          button: button.to_sym,
+          ctrl:  entry["ctrl"]  || entry[:ctrl]  || false,
+          meta:  entry["meta"]  || entry[:meta]  || false,
+          shift: entry["shift"] || entry[:shift] || false,
+          action: action.to_sym,
+        )
+      else
+        bind(
+          context: ctx.to_sym,
+          key:    key.to_sym,
+          ctrl:   entry["ctrl"]  || entry[:ctrl]  || false,
+          meta:   entry["meta"]  || entry[:meta]  || false,
+          shift:  entry["shift"] || entry[:shift] || false,
+          action: action.to_sym,
+        )
+      end
+      self
+    end
+
+    # Allow the user to supply an empty Array or nil to search all contexts.
+    def normalize_contexts(contexts)
+      case contexts
+      when Array
+        if contexts.empty?
+          self.class.registered_contexts
+        else
+          contexts.compact.map { |c| c.to_s.to_sym }
+        end
+      when String, Symbol
+        [contexts.to_s.to_sym]
+      when NilClass
+        self.class.registered_contexts
+      else
+        raise ArgumentError, "contexts must be Symbol/String, Array, or nil"
+      end
+    end
+
+    def truthy?(str)
+      return false unless str
+      return true if str == true
+      return true if str.to_s.match?(/\At/i)
+
+      false
+    end
+  end
+end

data/lib/fatty/keymaps/emacs.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module Fatty
+  module Keymaps
+    def self.emacs
+      map = KeyMap.new
+
+      # Motion
+      map.bind(key: :f, ctrl: true, action: :move_right)
+      map.bind(key: :b, ctrl: true, action: :move_left)
+      map.bind(key: :right, action: :move_right)
+      map.bind(key: :left,  action: :move_left)
+      map.bind(key: :f, meta: true, action: :move_word_right)
+      map.bind(key: :b, meta: true, action: :move_word_left)
+      map.bind(key: :right, meta: true, action: :move_word_right)
+      map.bind(key: :left, meta: true, action: :move_word_left)
+      map.bind(key: :right, ctrl: true, action: :move_word_right)
+      map.bind(key: :left, ctrl: true, action: :move_word_left)
+
+      map.bind(key: :t, ctrl: true,  context: :input, action: :transpose_chars)
+      map.bind(key: :t, meta: true,  context: :input, action: :transpose_words)
+
+      map.bind(key: :a, ctrl: true, action: :bol)
+      map.bind(key: :e, ctrl: true, action: :eol)
+      map.bind(key: :home, action: :bol)
+      map.bind(key: :end, action: :eol)
+
+      # Deletion
+      map.bind(key: :delete, action: :delete_char_forward)
+      map.bind(key: :d, ctrl: true, action: :delete_char_forward)
+      map.bind(key: :backspace, action: :delete_char_backward)
+      map.bind(key: :backspace, meta: true, action: :kill_word_backward)
+      map.bind(key: :w, ctrl: true, action: :kill_word_backward)
+      map.bind(key: :d, meta: true, action: :kill_word_forward)
+      map.bind(key: :k, ctrl: true, action: :kill_to_eol)
+
+      # Undo / Redo
+      map.bind(key: :/, ctrl: true, action: :undo)
+      map.bind(key: :_, ctrl: true, action: :undo)
+      map.bind(key: :/, ctrl: true, meta: true, action: :redo)
+      map.bind(key: :/, meta: true, action: :redo)
+
+      # Region / Mark
+      map.bind(key: :space, ctrl: true, action: :set_mark)
+      map.bind(key: :'@', ctrl: true, action: :set_mark)
+      map.bind(key: :g, ctrl: true, action: :clear_mark)
+      map.bind(key: :w, ctrl: true, action: :kill_region)
+      map.bind(key: :w, meta: true, action: :copy_region)
+
+      # Yank / Kill ring
+      map.bind(key: :y, ctrl: true, action: :yank)
+      map.bind(key: :y, meta: true, action: :yank_pop)
+
+      # 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)
+      # 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).
+      map.bind(context: :terminal, key: :u, ctrl: true, action: :universal_argument)
+
+      # History
+      map.bind(context: :input, key: :p, ctrl: true, action: :history_prev)
+      map.bind(context: :input, key: :n, ctrl: true, action: :history_next)
+      map.bind(context: :input, key: :up, action: :history_prev)
+      map.bind(context: :input, key: :down, action: :history_next)
+      map.bind(context: :input, key: :r, ctrl: true, action: :history_search)
+
+      # Completion on input
+      map.bind(context: :input, key: :tab, action: :complete)
+      map.bind(context: :input, key: :tab, meta: true, action: :completion_popup)
+
+      # Popup
+      map.bind(context: :popup, key: :c, ctrl: true, action: :popup_cancel)
+      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: :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)
+      map.bind(context: :popup, key: :v, ctrl: true, action: :popup_page_down)
+      map.bind(context: :popup, key: :home, action: :popup_top)
+      map.bind(context: :popup, key: :end, action: :popup_bottom)
+      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)
+
+      # Popups that present multiple items for selection have a special
+      # context that steals the SPACE key for toggling selection
+      map.bind(context: :popup_multi, key: :space, action: :popup_toggle_selected)
+
+      # 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: :enter, action: :prompt_accept)
+      map.bind(context: :prompt, key: :return, action: :prompt_accept)
+      map.bind(context: :prompt, key: :j, ctrl: true, action: :prompt_accept)
+
+      #
+      # Themes
+      map.bind(context: :terminal, key: :t, meta: true, ctrl: true, action: :cycle_theme)
+      map.bind(context: :terminal, key: :'=', meta: true, action: :choose_theme)
+
+      # Final States
+      map.bind(context: :terminal, key: :c, ctrl: true, action: :interrupt)
+      map.bind(context: :input, key: :d, ctrl: true, action: :interrupt_if_empty)
+      map.bind(context: :input, key: :enter, action: :submit_line)
+      map.bind(context: :input, key: :return, action: :submit_line)
+      map.bind(context: :input, key: :j, ctrl: true, action: :submit_line)
+      map.bind(context: :input, key: :j, ctrl: true, meta: true, action: :submit_and_scroll)
+
+      # Output control
+      map.bind(key: :l, ctrl: true, action: :clear_output)
+      map.bind(context: :paging, key: :up, action: :line_up)
+      map.bind(context: :paging, key: :down, action: :line_down)
+      map.bind(context: :paging, key: :k, action: :line_up)
+      map.bind(context: :paging, key: :j, action: :line_down)
+      map.bind(context: :paging, key: :page_up, action: :page_up)
+      map.bind(context: :paging, key: :b, action: :page_up)
+      map.bind(context: :paging, key: :u, action: :page_up)
+      map.bind(context: :paging, key: :h, ctrl: true, action: :page_up)
+      map.bind(context: :paging, key: :page_down, action: :page_down)
+      map.bind(context: :paging, key: :f, action: :page_down)
+      map.bind(context: :paging, key: :d, action: :page_down)
+      map.bind(context: :paging, key: :space, action: :page_down)
+      map.bind(context: :paging, key: :v, ctrl: true, action: :page_down)
+      map.bind(context: :paging, key: :v, meta: true, action: :page_up)
+      map.bind(context: :paging, key: :home, action: :page_top)
+      map.bind(context: :paging, key: :g, action: :page_top)
+      map.bind(context: :paging, key: :'<', meta: true, action: :page_top)
+      map.bind(context: :paging, key: :end, action: :page_bottom)
+      map.bind(context: :paging, key: :G, action: :page_bottom)
+      map.bind(context: :paging, key: :'>', meta: true, action: :page_bottom)
+      map.bind(context: :paging, key: :s, meta: true, action: :toggle_paging)
+      map.bind(context: :terminal, key: :s, meta: true, action: :toggle_paging)
+      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)
+
+      # 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)
+      # 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)
+
+      # I-search controls (within ISearchSession)
+      map.bind(context: :isearch, key: :enter, action: :isearch_accept)
+      map.bind(context: :isearch, key: :return, action: :isearch_accept)
+      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: :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)
+      map.bind(context: :search, key: :j, ctrl: true, action: :search_accept)
+      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: :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)
+
+      # 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)
+
+      # Load the user's keybindings
+      map.load_user_config.activate!
+    end
+  end
+end

data/lib/fatty/log_formats/json.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Fatty
+  module Logger
+    class JsonFormatter < ::Logger::Formatter
+      def call(level, time, progname, msg)
+        rec = {
+          t: time.utc.iso8601(6),
+          sev: level,
+          prog: progname
+        }
+
+        case msg
+        when Hash
+          rec.merge!(stringify_keys(msg))
+        else
+          merge_string_message!(rec, msg)
+        end
+
+        rec.to_json << "\n"
+      end
+
+      private
+
+      def stringify_keys(hash)
+        hash.each_with_object({}) do |(k, v), memo|
+          memo[k.to_s] = v
+        end
+      end
+
+      def merge_string_message!(rec, msg)
+        text = msg.to_s
+
+        begin
+          parsed = JSON.parse(text)
+          if parsed.is_a?(Hash)
+            rec.merge!(parsed)
+          else
+            rec["msg"] = parsed
+          end
+        rescue JSON::ParserError
+          rec["msg"] = text
+        end
+      end
+    end
+  end
+end

data/lib/fatty/log_formats/text.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+#       def render_hash(msg)
+#         event = msg[:event] || msg["event"]
+#         tag = msg[:tag] || msg["tag"]
+
+#         extras =
+#           msg.reject do |k, _|
+#           k.to_s == "event" || k.to_s == "tag"
+#         end
+
+#         parts = []
+#         parts << "[#{tag}]" if tag && !tag.to_s.empty?
+#         parts << event.to_s if event
+
+#         unless extras.empty?
+#           parts << "\n" + PP.pp(extras, +"").rstrip
+#         end
+
+#         parts.join(" ")
+#       end
+#     end
+#   end
+# end
+
+module Fatty
+  module Logger
+    class TextFormatter < ::Logger::Formatter
+      def call(level, time, progname, msg)
+        ts = time.utc.iso8601(6)
+
+        body =
+          case msg
+          when Hash
+            render_hash(msg)
+          else
+            msg.to_s
+          end
+
+        "#{ts} #{level} #{progname} #{body}\n"
+      end
+
+      private
+
+      def render_hash(msg)
+        event = msg[:event] || msg["event"]
+        tag = msg[:tag] || msg["tag"]
+
+        extras =
+          msg.reject do |k, _|
+            k.to_s == "event" || k.to_s == "tag"
+          end
+
+        parts = []
+        parts << "[#{tag}]" if tag && !tag.to_s.empty?
+        parts << event.to_s if event
+
+        unless extras.empty?
+          rendered = PP.pp(extras, +"").rstrip
+          parts << "\n#{rendered}"
+        end
+
+        parts.join(" ")
+      end
+    end
+  end
+end