fatty 0.99.0

data/lib/fatty/logger.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "logger"
+require "json"
+require "time"
+require "fileutils"
+
+require_relative "log_formats/json"
+require_relative "log_formats/text"
+
+module Fatty
+  module Logger
+    class << self
+      attr_accessor :logger, :path
+    end
+
+    def self.configure
+      progname = Fatty::Config.progname
+      cfg = Fatty::Config.config || 'fatty'
+      path =
+        if cfg.dig(:log, :file)
+          File.expand_path(cfg.dig(:log, :file))
+        elsif ENV['XDG_STATE_HOME']
+          File.expand_path(File.join(ENV['XDG_STATE_HOME'], progname, "#{progname}.log"))
+        else
+          File.expand_path(File.join("~/.state/#{progname}", "#{progname}.log"))
+        end
+      dir = File.dirname(path)
+      FileUtils.mkdir_p(dir)
+      FileUtils.touch(path)
+      unless File.readable?(path) && File.writable?(path)
+        return self.logger = nil
+      end
+
+      io = File.open(path, "a")
+      io.sync = true
+      self.logger = ::Logger.new(io)
+      self.path = path
+      logger.level = severity(cfg.dig(:log, :level))
+      logger.formatter =
+        if cfg.dig(:log, :format).nil?
+          JsonFormatter.new
+        elsif cfg.dig(:log, :format)&.to_sym == :json
+          JsonFormatter.new
+        else
+          TextFormatter.new
+        end
+      logger.progname = progname
+      logger
+    end
+
+    def self.active_tags
+      tags = Fatty::Config.config.dig(:log, :tags) || [:all]
+      Array(tags).map(&:to_sym)
+    end
+
+    # Convenience: log structured events without repeating formatting.
+    #
+    #   Fatty.log(:decode_getch, ch: 27, note: "escape")
+    #
+    #   Supported tags are:
+    #     - keycode:: raw curses input / bytes / ESC buffering
+    #     - keyevent:: constructed KeyEvent normalization (ctrl/meta mapping)
+    #     - keybinding:: KeyMap#resolve hits/misses, contexts used
+    #     - action:: Actions.call, target selection, unknown action
+    #     - 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
+    def self.log(event = nil, level: :debug, tag: nil, **data)
+      return unless logger
+
+      tags = active_tags
+      if tag && !tags.include?(:all)
+        return unless tags.include?(tag.to_sym)
+      end
+
+      payload = { event: event, tag: tag }
+      payload.merge!(data.reject { |k, _| k == :event || k == :tag })
+
+      logger.add(severity(level), payload)
+    rescue StandardError => ex
+      begin
+        logger&.add(
+          ::Logger::FATAL,
+          { event: "logger_error", err: ex.class.name, msg: ex.message, bt: ex.backtrace&.take(10) },
+        )
+      rescue StandardError
+        # swallow
+      end
+    end
+
+    # Translate our severity symbols to those expected by ::Logger.
+    def self.severity(sym)
+      case sym&.to_sym
+      when :debug
+        # This is 0
+        ::Logger::DEBUG
+      when :info
+        # This is 1
+        ::Logger::INFO
+      when :warn
+        # This is 2
+        ::Logger::WARN
+      when :error
+        # This is 3
+        ::Logger::ERROR
+      when :fatal
+        # This is 4
+        ::Logger::FATAL
+      else
+        ::Logger::DEBUG
+      end
+    end
+  end
+
+  # So we can just call Fatty.log
+  def self.log(event = nil, level: :debug, tag: nil, **data)
+    Logger.log(event, level: level, tag: tag, **data)
+  end
+
+  def self.debug(event, tag: nil, **data)
+    Logger.log(event, level: :debug, tag: tag, **data)
+  end
+
+  def self.info(event, tag: nil, **data)
+    Logger.log(event, level: :info, tag: tag, **data)
+  end
+
+  def self.warn(event, tag: nil, **data)
+    Logger.log(event, level: :warn, tag: tag, **data)
+  end
+
+  def self.error(event, tag: nil, **data)
+    Logger.log(event, level: :error, tag: tag, **data)
+  end
+
+  def self.fatal(event, tag: nil, **data)
+    Logger.log(event, level: :fatal, tag: tag, **data)
+  end
+end

data/lib/fatty/markdown/ansi_renderer.rb

@@ -0,0 +1,373 @@
+# frozen_string_literal: true
+
+require "rouge"
+require "cgi"
+
+module Fatty
+  class AnsiRenderer < Redcarpet::Render::Base
+    HARD_BREAK = "\uE000"
+
+    def initialize(width: 80, palette: nil)
+      super()
+      @width = width.to_i
+      @palette = palette || {}
+    end
+
+    def block_code(code, language)
+      lexer = rouge_lexer(language.to_s, code.to_s)
+      formatter = Rouge::Formatters::Terminal256.new
+      gutter = md("│ ", :markdown_code_gutter)
+
+      highlighted = formatter.format(lexer.lex(code.to_s))
+      lines = highlighted.lines.map(&:chomp)
+
+      lines.pop while lines.any? && Fatty::Ansi.plain_text(lines.last).strip.empty?
+
+      body = lines.map { |line|
+        "#{gutter}#{line}"
+      }.join("\n")
+
+      "#{body}\n\n"
+    end
+
+    def normal_text(text)
+      text = render_inline_html(CGI.unescapeHTML(text.to_s))
+      text
+    end
+
+    def raw_html(html)
+      text = CGI.unescapeHTML(html.to_s)
+      render_inline_html(text)
+    end
+
+    def render_inline_html(text)
+      text.to_s
+        .gsub(%r{<br\s*/?>}i, HARD_BREAK)
+        .gsub(%r{<span\s+class=["']underline["']>(.*?)</span>}m) do
+          md(Regexp.last_match(1), :markdown_underline)
+      end
+    end
+
+    # Curses does not support strike-through, but this emulates it with
+    # unicode "combining characters" by adding a "Long Stroke Overlay"
+    # (U+0366) after each character, which overlays each with a strike-through
+    # overlay.  We just had to make sure that Ansi.visible_length takes these
+    # into account in computing width.
+    def strikethrough(text)
+      text.to_s.each_char.map { |ch| "#{ch}\u0336" }.join
+    end
+
+    def link(link, _title, content)
+      label = content.to_s.empty? ? link : content
+      "#{md(label, :markdown_link)} #{md("<#{link}>", :markdown_url)}"
+    end
+
+    def codespan(code)
+      md(code.to_s, :markdown_code)
+    end
+
+    def double_emphasis(text)
+      md(text.to_s, :markdown_strong)
+    end
+
+    # Curses does not reliably render true italics, so we use underline instead.
+    def emphasis(text)
+      md(text.to_s, :markdown_emphasis)
+    end
+
+    def highlight(text)
+      md(text.to_s, :markdown_highlight)
+    end
+
+    def autolink(link, _link_type)
+      md(link.to_s, :markdown_link)
+    end
+
+    def quote(text)
+      "“#{text}”"
+    end
+
+    def block_quote(quote)
+      gutter = md("│ ", :markdown_quote_gutter)
+      quote = CGI.unescapeHTML(quote.to_s)
+      paragraphs = quote.to_s.split(/\n{2,}/).map do |para|
+        text = para.lines.map(&:strip).reject(&:empty?).join(" ")
+
+        if text.empty?
+          gutter
+        else
+          wrap(text, first_prefix: gutter, rest_prefix: gutter)
+        end
+      end
+      paragraphs.join("\n#{gutter}\n") + "\n\n"
+    end
+
+    def header(text, level)
+      body =
+        case level
+        when 1
+          h1(text)
+        when 2
+          h2(text)
+        when 3
+          h3(text)
+        else
+          Rainbow(text.to_s).bright.to_s
+        end
+      "#{body}\n\n"
+    end
+
+    def hrule
+      "#{md(TABLE_DASH * @width.to_i.clamp(20, 80), :markdown_hrule)}\n\n"
+    end
+
+    def linebreak
+      "\n"
+    end
+
+    def paragraph(text)
+      "#{wrap(text)}\n\n"
+    end
+
+    def list(contents, _type)
+      "#{contents}\n"
+    end
+
+    def list_item(text, _type)
+      text = render_inline_html(CGI.unescapeHTML(text.to_s))
+      head, rest = text.to_s.strip.split(/\n+/, 2)
+      out = wrap(
+        head.to_s.strip,
+        first_prefix: "  • ",
+        rest_prefix: "    ",
+      )
+
+      if rest && !rest.empty?
+        out << "\n"
+        out << indent_block(rest.rstrip, "  ")
+      end
+
+      out << "\n"
+      out
+    end
+
+    def indent_block(text, prefix)
+      text.to_s.lines.map { |line|
+        if line.strip.empty?
+          line
+        else
+          "#{prefix}#{line}"
+        end
+      }.join
+    end
+
+    CELL_SEP = "\u001F"
+    TABLE_BAR = "│"
+    TABLE_DASH = "─"
+
+    def table(header, body)
+      rows = (header + body).lines.map do |line|
+        line.chomp.split(CELL_SEP, -1)
+      end
+
+      widths = table_widths(rows)
+
+      rendered = rows.each_with_index.map do |row, index|
+        header_row = index.zero?
+
+        line = render_table_row_cells(row, widths, header: header_row)
+
+        if header_row
+          [line, render_table_separator(widths)].join("\n")
+        else
+          line
+        end
+      end
+
+      rendered.join("\n") + "\n\n"
+    end
+
+    def table_row(content)
+      content.chomp.delete_suffix(CELL_SEP) + "\n"
+    end
+
+    def table_cell(content, _alignment)
+      inline(content.strip) + CELL_SEP
+    end
+
+    def table_widths(rows)
+      widths = []
+
+      rows.each do |row|
+        row.each_with_index do |cell, index|
+          width = Fatty::Ansi.visible_length(cell)
+          widths[index] = [widths[index] || 0, width].max
+        end
+      end
+
+      widths
+    end
+
+    def render_table_row_cells(row, widths, header: false)
+      cells = widths.each_with_index.map do |width, index|
+        text = row[index].to_s
+        text = header ? th(text) : td(text)
+        pad_visible(text, width)
+      end
+
+      "  │ #{cells.join(' │ ')} │"
+    end
+
+    def render_table_separator(widths)
+      parts = widths.map do |width|
+        TABLE_DASH * (width + 2)
+      end
+
+      "  #{TABLE_BAR}#{parts.join(TABLE_BAR)}#{TABLE_BAR}"
+    end
+
+    def pad_visible(text, width)
+      padding = width - Fatty::Ansi.visible_length(text)
+      padding = 0 if padding.negative?
+      "#{text}#{' ' * padding}"
+    end
+
+    def inline(text)
+      text.to_s
+    end
+
+    def h1(text)
+      md(text.to_s, :markdown_h1)
+    end
+
+    def h2(text)
+      md(text.to_s, :markdown_h2)
+    end
+
+    def h3(text)
+      md(text.to_s, :markdown_h3)
+    end
+
+    def th(text)
+      md(text.to_s, :markdown_table_header)
+    end
+
+    def td(text)
+      md(text.to_s, :markdown_table_cell)
+    end
+
+    def rouge_lexer(language, code)
+      lexer =
+        if !language.empty?
+          Rouge::Lexer.find_fancy(language, code)
+        else
+          Rouge::Lexer.guess(source: code)
+        end
+
+      lexer || Rouge::Lexers::PlainText.new
+    rescue StandardError
+      Rouge::Lexers::PlainText.new
+    end
+
+    private
+
+    def wrap(text, first_prefix: "", rest_prefix: first_prefix)
+      hard_lines = text.to_s.split(HARD_BREAK, -1)
+
+      hard_lines.each_with_index.map { |hard_line, index|
+        wrap_soft_line(
+          hard_line,
+          first_prefix: index.zero? ? first_prefix : rest_prefix,
+          rest_prefix: rest_prefix,
+        )
+      }.join("\n")
+    end
+
+    def wrap_soft_line(text, first_prefix: "", rest_prefix: first_prefix)
+      width = @width.to_i.clamp(20, 80)
+
+      words = text.to_s.split(/\s+/)
+      lines = []
+      line = +""
+
+      words.each do |word|
+        next if word.empty?
+
+        prefix = lines.empty? ? first_prefix : rest_prefix
+        available = width - Fatty::Ansi.visible_length(prefix)
+        available = 20 if available < 20
+
+        candidate = line.empty? ? word : "#{line} #{word}"
+
+        if Fatty::Ansi.visible_length(candidate) > available && !line.empty?
+          lines << "#{prefix}#{line}"
+          line = word.dup
+        else
+          line = candidate
+        end
+      end
+
+      unless line.empty?
+        prefix = lines.empty? ? first_prefix : rest_prefix
+        lines << "#{prefix}#{line}"
+      end
+
+      lines.empty? ? first_prefix.rstrip : lines.join("\n")
+    end
+
+    def md(text, role)
+      spec = @palette[role.to_sym] || {}
+      codes = sgr_codes_for(spec)
+
+      if codes.empty?
+        text.to_s
+      else
+        "\e[#{codes.join(';')}m#{text}\e[0m"
+      end
+    end
+
+    def sgr_codes_for(spec)
+      attrs = Array(spec[:attrs] || spec["attrs"]).map(&:to_sym)
+      codes = []
+
+      codes << 1 if attrs.include?(:bold)
+      codes << 2 if attrs.include?(:dim)
+      codes << 3 if attrs.include?(:italic)
+      codes << 4 if attrs.include?(:underline)
+      codes << 7 if attrs.include?(:reverse)
+
+      if (fg_rgb = spec[:fg_rgb] || spec["fg_rgb"])
+        codes.push(38, 2, *fg_rgb)
+      elsif (fg = spec[:fg] || spec["fg"])
+        codes.concat(color_codes(fg, foreground: true))
+      end
+
+      if (bg_rgb = spec[:bg_rgb] || spec["bg_rgb"])
+        codes.push(48, 2, *bg_rgb)
+      elsif (bg = spec[:bg] || spec["bg"])
+        codes.concat(color_codes(bg, foreground: false))
+      end
+      codes
+    end
+
+    def color_codes(color, foreground:)
+      color = color.to_i
+
+      if foreground
+        if color.between?(0, 7)
+          [30 + color]
+        elsif color.between?(8, 15)
+          [90 + color - 8]
+        else
+          [38, 5, color]
+        end
+      elsif color.between?(0, 7)
+        [40 + color]
+      elsif color.between?(8, 15)
+        [100 + color - 8]
+      else
+        [48, 5, color]
+      end
+    end
+  end
+end

data/lib/fatty/markdown/render.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Fatty
+  module Markdown
+    def self.render(text, width: 80, palette: nil)
+      markdown = Redcarpet::Markdown.new(
+        Fatty::AnsiRenderer.new(width: width, palette: palette),
+        no_intra_emphasis: true,
+        tables: true,
+        fenced_code_blocks: true,
+        autolink: true,
+        disable_indented_code_blocks: true,
+        strikethrough: true,
+        space_after_headers: true,
+        underline: true,
+        highlight: true,
+        footnotes: true,
+      )
+      markdown.render(text)
+    end
+  end
+end

data/lib/fatty/markdown.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "markdown/ansi_renderer"
+require_relative "markdown/render"

data/lib/fatty/menu_env.rb

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Fatty
+  # The MouseEvent class is a simple class to store a mouse event with its
+  # modifiers.
+  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)
+      @button = button
+      @x = x
+      @y = y
+      @raw = raw
+      @ctrl = ctrl
+      @meta = meta
+      @shift = shift
+      Fatty.debug("#{self.class}#new(#{self})", tag: :event)
+    end
+
+    def to_s
+      "MouseEvent: button: `#{button}`, x: `#{x}`, y: `#{y}`, raw: `#{raw}`, ctrl: `#{ctrl}`, meta: `#{meta}`, shift: `#{shift}`"
+    end
+
+    def printable?
+      false
+    end
+
+    def mouse?
+      true
+    end
+  end
+end

data/lib/fatty/output_buffer.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Fatty
+  class OutputBuffer
+    DEFAULT_MAX_LINES = 10_000
+
+    attr_reader :lines
+    attr_accessor :max_lines
+
+    def initialize(max_lines: DEFAULT_MAX_LINES)
+      @lines = []
+      @scroll = 0
+      @max_lines = Integer(max_lines)
+      @line_open = false
+    end
+
+    # Append text to the output buffer. Text may contain complete lines,
+    # partial lines, or both. Returns the number of lines trimmed.  The
+    # Terminal can use this to adjust the Viewport.
+    def append(text)
+      ntrimmed = 0
+      str = text.to_s
+      return ntrimmed if str.empty?
+
+      str.split(/(\n)/).each do |part|
+        if part == "\n"
+          if @line_open
+            @line_open = false
+          else
+            ntrimmed += append_new_line("")
+          end
+        elsif !part.empty?
+          ntrimmed += append_fragment(part)
+        end
+      end
+
+      ntrimmed
+    end
+
+    def visible_lines(height)
+      start = [@lines.length - height - @scroll, 0].max
+      @lines[start, height] || []
+    end
+
+    def scroll_up
+      @scroll += 1
+    end
+
+    def scroll_down
+      @scroll -= 1 if @scroll.positive?
+    end
+
+    private
+
+    def append_fragment(fragment)
+      ntrimmed = 0
+      if @line_open && @lines.any?
+        @lines[-1] = "#{@lines[-1]}#{fragment}".freeze
+      else
+        ntrimmed += append_new_line(fragment)
+        @line_open = true
+      end
+      ntrimmed
+    end
+
+    def append_new_line(line)
+      ntrimmed = 0
+
+      if @lines.length >= @max_lines
+        @lines.shift
+        ntrimmed = 1
+      end
+
+      @lines << line.to_s.dup.freeze
+      ntrimmed
+    end
+  end
+end